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

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/index.js

@@ -55,7 +55,6 @@ export function PluggableStorage(options) {
         var metadata = metadataBuilder(settings);
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
-        var connectPromise;
         var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
         var telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
@@ -73,6 +72,37 @@ export function PluggableStorage(options) {
                 settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
             undefined;
+        // Connects to wrapper and emits SDK_READY event on main client
+        var connectPromise = wrapper.connect().then(function () {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var 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(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(function () {
+                    onReadyCb();
+                });
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+                onReadyCb();
+            }
+        }).catch(function (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),
@@ -81,41 +111,6 @@ export function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            init: function () {
-                if (connectPromise)
-                    return connectPromise;
-                // Connects to wrapper and emits SDK_READY event on main client
-                return connectPromise = wrapper.connect().then(function () {
-                    if (isSyncronizer) {
-                        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-                        return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                            var 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(function (storageKeys) {
-                                    return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                                }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                            }
-                        }).then(function () {
-                            onReadyCb();
-                        });
-                    }
-                    else {
-                        // Start periodic flush of async storages if not running synchronizer (producer mode)
-                        if (impressionCountsCache && impressionCountsCache.start)
-                            impressionCountsCache.start();
-                        if (uniqueKeysCache && uniqueKeysCache.start)
-                            uniqueKeysCache.start();
-                        if (telemetry && telemetry.recordConfig)
-                            telemetry.recordConfig();
-                        onReadyCb();
-                    }
-                }).catch(function (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: function () {
                 return Promise.all(isSyncronizer ? [] : [
@@ -125,7 +120,7 @@ export function PluggableStorage(options) {
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                this.init().then(onReadyCb);
+                connectPromise.then(onReadyCb);
                 return __assign(__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

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/offline/syncTasks/fromObjectSyncTask.js

@@ -1,7 +1,7 @@
 import { forOwn } from '../../../utils/lang';
 import { syncTaskFactory } from '../../syncTask';
 import { CONTROL } from '../../../utils/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 { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -43,8 +43,13 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    // Emits SDK_READY
-                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                    Promise.resolve(splitsCache.checkCache()).then(function (cacheReady) {
+                        // Emits SDK_READY_FROM_CACHE
+                        if (cacheReady)
+                            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+                        // Emits SDK_READY
+                        readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+                    });
                 }
                 return true;
             });

package/esm/sync/polling/pollingManagerSS.js

@@ -1,6 +1,5 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -19,9 +18,10 @@ export function pollingManagerSSFactory(params) {
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

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(x.name, 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

@@ -1,6 +1,6 @@
 import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 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';
@@ -121,7 +121,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            return Promise.resolve(splitUpdateNotification ?
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,6 +165,15 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 return false;
             });
+            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+            // Wrapping in a promise since checkCache can be async.
+            if (splitsEventEmitter && startingUp) {
+                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
+                    if (isCacheReady)
+                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+                });
+            }
+            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

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

@@ -19,8 +19,8 @@ export function eventTrackerFactory(settings, eventsCache, whenInit, integration
         if (tracked) {
             log.info(EVENTS_TRACKER_SUCCESS, [msg]);
             if (integrationsManager) {
-                // Wrap in a timeout because we don't want it to be blocking.
                 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);

package/esm/trackers/impressionsTracker.js

@@ -50,8 +50,8 @@ export function impressionsTrackerFactory(settings, impressionsCache, strategy,
                         hostname: hostname,
                         sdkLanguageVersion: version
                     };
-                    // Wrap in a timeout because we don't want it to be blocking.
                     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)

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -1,6 +1,12 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
 import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+export function __InLocalStorageMockFactory(params) {
+    var result = InMemoryStorageCSFactory(params);
+    result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
+    return result;
+}
+__InLocalStorageMockFactory.type = STORAGE_MEMORY;
 /**
  * This function validates `settings.storage` object
  *
@@ -17,6 +23,10 @@ export function validateStorageCS(settings) {
         storage = InMemoryStorageCSFactory;
         log.error(ERROR_STORAGE_INVALID);
     }
+    // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
+    if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
+        return __InLocalStorageMockFactory;
+    }
     if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
         // Consumer modes require an async storage
         if (storage.type !== STORAGE_PLUGGABLE)

package/package.json

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

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:
@@ -55,7 +57,6 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
-  let readyTimeoutId: ReturnType<typeof setTimeout>;
 
   function timeout() { // eslint-disable-next-line no-use-before-define
     if (hasTimedout || isReady) return;
@@ -64,6 +65,12 @@ export function readinessManagerFactory(
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
   }
 
+  let readyTimeoutId: ReturnType<typeof setTimeout>;
+  if (readyTimeout > 0) {
+    if (splits.initialized) readyTimeoutId = setTimeout(timeout, readyTimeout);
+    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
+  }
+
   // emit SDK_READY and SDK_UPDATE
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
@@ -129,9 +136,9 @@ export function readinessManagerFactory(
     setDestroyed() { isDestroyed = true; },
 
     init() {
-      if (readyTimeout > 0) {
-        readyTimeoutId = setTimeout(timeout, readyTimeout);
-      }
+      if (splits.initialized) return;
+      splits.initialized = true;
+      splits.initCallbacks.forEach(cb => cb());
     },
 
     destroy() {

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 */

package/src/sdkClient/sdkClientMethodCS.ts

@@ -15,7 +15,7 @@ import { buildInstanceId } from './identity';
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log }, whenInit } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -75,11 +75,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validKey
       );
 
-      whenInit(() => {
-        sharedSdkReadiness.readinessManager.init();
-        sharedSyncManager && sharedSyncManager.start();
-      });
-
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -17,7 +17,7 @@ import { buildInstanceId } from './identity';
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log }, whenInit } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -86,11 +86,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validTrafficType
       );
 
-      whenInit(() => {
-        sharedSdkReadiness.readinessManager.init();
-        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, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -23,18 +23,18 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory, isPure } = 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.
 
   // initialization
-  let isInit = false;
+  let hasInit = false;
   const initCallbacks: (() => void)[] = [];
 
   function whenInit(cb: () => void) {
-    if (isInit) cb();
+    if (hasInit) cb();
     else initCallbacks.push(cb);
   }
 
@@ -52,11 +52,8 @@ 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 });
@@ -82,7 +79,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform, whenInit };
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -96,13 +93,12 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
 
   function init() {
-    if (isInit) return;
-    isInit = true;
+    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();
-    storage.init && storage.init();
     uniqueKeysTracker && uniqueKeysTracker.start();
     syncManager && syncManager.start();
     signalListener && signalListener.start();
@@ -111,8 +107,6 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     initCallbacks.length = 0;
   }
 
-  if (!isPure) init();
-
   log.info(NEW_FACTORY);
 
   // @ts-ignore
@@ -134,5 +128,5 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     destroy() {
       return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
-  }, extraProps && extraProps(ctx), isPure && { init });
+  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
 }