@splitsoftware/splitio-commons 1.4.1 → 1.4.2-rc.2

package/esm/storages/dataLoader.js

@@ -1,23 +1,24 @@
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 /**
- * Factory of client-side storage loader
+ * Factory of storage loader
  *
  * @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
  */
-export function dataLoaderFactory(preloadedData) {
+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
+     * @param userKey user key (matching key) 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.
+     * @TODO add logs, and input validation in this module, in favor of size reduction.
+     * @TODO unit tests
      */
-    return function loadData(storage, userId) {
+    return function loadData(storage, userKey) {
         // Do not load data if current preloadedData is empty
         if (Object.keys(preloadedData).length === 0)
             return;
@@ -33,15 +34,22 @@ export function dataLoaderFactory(preloadedData) {
         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 [splitName, splitsData[splitName]]; }));
-        // add mySegments data
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-        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;
+        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 userKeys = segmentsData[segmentName];
+                    return userKeys.indexOf(userKey) > -1;
+                });
+            }
+            storage.segments.resetSegments(mySegmentsData);
+        }
+        else { // add segments data (server-side)
+            Object.keys(segmentsData).filter(function (segmentName) {
+                var userKeys = segmentsData[segmentName];
+                storage.segments.addToSegment(segmentName, userKeys);
             });
         }
-        storage.segments.resetSegments(mySegmentsData);
     };
 }

package/esm/storages/inMemory/InMemoryStorage.js

@@ -5,6 +5,7 @@ import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { setToArray } from '../../utils/lang/sets';
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -25,7 +26,20 @@ export function InMemoryStorageFactory(params) {
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
-        }
+        },
+        // @ts-ignore, private method, for POC
+        getSnapshot: function () {
+            var _this = this;
+            return {
+                lastUpdated: Date.now(),
+                since: this.splits.changeNumber,
+                splitsData: this.splits.splitsCache,
+                segmentsData: Object.keys(this.segments.segmentCache).reduce(function (prev, cur) {
+                    prev[cur] = setToArray(_this.segments.segmentCache[cur]);
+                    return prev;
+                }, {})
+            };
+        },
     };
 }
 InMemoryStorageFactory.type = STORAGE_MEMORY;

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -26,6 +26,18 @@ export function InMemoryStorageCSFactory(params) {
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
         },
