@splitsoftware/splitio-commons 2.0.0-rc.0 → 2.0.0-rc.2

package/esm/storages/inRedis/UniqueKeysCacheInRedis.js

@@ -2,6 +2,7 @@ import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
 var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
     __extends(UniqueKeysCacheInRedis, _super);
     function UniqueKeysCacheInRedis(log, key, redis, uniqueKeysQueueSize, refreshRate) {
@@ -21,7 +22,7 @@ var UniqueKeysCacheInRedis = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/SegmentsCachePluggable.js

@@ -12,32 +12,19 @@ var SegmentsCachePluggable = /** @class */ (function () {
         this.wrapper = wrapper;
     }
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    SegmentsCachePluggable.prototype.addToSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.addItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    SegmentsCachePluggable.prototype.removeFromSegment = function (name, segmentKeys) {
+    SegmentsCachePluggable.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.removeItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
+        return Promise.all([
+            addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+            removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+            this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
@@ -46,14 +33,6 @@ var SegmentsCachePluggable = /** @class */ (function () {
     SegmentsCachePluggable.prototype.isInSegment = function (name, key) {
         return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
     };
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '');
-    };
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/esm/storages/pluggable/UniqueKeysCachePluggable.js

@@ -2,6 +2,7 @@ import { __extends } from "tslib";
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
+import { setToArray } from '../../utils/lang/sets';
 var UniqueKeysCachePluggable = /** @class */ (function (_super) {
     __extends(UniqueKeysCachePluggable, _super);
     function UniqueKeysCachePluggable(log, key, wrapper, uniqueKeysQueueSize, refreshRate) {
@@ -21,7 +22,7 @@ var UniqueKeysCachePluggable = /** @class */ (function (_super) {
         if (!featureNames.length)
             return Promise.resolve(false);
         var uniqueKeysArray = featureNames.map(function (featureName) {
-            var featureKeys = Array.from(_this.uniqueKeysTracker[featureName]);
+            var featureKeys = setToArray(_this.uniqueKeysTracker[featureName]);
             var uniqueKeysPayload = {
                 f: featureName,
                 ks: featureKeys

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -1,4 +1,5 @@
 import { startsWith, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
@@ -115,7 +116,7 @@ export function inMemoryWrapperFactory(connDelay) {
             if (!set)
                 return Promise.resolve([]);
             if (set instanceof Set)
-                return Promise.resolve(Array.from(set));
+                return Promise.resolve(setToArray(set));
             return Promise.reject('key is not a set');
         },
         // always connects and disconnects

package/esm/sync/offline/syncManagerOffline.js

@@ -16,23 +16,30 @@ export function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return objectAssign(fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings), {
+        var mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
+        var mainStart = mainSyncManager.start;
+        var sharedStarts = [];
+        return objectAssign(mainSyncManager, {
+            start: function () {
+                mainStart();
+                sharedStarts.forEach(function (cb) { return cb(); });
+                sharedStarts.length = 0;
+            },
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]
             shared: function (matchingKey, readinessManager) {
+                // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+                // SDK_READY cannot be emitted directly because this will not update the readiness status
+                function emitSdkReady() {
+                    readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+                }
+                if (mainSyncManager.isRunning())
+                    setTimeout(emitSdkReady);
+                else
+                    sharedStarts.push(emitSdkReady);
                 return {
-                    start: function () {
-                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-                        // SDK_READY cannot be emitted directly because this will not update the readiness status
-                        setTimeout(function () {
-                            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-                        }, 0);
-                    },
                     stop: function () { },
-                    isRunning: function () {
-                        return true;
-                    },
                     flush: flush,
                 };
             }

package/esm/sync/polling/updaters/segmentChangesUpdater.js

@@ -1,7 +1,5 @@
-import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { thenable } from '../../../utils/promise/thenable';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -20,27 +18,16 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            if (fetchOnlyNew && since !== -1)
-                return -1;
-            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-                var changeNumber = -1;
-                var results = [];
-                changes.forEach(function (x) {
-                    if (x.added.length > 0)
-                        results.push(segments.addToSegment(segmentName, x.added));
-                    if (x.removed.length > 0)
-                        results.push(segments.removeFromSegment(segmentName, x.removed));
-                    if (x.added.length > 0 || x.removed.length > 0) {
-                        results.push(segments.setChangeNumber(segmentName, x.till));
-                        changeNumber = x.till;
-                    }
-                    log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+            return fetchOnlyNew && since !== -1 ?
+                false :
+                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+                    return Promise.all(changes.map(function (x) {
+                        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
+                        return segments.update(segmentName, x.added, x.removed, x.till);
+                    })).then(function (updates) {
+                        return updates.some(function (update) { return update; });
+                    });
                 });
-                // If at least one storage operation result is a promise, join all in a single promise.
-                if (results.some(function (result) { return thenable(result); }))
-                    return Promise.all(results).then(function () { return changeNumber; });
-                return changeNumber;
-            });
         });
     }
     /**
@@ -59,14 +46,11 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers are collected here.
-            var updaters = [];
-            for (var index = 0; index < segmentNames.length; index++) {
-                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-            }
+            // Async fetchers
+            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if (findIndex(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
+                if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -3,6 +3,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
+import { setToArray } from '../../../utils/lang/sets';
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
 // @TODO review together with Segments and MySegments storage APIs
@@ -67,7 +68,7 @@ export function computeSplitsMutation(entries, filters) {
         }
         return accum;
     }, { added: [], removed: [], segments: [] });
-    computed.segments = Array.from(segments);
+    computed.segments = setToArray(segments);
     return computed;
 }
 /**

package/esm/sync/syncManagerOnline.js

@@ -115,33 +115,32 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 if (!pollingManager)
                     return;
                 var mySegmentsSyncTask = pollingManager.add(matchingKey, readinessManager, storage);
-                return {
-                    isRunning: mySegmentsSyncTask.isRunning,
-                    start: function () {
-                        if (syncEnabled) {
-                            if (pushManager) {
-                                if (pollingManager.isRunning()) {
-                                    // if doing polling, we must start the periodic fetch of data
-                                    if (storage.splits.usesSegments())
-                                        mySegmentsSyncTask.start();
-                                }
-                                else {
-                                    // if not polling, we must execute the sync task for the initial fetch
-                                    // of segments since `syncAll` was already executed when starting the main client
-                                    mySegmentsSyncTask.execute();
-                                }
-                                pushManager.add(matchingKey, mySegmentsSyncTask);
-                            }
-                            else {
+                if (running) {
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            if (pollingManager.isRunning()) {
+                                // if doing polling, we must start the periodic fetch of data
                                 if (storage.splits.usesSegments())
                                     mySegmentsSyncTask.start();
                             }
+                            else {
+                                // if not polling, we must execute the sync task for the initial fetch
+                                // of segments since `syncAll` was already executed when starting the main client
+                                mySegmentsSyncTask.execute();
+                            }
+                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (!readinessManager.isReady())
-                                mySegmentsSyncTask.execute();
+                            if (storage.splits.usesSegments())
+                                mySegmentsSyncTask.start();
                         }
-                    },
+                    }
+                    else {
+                        if (!readinessManager.isReady())
+                            mySegmentsSyncTask.execute();
+                    }
+                }
+                return {
                     stop: function () {
                         // check in case `client.destroy()` has been invoked more than once for the same client
                         var mySegmentsSyncTask = pollingManager.get(matchingKey);

package/esm/trackers/eventTracker.js

@@ -9,7 +9,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export function eventTrackerFactory(settings, eventsCache, integrationsManager, telemetryCache) {
+export function eventTrackerFactory(settings, eventsCache, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, mode = settings.mode;
     var isAsync = isConsumerMode(mode);
     function queueEventsCallback(eventData, tracked) {
@@ -19,15 +19,17 @@ export function eventTrackerFactory(settings, eventsCache, integrationsManager,
         if (tracked) {
             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
-                    var 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(function () {
+                    // 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
+                        var 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 {

package/esm/trackers/impressionsTracker.js

@@ -11,7 +11,7 @@ import { CONSENT_DECLINED, DEDUPED, QUEUED } from '../utils/constants';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export function impressionsTrackerFactory(settings, impressionsCache, strategy, integrationsManager, telemetryCache) {
+export function impressionsTrackerFactory(settings, impressionsCache, strategy, whenInit, integrationsManager, telemetryCache) {
     var log = settings.log, impressionListener = settings.impressionListener, _a = settings.runtime, ip = _a.ip, hostname = _a.hostname, version = settings.version;
     return {
         track: function (impressions, attributes) {
@@ -50,19 +50,21 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    // 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);
-                        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);
+                    whenInit(function () {
+                        // 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);
+                            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]);
+                            }
+                        });
+                    });
                 };
                 for (var i = 0; i < impressionsToListenerCount; i++) {
                     _loop_1(i);

package/esm/trackers/uniqueKeysTracker.js

@@ -16,9 +16,6 @@ var noopFilterAdapter = {
 export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
     if (filterAdapter === void 0) { filterAdapter = noopFilterAdapter; }
     var intervalId;
-    if (filterAdapter.refreshRate) {
-        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-    }
     return {
         track: function (key, featureName) {
             if (!filterAdapter.add(key, featureName)) {
@@ -27,6 +24,11 @@ export function uniqueKeysTrackerFactory(log, uniqueKeysCache, filterAdapter) {
             }
             uniqueKeysCache.track(key, featureName);
         },
+        start: function () {
+            if (filterAdapter.refreshRate) {
+                intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+            }
+        },
         stop: function () {
             clearInterval(intervalId);
         }

package/esm/utils/lang/sets.js

@@ -1,5 +1,14 @@
+export function setToArray(set) {
+    if (Array.from)
+        return Array.from(set);
+    var array = [];
+    set.forEach(function (value) {
+        array.push(value);
+    });
+    return array;
+}
 export function returnSetsUnion(set, set2) {
-    return new Set(Array.from(set).concat(Array.from(set2)));
+    return new Set(setToArray(set).concat(setToArray(set2)));
 }
 export function returnDifference(list, list2) {
     if (list === void 0) { list = []; }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "2.0.0-rc.0",
+  "version": "2.0.0-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/Engine.ts

@@ -21,7 +21,7 @@ export class Engine {
 
   constructor(private baseInfo: ISplit, private evaluator: IEvaluator) {
 
-    // in case we don't have a default treatment in the instanciation, use 'control'
+    // in case we don't have a default treatment in the instantiation, use 'control'
     if (typeof this.baseInfo.defaultTreatment !== 'string') {
       this.baseInfo.defaultTreatment = CONTROL;
     }

package/src/evaluator/index.ts

@@ -7,7 +7,7 @@ import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
-import { returnSetsUnion } from '../utils/lang/sets';
+import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
 const treatmentException = {
@@ -113,7 +113,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
       {};
   }
 

package/src/readiness/readinessManager.ts

@@ -7,6 +7,8 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
     splitsArrived: false,
     splitsCacheLoaded: false,
+    initialized: false,
+    initCallbacks: []
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
@@ -56,8 +58,8 @@ export function readinessManagerFactory(
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
 
-  function timeout() {
-    if (hasTimedout) return;
+  function timeout() { // eslint-disable-next-line no-use-before-define
+    if (hasTimedout || isReady) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
@@ -65,7 +67,8 @@ export function readinessManagerFactory(
 
   let readyTimeoutId: ReturnType<typeof setTimeout>;
   if (readyTimeout > 0) {
-    readyTimeoutId = setTimeout(timeout, readyTimeout);
+    if (splits.initialized) readyTimeoutId = setTimeout(timeout, readyTimeout);
+    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
   }
 
   // emit SDK_READY and SDK_UPDATE
@@ -132,6 +135,12 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
+    init() {
+      if (splits.initialized) return;
+      splits.initialized = true;
+      splits.initCallbacks.forEach(cb => cb());
+    },
+
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/types.ts

@@ -12,6 +12,8 @@ export interface ISplitsEventEmitter extends IEventEmitter {
   once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
   splitsArrived: boolean
   splitsCacheLoaded: boolean
+  initialized: boolean,
+  initCallbacks: (() => void)[]
 }
 
 /** Segments data emitter */
@@ -59,6 +61,7 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
+  init(): void,
 
   /** for client-side */
   shared(): IReadinessManager,

package/src/sdkClient/sdkClientMethodCS.ts

@@ -75,8 +75,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validKey
       );
 
-      sharedSyncManager && sharedSyncManager.start();
-
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 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 } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -23,21 +23,27 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    filterAdapterFactory, lazyInit } = params;
   const { log, sync: { impressionsMode } } = settings;
 
   // @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.
 
-  // 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);
+  // initialization
+  let hasInit = false;
+  const initCallbacks: (() => void)[] = [];
+
+  function whenInit(cb: () => void) {
+    if (hasInit) cb();
+    else initCallbacks.push(cb);
+  }
 
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
 
   const storage = storageFactory({
     settings,
-    onReadyCb: (error) => {
+    onReadyCb(error) {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -46,8 +52,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
+    onReadyFromCacheCb() {
+      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    }
   });
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
@@ -67,8 +76,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
@@ -85,8 +94,21 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-  syncManager && syncManager.start();
-  signalListener && signalListener.start();
+
+  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 && uniqueKeysTracker.start();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
+
+    initCallbacks.forEach((cb) => cb());
+    initCallbacks.length = 0;
+  }
 
   log.info(NEW_FACTORY);
 
@@ -107,7 +129,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     settings,
 
     destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => {});
+      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
-  }, extraProps && extraProps(ctx));
+  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
 }

package/src/sdkFactory/types.ts

@@ -68,6 +68,8 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
+  lazyInit?: boolean,
 
   // The settings must be already validated
   settings: ISettings,