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

package/CHANGES.txt

@@ -1,7 +1,7 @@
-1.4.2 (June XX, 2022)
- - Added `sync.enabled` property to SDK configuration to allow synchronize splits and segments only once.
- - Updated telemetry to submit data even if user consent is not granted.
- - Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while performing its periodic post of impressions.
+1.5.0 (June 24, 2022)
+- Added a new config option to control the tasks that listen or poll for updates on feature flags and segments, via the new config sync.enabled . Running online Split will always pull the most recent updates upon initialization, this only affects updates fetching on a running instance. Useful when a consistent session experience is a must or to save resources when updates are not being used.
+- Updated telemetry logic to track the anonymous config for user consent flag set to declined or unknown.
+- Updated submitters logic, to avoid duplicating the post of impressions to Split cloud when the SDK is destroyed while its periodic post of impressions is running.
 
 1.4.1 (June 13, 2022)
  - Bugfixing - Updated submitters logic, to avoid dropping impressions and events that are being tracked while POST request is pending.

package/cjs/sdkFactory/index.js

@@ -25,13 +25,14 @@ function sdkFactory(params) {
     (0, apiKey_1.validateAndTrackApiKey)(log, settings.core.authorizationKey);
     var sdkReadinessManager = (0, sdkReadinessManager_1.sdkReadinessManagerFactory)(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
+    var matchingKey = (0, key_1.getMatching)(settings.core.key);
     // @TODO consider passing the settings object, so that each storage access only what it needs
     var storageFactoryParams = {
         impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
         optimize: (0, utils_1.shouldBeOptimized)(settings),
         // ATM, only used by InLocalStorage
-        matchingKey: (0, key_1.getMatching)(settings.core.key),
+        matchingKey: matchingKey,
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
@@ -47,7 +48,21 @@ function sdkFactory(params) {
         log: log
     };
     var storage = storageFactory(storageFactoryParams);
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    // @TODO dataLoader requires validation
+    if (settings.dataLoader) {
+        settings.dataLoader(storage, matchingKey);
+        Promise.resolve(storage.splits.checkCache()).then(function (cacheReady) {
+            if (cacheReady) {
+                if (settings.sync.onlySubmitters) { // emit SDK_READY to not timeout when not synchronizing splits & segments
+                    readiness.splits.emit(constants_2.SDK_SPLITS_ARRIVED);
+                    readiness.segments.emit(constants_2.SDK_SEGMENTS_ARRIVED);
+                }
+                else { // emit SDK_READY_FROM_CACHE
+                    readiness.splits.emit(constants_2.SDK_SPLITS_CACHE_LOADED);
+                }
+            }
+        });
+    }
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
@@ -79,6 +94,9 @@ function sdkFactory(params) {
         // Logger wrapper API
         Logger: (0, sdkLogger_1.createLoggerAPI)(settings.log),
         settings: settings,
+        // @TODO remove
+        __storage: storage,
+        __ctx: ctx
     }, extraProps && extraProps(ctx));
 }
 exports.sdkFactory = sdkFactory;

package/cjs/storages/AbstractSplitsCacheSync.js

@@ -33,7 +33,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
      */
     AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
+        return this.getChangeNumber() > -1;
     };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.

package/cjs/storages/dataLoader.js

@@ -1,26 +1,27 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.dataLoaderFactory = void 0;
+exports.DataLoaderFactory = void 0;
 var browser_1 = require("../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
  */
-function dataLoaderFactory(preloadedData) {
+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;
@@ -36,16 +37,23 @@ 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);
     };
 }
-exports.dataLoaderFactory = dataLoaderFactory;
+exports.DataLoaderFactory = DataLoaderFactory;

package/cjs/storages/inMemory/InMemoryStorage.js

@@ -8,6 +8,7 @@ var EventsCacheInMemory_1 = require("./EventsCacheInMemory");
 var ImpressionCountsCacheInMemory_1 = require("./ImpressionCountsCacheInMemory");
 var constants_1 = require("../../utils/constants");
 var TelemetryCacheInMemory_1 = require("./TelemetryCacheInMemory");
