[FSSDK-11113] make Optimizely class instance of Service interface

Author: raju-opti

lib/event_processor/forwarding_event_processor.ts

@@ -23,7 +23,7 @@ import { buildLogEvent } from './event_builder/log_event';
 import { BaseService, ServiceState } from '../service';
 import { EventEmitter } from '../utils/event_emitter/event_emitter';
 import { Consumer, Fn } from '../utils/type';
-import { SERVICE_STOPPED_BEFORE_IT_WAS_STARTED } from 'error_message';
+import { SERVICE_STOPPED_BEFORE_RUNNING } from 'error_message';
 import { OptimizelyError } from '../error/optimizly_error';
 class ForwardingEventProcessor extends BaseService implements EventProcessor {
   private dispatcher: EventDispatcher;
@@ -56,7 +56,7 @@ class ForwardingEventProcessor extends BaseService implements EventProcessor {
     }
 
     if (this.isNew()) {
-      this.startPromise.reject(new OptimizelyError(SERVICE_STOPPED_BEFORE_IT_WAS_STARTED));
+      this.startPromise.reject(new OptimizelyError(SERVICE_STOPPED_BEFORE_RUNNING));
     }
 
     this.state = ServiceState.Terminated;

lib/message/error_message.ts

@@ -95,7 +95,7 @@ export const DATAFILE_MANAGER_STOPPED = 'Datafile manager stopped before it coul
 export const FAILED_TO_FETCH_DATAFILE = 'Failed to fetch datafile';
 export const NO_SDKKEY_OR_DATAFILE = 'At least one of sdkKey or datafile must be provided';
 export const RETRY_CANCELLED = 'Retry cancelled';
-export const SERVICE_STOPPED_BEFORE_IT_WAS_STARTED = 'Service stopped before it was started';
+export const SERVICE_STOPPED_BEFORE_RUNNING = 'Service stopped before running';
 export const ONLY_POST_REQUESTS_ARE_SUPPORTED = 'Only POST requests are supported';
 export const SEND_BEACON_FAILED = 'sendBeacon failed';
 export const FAILED_TO_DISPATCH_EVENTS = 'Failed to dispatch events'

lib/optimizely/index.tests.js

@@ -37,26 +37,15 @@ import {
   FEATURE_NOT_ENABLED_FOR_USER,
   INVALID_CLIENT_ENGINE,
   INVALID_DEFAULT_DECIDE_OPTIONS,
-  INVALID_OBJECT,
   NOT_ACTIVATING_USER,
-  USER_HAS_NO_FORCED_VARIATION,
-  USER_HAS_NO_FORCED_VARIATION_FOR_EXPERIMENT,
-  USER_MAPPED_TO_FORCED_VARIATION,
-  USER_RECEIVED_DEFAULT_VARIABLE_VALUE,
   VALID_USER_PROFILE_SERVICE,
-  VARIATION_REMOVED_FOR_USER,
 } from 'log_message';
 import {
-  EXPERIMENT_KEY_NOT_IN_DATAFILE,
-  INVALID_ATTRIBUTES,
   NOT_TRACKING_USER,
   EVENT_KEY_NOT_FOUND,
   INVALID_EXPERIMENT_KEY,
-  INVALID_INPUT_FORMAT,
-  NO_VARIATION_FOR_EXPERIMENT_KEY,
-  USER_NOT_IN_FORCED_VARIATION,
-  INSTANCE_CLOSED,
   ONREADY_TIMEOUT,
+  SERVICE_STOPPED_BEFORE_RUNNING
 } from 'error_message';
 
 import {
@@ -77,6 +66,8 @@ import {
 } from '../core/decision_service';
 
 import { USER_BUCKETED_INTO_EXPERIMENT_IN_GROUP } from '../core/bucketer';
+import { read } from 'fs';
+import { resolvablePromise } from '../utils/promise/resolvablePromise';
 
 var LOG_LEVEL = enums.LOG_LEVEL;
 var DECISION_SOURCES = enums.DECISION_SOURCES;
@@ -9463,7 +9454,7 @@ describe('lib/optimizely', function() {
         var readyPromise = optlyInstance.onReady();
         clock.tick(300001);
         return readyPromise.then(() => {
-          return Promise.reject(new Error(PROMISE_SHOULD_NOT_HAVE_RESOLVED));
+          return Promise.reject(new Error('PROMISE_SHOULD_NOT_HAVE_RESOLVED'));
         }, (err) => {
           assert.equal(err.baseMessage, ONREADY_TIMEOUT);
           assert.deepEqual(err.params, [ 30000 ]);
@@ -9485,18 +9476,25 @@ describe('lib/optimizely', function() {
           eventProcessor,
         });
         var readyPromise = optlyInstance.onReady({ timeout: 100 });
+
         optlyInstance.close();
+
         return readyPromise.then(() => {
-          return Promise.reject(new Error(PROMISE_SHOULD_NOT_HAVE_RESOLVED));
+          return Promise.reject(new Error('PROMISE_SHOULD_NOT_HAVE_RESOLVED'));
         }, (err) => {
-          assert.equal(err.baseMessage, INSTANCE_CLOSED);
+          assert.equal(err.baseMessage, SERVICE_STOPPED_BEFORE_RUNNING);
         });
       });
 
       it('can be called several times with different timeout values and the returned promises behave correctly', function() {
+        const onRunning = resolvablePromise();
+
         optlyInstance = new Optimizely({
           clientEngine: 'node-sdk',
-          projectConfigManager: getMockProjectConfigManager(),
+          projectConfigManager: getMockProjectConfigManager({
+            onRunning: onRunning.promise,
+          }),
+
           eventProcessor,
           jsonSchemaValidator: jsonSchemaValidator,
           logger: createdLogger,
@@ -9510,16 +9508,16 @@ describe('lib/optimizely', function() {
         var readyPromise3 = optlyInstance.onReady({ timeout: 300 });
         clock.tick(101);
         return readyPromise1
-          .then(function() {
+          .catch(function() {
             clock.tick(100);
             return readyPromise2;
           })
-          .then(function() {
+          .catch(function() {
             // readyPromise3 has not resolved yet because only 201 ms have elapsed.
             // Calling close on the instance should resolve readyPromise3
-            optlyInstance.close();
+            optlyInstance.close().catch(() => {});
             return readyPromise3;
-          });
+          }).catch(() => {});
       });
 
       it('clears the timeout when the project config manager ready promise fulfills', function() {

lib/optimizely/index.ts

@@ -77,7 +77,8 @@ import {
   NOT_TRACKING_USER,
   VARIABLE_REQUESTED_WITH_WRONG_TYPE,
   ONREADY_TIMEOUT,
-  INSTANCE_CLOSED
+  INSTANCE_CLOSED,
+  SERVICE_STOPPED_BEFORE_RUNNING
 } from 'error_message';
 
 import {
@@ -133,10 +134,8 @@ export type OptimizelyOptions = {
 }
 
 export default class Optimizely extends BaseService implements Client {
-  // readyTimeout is specified as any to make this work in both browser & Node
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readyTimeouts: { [key: string]: { readyTimeout: any; onClose: () => void } };
-  private nextReadyTimeoutId: number;
+  private cleanupTasks: Map<number, Fn> = new Map();
+  private nextCleanupTaskId = 0;
   private clientEngine: string;
   private clientVersion: string;
   private errorNotifier?: ErrorNotifier;
@@ -233,22 +232,25 @@ export default class Optimizely extends BaseService implements Client {
 
     this.notificationCenter = createNotificationCenter({ logger: this.logger, errorNotifier: this.errorNotifier });
 
-    this.readyTimeouts = {};
-    this.nextReadyTimeoutId = 0;
-
     this.start();
   }
 
   start(): void {
+    if (!this.isNew()) {
+      return;
+    }
+
     super.start();
 
     this.state = ServiceState.Starting;
     this.projectConfigManager.start();
     this.eventProcessor?.start();
     this.odpManager?.start();
 
+    const configManOnRunning = this.projectConfigManager.onRunning();
+
     Promise.all([
-      this.projectConfigManager.onRunning(),
+      configManOnRunning,
       this.eventProcessor ? this.eventProcessor.onRunning() : Promise.resolve(),
       this.odpManager ? this.odpManager.onRunning() : Promise.resolve(),
       this.vuidManager ? this.vuidManager.initialize() : Promise.resolve(),
@@ -260,11 +262,13 @@ export default class Optimizely extends BaseService implements Client {
       if (vuid) {
         this.odpManager?.setVuid(vuid);
       }
+    }, (err) => {
+      this.state = ServiceState.Failed;
+      this.errorReporter.report(err);
+      this.startPromise.reject(err);
     });
   }
 
-    
-
   /**
    * Returns the project configuration retrieved from projectConfigManager
    * @return {projectConfig.ProjectConfig}
@@ -1233,24 +1237,30 @@ export default class Optimizely extends BaseService implements Client {
    *
    * @return {Promise}
    */
-  close(): Promise<unknown> {
+  close(): Promise<unknown> {    
     this.stop();
     return this.onTerminated();
   }
 
   stop(): void {
+    if (this.isDone()) {
+      return;
+    }
+
+    this.startPromise.promise.then(() => {}, (err) => {});
+
+    if (!this.isRunning()) {
+      this.startPromise.reject(new OptimizelyError(SERVICE_STOPPED_BEFORE_RUNNING));
+    }
+
     this.state = ServiceState.Stopping;
 
     this.projectConfigManager.stop();
     this.eventProcessor?.stop();
     this.odpManager?.stop();
     this.notificationCenter.clearAllNotificationListeners();
 
-    Object.keys(this.readyTimeouts).forEach((readyTimeoutId: string) => {
-      const readyTimeoutRecord = this.readyTimeouts[readyTimeoutId];
-      clearTimeout(readyTimeoutRecord.readyTimeout);
-      readyTimeoutRecord.onClose();
-    });
+    this.cleanupTasks.forEach((onClose) => onClose());
 
     Promise.all([
       this.projectConfigManager.onTerminated(),
@@ -1305,30 +1315,26 @@ export default class Optimizely extends BaseService implements Client {
     }
 
     const timeoutPromise = resolvablePromise();
+    timeoutPromise.promise.catch(() => {});
 
-    const timeoutId = this.nextReadyTimeoutId++;
+    const cleanupTaskId = this.nextCleanupTaskId++;
 
     const onReadyTimeout = () => {
-      delete this.readyTimeouts[timeoutId];
+      this.cleanupTasks.delete(cleanupTaskId);
       timeoutPromise.reject(new OptimizelyError(ONREADY_TIMEOUT, timeoutValue));
     };
 
     const readyTimeout = setTimeout(onReadyTimeout, timeoutValue);
-    const onClose = function() {
-      timeoutPromise.reject(new OptimizelyError(INSTANCE_CLOSED));
-    };
-
-    this.readyTimeouts[timeoutId] = {
-      readyTimeout: readyTimeout,
-      onClose: onClose,
-    };
-
-    this.onRunning().then(() => {
+    
+    this.cleanupTasks.set(cleanupTaskId, () => {
       clearTimeout(readyTimeout);
-      delete this.readyTimeouts[timeoutId];
+      timeoutPromise.reject(new OptimizelyError(INSTANCE_CLOSED));
     });
 
-    return Promise.race([this.onRunning(), timeoutPromise]);
+    return Promise.race([this.onRunning().then(() => {
+      clearTimeout(readyTimeout);
+      this.cleanupTasks.delete(cleanupTaskId);
+    }), timeoutPromise]);
   }
 
   //============ decide ============//
@@ -1351,12 +1357,19 @@ export default class Optimizely extends BaseService implements Client {
       return null;
     }
 
-    return new OptimizelyUserContext({
+    const userContext = new OptimizelyUserContext({
       optimizely: this,
       userId: userIdentifier,
       attributes,
-      shouldIdentifyUser: true,
     });
+
+    this.onRunning().then(() => {
+      if (this.odpManager && this.isOdpIntegrated()) {
+        this.odpManager.identifyUser(userIdentifier);
+      }
+    }).catch(() => {});
+
+    return userContext;
   }
 
   /**
@@ -1375,7 +1388,6 @@ export default class Optimizely extends BaseService implements Client {
       optimizely: this,
       userId,
       attributes,
-      shouldIdentifyUser: false,
     });
   }
 
@@ -1662,9 +1674,7 @@ export default class Optimizely extends BaseService implements Client {
    * @param {string} userId
    */
   public identifyUser(userId: string): void {
-    if (this.odpManager && this.isOdpIntegrated()) {
-      this.odpManager.identifyUser(userId);
-    }
+    
   }
 
   /**

lib/optimizely_user_context/index.ts

@@ -30,7 +30,6 @@ interface OptimizelyUserContextConfig {
   optimizely: Optimizely;
   userId: string;
   attributes?: UserAttributes;
-  shouldIdentifyUser?: boolean;
 }
 
 export interface IOptimizelyUserContext {
@@ -57,25 +56,11 @@ export default class OptimizelyUserContext implements IOptimizelyUserContext {
   private forcedDecisionsMap: { [key: string]: { [key: string]: OptimizelyForcedDecision } };
   private _qualifiedSegments: string[] | null = null;
 
-  constructor({ optimizely, userId, attributes, shouldIdentifyUser = true }: OptimizelyUserContextConfig) {
+  constructor({ optimizely, userId, attributes }: OptimizelyUserContextConfig) {
     this.optimizely = optimizely;
     this.userId = userId;
     this.attributes = { ...attributes } ?? {};
     this.forcedDecisionsMap = {};
-
-    if (shouldIdentifyUser) {
-      this.optimizely.onReady().then(() => {
-        this.identifyUser();
-      }).catch(() => {});
-    }
-  }
-
-  /**
-   * On user context instantiation, fire event to attempt to identify user to ODP.
-   * Note: This fails if ODP is not enabled.
-   */
-  private identifyUser(): void {
-    this.optimizely.identifyUser(this.userId);
   }
 
   /**
@@ -235,7 +220,6 @@ export default class OptimizelyUserContext implements IOptimizelyUserContext {
 
   private cloneUserContext(): OptimizelyUserContext {
     const userContext = new OptimizelyUserContext({
-      shouldIdentifyUser: false,
       optimizely: this.getOptimizely(),
       userId: this.getUserId(),
       attributes: this.getAttributes(),

lib/service.ts

@@ -66,7 +66,7 @@ export abstract class BaseService implements Service {
     this.startPromise = resolvablePromise();
     this.stopPromise = resolvablePromise();
     this.startupLogs = startupLogs;
-    
+
     // avoid unhandled promise rejection
     this.startPromise.promise.catch(() => {});
     this.stopPromise.promise.catch(() => {});