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

package/CHANGES.txt

@@ -1,6 +1,9 @@
 2.0.0 (October XX, 2024)
  - Added support for targeting rules based on large segments.
  - Added `factory.destroy()` method, which invokes the `destroy` method on all SDK clients created by the factory.
+ - Added `factory.getState()` method for standalone server-side SDKs, which returns the rollout plan snapshot from the storage.
+ - Added `preloadedData` configuration option for standalone client-side SDKs, which allows preloading the SDK storage with a snapshot of the rollout plan.
+ - Updated internal storage factory to emit the SDK_READY_FROM_CACHE event when it corresponds, to clean up the initialization flow.
  - Updated the handling of timers and async operations inside an `init` factory method to enable lazy initialization of the SDK in standalone mode. This update is intended for the React SDK.
  - Bugfixing - Fixed an issue with the server-side polling manager that caused dangling timers when the SDK was destroyed before it was ready.
  - BREAKING CHANGES:

package/cjs/sdkFactory/index.js

@@ -45,8 +45,10 @@ function sdkFactory(params) {
             readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
             readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
         },
+        onReadyFromCacheCb: function () {
+            readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+        }
     });
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
     var clients = {};
     var telemetryTracker = (0, telemetryTracker_1.telemetryTrackerFactory)(storage.telemetry, platform.now);
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage, telemetryTracker: telemetryTracker });

package/cjs/storages/dataLoader.js

@@ -1,51 +1,113 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
-var browser_1 = require("../utils/constants/browser");
+exports.getSnapshot = exports.loadData = void 0;
+var sets_1 = require("../utils/lang/sets");
+var key_1 = require("../utils/key");
 /**
- * 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
  */