+        // @ts-ignore, private method, for POC
+        getSnapshot: function () {
+            var _a;
+            return {
+                lastUpdated: Date.now(),
+                since: this.splits.changeNumber,
+                splitsData: this.splits.splitsCache,
+                mySegmentsData: (_a = {},
+                    _a[params.matchingKey] = Object.keys(this.segments.segmentCache),
+                    _a)
+            };
+        },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
         shared: function () {
             return {

package/esm/sync/submitters/submitterManager.js

@@ -1,4 +1,3 @@
-import { syncTaskComposite } from '../syncTaskComposite';
 import { eventsSubmitterFactory } from './eventsSubmitter';
 import { impressionsSubmitterFactory } from './impressionsSubmitter';
 import { impressionCountsSubmitterFactory } from './impressionCountsSubmitter';
@@ -12,7 +11,32 @@ export function submitterManagerFactory(params) {
     if (impressionCountsSubmitter)
         submitters.push(impressionCountsSubmitter);
     var telemetrySubmitter = telemetrySubmitterFactory(params);
-    if (telemetrySubmitter)
-        submitters.push(telemetrySubmitter);
-    return syncTaskComposite(submitters);
+    return {
+        // `onlyTelemetry` true if SDK is created with userConsent not GRANTED
+        start: function (onlyTelemetry) {
+            if (!onlyTelemetry)
+                submitters.forEach(function (submitter) { return submitter.start(); });
+            if (telemetrySubmitter)
+                telemetrySubmitter.start();
+        },
+        // `allExceptTelemetry` true if userConsent is changed to DECLINED
+        stop: function (allExceptTelemetry) {
+            submitters.forEach(function (submitter) { return submitter.stop(); });
+            if (!allExceptTelemetry && telemetrySubmitter)
+                telemetrySubmitter.stop();
+        },
+        isRunning: function () {
+            return submitters.some(function (submitter) { return submitter.isRunning(); });
+        },
+        // Flush data. Called with `onlyTelemetry` true if SDK is destroyed with userConsent not GRANTED
+        execute: function (onlyTelemetry) {
+            var promises = onlyTelemetry ? [] : submitters.map(function (submitter) { return submitter.execute(); });
+            if (telemetrySubmitter)
+                promises.push(telemetrySubmitter.execute());
+            return Promise.all(promises);
+        },
+        isExecuting: function () {
+            return submitters.some(function (submitter) { return submitter.isExecuting(); });
+        }
+    };
 }

package/esm/sync/syncManagerOnline.js

@@ -16,16 +16,16 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, telemetryTracker = params.telemetryTracker;
+        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, _b = _a.sync, syncEnabled = _b.enabled, onlySubmitters = _b.onlySubmitters, telemetryTracker = params.telemetryTracker;
         /** Polling Manager */
-        var pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+        var pollingManager = onlySubmitters ? undefined : pollingManagerFactory && pollingManagerFactory(params);
         /** Push Manager */
-        var pushManager = streamingEnabled && pollingManager && pushManagerFactory ?
+        var pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :
             undefined;
         /** Submitter Manager */
         // It is not inyected as push and polling managers, because at the moment it is required
-        var submitter = submitterManagerFactory(params);
+        var submitterManager = submitterManagerFactory(params);
         /** Sync Manager logic */
         function startPolling() {
             if (pollingManager.isRunning()) {
@@ -58,7 +58,7 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
             // E.g.: user consent, app state changes (Page hide, Foreground/Background, Online/Offline).
             pollingManager: pollingManager,
             pushManager: pushManager,
-            submitter: submitter,
+            submitterManager: submitterManager,
             /**
              * Method used to start the syncManager for the first time, or resume it after being stopped.
              */
@@ -66,21 +66,29 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 running = true;
                 // start syncing splits and segments
                 if (pollingManager) {
-                    if (pushManager) {
-                        // Doesn't call `syncAll` when the syncManager is resuming
+                    // If synchronization is disabled pushManager and pollingManager should not start
+                    if (syncEnabled) {
+                        if (pushManager) {
+                            // Doesn't call `syncAll` when the syncManager is resuming
+                            if (startFirstTime) {
+                                pollingManager.syncAll();
+                                startFirstTime = false;
+                            }
+                            pushManager.start();
+                        }
+                        else {
+                            pollingManager.start();
+                        }
+                    }
+                    else {
                         if (startFirstTime) {
                             pollingManager.syncAll();
                             startFirstTime = false;
                         }
-                        pushManager.start();
-                    }
-                    else {
-                        pollingManager.start();
                     }
                 }
                 // start periodic data recording (events, impressions, telemetry).
-                if (isConsentGranted(settings))
-                    submitter.start();
+                submitterManager.start(!isConsentGranted(settings));
             },
             /**
              * Method used to stop/pause the syncManager.
@@ -93,16 +101,13 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 if (pollingManager && pollingManager.isRunning())
                     pollingManager.stop();
                 // stop periodic data recording (events, impressions, telemetry).
-                submitter.stop();
+                submitterManager.stop();
             },
             isRunning: function () {
                 return running;
             },
             flush: function () {
-                if (isConsentGranted(settings))
-                    return submitter.execute();
-                else
-                    return Promise.resolve();
+                return submitterManager.execute(!isConsentGranted(settings));
             },
             // [Only used for client-side]
             // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side
@@ -113,22 +118,28 @@ export function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFacto
                 return {
                     isRunning: mySegmentsSyncTask.isRunning,
                     start: function () {
-                        if (pushManager) {
-                            if (pollingManager.isRunning()) {
-                                // if doing polling, we must start the periodic fetch of data
-                                if (storage.splits.usesSegments())
-                                    mySegmentsSyncTask.start();
+                        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 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();
+                                if (storage.splits.usesSegments())
+                                    mySegmentsSyncTask.start();
                             }
-                            pushManager.add(matchingKey, mySegmentsSyncTask);
                         }
                         else {
-                            if (storage.splits.usesSegments())
-                                mySegmentsSyncTask.start();
+                            if (!readinessManager.isReady())
+                                mySegmentsSyncTask.execute();
                         }
                     },
                     stop: function () {

package/esm/sync/syncTask.js

@@ -1,8 +1,8 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/constants';
 /**
  * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be executed once calling the "execute" method.
- * NOTE: Multiple calls to "execute" are not queued. Use "isExecuting" method to handle synchronization.
+ * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
+ * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -12,8 +12,8 @@ import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/co
  */
 export function syncTaskFactory(log, task, period, taskName) {
     if (taskName === void 0) { taskName = 'task'; }
-    // Flag that indicates if the task is being executed
-    var executing = false;
+    // Task promise while it is pending. Undefined once the promise is resolved
+    var pendingTask;
     // flag that indicates if the task periodic execution has been started/stopped.
     var running = false;
     // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -27,13 +27,19 @@ export function syncTaskFactory(log, task, period, taskName) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        executing = true;
+        // If task is executing, chain the new execution
+        if (pendingTask) {
+            return pendingTask.then(function () {
+                return execute.apply(void 0, args);
+            });
+        }
+        // Execute task
         log.debug(SYNC_TASK_EXECUTE, [taskName]);
-        return task.apply(void 0, args).then(function (result) {
-            executing = false;
+        pendingTask = task.apply(void 0, args).then(function (result) {
+            pendingTask = undefined;
             return result;
         });
-        // No need to handle promise rejection because it is a pre-condition that provided task never rejects.
+        return pendingTask;
     }
     function periodicExecute(currentRunningId) {
         return execute.apply(void 0, runningArgs).then(function (result) {
@@ -45,10 +51,9 @@ export function syncTaskFactory(log, task, period, taskName) {
         });
     }
     return {
-        // @TODO check if we need to queued `execute` calls, to avoid possible race conditions on submitters and updaters with streaming.
         execute: execute,
         isExecuting: function () {
-            return executing;
+            return pendingTask !== undefined;
         },
         start: function () {
             var args = [];

package/esm/trackers/impressionObserver/impressionObserverCS.js

@@ -2,7 +2,7 @@ import { ImpressionObserver } from './ImpressionObserver';
 import { hash } from '../../utils/murmur3/murmur3';
 import { buildKey } from './buildKey';
 export function hashImpression32(impression) {
-    return hash(buildKey(impression));
+    return hash(buildKey(impression)).toString();
 }
 var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes
 export function impressionObserverCSFactory() {

package/esm/utils/settingsValidation/index.js

@@ -70,7 +70,8 @@ export var base = {
         splitFilters: undefined,
         // impressions collection mode
         impressionsMode: OPTIMIZED,
-        localhostMode: undefined
+        localhostMode: undefined,
+        enabled: true
     },
     // Logger
     log: undefined
@@ -123,6 +124,9 @@ export function settingsValidation(config, validationParams) {
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
     withDefaults.mode = mode(withDefaults.core.authorizationKey, withDefaults.mode);
+    if (withDefaults.sync.onlySubmitters && withDefaults.mode === STANDALONE_MODE && !withDefaults.dataLoader) {
+        throw new Error('To use `onlySubmitters` param in standalone mode, DataLoader is required to preload data into the storage');
+    }
     // ensure a valid Storage based on mode defined.
     // @ts-ignore, modify readonly prop
     if (storage)
@@ -164,6 +168,14 @@ export function settingsValidation(config, validationParams) {
         // We are not checking if bases are positive numbers. Thus, we might be reauthenticating immediately (`setTimeout` with NaN or negative number)
         scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
     }
+    // validate sync enabled
+    if (withDefaults.sync.enabled !== false) {
+        withDefaults.sync.enabled = true;
+    }
+    // validate sync onlySubmitters
+    if (withDefaults.sync.onlySubmitters !== true) {
+        withDefaults.sync.onlySubmitters = false;
+    }
     // validate the `splitFilters` settings and parse splits query
     var splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;

package/package.json

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

package/src/consent/sdkUserConsent.ts

@@ -34,9 +34,10 @@ export function createUserConsentAPI(params: ISdkFactoryContext) {
         settings.userConsent = newConsentStatus;
 
         if (consent) { // resumes submitters if transitioning to GRANTED
-          syncManager?.submitter?.start();
-        } else { // pauses submitters and drops tracked data if transitioning to DECLINED
-          syncManager?.submitter?.stop();
+          syncManager?.submitterManager?.start();
+        } else { // pauses submitters (except telemetry), and drops tracked data if transitioning to DECLINED
+          syncManager?.submitterManager?.stop(true);
+
           // @ts-ignore, clear method is present in storage for standalone and partial consumer mode
           if (events.clear) events.clear(); // @ts-ignore
           if (impressions.clear) impressions.clear();

package/src/listeners/browser.ts

@@ -67,7 +67,7 @@ export class BrowserSignalListener implements ISignalListener {
   flushData() {
     if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
 
-    // Flush data if there is user consent
+    // Flush impressions & events data if there is user consent
     if (isConsentGranted(this.settings)) {
       const eventsUrl = this.settings.urls.events;
       const extraMetadata = {
@@ -78,11 +78,13 @@ export class BrowserSignalListener implements ISignalListener {
       this._flushData(eventsUrl + '/testImpressions/beacon', this.storage.impressions, this.serviceApi.postTestImpressionsBulk, this.fromImpressionsCollector, extraMetadata);
       this._flushData(eventsUrl + '/events/beacon', this.storage.events, this.serviceApi.postEventsBulk);
       if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
-      if (this.storage.telemetry) {
-        const telemetryUrl = this.settings.urls.telemetry;
-        const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
-        this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
-      }
+    }
+
+    // Flush telemetry data
+    if (this.storage.telemetry) {
+      const telemetryUrl = this.settings.urls.telemetry;
+      const telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
+      this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
     }
 
     // Close streaming connection

package/src/sdkClient/clientAttributesDecoration.ts

@@ -5,7 +5,7 @@ import { ILogger } from '../logger/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 
 /**
- * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
+ * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call
  */
 export function clientAttributesDecoration<TClient extends SplitIO.IClient | SplitIO.IAsyncClient>(log: ILogger, client: TClient) {
 
@@ -52,10 +52,10 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     getTreatments: getTreatments,
     getTreatmentsWithConfig: getTreatmentsWithConfig,
     track: track,
-    
+
     /**
      * Add an attribute to client's in memory attributes storage
-     * 
+     *
      * @param {string} attributeName Attrinute name
      * @param {string, number, boolean, list} attributeValue Attribute value
      * @returns {boolean} true if the attribute was stored and false otherways
@@ -70,7 +70,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
 
     /**
      * Returns the attribute with the given key
-     * 
+     *
      * @param {string} attributeName Attribute name
      * @returns {Object} Attribute with the given key
      */
@@ -81,7 +81,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
 
     /**
      * Add to client's in memory attributes storage the attributes in 'attributes'
-     * 
+     *
      * @param {Object} attributes Object with attributes to store
      * @returns true if attributes were stored an false otherways
      */
@@ -92,7 +92,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
 
     /**
      * Return all the attributes stored in client's in memory attributes storage
-     * 
+     *
      * @returns {Object} returns all the stored attributes
      */
     getAttributes(): Record<string, Object> {
@@ -101,8 +101,8 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
 
     /**
      * Removes from client's in memory attributes storage the attribute with the given key
-     * 
-     * @param {string} attributeName 
+     *
+     * @param {string} attributeName
      * @returns {boolean} true if attribute was removed and false otherways
      */
     removeAttribute(attributeName: string) {
@@ -116,7 +116,7 @@ export function clientAttributesDecoration<TClient extends SplitIO.IClient | Spl
     clearAttributes() {
       return attributeStorage.clear();
     }
-    
+
   });
 
 }

package/src/sdkFactory/index.ts

@@ -3,7 +3,7 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { IStorageFactoryParams } from '../storages/types';
+import { IStorageFactoryParams, IStorageSync } from '../storages/types';
 import { SplitIO } from '../types';
 import { getMatching } from '../utils/key';
 import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
@@ -11,7 +11,7 @@ import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
-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';
 
 /**
@@ -32,6 +32,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
+  const matchingKey = getMatching(settings.core.key);
 
   // @TODO consider passing the settings object, so that each storage access only what it needs
   const storageFactoryParams: IStorageFactoryParams = {
@@ -40,7 +41,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     optimize: shouldBeOptimized(settings),
 
     // ATM, only used by InLocalStorage
-    matchingKey: getMatching(settings.core.key),
+    matchingKey,
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
     // ATM, only used by PluggableStorage
@@ -58,7 +59,21 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   };
 
   const storage = storageFactory(storageFactoryParams);
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+
+  // @TODO dataLoader requires validation
+  if (settings.dataLoader) {
+    settings.dataLoader(storage as IStorageSync, matchingKey);
+    Promise.resolve(storage.splits.checkCache()).then(cacheReady => {
+      if (cacheReady) {
+        if (settings.sync.onlySubmitters) { // emit SDK_READY to not timeout when not synchronizing splits & segments
+          readiness.splits.emit(SDK_SPLITS_ARRIVED);
+          readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+        } else { // emit SDK_READY_FROM_CACHE
+          readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+        }
+      }
+    });
+  }
 
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
 
@@ -103,5 +118,9 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(settings.log),
 
     settings,
+
+    // @TODO remove
+    __storage: storage,
+    __ctx: ctx
   }, extraProps && extraProps(ctx));
 }

package/src/storages/AbstractSplitsCacheSync.ts

@@ -50,7 +50,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
    * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
    */
   checkCache(): boolean {
-    return false;
+    return this.getChangeNumber() > -1;
   }
 
   /**

package/src/storages/dataLoader.ts

@@ -3,25 +3,26 @@ import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
 /**
- * Factory of client-side storage loader
+ * Factory of storage loader
  *
  * @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
  */
-export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+export function DataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
 
   /**
    * 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
+   * @param userKey user key (matching key) 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.
+   * @TODO add logs, and input validation in this module, in favor of size reduction.
+   * @TODO unit tests
    */
-  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
+  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userKey?: string) {
     // Do not load data if current preloadedData is empty
     if (Object.keys(preloadedData).length === 0) return;
 
@@ -41,15 +42,21 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
     // 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(splitName => [splitName, splitsData[splitName]]));
 
-    // add mySegments data
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
-    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(segmentName => {
-        const userIds = JSON.parse(segmentsData[segmentName]).added;
-        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
+    if (userKey) { // add mySegments data (client-side)
+      let 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(segmentName => {
+          const userKeys = segmentsData[segmentName];
+          return userKeys.indexOf(userKey) > -1;
+        });
+      }
+      storage.segments.resetSegments(mySegmentsData);
+    } else { // add segments data (server-side)
+      Object.keys(segmentsData).filter(segmentName => {
+        const userKeys = segmentsData[segmentName];
+        storage.segments.addToSegment(segmentName, userKeys);
       });
     }
-    storage.segments.resetSegments(mySegmentsData);
   };
 }