Merge branch 'master' into junaed/fssdk-11403-readme-update

Author: junaed-optimizely

.github/workflows/javascript.yml

@@ -63,7 +63,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        node: ['18', '20', '22']
+        node: ['18', '20', '22', '24']
     steps:
     - uses: actions/checkout@v3
     - name: Set up Node ${{ matrix.node }}

README.md

@@ -31,21 +31,15 @@ Optimizely Rollouts is [free feature flags](https://www.optimizely.com/free-feat
 
 ### Prerequisites
 
-Ensure the SDK supports all of the platforms you're targeting. In particular, the SDK targets modern ES5-compliant JavaScript environment. We officially support:
-- Node.js >= 16.0.0. By extension, environments like AWS Lambda, Google Cloud Functions, and Auth0 Webtasks are supported as well. Older Node.js releases likely work too (try `npm test` to validate for yourself), but are not formally supported.
+Ensure the SDK supports all of the platforms you're targeting. In particular, the SDK targets modern ES6-compliant JavaScript environments. We officially support:
+- Node.js >= 18.0.0. By extension, environments like AWS Lambda, Google Cloud Functions, and Auth0 Webtasks are supported as well. Older Node.js releases likely work too (try `npm test` to validate for yourself), but are not formally supported.
 - Modern Web Browsers, such as Microsoft Edge 84+, Firefox 91+, Safari 13+, and Chrome 102+, Opera 76+
 
 In addition, other environments are likely compatible but are not formally supported including:
 - Progressive Web Apps, WebViews, and hybrid mobile apps like those built with React Native and Apache Cordova.
 - [Cloudflare Workers](https://developers.cloudflare.com/workers/) and [Fly](https://fly.io/), both of which are powered by recent releases of V8.
 - Anywhere else you can think of that might embed a JavaScript engine. The sky is the limit; experiment everywhere! 🚀
 
-### Requirements
-
-* JavaScript (Browser): Modern web browser that is ES6-compliant.
-
-* JavaScript (Node): Node 16.0.0+
-
 
 ### Install the SDK
 

lib/client_factory.spec.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright 2025, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, it, expect } from 'vitest';
+
+import { getOptimizelyInstance } from './client_factory';
+import { createStaticProjectConfigManager } from './project_config/config_manager_factory';
+import Optimizely from './optimizely';
+
+describe('getOptimizelyInstance', () => {
+  it('should throw if the projectConfigManager is not a valid ProjectConfigManager', () => {
+    expect(() => getOptimizelyInstance({
+      projectConfigManager: undefined as any,
+      requestHandler: {} as any,
+    })).toThrow('Invalid config manager');
+
+    expect(() => getOptimizelyInstance({
+      projectConfigManager: null as any,
+      requestHandler: {} as any,
+    })).toThrow('Invalid config manager');
+
+    expect(() => getOptimizelyInstance({
+      projectConfigManager: 'abc' as any,
+      requestHandler: {} as any,
+    })).toThrow('Invalid config manager');
+
+    expect(() => getOptimizelyInstance({
+      projectConfigManager: 123 as any,
+      requestHandler: {} as any,
+    })).toThrow('Invalid config manager');
+
+    expect(() => getOptimizelyInstance({
+      projectConfigManager: {} as any,
+      requestHandler: {} as any,
+    })).toThrow('Invalid config manager');
+  });
+
+  it('should return an instance of Optimizely if a valid projectConfigManager is provided', () => {
+    const optimizelyInstance = getOptimizelyInstance({
+      projectConfigManager: createStaticProjectConfigManager({
+        datafile: '{}',
+      }),
+      requestHandler: {} as any,
+    });
+
+    expect(optimizelyInstance).toBeInstanceOf(Optimizely);
+  });
+});

lib/client_factory.ts

@@ -13,11 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
-import { LoggerFacade } from "./logging/logger";
 import { Client, Config } from "./shared_types";
-import { Maybe } from "./utils/type";
-import configValidator from './utils/config_validator';
 import { extractLogger } from "./logging/logger_factory";
 import { extractErrorNotifier } from "./error/error_notifier_factory";
 import { extractConfigManager } from "./project_config/config_manager_factory";
@@ -35,61 +31,50 @@ export type OptimizelyFactoryConfig = Config & {
   requestHandler: RequestHandler;
 }
 
-export const getOptimizelyInstance = (config: OptimizelyFactoryConfig): Client | null => {
-  let logger: Maybe<LoggerFacade>;
-
-  try {
-    logger = config.logger ? extractLogger(config.logger) : undefined;
-
-    configValidator.validate(config);
-    
-    const { 
-      clientEngine,
-      clientVersion,
-      jsonSchemaValidator,
-      userProfileService,
-      userProfileServiceAsync,
-      defaultDecideOptions,
-      disposable,
-      requestHandler,
-    } = config;
-    
-    const errorNotifier = config.errorNotifier ? extractErrorNotifier(config.errorNotifier) : undefined;
-
-    const projectConfigManager = extractConfigManager(config.projectConfigManager);
-    const eventProcessor = config.eventProcessor ? extractEventProcessor(config.eventProcessor) : undefined;
-    const odpManager = config.odpManager ? extractOdpManager(config.odpManager) : undefined;
-    const vuidManager = config.vuidManager ? extractVuidManager(config.vuidManager) : undefined;
+export const getOptimizelyInstance = (config: OptimizelyFactoryConfig): Client => {
+  const { 
+    clientEngine,
+    clientVersion,
+    jsonSchemaValidator,
+    userProfileService,
+    userProfileServiceAsync,
+    defaultDecideOptions,
+    disposable,
+    requestHandler,
+  } = config;
+  
+  const projectConfigManager = extractConfigManager(config.projectConfigManager);
+  const eventProcessor = extractEventProcessor(config.eventProcessor);
+  const odpManager = extractOdpManager(config.odpManager);
+  const vuidManager = extractVuidManager(config.vuidManager);
+  const errorNotifier = extractErrorNotifier(config.errorNotifier);
+  const logger = extractLogger(config.logger);
 
-    const cmabClient = new DefaultCmabClient({
-      requestHandler,
-    });
+  const cmabClient = new DefaultCmabClient({
+    requestHandler,
+  });
 
-    const cmabService = new DefaultCmabService({
-      cmabClient,
-      cmabCache: new InMemoryLruCache<CmabCacheValue>(DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT),
-    });
+  const cmabService = new DefaultCmabService({
+    cmabClient,
+    cmabCache: new InMemoryLruCache<CmabCacheValue>(DEFAULT_CMAB_CACHE_SIZE, DEFAULT_CMAB_CACHE_TIMEOUT),
+  });
 
-    const optimizelyOptions = {
-      cmabService,
-      clientEngine: clientEngine || JAVASCRIPT_CLIENT_ENGINE,
-      clientVersion: clientVersion || CLIENT_VERSION,
-      jsonSchemaValidator,
-      userProfileService,
-      userProfileServiceAsync,
-      defaultDecideOptions,
-      disposable,
-      logger,
-      errorNotifier,
-      projectConfigManager,
-      eventProcessor,
-      odpManager,
-      vuidManager,
-    };
+  const optimizelyOptions = {
+    cmabService,
+    clientEngine: clientEngine || JAVASCRIPT_CLIENT_ENGINE,
+    clientVersion: clientVersion || CLIENT_VERSION,
+    jsonSchemaValidator,
+    userProfileService,
+    userProfileServiceAsync,
+    defaultDecideOptions,
+    disposable,
+    logger,
+    errorNotifier,
+    projectConfigManager,
+    eventProcessor,
+    odpManager,
+    vuidManager,
+  };
 
-    return new Optimizely(optimizelyOptions);
-  } catch (e) {
-    logger?.error(e);
-    return null;
-  }
+  return new Optimizely(optimizelyOptions);
 }

lib/core/decision_service/index.tests.js

@@ -25,7 +25,7 @@ import {
   LOG_LEVEL,
   DECISION_SOURCES,
 } from '../../utils/enums';
-import { getForwardingEventProcessor } from '../../event_processor/forwarding_event_processor';
+import { getForwardingEventProcessor } from '../../event_processor/event_processor_factory';
 import { createNotificationCenter } from '../../notification_center';
 import Optimizely from '../../optimizely';
 import OptimizelyUserContext from '../../optimizely_user_context';

lib/entrypoint.test-d.ts

@@ -59,7 +59,7 @@ import { Maybe } from './utils/type';
 
 export type Entrypoint = {
   // client factory
-  createInstance: (config: Config) => Client | null;
+  createInstance: (config: Config) => Client;
 
   // config manager related exports
   createStaticProjectConfigManager: (config: StaticConfigManagerConfig) => OpaqueConfigManager;

lib/entrypoint.universal.test-d.ts

@@ -55,7 +55,7 @@ import { UniversalOdpManagerOptions } from './odp/odp_manager_factory.universal'
 
 export type UniversalEntrypoint = {
   // client factory
-  createInstance: (config: UniversalConfig) => Client | null;
+  createInstance: (config: UniversalConfig) => Client;
 
   // config manager related exports
   createStaticProjectConfigManager: (config: StaticConfigManagerConfig) => OpaqueConfigManager;

lib/error/error_notifier_factory.spec.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2025, Optimizely
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createErrorNotifier } from './error_notifier_factory';
+
+describe('createErrorNotifier', () => {
+  it('should throw errors for invalid error handlers', () => {
+    expect(() => createErrorNotifier(null as any)).toThrow('Invalid error handler');
+    expect(() => createErrorNotifier(undefined as any)).toThrow('Invalid error handler');
+
+
+    expect(() => createErrorNotifier('abc' as any)).toThrow('Invalid error handler');
+    expect(() => createErrorNotifier(123 as any)).toThrow('Invalid error handler');
+
+    expect(() => createErrorNotifier({} as any)).toThrow('Invalid error handler');
+
+    expect(() => createErrorNotifier({ handleError: 'abc' } as any)).toThrow('Invalid error handler');
+  });
+});

lib/error/error_notifier_factory.ts

@@ -14,21 +14,35 @@
  * limitations under the License.
  */
 import { errorResolver } from "../message/message_resolver";
+import { Maybe } from "../utils/type";
 import { ErrorHandler } from "./error_handler";
 import { DefaultErrorNotifier } from "./error_notifier";
 
+export const INVALID_ERROR_HANDLER = 'Invalid error handler';
+
 const errorNotifierSymbol = Symbol();
 
 export type OpaqueErrorNotifier = {
   [errorNotifierSymbol]: unknown;
 };
 
+const validateErrorHandler = (errorHandler: ErrorHandler) => {
+  if (!errorHandler || typeof errorHandler !== 'object' || typeof errorHandler.handleError !== 'function') {
+    throw new Error(INVALID_ERROR_HANDLER);
+  }
+}
+
 export const createErrorNotifier = (errorHandler: ErrorHandler): OpaqueErrorNotifier => {
+  validateErrorHandler(errorHandler);
   return {
     [errorNotifierSymbol]: new DefaultErrorNotifier(errorHandler, errorResolver),
   }
 }
 
-export const extractErrorNotifier = (errorNotifier: OpaqueErrorNotifier): DefaultErrorNotifier => {
-  return errorNotifier[errorNotifierSymbol] as DefaultErrorNotifier;
+export const extractErrorNotifier = (errorNotifier: Maybe<OpaqueErrorNotifier>): Maybe<DefaultErrorNotifier> => {
+  if (!errorNotifier || typeof errorNotifier !== 'object') {
+    return undefined;
+  }
+
+  return errorNotifier[errorNotifierSymbol] as Maybe<DefaultErrorNotifier>;
 }

lib/event_processor/event_dispatcher/event_dispatcher_factory.ts

@@ -18,6 +18,9 @@ import { RequestHandler } from '../../utils/http_request_handler/http';
 import { DefaultEventDispatcher } from './default_dispatcher';
 import { EventDispatcher } from './event_dispatcher';
 
+import { validateRequestHandler } from '../../utils/http_request_handler/request_handler_validator';
+
 export const createEventDispatcher = (requestHander: RequestHandler): EventDispatcher => {
+  validateRequestHandler(requestHander);
   return new DefaultEventDispatcher(requestHander);
 }