-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;
+function loadData(preloadedData, storage, matchingKey) {
+    // 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() - browser_1.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];
-        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;
-            });
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (matchingKey) { // add mySegments data (client-side)
+        var membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
+        if (!membershipsData && segmentsData) {
+            membershipsData = {
+                ms: {
+                    k: Object.keys(segmentsData).filter(function (segmentName) {
+                        var segmentKeys = segmentsData[segmentName];
+                        return segmentKeys.indexOf(matchingKey) > -1;
+                    }).map(function (segmentName) { return ({ n: segmentName }); })
+                }
+            };
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        if (membershipsData) {
+            if (membershipsData.ms)
+                storage.segments.resetSegments(membershipsData.ms);
+            if (membershipsData.ls && storage.largeSegments)
+                storage.largeSegments.resetSegments(membershipsData.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).forEach(function (segmentName) {
+            var segmentKeys = segmentsData[segmentName];
+            storage.segments.update(segmentName, segmentKeys, [], -1);
+        });
+    }
+}
+exports.loadData = loadData;
+function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        since: storage.splits.getChangeNumber(),
+        splitsData: storage.splits.getAll(),
+        segmentsData: userKeys ?
+            undefined : // @ts-ignore accessing private prop
+            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
+                prev[cur] = (0, sets_1.setToArray)(storage.segments.segmentCache[cur]);
+                return prev;
+            }, {}),
+        membershipsData: userKeys ?
+            userKeys.reduce(function (prev, userKey) {
+                if (storage.shared) {
+                    // Client-side segments
+                    // @ts-ignore accessing private prop
+                    var sharedStorage = storage.shared(userKey);
+                    prev[(0, key_1.getMatching)(userKey)] = {
+                        ms: {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                            // cn: sharedStorage.segments.getChangeNumber()
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                            // cn: sharedStorage.largeSegments.getChangeNumber()
+                        } : undefined
+                    };
+                }
+                else {
+                    prev[(0, key_1.getMatching)(userKey)] = {
+                        ms: {
+                            // Server-side segments
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(userKey) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
     };
 }
-exports.dataLoaderFactory = dataLoaderFactory;
+exports.getSnapshot = getSnapshot;

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -9,13 +9,15 @@ var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory")
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
 var UniqueKeysCacheInMemoryCS_1 = require("./UniqueKeysCacheInMemoryCS");
+var key_1 = require("../../utils/key");
+var dataLoader_1 = require("../dataLoader");
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
 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_1.SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
@@ -39,11 +41,16 @@ function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function () {
+        shared: function (matchingKey) {
+            var segments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+            var largeSegments = new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory();
+            if (preloadedData) {
+                (0, dataLoader_1.loadData)(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
+            }
             return {
                 splits: this.splits,
-                segments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
-                largeSegments: new MySegmentsCacheInMemory_1.MySegmentsCacheInMemory(),
+                segments: segments,
+                largeSegments: largeSegments,
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -68,6 +75,11 @@ function InMemoryStorageCSFactory(params) {
         if (storage.uniqueKeys)
             storage.uniqueKeys.track = noopTrack;
     }
+    if (preloadedData) {
+        (0, dataLoader_1.loadData)(preloadedData, storage, (0, key_1.getMatching)(params.settings.core.key));
+        if (splits.getChangeNumber() > -1)
+            onReadyFromCacheCb();
+    }
     return storage;
 }
 exports.InMemoryStorageCSFactory = InMemoryStorageCSFactory;

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

@@ -26,7 +26,7 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
                 segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
                     return Promise.all(changes.map(function (x) {
                         log.debug(constants_2.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);
+                        return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });

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';
@@ -42,8 +42,10 @@ 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 });

package/esm/storages/dataLoader.js

@@ -1,47 +1,108 @@
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
 /**
- * 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, matchingKey) {
+    // 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];
-        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;
-            });
+        storage.splits.addSplits(splitsData.map(function (split) { return ([split.name, split]); }));
+    }
+    if (matchingKey) { // add mySegments data (client-side)
+        var membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
+        if (!membershipsData && segmentsData) {
+            membershipsData = {
+                ms: {
+                    k: Object.keys(segmentsData).filter(function (segmentName) {
+                        var segmentKeys = segmentsData[segmentName];
+                        return segmentKeys.indexOf(matchingKey) > -1;
+                    }).map(function (segmentName) { return ({ n: segmentName }); })
+                }
+            };
         }
-        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
+        if (membershipsData) {
+            if (membershipsData.ms)
+                storage.segments.resetSegments(membershipsData.ms);
+            if (membershipsData.ls && storage.largeSegments)
+                storage.largeSegments.resetSegments(membershipsData.ls);
+        }
+    }
+    else { // add segments data (server-side)
+        Object.keys(segmentsData).forEach(function (segmentName) {
+            var segmentKeys = segmentsData[segmentName];
+            storage.segments.update(segmentName, segmentKeys, [], -1);
+        });
+    }
+}
+export function getSnapshot(storage, userKeys) {
+    return {
+        // lastUpdated: Date.now(),
+        since: storage.splits.getChangeNumber(),
+        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;
+            }, {}),
+        membershipsData: userKeys ?
+            userKeys.reduce(function (prev, userKey) {
+                if (storage.shared) {
+                    // Client-side segments
+                    // @ts-ignore accessing private prop
+                    var sharedStorage = storage.shared(userKey);
+                    prev[getMatching(userKey)] = {
+                        ms: {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.segments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                            // cn: sharedStorage.segments.getChangeNumber()
+                        },
+                        ls: sharedStorage.largeSegments ? {
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(sharedStorage.largeSegments.segmentCache).map(function (segmentName) { return ({ n: segmentName }); }),
+                            // cn: sharedStorage.largeSegments.getChangeNumber()
+                        } : undefined
+                    };
+                }
+                else {
+                    prev[getMatching(userKey)] = {
+                        ms: {
+                            // Server-side segments
+                            // @ts-ignore accessing private prop
+                            k: Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
+                                return storage.segments.segmentCache[segmentName].has(userKey) ?
+                                    prev.concat({ n: segmentName }) :
+                                    prev;
+                            }, [])
+                        },
+                        ls: {
+                            k: []
+                        }
+                    };
+                }
+                return prev;
+            }, {}) :
+            undefined
     };
 }

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 instantiation 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/polling/updaters/segmentChangesUpdater.js

@@ -23,7 +23,7 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
                 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);
+                        return segments.update(segmentName, x.added, x.removed, x.till);
                     })).then(function (updates) {
                         return updates.some(function (update) { return update; });
                     });

package/package.json

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

package/src/sdkFactory/index.ts

@@ -7,7 +7,7 @@ import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
 import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
@@ -43,7 +43,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const storage = storageFactory({
     settings,
-    onReadyCb: (error) => {
+    onReadyCb(error) {
       if (error) {
         // If storage fails to connect, SDK_READY_TIMED_OUT event is emitted immediately. Review when timeout and non-recoverable errors are reworked
         readiness.timeout();
@@ -52,8 +52,11 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       readiness.splits.emit(SDK_SPLITS_ARRIVED);
       readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     },
+    onReadyFromCacheCb() {
+      readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+    }
   });
-  // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+
   const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });

package/src/storages/dataLoader.ts

@@ -1,55 +1,114 @@
 import { SplitIO } from '../types';
-import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
-import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
+import { setToArray } from '../utils/lang/sets';
+import { getMatching } from '../utils/key';
+import { IMembershipsResponse, IMySegmentsResponse } from '../dtos/types';
 
 /**
- * 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: 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
-   *
-   * @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: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0) return;
-
-    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
+export function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
+  // Do not load data if current preloadedData is empty
+  if (Object.keys(preloadedData).length === 0) return;
+
+  const { segmentsData = {}, since = -1, splitsData = [] } = preloadedData;
 
+  if (storage.splits) {
     const storedSince = storage.splits.getChangeNumber();
-    const 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) return;
+    // 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(splitName => JSON.parse(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;
-      });
+    storage.splits.addSplits(splitsData.map(split => ([split.name, split])));
+  }
+
+  if (matchingKey) { // add mySegments data (client-side)
+    let membershipsData = preloadedData.membershipsData && preloadedData.membershipsData[matchingKey];
+    if (!membershipsData && segmentsData) {
+      membershipsData = {
+        ms: {
+          k: Object.keys(segmentsData).filter(segmentName => {
+            const segmentKeys = segmentsData[segmentName];
+            return segmentKeys.indexOf(matchingKey) > -1;
+          }).map(segmentName => ({ n: segmentName }))
+        }
+      };
+    }
+    if (membershipsData) {
+      if (membershipsData.ms) storage.segments.resetSegments(membershipsData.ms);
+      if (membershipsData.ls && storage.largeSegments) storage.largeSegments.resetSegments(membershipsData.ls);
     }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
+
+  } else { // add segments data (server-side)
+    Object.keys(segmentsData).forEach(segmentName => {
+      const segmentKeys = segmentsData[segmentName];
+      storage.segments.update(segmentName, segmentKeys, [], -1);
+    });
+  }
+}
+
+export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
+  return {
+    // lastUpdated: Date.now(),
+    since: storage.splits.getChangeNumber(),
+    splitsData: storage.splits.getAll(),
+    segmentsData: userKeys ?
+      undefined : // @ts-ignore accessing private prop
+      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
+        prev[cur] = setToArray(storage.segments.segmentCache[cur] as Set<string>);
+        return prev;
+      }, {}),
+    membershipsData: userKeys ?
+      userKeys.reduce<Record<string, IMembershipsResponse>>((prev, userKey) => {
+        if (storage.shared) {
+          // Client-side segments
+          // @ts-ignore accessing private prop
+          const sharedStorage = storage.shared(userKey);
+          prev[getMatching(userKey)] = {
+            ms: {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.segments.segmentCache).map(segmentName => ({ n: segmentName })),
+              // cn: sharedStorage.segments.getChangeNumber()
+            },
+            ls: sharedStorage.largeSegments ? {
+              // @ts-ignore accessing private prop
+              k: Object.keys(sharedStorage.largeSegments.segmentCache).map(segmentName => ({ n: segmentName })),
+              // cn: sharedStorage.largeSegments.getChangeNumber()
+            } : undefined
+          };
+        } else {
+          prev[getMatching(userKey)] = {
+            ms: {
+              // Server-side segments
+              // @ts-ignore accessing private prop
+              k: Object.keys(storage.segments.segmentCache).reduce<IMySegmentsResponse['k']>((prev, segmentName) => { // @ts-ignore accessing private prop
+                return storage.segments.segmentCache[segmentName].has(userKey) ?
+                  prev!.concat({ n: segmentName }) :
+                  prev;
+              }, [])
+            },
+            ls: {
+              k: []
+            }
+          };
+        }
+        return prev;
+      }, {}) :
+      undefined
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,6 +7,8 @@ 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
@@ -14,7 +16,7 @@ import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -42,11 +44,18 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
 
     // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
-    shared() {
+    shared(matchingKey: string) {
+      const segments = new MySegmentsCacheInMemory();
+      const largeSegments = new MySegmentsCacheInMemory();
+
+      if (preloadedData) {
+        loadData(preloadedData, { segments, largeSegments }, matchingKey);
+      }
+
       return {
         splits: this.splits,
-        segments: new MySegmentsCacheInMemory(),
-        largeSegments: new MySegmentsCacheInMemory(),
+        segments,
+        largeSegments,
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -72,6 +81,12 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     if (storage.uniqueKeys) storage.uniqueKeys.track = noopTrack;
   }
 
+
+  if (preloadedData) {
+    loadData(preloadedData, storage, getMatching(params.settings.core.key));
+    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
+  }
+
   return storage;
 }
 

package/src/storages/types.ts

@@ -488,8 +488,6 @@ export interface IStorageAsync extends IStorageBase<
 
 /** StorageFactory */
 
-export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
-
 export interface IStorageFactoryParams {
   settings: ISettings,
   /**
@@ -497,6 +495,10 @@ export interface IStorageFactoryParams {
    * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
    */
   onReadyCb: (error?: any) => void,
+  /**
+   * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
+   */
+  onReadyFromCacheCb: () => void,
 }
 
 export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';

package/src/sync/polling/updaters/segmentChangesUpdater.ts

@@ -38,7 +38,7 @@ export function segmentChangesUpdaterFactory(
         segmentChangesFetcher(since, segmentName, noCache, till).then((changes) => {
           return Promise.all(changes.map(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);
+            return segments.update(segmentName, x.added, x.removed, x.till);
           })).then((updates) => {
             return updates.some(update => update);
           });

package/src/types.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from './dtos/types';
+import { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -97,6 +97,7 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
+  readonly preloadedData?: SplitIO.PreloadedData,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -770,31 +771,31 @@ export namespace SplitIO {
      * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
      * @TODO configurable expiration time policy?
      */
-    lastUpdated: number,
+    // lastUpdated: number,
     /**
      * Change number of the preloaded data.
      * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
      */
     since: number,
     /**
-     * Map of feature flags to their stringified definitions.
+     * List of feature flag definitions.
+     * @TODO rename to flags
      */
-    splitsData: {
-      [splitName: string]: string
-    },
+    splitsData: ISplit[],
     /**
-     * Optional map of user keys to their list of segments.
-     * @TODO remove when releasing first version
+     * Optional map of user keys to their memberships.
+     * @TODO rename to memberships
      */
-    mySegmentsData?: {
-      [key: string]: string[]
+    membershipsData?: {
+      [key: string]: IMembershipsResponse
     },
     /**
-     * Optional map of segments to their stringified definitions.
-     * This property is ignored if `mySegmentsData` was provided.
+     * Optional map of segments to their list of keys.
+     * This property is ignored if `membershipsData` was provided.
+     * @TODO rename to segments
      */
     segmentsData?: {
-      [segmentName: string]: string
+      [segmentName: string]: string[]
     },
   }
   /**

package/types/storages/dataLoader.d.ts

@@ -1,10 +1,21 @@
 import { SplitIO } from '../types';
-import { DataLoader } from './types';
+import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
 /**
- * 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 declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;
+export declare function loadData(preloadedData: SplitIO.PreloadedData, storage: {
+    splits?: ISplitsCacheSync;
+    segments: ISegmentsCacheSync;
+    largeSegments?: ISegmentsCacheSync;
+}, matchingKey?: string): void;
+export declare function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData;

package/types/storages/types.d.ts

@@ -387,7 +387,6 @@ export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCa
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }
 /** StorageFactory */
-export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
     settings: ISettings;
     /**
@@ -395,6 +394,10 @@ export interface IStorageFactoryParams {
      * It is meant for emitting SDK_READY event in consumer mode, and waiting before using the storage in the synchronizer.
      */
     onReadyCb: (error?: any) => void;
+    /**
+     * It is meant for emitting SDK_READY_FROM_CACHE event in standalone mode with preloaded data
+     */
+    onReadyFromCacheCb: () => void;
 }
 export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {

package/types/types.d.ts

@@ -1,4 +1,4 @@
-import { ISplitFiltersValidation } from './dtos/types';
+import { IMembershipsResponse, ISplit, ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
@@ -91,6 +91,7 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
+    readonly preloadedData?: SplitIO.PreloadedData;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -769,31 +770,30 @@ export declare namespace SplitIO {
          * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
          * @TODO configurable expiration time policy?
          */
-        lastUpdated: number;
         /**
          * Change number of the preloaded data.
          * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
          */
         since: number;
         /**
-         * Map of feature flags to their stringified definitions.
+         * List of feature flag definitions.
+         * @TODO rename to flags
          */
-        splitsData: {
-            [splitName: string]: string;
-        };
+        splitsData: ISplit[];
         /**
-         * Optional map of user keys to their list of segments.
-         * @TODO remove when releasing first version
+         * Optional map of user keys to their memberships.
+         * @TODO rename to memberships
          */
-        mySegmentsData?: {
-            [key: string]: string[];
+        membershipsData?: {
+            [key: string]: IMembershipsResponse;
         };
         /**
-         * Optional map of segments to their stringified definitions.
-         * This property is ignored if `mySegmentsData` was provided.
+         * Optional map of segments to their list of keys.
+         * This property is ignored if `membershipsData` was provided.
+         * @TODO rename to segments
          */
         segmentsData?: {
-            [segmentName: string]: string;
+            [segmentName: string]: string[];
         };
     }
     /**