+var sets_1 = require("../../utils/lang/sets");
 /**
  * InMemory storage factory for standalone server-side SplitFactory
  *
@@ -28,7 +29,20 @@ 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] = (0, sets_1.setToArray)(_this.segments.segmentCache[cur]);
+                    return prev;
+                }, {})
+            };
+        },
     };
 }
 exports.InMemoryStorageFactory = InMemoryStorageFactory;

package/cjs/storages/inMemory/InMemoryStorageCS.js

@@ -29,6 +29,18 @@ 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/cjs/sync/syncManagerOnline.js

@@ -19,9 +19,9 @@ function syncManagerOnlineFactory(pollingManagerFactory, pushManagerFactory) {
      * SyncManager factory for modular SDK
      */
     return function (params) {
-        var settings = params.settings, _a = params.settings, log = _a.log, streamingEnabled = _a.streamingEnabled, syncEnabled = _a.sync.enabled, 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 = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :

package/cjs/trackers/impressionObserver/impressionObserverCS.js

@@ -5,7 +5,7 @@ var ImpressionObserver_1 = require("./ImpressionObserver");
 var murmur3_1 = require("../../utils/murmur3/murmur3");
 var buildKey_1 = require("./buildKey");
 function hashImpression32(impression) {
-    return (0, murmur3_1.hash)((0, buildKey_1.buildKey)(impression));
+    return (0, murmur3_1.hash)((0, buildKey_1.buildKey)(impression)).toString();
 }
 exports.hashImpression32 = hashImpression32;
 var LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes

package/cjs/utils/settingsValidation/index.js

@@ -127,6 +127,9 @@ function settingsValidation(config, validationParams) {
     // ensure a valid SDK mode
     // @ts-ignore, modify readonly prop
     withDefaults.mode = (0, mode_1.mode)(withDefaults.core.authorizationKey, withDefaults.mode);
+    if (withDefaults.sync.onlySubmitters && withDefaults.mode === constants_1.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)
@@ -169,9 +172,13 @@ function settingsValidation(config, validationParams) {
         scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
     }
     // validate sync enabled
-    if (withDefaults.sync.enabled !== false) { // @ts-ignore, modify readonly prop
+    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 = (0, splitFilters_1.validateSplitFilters)(log, withDefaults.sync.splitFilters, withDefaults.mode);
     withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;

package/esm/sdkFactory/index.js

@@ -8,7 +8,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';
 /**
  * Modular SDK factory
@@ -22,13 +22,14 @@ export function sdkFactory(params) {
     validateAndTrackApiKey(log, settings.core.authorizationKey);
     var sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
     var readiness = sdkReadinessManager.readinessManager;
+    var matchingKey = getMatching(settings.core.key);
     // @TODO consider passing the settings object, so that each storage access only what it needs
     var storageFactoryParams = {
         impressionsQueueSize: settings.scheduler.impressionsQueueSize,
         eventsQueueSize: settings.scheduler.eventsQueueSize,
         optimize: shouldBeOptimized(settings),
         // ATM, only used by InLocalStorage
-        matchingKey: getMatching(settings.core.key),
+        matchingKey: matchingKey,
         splitFiltersValidation: settings.sync.__splitFiltersValidation,
         // ATM, only used by PluggableStorage
         mode: settings.mode,
@@ -44,7 +45,21 @@ export function sdkFactory(params) {
         log: log
     };
     var storage = storageFactory(storageFactoryParams);
-    // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
+    // @TODO dataLoader requires validation
+    if (settings.dataLoader) {
+        settings.dataLoader(storage, matchingKey);
+        Promise.resolve(storage.splits.checkCache()).then(function (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);
+                }
+            }
+        });
+    }
     var integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings: settings, storage: storage });
     // trackers
     var observer = impressionsObserverFactory && impressionsObserverFactory();
@@ -76,5 +91,8 @@ export function sdkFactory(params) {
         // Logger wrapper API
         Logger: createLoggerAPI(settings.log),
         settings: settings,
+        // @TODO remove
+        __storage: storage,
+        __ctx: ctx
     }, extraProps && extraProps(ctx));
 }

package/esm/storages/AbstractSplitsCacheSync.js

@@ -30,7 +30,7 @@ var AbstractSplitsCacheSync = /** @class */ (function () {
      * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
      */
     AbstractSplitsCacheSync.prototype.checkCache = function () {
-        return false;
+        return this.getChangeNumber() > -1;
     };
     /**
      * Kill `name` split and set `defaultTreatment` and `changeNumber`.

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

@@ -16,9 +16,9 @@ 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, syncEnabled = _a.sync.enabled, 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 = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?
             pushManagerFactory(params, pollingManager) :

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

@@ -124,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)
@@ -166,9 +169,13 @@ export function settingsValidation(config, validationParams) {
         scheduler.pushRetryBackoffBase = fromSecondsToMillis(scheduler.pushRetryBackoffBase);
     }
     // validate sync enabled
-    if (withDefaults.sync.enabled !== false) { // @ts-ignore, modify readonly prop
+    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.2-rc.1",
+  "version": "1.4.2-rc.2",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

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);
   };
 }

package/src/storages/inMemory/InMemoryStorage.ts

@@ -6,6 +6,8 @@ import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { SplitIO } from '../../types';
+import { setToArray, ISet } from '../../utils/lang/sets';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -29,7 +31,20 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
-    }
+    },
+
+    // @ts-ignore, private method, for POC
+    getSnapshot(): SplitIO.PreloadedData {
+      return {
+        lastUpdated: Date.now(), // @ts-ignore accessing private prop
+        since: this.splits.changeNumber, // @ts-ignore accessing private prop
+        splitsData: this.splits.splitsCache, // @ts-ignore accessing private prop
+        segmentsData: Object.keys(this.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
+          prev[cur] = setToArray(this.segments.segmentCache[cur] as ISet<string>);
+          return prev;
+        }, {})
+      };
+    },
   };
 }
 

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -6,6 +6,7 @@ import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
+import { SplitIO } from '../../types';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -31,6 +32,18 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.events.clear();
     },
 
+    // @ts-ignore, private method, for POC
+    getSnapshot(): SplitIO.PreloadedData {
+      return {
+        lastUpdated: Date.now(), // @ts-ignore accessing private prop
+        since: this.splits.changeNumber, // @ts-ignore accessing private prop
+        splitsData: this.splits.splitsCache,
+        mySegmentsData: { // @ts-ignore accessing private prop
+          [params.matchingKey as string]: Object.keys(this.segments.segmentCache)
+        }
+      };
+    },
+
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {

package/src/sync/syncManagerOnline.ts

@@ -28,10 +28,10 @@ export function syncManagerOnlineFactory(
    */
   return function (params: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled } },  telemetryTracker } = params;
+    const { settings, settings: { log, streamingEnabled, sync: { enabled: syncEnabled, onlySubmitters } },  telemetryTracker } = params;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory && pollingManagerFactory(params);
+    const pollingManager = onlySubmitters ? undefined : pollingManagerFactory && pollingManagerFactory(params);
 
     /** Push Manager */
     const pushManager = syncEnabled && streamingEnabled && pollingManager && pushManagerFactory ?

package/src/trackers/impressionObserver/impressionObserverCS.ts

@@ -4,7 +4,7 @@ import { buildKey } from './buildKey';
 import { ImpressionDTO } from '../../types';
 
 export function hashImpression32(impression: ImpressionDTO) {
-  return hash(buildKey(impression));
+  return hash(buildKey(impression)).toString();
 }
 
 const LAST_SEEN_CACHE_SIZE = 500; // cache up to 500 impression hashes

package/src/types.ts

@@ -4,7 +4,7 @@ import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
 /* eslint-disable no-use-before-define */
 
-import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory, DataLoader } from './storages/types';
 import { ISyncManagerCS } from './sync/types';
 
 /**
@@ -98,6 +98,7 @@ export interface ISettings {
     eventsFirstPushWindow: number
   },
   readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
+  readonly dataLoader?: DataLoader,
   readonly integrations: Array<{
     readonly type: string,
     (params: IIntegrationFactoryParams): IIntegration | void
@@ -118,7 +119,8 @@ export interface ISettings {
     impressionsMode: SplitIO.ImpressionsMode,
     __splitFiltersValidation: ISplitFiltersValidation,
     localhostMode?: SplitIO.LocalhostFactory,
-    enabled: boolean
+    enabled: boolean,
+    onlySubmitters: boolean
   },
   readonly runtime: {
     ip: string | false
@@ -752,7 +754,7 @@ export namespace SplitIO {
      * This property is ignored if `mySegmentsData` was provided.
      */
     segmentsData?: {
-      [segmentName: string]: string
+      [segmentName: string]: string[]
     },
   }
   /**

package/src/utils/settingsValidation/index.ts

@@ -147,6 +147,9 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   // 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
@@ -193,10 +196,15 @@ export function settingsValidation(config: unknown, validationParams: ISettingsV
   }
 
   // validate sync enabled
-  if (withDefaults.sync.enabled !== false) { // @ts-ignore, modify readonly prop
+  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
   const splitFiltersValidation = validateSplitFilters(log, withDefaults.sync.splitFilters, withDefaults.mode);
   withDefaults.sync.splitFilters = splitFiltersValidation.validFilters;

package/types/storages/dataLoader.d.ts

@@ -1,10 +1,10 @@
 import { SplitIO } from '../types';
 import { DataLoader } 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 declare function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;
+export declare function DataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader;

package/types/trackers/impressionObserver/impressionObserverCS.d.ts

@@ -1,4 +1,4 @@
 import { ImpressionObserver } from './ImpressionObserver';
 import { ImpressionDTO } from '../../types';
-export declare function hashImpression32(impression: ImpressionDTO): number;
-export declare function impressionObserverCSFactory(): ImpressionObserver<number>;
+export declare function hashImpression32(impression: ImpressionDTO): string;
+export declare function impressionObserverCSFactory(): ImpressionObserver<string>;

package/types/types.d.ts

@@ -2,7 +2,7 @@ import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 import { ISdkFactoryContext } from './sdkFactory/types';
-import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory, DataLoader } from './storages/types';
 import { ISyncManagerCS } from './sync/types';
 /**
  * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
@@ -92,6 +92,7 @@ export interface ISettings {
         eventsFirstPushWindow: number;
     };
     readonly storage: IStorageSyncFactory | IStorageAsyncFactory;
+    readonly dataLoader?: DataLoader;
     readonly integrations: Array<{
         readonly type: string;
         (params: IIntegrationFactoryParams): IIntegration | void;
@@ -113,6 +114,7 @@ export interface ISettings {
         __splitFiltersValidation: ISplitFiltersValidation;
         localhostMode?: SplitIO.LocalhostFactory;
         enabled: boolean;
+        onlySubmitters: boolean;
     };
     readonly runtime: {
         ip: string | false;
@@ -749,7 +751,7 @@ export declare namespace SplitIO {
          * This property is ignored if `mySegmentsData` was provided.
          */
         segmentsData?: {
-            [segmentName: string]: string;
+            [segmentName: string]: string[];
         };
     }
     /**