Move SDK initialization logic together with destroy, since both use the same modules.

Author: EmilianoSanchez

src/sdkClient/sdkClient.ts

@@ -1,18 +1,19 @@
 import { objectAssign } from '../utils/lang/objectAssign';
 import SplitIO from '../../types/splitio';
-import { releaseApiKey } from '../utils/inputValidation/apiKey';
+import { releaseApiKey, validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { clientFactory } from './client';
 import { clientInputValidationDecorator } from './clientInputValidation';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 const COOLDOWN_TIME_IN_MILLIS = 1000;
 
 /**
- * Creates an Sdk client, i.e., a base client with status and destroy interface
+ * Creates an Sdk client, i.e., a base client with status, init, flush and destroy interface
  */
 export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: boolean): SplitIO.IClient | SplitIO.IAsyncClient {
   const { sdkReadinessManager, syncManager, storage, signalListener, settings, telemetryTracker, uniqueKeysTracker } = params;
 
+  let hasInit = false;
   let lastActionTime = 0;
 
   function __cooldown(func: Function, time: number) {
@@ -47,13 +48,27 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
       params.fallbackTreatmentsCalculator
     ),
 
-    // Sdk destroy
     {
+      init() {
+        if (hasInit) return;
+        hasInit = true;
+
+        if (!isSharedClient) {
+          validateAndTrackApiKey(settings.log, settings.core.authorizationKey);
+          sdkReadinessManager.readinessManager.init();
+          uniqueKeysTracker.start();
+          syncManager && syncManager.start();
+          signalListener && signalListener.start();
+        }
+      },
+
       flush() {
         // @TODO define cooldown time
         return __cooldown(__flush, COOLDOWN_TIME_IN_MILLIS);
       },
+
       destroy() {
+        hasInit = false;
         // Mark the SDK as destroyed immediately
         sdkReadinessManager.readinessManager.destroy();
 

src/sdkFactory/__tests__/index.spec.ts

@@ -7,7 +7,7 @@ import { FallbackTreatmentsCalculator } from '../../evaluator/fallbackTreatments
 
 /** Mocks */
 
-const clientInstance = { destroy: jest.fn() };
+const clientInstance = { init: jest.fn(), destroy: jest.fn() };
 const managerInstance = 'manager';
 const mockStorage = {
   splits: jest.fn(),
@@ -40,13 +40,10 @@ const paramsForAsyncSDK = {
   fallbackTreatmentsCalculator: new FallbackTreatmentsCalculator()
 };
 
-const SignalListenerInstanceMock = { start: jest.fn() };
-
 // IBrowserSDK, full params
 const fullParamsForSyncSDK = {
   ...paramsForAsyncSDK,
   syncManagerFactory: jest.fn(),
-  SignalListener: jest.fn(() => SignalListenerInstanceMock),
   impressionsObserverFactory: jest.fn(),
   platform: {
     getEventSource: jest.fn(),
@@ -79,10 +76,6 @@ function assertModulesCalled(params: any) {
   if (params.impressionsObserverFactory) {
     expect(params.impressionsObserverFactory).toBeCalledTimes(1);
   }
-  if (params.SignalListener) {
-    expect(params.SignalListener).toBeCalledTimes(1);
-    expect(SignalListenerInstanceMock.start).toBeCalledTimes(1);
-  }
   if (params.splitApiFactory) {
     expect(params.splitApiFactory.mock.calls).toEqual([[params.settings, params.platform, telemetryTrackerMock]]);
   }

src/sdkFactory/index.ts

@@ -4,7 +4,6 @@ import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import SplitIO from '../../types/splitio';
-import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
@@ -33,9 +32,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // initialization
-  let hasInit = false;
-
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
 
@@ -62,7 +58,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     if ((storage as IStorageSync).splits.getChangeNumber() > -1) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED, { initialCacheLoad: false /* Not an initial load, cache exists */ });
   }
 
-  const clients: Record<string, SplitIO.IBasicClient> = {};
+  const clients: Record<string, SplitIO.IBasicClient & { init: () => void }> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
@@ -87,6 +83,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
 
+  // @TODO: move into platform, and call inside sdkClientFactory (if it's used only there)
   const signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
   ctx.signalListener = signalListener;
 
@@ -96,15 +93,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
 
 
   function init() {
-    if (hasInit) return;
-    hasInit = true;
-
-    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-    validateAndTrackApiKey(log, settings.core.authorizationKey);
-    readiness.init();
-    uniqueKeysTracker.start();
-    syncManager && syncManager.start();
-    signalListener && signalListener.start();
+    Object.keys(clients).map(key => clients[key].init());
   }
 
   log.info(NEW_FACTORY, [settings.version]);
@@ -126,7 +115,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ISDK | SplitIO.IA
     settings,
 
     destroy() {
-      hasInit = false;
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
   }, extraProps && extraProps(ctx), lazyInit ? { init } : init());

src/sdkFactory/types.ts

@@ -98,7 +98,11 @@ export interface ISdkFactoryParams {
 
   // Sdk client method factory.
   // It Allows to distinguish SDK clients with the client-side API (`IBrowserSDK` and `IBrowserAsyncSDK`) or server-side API (`ISDK` and `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.IBrowserClient; (key: SplitIO.SplitKey): SplitIO.IBrowserClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => (
+    { (): SplitIO.IBrowserClient & { init(): void }; (key: SplitIO.SplitKey): SplitIO.IBrowserClient & { init(): void }; } |
+    (() => SplitIO.IClient & { init(): void }) |
+    (() => SplitIO.IAsyncClient & { init(): void })
+  )
 
   // Impression observer factory.
   impressionsObserverFactory: () => IImpressionObserver