@splitsoftware/splitio-commons 1.17.1-rc.2 → 1.17.1-rc.3

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IStorageAsyncFactory, IStorageFactoryParams, ITelemetryCacheAsync } from '../types';
 
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -62,11 +62,12 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory(params: IStorageFactoryParams) {
     const { onReadyCb, settings, settings: { log, mode, sync: { impressionsMode }, scheduler: { impressionsQueueSize, eventsQueueSize } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
+    let connectPromise: Promise<void>;
 
     const isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
@@ -89,35 +90,6 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
         new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
       undefined;
 
-    // Connects to wrapper and emits SDK_READY event on main client
-    const connectPromise = wrapper.connect().then(() => {
-      if (isSyncronizer) {
-        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-        return wrapper.get(keys.buildHashKey()).then((hash) => {
-          const currentHash = getStorageHash(settings);
-          if (hash !== currentHash) {
-            log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-            return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
-              return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
-            }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
-          }
-        }).then(() => {
-          onReadyCb();
-        });
-      } else {
-        // Start periodic flush of async storages if not running synchronizer (producer mode)
-        if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
-        if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
-        if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
-
-        onReadyCb();
-      }
-    }).catch((e) => {
-      e = e || new Error('Error connecting wrapper');
-      onReadyCb(e);
-      return e; // Propagate error for shared clients
-    });
-
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
@@ -127,6 +99,39 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       telemetry,
       uniqueKeys: uniqueKeysCache,
 
+      init() {
+        if (connectPromise) return connectPromise;
+
+        // Connects to wrapper and emits SDK_READY event on main client
+        return connectPromise = wrapper.connect().then(() => {
+          if (isSyncronizer) {
+            // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+            return wrapper.get(keys.buildHashKey()).then((hash) => {
+              const currentHash = getStorageHash(settings);
+              if (hash !== currentHash) {
+                log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+                return wrapper.getKeysByPrefix(`${keys.prefix}.`).then(storageKeys => {
+                  return Promise.all(storageKeys.map(storageKey => wrapper.del(storageKey)));
+                }).then(() => wrapper.set(keys.buildHashKey(), currentHash));
+              }
+            }).then(() => {
+              onReadyCb();
+            });
+          } else {
+            // Start periodic flush of async storages if not running synchronizer (producer mode)
+            if (impressionCountsCache && (impressionCountsCache as ImpressionCountsCachePluggable).start) (impressionCountsCache as ImpressionCountsCachePluggable).start();
+            if (uniqueKeysCache && (uniqueKeysCache as UniqueKeysCachePluggable).start) (uniqueKeysCache as UniqueKeysCachePluggable).start();
+            if (telemetry && (telemetry as ITelemetryCacheAsync).recordConfig) (telemetry as ITelemetryCacheAsync).recordConfig();
+
+            onReadyCb();
+          }
+        }).catch((e) => {
+          e = e || new Error('Error connecting wrapper');
+          onReadyCb(e);
+          return e; // Propagate error for shared clients
+        });
+      },
+
       // Stop periodic flush and disconnect the underlying storage
       destroy() {
         return Promise.all(isSyncronizer ? [] : [
@@ -136,8 +141,8 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       },
 
       // emits SDK_READY event on shared clients and returns a reference to the storage
-      shared(_, onReadyCb) {
-        connectPromise.then(onReadyCb);
+      shared(_: string, onReadyCb: (error?: any) => void) {
+        this.init().then(onReadyCb);
 
         return {
           ...this,

package/src/storages/types.ts

@@ -462,6 +462,7 @@ export interface IStorageBase<
   events: TEventsCache,
   telemetry?: TTelemetryCache,
   uniqueKeys?: TUniqueKeysCache,
+  init?: () => void | Promise<void>,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }

package/src/trackers/eventTracker.ts

@@ -16,6 +16,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -32,13 +33,15 @@ export function eventTrackerFactory(
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
         // Wrap in a timeout because we don't want it to be blocking.
-        setTimeout(function () {
-          // copy of event, to avoid unexpected behaviour if modified by integrations
-          const eventDataCopy = objectAssign({}, eventData);
-          if (properties) eventDataCopy.properties = objectAssign({}, properties);
-          // integrationsManager does not throw errors (they are internally handled by each integration module)
-          integrationsManager.handleEvent(eventDataCopy);
-        }, 0);
+        whenInit(() => {
+          setTimeout(() => {
+            // copy of event, to avoid unexpected behaviour if modified by integrations
+            const eventDataCopy = objectAssign({}, eventData);
+            if (properties) eventDataCopy.properties = objectAssign({}, properties);
+            // integrationsManager does not throw errors (they are internally handled by each integration module)
+            integrationsManager.handleEvent(eventDataCopy);
+          });
+        });
       }
     } else {
       log.error(ERROR_EVENTS_TRACKER, [msg]);

package/src/trackers/impressionsTracker.ts

@@ -19,6 +19,7 @@ export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
   strategy: IStrategy,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IImpressionsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
@@ -67,16 +68,18 @@ export function impressionsTrackerFactory(
           };
 
           // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(function () {
-            // integrationsManager.handleImpression does not throw errors
-            if (integrationsManager) integrationsManager.handleImpression(impressionData);
+          whenInit(() => {
+            setTimeout(() => {
+              // integrationsManager.handleImpression does not throw errors
+              if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-              if (impressionListener) impressionListener.logImpression(impressionData);
-            } catch (err) {
-              log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-            }
-          }, 0);
+              try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                if (impressionListener) impressionListener.logImpression(impressionData);
+              } catch (err) {
+                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+              }
+            });
+          });
         }
       }
     }

