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

package/esm/storages/{AbstractSegmentsCacheSync.js → AbstractMySegmentsCacheSync.js}

@@ -2,35 +2,33 @@
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-var AbstractSegmentsCacheSync = /** @class */ (function () {
-    function AbstractSegmentsCacheSync() {
+var AbstractMySegmentsCacheSync = /** @class */ (function () {
+    function AbstractMySegmentsCacheSync() {
     }
     /**
      * clear the cache.
      */
-    AbstractSegmentsCacheSync.prototype.clear = function () {
+    AbstractMySegmentsCacheSync.prototype.clear = function () {
         this.resetSegments({});
     };
-    /**
-     * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
-     * For client-side synchronizer: the method is not used.
-     */
-    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    // No-op. Not used in client-side.
+    AbstractMySegmentsCacheSync.prototype.registerSegments = function () { return false; };
+    AbstractMySegmentsCacheSync.prototype.update = function () { return false; };
     /**
      * For server-side synchronizer: the method is not used.
      * For client-side synchronizer: it resets or updates the cache.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
+    AbstractMySegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
         var _this = this;
-        this.setChangeNumber(undefined, segmentsData.cn);
+        this.setChangeNumber(segmentsData.cn);
         var _a = segmentsData, added = _a.added, removed = _a.removed;
         if (added && removed) {
             var isDiff_1 = false;
             added.forEach(function (segment) {
-                isDiff_1 = _this.addToSegment(segment) || isDiff_1;
+                isDiff_1 = _this.addSegment(segment) || isDiff_1;
             });
             removed.forEach(function (segment) {
-                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
+                isDiff_1 = _this.removeSegment(segment) || isDiff_1;
             });
             return isDiff_1;
         }
@@ -47,13 +45,13 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
             return false;
         // Slowest path => add and/or remove segments
         for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-            this.removeFromSegment(storedSegmentKeys[removeIndex]);
+            this.removeSegment(storedSegmentKeys[removeIndex]);
         }
         for (var addIndex = index; addIndex < names.length; addIndex++) {
-            this.addToSegment(names[addIndex]);
+            this.addSegment(names[addIndex]);
         }
         return true;
     };
-    return AbstractSegmentsCacheSync;
+    return AbstractMySegmentsCacheSync;
 }());
-export { AbstractSegmentsCacheSync };
+export { AbstractMySegmentsCacheSync };

package/esm/storages/AbstractSplitsCacheAsync.js

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

package/esm/storages/AbstractSplitsCacheSync.js

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

package/esm/storages/dataLoader.js

@@ -1,79 +1,47 @@
-import { setToArray } from '../utils/lang/sets';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side 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.
- * @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
+ * @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 loadData(preloadedData, storage, userKey) {
-    // Do not load data if current preloadedData is empty
-    if (Object.keys(preloadedData).length === 0)
-        return;
-    var _a = preloadedData.segmentsData, segmentsData = _a === void 0 ? {} : _a, _b = preloadedData.since, since = _b === void 0 ? -1 : _b, _c = preloadedData.splitsData, splitsData = _c === void 0 ? [] : _c;
-    if (storage.splits) {
+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;
         var storedSince = storage.splits.getChangeNumber();
-        // Do not load data if current data is more recent
-        if (storedSince > since)
+        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)
             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(splitsData.map(function (split) { return ([split.name, split]); }));
-    }
-    if (userKey) { // add mySegments data (client-side)
-        var mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
+        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 userKeys = segmentsData[segmentName];
-                return userKeys.indexOf(userKey) > -1;
+                var userIds = JSON.parse(segmentsData[segmentName]).added;
+                return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
         storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
-    }
-    else { // add segments data (server-side)
-        Object.keys(segmentsData).filter(function (segmentName) {
-            var userKeys = segmentsData[segmentName];
-            storage.segments.addToSegment(segmentName, userKeys);
-        });
-    }
-}
-export function getSnapshot(storage, userKeys) {
-    return {
-        // lastUpdated: Date.now(),
-        // @ts-ignore accessing private prop
-        since: storage.splits.changeNumber,
-        splitsData: storage.splits.getAll(),
-        segmentsData: userKeys ?
-            undefined : // @ts-ignore accessing private prop
-            Object.keys(storage.segments.segmentCache).reduce(function (prev, cur) {
-                prev[cur] = setToArray(storage.segments.segmentCache[cur]);
-                return prev;
-            }, {}),
-        mySegmentsData: userKeys ?
-            userKeys.reduce(function (prev, userKey) {
-                // @ts-ignore accessing private prop
-                prev[userKey] = storage.shared ?
-                    // Client-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.shared(userKey).segments.segmentCache) :
-                    // Server-side segments
-                    // @ts-ignore accessing private prop
-                    Object.keys(storage.segments.segmentCache).reduce(function (prev, segmentName) {
-                        return storage.segments.segmentCache[segmentName].has(userKey) ?
-                            prev.concat(segmentName) :
-                            prev;
-                    }, []);
-                return prev;
-            }, {}) :
-            undefined
     };
 }

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,6 +1,6 @@
 import { __extends } from "tslib";
 import { isNaNNumber } from '../../utils/lang';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     __extends(MySegmentsCacheInLocal, _super);
@@ -11,7 +11,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return _this;
         // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
     }
-    MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.addSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
             if (localStorage.getItem(segmentKey) === DEFINED)
@@ -24,7 +24,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             return false;
         }
     };
-    MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
+    MySegmentsCacheInLocal.prototype.removeSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
             if (localStorage.getItem(segmentKey) !== DEFINED)
@@ -73,7 +73,7 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
     };
-    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
+    MySegmentsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         try {
             if (changeNumber)
                 localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
@@ -94,5 +94,5 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
         return n;
     };
     return MySegmentsCacheInLocal;
-}(AbstractSegmentsCacheSync));
+}(AbstractMySegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

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

package/esm/storages/inLocalStorage/index.js

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

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -6,15 +6,13 @@ 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, preloadedData = _a.preloadedData, onReadyFromCacheCb = params.onReadyFromCacheCb;
+    var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
     var largeSegments = new MySegmentsCacheInMemory();
@@ -38,16 +36,11 @@ export function InMemoryStorageCSFactory(params) {
             this.uniqueKeys && this.uniqueKeys.clear();
         },
         // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-        shared: function (matchingKey) {
-            var segments = new MySegmentsCacheInMemory();
-            var largeSegments = new MySegmentsCacheInMemory();
-            if (preloadedData) {
-                loadData(preloadedData, { segments: segments, largeSegments: largeSegments }, matchingKey);
-            }
+        shared: function () {
             return {
                 splits: this.splits,
-                segments: segments,
-                largeSegments: largeSegments,
+                segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -62,7 +55,7 @@ export function InMemoryStorageCSFactory(params) {
         },
     };
     // @TODO revisit storage logic in localhost mode
-    // No tracking data in localhost mode to avoid memory leaks
+    // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
     if (params.settings.mode === LOCALHOST_MODE) {
         var noopTrack = function () { return true; };
         storage.impressions.track = noopTrack;
@@ -72,11 +65,6 @@ 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/storages/inMemory/MySegmentsCacheInMemory.js

@@ -1,5 +1,5 @@
 import { __extends } from "tslib";
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
@@ -11,13 +11,13 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
-    MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
+    MySegmentsCacheInMemory.prototype.addSegment = function (name) {
         if (this.segmentCache[name])
             return false;
         this.segmentCache[name] = true;
         return true;
     };
-    MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
+    MySegmentsCacheInMemory.prototype.removeSegment = function (name) {
         if (!this.segmentCache[name])
             return false;
         delete this.segmentCache[name];
@@ -26,7 +26,7 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
+    MySegmentsCacheInMemory.prototype.setChangeNumber = function (changeNumber) {
         this.cn = changeNumber;
     };
     MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
@@ -39,5 +39,5 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         return 1;
     };
     return MySegmentsCacheInMemory;
-}(AbstractSegmentsCacheSync));
+}(AbstractMySegmentsCacheSync));
 export { MySegmentsCacheInMemory };

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -1,32 +1,20 @@
-import { __extends } from "tslib";
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
 /**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
-var SegmentsCacheInMemory = /** @class */ (function (_super) {
-    __extends(SegmentsCacheInMemory, _super);
+var SegmentsCacheInMemory = /** @class */ (function () {
     function SegmentsCacheInMemory() {
-        var _this = _super !== null && _super.apply(this, arguments) || this;
-        _this.segmentCache = {};
-        _this.segmentChangeNumber = {};
-        return _this;
+        this.segmentCache = {};
+        this.segmentChangeNumber = {};
     }
-    SegmentsCacheInMemory.prototype.addToSegment = function (name, segmentKeys) {
-        var values = this.segmentCache[name];
-        var keySet = values ? values : new _Set();
-        segmentKeys.forEach(function (k) { return keySet.add(k); });
-        this.segmentCache[name] = keySet;
-        return true;
-    };
-    SegmentsCacheInMemory.prototype.removeFromSegment = function (name, segmentKeys) {
-        var values = this.segmentCache[name];
-        var keySet = values ? values : new _Set();
-        segmentKeys.forEach(function (k) { return keySet.delete(k); });
+    SegmentsCacheInMemory.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
+        var keySet = this.segmentCache[name] || new _Set();
+        addedKeys.forEach(function (k) { return keySet.add(k); });
+        removedKeys.forEach(function (k) { return keySet.delete(k); });
         this.segmentCache[name] = keySet;
-        return true;
+        this.segmentChangeNumber[name] = changeNumber;
+        return addedKeys.length > 0 || removedKeys.length > 0;
     };
     SegmentsCacheInMemory.prototype.isInSegment = function (name, key) {
         var segmentValues = this.segmentCache[name];
@@ -60,14 +48,12 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
             return acum + _this.segmentCache[segmentName].size;
         }, 0);
     };
-    SegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
-        this.segmentChangeNumber[name] = changeNumber;
-        return true;
-    };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
         return isIntegerNumber(value) ? value : -1;
     };
+    // No-op. Not used in server-side
+    SegmentsCacheInMemory.prototype.resetSegments = function () { return false; };
     return SegmentsCacheInMemory;
-}(AbstractSegmentsCacheSync));
+}());
 export { SegmentsCacheInMemory };

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -4,7 +4,6 @@ import { isFiniteNumber } from '../../utils/lang';
 import { _Set } from '../../utils/lang/sets';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     __extends(SplitsCacheInMemory, _super);

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -6,30 +6,24 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         this.redis = redis;
         this.keys = keys;
     }
-    SegmentsCacheInRedis.prototype.addToSegment = function (name, segmentKeys) {
+    /**
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., Redis operation fails).
+     */
+    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.sadd(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
-    };
-    SegmentsCacheInRedis.prototype.removeFromSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.redis.srem(segmentKey, segmentKeys).then(function () { return true; });
-        }
-        else {
-            return Promise.resolve(true);
-        }
+        return Promise.all([
+            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
+            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
+            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
         return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
     };
-    SegmentsCacheInRedis.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '').then(function (status) { return status === 'OK'; });
-    };
     SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {

package/esm/storages/pluggable/SegmentsCachePluggable.js

@@ -12,32 +12,19 @@ var SegmentsCachePluggable = /** @class */ (function () {
         this.wrapper = wrapper;
     }
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    SegmentsCachePluggable.prototype.addToSegment = function (name, segmentKeys) {
-        var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.addItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
-    };
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    SegmentsCachePluggable.prototype.removeFromSegment = function (name, segmentKeys) {
+    SegmentsCachePluggable.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        if (segmentKeys.length) {
-            return this.wrapper.removeItems(segmentKey, segmentKeys);
-        }
-        else {
-            return Promise.resolve();
-        }
+        return Promise.all([
+            addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+            removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+            this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+        ]).then(function () {
+            return addedKeys.length > 0 || removedKeys.length > 0;
+        });
     };
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
@@ -46,14 +33,6 @@ var SegmentsCachePluggable = /** @class */ (function () {
     SegmentsCachePluggable.prototype.isInSegment = function (name, key) {
         return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
     };
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    SegmentsCachePluggable.prototype.setChangeNumber = function (name, changeNumber) {
-        return this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '');
-    };
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/esm/sync/offline/syncManagerOffline.js

@@ -16,23 +16,30 @@ export function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        return objectAssign(fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings), {
+        var mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
+        var mainStart = mainSyncManager.start;
+        var sharedStarts = [];
+        return objectAssign(mainSyncManager, {
+            start: function () {
+                mainStart();
+                sharedStarts.forEach(function (cb) { return cb(); });
+                sharedStarts.length = 0;
+            },
             // fake flush, that resolves immediately
             flush: flush,
             // [Only used for client-side]
             shared: function (matchingKey, readinessManager) {
+                // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+                // SDK_READY cannot be emitted directly because this will not update the readiness status
+                function emitSdkReady() {
+                    readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+                }
+                if (mainSyncManager.isRunning())
+                    setTimeout(emitSdkReady);
+                else
+                    sharedStarts.push(emitSdkReady);
                 return {
-                    start: function () {
-                        // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-                        // SDK_READY cannot be emitted directly because this will not update the readiness status
-                        setTimeout(function () {
-                            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-                        }, 0);
-                    },
                     stop: function () { },
-                    isRunning: function () {
-                        return true;
-                    },
                     flush: flush,
                 };
             }

package/esm/sync/offline/syncTasks/fromObjectSyncTask.js

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