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

package/esm/sdkClient/sdkClientMethodCSWithTT.js

@@ -6,23 +6,19 @@ import { sdkClientFactory } from './sdkClient';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
-function buildInstanceId(key, trafficType) {
-    // @ts-ignore
-    return (key.matchingKey ? key.matchingKey : key) + "-" + (key.bucketingKey ? key.bucketingKey : key) + "-" + (trafficType !== undefined ? trafficType : '');
-}
+import { buildInstanceId } from './identity';
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
  * where clients can have a bound TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params) {
-    var storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
+    var clients = params.clients, storage = params.storage, syncManager = params.syncManager, sdkReadinessManager = params.sdkReadinessManager, _a = params.settings, _b = _a.core, key = _b.key, trafficType = _b.trafficType, log = _a.log;
     var mainClientInstance = clientCSDecorator(log, sdkClientFactory(params), key, trafficType);
     var parsedDefaultKey = keyParser(key);
     var defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
     // Cache instances created per factory.
-    var clientInstances = {};
-    clientInstances[defaultInstanceId] = mainClientInstance;
+    clients[defaultInstanceId] = mainClientInstance;
     return function client(key, trafficType) {
         if (key === undefined) {
             log.debug(RETRIEVE_CLIENT_DEFAULT);
@@ -41,7 +37,7 @@ export function sdkClientMethodCSFactory(params) {
             }
         }
         var instanceId = buildInstanceId(validKey, validTrafficType);
-        if (!clientInstances[instanceId]) {
+        if (!clients[instanceId]) {
             var matchingKey = getMatching(validKey);
             var sharedSdkReadiness_1 = sdkReadinessManager.shared();
             var sharedStorage = storage.shared && storage.shared(matchingKey, function (err) {
@@ -60,11 +56,10 @@ export function sdkClientMethodCSFactory(params) {
             var sharedSyncManager = syncManager && sharedStorage && syncManager.shared(matchingKey, sharedSdkReadiness_1.readinessManager, sharedStorage);
             // As shared clients reuse all the storage information, we don't need to check here if we
             // will use offline or online mode. We should stick with the original decision.
-            clientInstances[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
+            clients[instanceId] = clientCSDecorator(log, sdkClientFactory(objectAssign({}, params, {
                 sdkReadinessManager: sharedSdkReadiness_1,
                 storage: sharedStorage || storage,
                 syncManager: sharedSyncManager,
-                signalListener: undefined, // only the main client "destroy" method stops the signal listener
             }), true), validKey, validTrafficType);
             sharedSyncManager && sharedSyncManager.start();
             log.info(NEW_SHARED_CLIENT);
@@ -72,6 +67,6 @@ export function sdkClientMethodCSFactory(params) {
         else {
             log.debug(RETRIEVE_CLIENT_EXISTING);
         }
-        return clientInstances[instanceId];
+        return clients[instanceId];
     };
 }

package/esm/sdkFactory/index.js

@@ -5,7 +5,7 @@ import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 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';
@@ -35,8 +35,11 @@ export function sdkFactory(params) {
             readiness.splits.emit(SDK_SPLITS_ARRIVED);
             readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         },
+        onReadyFromCacheCb: function () {
+            readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+        }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    var clients = {};
     var telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });
     var observer = impressionsObserverFactory();
@@ -56,7 +59,7 @@ export function sdkFactory(params) {
     var eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
     // splitApi is used by SyncManager and Browser signal listener
     var splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
-    var ctx = { splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
+    var ctx = { clients: clients, splitApi: splitApi, eventTracker: eventTracker, impressionsTracker: impressionsTracker, telemetryTracker: telemetryTracker, uniqueKeysTracker: uniqueKeysTracker, sdkReadinessManager: sdkReadinessManager, readiness: readiness, settings: settings, storage: storage, platform: platform };
     var syncManager = syncManagerFactory && syncManagerFactory(ctx);
     ctx.syncManager = syncManager;
     var signalListener = SignalListener && new SignalListener(syncManager, settings, storage, splitApi);
@@ -79,5 +82,8 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(log),
         settings: settings,
+        destroy: function () {
+            return Promise.all(Object.keys(clients).map(function (key) { return clients[key].destroy(); })).then(function () { });
+        }
     }, extraProps && extraProps(ctx));
 }

package/esm/storages/AbstractSplitsCacheAsync.js

@@ -11,13 +11,6 @@ var AbstractSplitsCacheAsync = /** @class */ (function () {
     AbstractSplitsCacheAsync.prototype.usesSegments = function () {
         return Promise.resolve(true);
     };
-    /**
-     * Check if the splits information is already stored in cache.
-     * Noop, just keeping the interface. This is used by client-side implementations only.
-     */
-    AbstractSplitsCacheAsync.prototype.checkCache = function () {
-        return Promise.resolve(false);
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/esm/storages/AbstractSplitsCacheSync.js

@@ -27,13 +27,6 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
         var _this = this;
         return this.getSplitNames().map(function (key) { return _this.getSplit(key); });
     };
-    /**
-     * Check if the splits information is already stored in cache. This data can be preloaded.
-     * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
-     */
-    AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
-    };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.
      * Used for SPLIT_KILL push notifications.

package/esm/storages/dataLoader.js

@@ -1,47 +1,79 @@
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { setToArray } from '../utils/lang/sets';
 /**
- * Factory of client-side storage loader
+ * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+ * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
- * and extended with a `mySegmentsData` property.
- * @returns function to preload the storage
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
+ * @param storage object containing `splits` and `segments` cache (client-side variant)
+ * @param userKey user key (matching key) of the provided MySegmentsCache
+ *
+ * @TODO extend to load largeSegments
+ * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+ * @TODO add logs, and input validation in this module, in favor of size reduction.
+ * @TODO unit tests
  */
-export function dataLoaderFactory(preloadedData) {
-    /**
-     * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
-     * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
-     *
-     * @param storage object containing `splits` and `segments` cache (client-side variant)
-     * @param userId user key string of the provided MySegmentsCache
-     *
-     * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
-     * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
-     */
-    return function loadData(storage, userId) {
-        // Do not load data if current preloadedData is empty
-        if (Object.keys(preloadedData).length === 0)
-            return;
-        var _a = preloadedData.lastUpdated, lastUpdated = _a === void 0 ? -1 : _a, _b = preloadedData.segmentsData, segmentsData = _b === void 0 ? {} : _b, _c = preloadedData.since, since = _c === void 0 ? -1 : _c, _d = preloadedData.splitsData, splitsData = _d === void 0 ? {} : _d;
+export function loadData(preloadedData, storage, userKey) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0)
+        return;
+    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
+    if (storage.splits) {
         var storedSince = storage.splits.getChangeNumber();
-        var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
-        // Do not load data if current localStorage data is more recent,
-        // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
-        if (storedSince > since || lastUpdated < expirationTimestamp)
+        // Do not load data if current data is more recent
+        if (storedSince > since)
             return;
         // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
         storage.splits.clear();
         storage.splits.setChangeNumber(since);
         // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-        storage.splits.addSplits(Object.keys(splitsData).map(function (splitName) { return JSON.parse(splitsData[splitName]); }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (userKey) { // add mySegments data (client-side)
+        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
         if (!mySegmentsData) {
             // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
             mySegmentsData = Object.keys(segmentsData).filter(function (segmentName) {
-                var userIds = JSON.parse(segmentsData[segmentName]).added;
-                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+                var userKeys = segmentsData[segmentName];
+                return userKeys.indexOf(userKey) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).filter(function (segmentName) {
+            var userKeys = segmentsData[segmentName];
+            storage.segments.addToSegment(segmentName, userKeys);
+        });
+    }
+}
+export function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        // @ts-ignore accessing private prop
+        since: storage.splits.changeNumber,
+        splitsData: storage.splits.getAll(),
+        segmentsData: userKeys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        mySegmentsData: userKeys ?
+            userKeys.reduce(function (prev, userKey) {
+                // @ts-ignore accessing private prop
+                prev[userKey] = storage.shared ?
+                    // Client-side segments
+                    // @ts-ignore accessing private prop
+                    Object.keys(storage.shared(userKey).segments.segmentCache) :
+                    // Server-side segments
+                    // @ts-ignore accessing private prop
+                    Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                        return storage.segments.segmentCache[segmentName].has(userKey) ?
+                            prev.concat(segmentName) :
+                            prev;
+                    }, []);
+                return prev;
+            }, {}) :
+            undefined
     };
 }

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -183,14 +183,6 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
             return true;
         }
     };
-    /**
-     * Check if the splits information is already stored in browser LocalStorage.
-     * In this function we could add more code to check if the data is valid.
-     * @override
-     */
-    SplitsCacheInLocal.prototype.checkCache = function () {
-        return this.getChangeNumber() > -1;
-    };
     /**
      * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
      *
@@ -213,7 +205,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
                 // mark cache to update the new query filter on first successful splits fetch
                 this.updateNewFilter = true;
                 // if there is cache, clear it
-                if (this.checkCache())
+                if (this.getChangeNumber() > -1)
                     this.clear();
             }
             catch (e) {

package/esm/storages/inLocalStorage/index.js

@@ -11,7 +11,7 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
@@ -27,13 +27,16 @@ export function InLocalStorage(options) {
             params.settings.log.warn(LOG_PREFIX + 'LocalStorage API is unavailable. Falling back to default MEMORY storage');
             return InMemoryStorageCSFactory(params);
         }
-        var settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+        var onReadyFromCacheCb = params.onReadyFromCacheCb, settings = params.settings, _a = params.settings, log = _a.log, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
         var matchingKey = getMatching(settings.core.key);
         var keys = new KeyBuilderCS(prefix, matchingKey);
         var expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
         var splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
         var segments = new MySegmentsCacheInLocal(log, keys);
         var largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
+        if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
+            Promise.resolve().then(onReadyFromCacheCb);
+        }
         return {
             splits: splits,
             segments: segments,

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,13 +6,15 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
+import { getMatching } from '../../utils/key';
+import { loadData } from '../dataLoader';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params) {
-    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
@@ -36,11 +38,16 @@ export function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
+        shared: function (matchingKey) {
+            var segments = new MySegmentsCacheInMemory();
+            var largeSegments = new MySegmentsCacheInMemory();
+            if (preloadedData) {
+                loadData(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
+            }
             return {
                 splits: this.splits,
-                segments: new MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory(),
+                segments: segments,
+                largeSegments: largeSegments,
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -65,6 +72,11 @@ export function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
+    if (preloadedData) {
+        loadData(preloadedData, storage, getMatching(params.settings.core.key));
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 InMemoryStorageCSFactory.type = STORAGE_MEMORY;

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, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 /**
  * Offline equivalent of `splitChangesUpdaterFactory`
@@ -43,13 +43,8 @@ export function fromObjectUpdaterFactory(splitsParser, storage, readiness, setti
                 readiness.splits.emit(SDK_SPLITS_ARRIVED);
                 if (startingUp) {
                     startingUp = false;
-                    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);
-                    });
+                    // Emits SDK_READY
+                    readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
                 }
                 return true;
             });

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, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED } 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]);
-            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
+            return Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,15 +165,6 @@ 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/utils/settingsValidation/storage/storageCS.js

@@ -1,12 +1,6 @@
 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
  *
@@ -23,10 +17,6 @@ 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.0",
+  "version": "1.17.1-rc.2",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/sdkClient/identity.ts

@@ -0,0 +1,5 @@
+import { SplitIO } from '../types';
+
+export function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) { // @ts-ignore
+  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType ? trafficType : ''}`;
+}

package/src/sdkClient/sdkClient.ts

@@ -66,11 +66,11 @@ export function sdkClientFactory(params: ISdkFactoryContext, isSharedClient?: bo
         syncManager && syncManager.stop();
 
         return __flush().then(() => {
-          // Cleanup event listeners
-          signalListener && signalListener.stop();
-
-          // @TODO stop only if last client is destroyed
-          if (uniqueKeysTracker) uniqueKeysTracker.stop();
+          // For main client, cleanup event listeners and scheduled jobs
+          if (!isSharedClient) {
+            signalListener && signalListener.stop();
+            uniqueKeysTracker && uniqueKeysTracker.stop();
+          }
 
           // Cleanup storage
           return storage.destroy();

package/src/sdkClient/sdkClientMethod.ts

@@ -4,12 +4,15 @@ import { RETRIEVE_CLIENT_DEFAULT } from '../logger/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
 /**
- * Factory of client method for server-side SDKs (ISDK and IAsyncSDK)
+ * Factory of client method for server-side SDKs
  */
 export function sdkClientMethodFactory(params: ISdkFactoryContext): () => SplitIO.IClient | SplitIO.IAsyncClient {
   const log = params.settings.log;
   const clientInstance = sdkClientFactory(params);
 
+  // Only one client in server-side without bound key
+  params.clients[''] = clientInstance;
+
   return function client() {
     if (arguments.length > 0) {
       throw new Error('Shared Client not supported by the storage mechanism. Create isolated instances instead.');

package/src/sdkClient/sdkClientMethodCS.ts

@@ -8,18 +8,14 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-
-function buildInstanceId(key: SplitIO.SplitKey) {
-  // @ts-ignore
-  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
-}
+import { buildInstanceId } from './identity';
 
 /**
  * Factory of client method for the client-side API variant where TT is ignored.
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -31,8 +27,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
-  clientInstances[defaultInstanceId] = mainClientInstance;
+  clients[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey) {
     if (key === undefined) {
@@ -48,7 +43,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
     const instanceId = buildInstanceId(validKey);
 
-    if (!clientInstances[instanceId]) {
+    if (!clients[instanceId]) {
       const matchingKey = getMatching(validKey);
 
       const sharedSdkReadiness = sdkReadinessManager.shared();
@@ -70,13 +65,12 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clientInstances[instanceId] = clientCSDecorator(
+      clients[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
-          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey
       );
@@ -88,6 +82,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clientInstances[instanceId];
+    return clients[instanceId] as SplitIO.ICsClient;
   };
 }

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -9,11 +9,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-
-function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
-  // @ts-ignore
-  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
-}
+import { buildInstanceId } from './identity';
 
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
@@ -21,7 +17,7 @@ function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
+  const { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -34,8 +30,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
-  clientInstances[defaultInstanceId] = mainClientInstance;
+  clients[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey, trafficType?: string) {
     if (key === undefined) {
@@ -58,7 +53,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     }
     const instanceId = buildInstanceId(validKey, validTrafficType);
 
-    if (!clientInstances[instanceId]) {
+    if (!clients[instanceId]) {
       const matchingKey = getMatching(validKey);
 
       const sharedSdkReadiness = sdkReadinessManager.shared();
@@ -80,13 +75,12 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clientInstances[instanceId] = clientCSDecorator(
+      clients[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
-          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
@@ -99,6 +93,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clientInstances[instanceId];
+    return clients[instanceId] as SplitIO.ICsClient;
   };
 }