package/src/trackers/types.ts

@@ -65,6 +65,7 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+  start(): void;
   stop(): void;
   track(key: string, featureName: string): void;
 }

package/src/trackers/uniqueKeysTracker.ts

@@ -25,10 +25,6 @@ export function uniqueKeysTrackerFactory(
 ): IUniqueKeysTracker {
   let intervalId: any;
 
-  if (filterAdapter.refreshRate) {
-    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-  }
-
   return {
 
     track(key: string, featureName: string): void {
@@ -39,6 +35,12 @@ export function uniqueKeysTrackerFactory(
       uniqueKeysCache.track(key, featureName);
     },
 
+    start(): void {
+      if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+      }
+    },
+
     stop(): void {
       clearInterval(intervalId);
     }

package/types/readiness/types.d.ts

@@ -46,6 +46,7 @@ export interface IReadinessManager {
     timeout(): void;
     setDestroyed(): void;
     destroy(): void;
+    init(): void;
     /** for client-side */
     shared(): IReadinessManager;
 }

package/types/sdkFactory/types.d.ts

@@ -48,6 +48,7 @@ export interface ISdkFactoryContext {
     splitApi?: ISplitApi;
     syncManager?: ISyncManager;
     clients: Record<string, IBasicClient>;
+    whenInit(cb: () => void): void;
 }
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {
     storage: IStorageSync;
@@ -63,6 +64,7 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+    isPure?: boolean;
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;

package/types/storages/dataLoader.d.ts

@@ -17,5 +17,5 @@ export declare function loadData(preloadedData: SplitIO.PreloadedData, storage:
     splits?: ISplitsCacheSync;
     segments: ISegmentsCacheSync;
     largeSegments?: ISegmentsCacheSync;
-}, userKey?: string): void;
-export declare function getSnapshot(storage: IStorageSync, userKeys?: string[]): SplitIO.PreloadedData;
+}, matchingKey?: string): void;
+export declare function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData;

package/types/storages/types.d.ts

@@ -382,6 +382,7 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     events: TEventsCache;
     telemetry?: TTelemetryCache;
     uniqueKeys?: TUniqueKeysCache;
+    init?: () => void | Promise<void>;
     destroy(): void | Promise<void>;
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }

package/types/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -54,6 +54,7 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+    start(): void;
     stop(): void;
     track(key: string, featureName: string): void;
 }