@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -11,26 +11,57 @@ var MySegmentsCacheInMemory = /** @class */ (function (_super) {
         _this.segmentCache = {};
         return _this;
     }
+    MySegmentsCacheInMemory.prototype.clear = function () {
+        this.segmentCache = {};
+    };
     MySegmentsCacheInMemory.prototype.addToSegment = function (name) {
-        if (this.segmentCache[name])
-            return false;
         this.segmentCache[name] = true;
         return true;
     };
     MySegmentsCacheInMemory.prototype.removeFromSegment = function (name) {
-        if (!this.segmentCache[name])
-            return false;
         delete this.segmentCache[name];
         return true;
     };
     MySegmentsCacheInMemory.prototype.isInSegment = function (name) {
         return this.segmentCache[name] === true;
     };
-    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
-        this.cn = changeNumber;
-    };
-    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
-        return this.cn || -1;
+    /**
+     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
+     * @NOTE based on the way we use segments in the browser, this way is the best option
+     *
+     * @param {string[]} names list of segment names
+     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
+     */
+    MySegmentsCacheInMemory.prototype.resetSegments = function (names) {
+        var _this = this;
+        var isDiff = false;
+        var index;
+        var storedSegmentKeys = Object.keys(this.segmentCache);
+        // Extreme fast => everything is empty
+        if (names.length === 0 && storedSegmentKeys.length === names.length)
+            return isDiff;
+        // Quick path
+        if (storedSegmentKeys.length !== names.length) {
+            isDiff = true;
+            this.segmentCache = {};
+            names.forEach(function (s) {
+                _this.addToSegment(s);
+            });
+        }
+        else {
+            // Slowest path => we need to find at least 1 difference because
+            for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
+                // TODO: why empty statement?
+            }
+            if (index < names.length) {
+                isDiff = true;
+                this.segmentCache = {};
+                names.forEach(function (s) {
+                    _this.addToSegment(s);
+                });
+            }
+        }
+        return isDiff;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);

package/esm/storages/inMemory/SegmentsCacheInMemory.js

@@ -66,7 +66,7 @@ var SegmentsCacheInMemory = /** @class */ (function (_super) {
     };
     SegmentsCacheInMemory.prototype.getChangeNumber = function (name) {
         var value = this.segmentChangeNumber[name];
-        return isIntegerNumber(value) ? value : -1;
+        return isIntegerNumber(value) ? value : undefined;
     };
     return SegmentsCacheInMemory;
 }(AbstractSegmentsCacheSync));

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -13,7 +13,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.segmentsCount = 0;
+        _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -22,7 +22,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.segmentsCount = 0;
+        this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -32,9 +32,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if (usesSegments(previousSplit))
-                this.segmentsCount--;
+            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -45,7 +45,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if (usesSegments(split))
-                this.segmentsCount++;
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -64,7 +64,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if (usesSegments(split))
-                this.segmentsCount--;
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -88,7 +88,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
     SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,10 +18,9 @@ export function shouldRecordTelemetry(_a) {
     return settings.mode !== LOCALHOST_MODE && (settings.core.key === undefined || Math.random() <= ACCEPTANCE_RANGE);
 }
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+    function TelemetryCacheInMemory(splits, segments) {
         this.splits = splits;
         this.segments = segments;
-        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -37,7 +36,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -57,8 +59,6 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(QUEUED),
             eD: this.getEventStats(DROPPED),
@@ -190,11 +190,14 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+        this.updatesFromSSE[type]++;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/esm/storages/inRedis/RedisAdapter.js

@@ -17,7 +17,7 @@ var DEFAULT_OPTIONS = {
 var DEFAULT_LIBRARY_OPTIONS = {
     enableOfflineQueue: false,
     connectTimeout: DEFAULT_OPTIONS.connectionTimeout,
-    lazyConnect: false // @TODO true to avoid side-effects on instantiation.
+    lazyConnect: false
 };
 /**
  * Redis adapter on top of the library of choice (written with ioredis) for some extra control.

package/esm/storages/inRedis/SegmentsCacheInRedis.js

@@ -34,10 +34,10 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
+            return isNaNNumber(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/esm/storages/inRedis/index.js

@@ -9,17 +9,23 @@ import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
 import { UniqueKeysCacheInRedis } from './UniqueKeysCacheInRedis';
 import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 import { metadataBuilder } from '../utils';
+var RD;
+try {
+    // Using `require` to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
+    // Redis storage is not supported with .mjs files.
+    RD = require('./RedisAdapter').RedisAdapter;
+}
+catch (error) { /* empty */ }
 /**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
+ * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
 export function InRedisStorage(options) {
     if (options === void 0) { options = {}; }
-    // Lazy loading to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
-    // Redis storage is not supported with .mjs files.
-    var RD = require('./RedisAdapter').RedisAdapter;
     var prefix = validatePrefix(options.prefix);
     function InRedisStorageFactory(params) {
+        if (!RD)
+            throw new Error('The SDK Redis storage is unavailable. Make sure your runtime environment supports CommonJS (`require`) so the `ioredis` dependency can be imported.');
         var onReadyCb = params.onReadyCb, settings = params.settings, _a = params.settings, log = _a.log, impressionsMode = _a.sync.impressionsMode;
         var metadata = metadataBuilder(settings);
         var keys = new KeyBuilderSS(prefix, metadata);
@@ -27,7 +33,7 @@ export function InRedisStorage(options) {
         var telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
         var impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
         var uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
-        // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
+        // Subscription to Redis connect event in order to emit SDK_READY event on consumer mode
         redisClient.on('connect', function () {
             onReadyCb();
             if (impressionCountsCache)

package/esm/storages/pluggable/SegmentsCachePluggable.js

@@ -63,10 +63,10 @@ var SegmentsCachePluggable = /** @class */ (function () {
         var _this = this;
         return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return isNaNNumber(i) ? -1 : i;
+            return isNaNNumber(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     /**

package/esm/storages/pluggable/inMemoryWrapper.js

@@ -5,7 +5,7 @@ import { setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 export function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

package/esm/storages/pluggable/index.js

@@ -55,7 +55,6 @@ export function PluggableStorage(options) {
         var metadata = metadataBuilder(settings);
         var keys = new KeyBuilderSS(prefix, metadata);
         var wrapper = wrapperAdapter(log, options.wrapper);
-        var connectPromise;
         var isSyncronizer = mode === undefined; // If mode is not defined, the synchronizer is running
         var isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
         var telemetry = shouldRecordTelemetry(params) || isSyncronizer ?
@@ -73,6 +72,37 @@ export function PluggableStorage(options) {
                 settings.core.key === undefined ? new UniqueKeysCacheInMemory() : new UniqueKeysCacheInMemoryCS() :
                 new UniqueKeysCachePluggable(log, keys.buildUniqueKeysKey(), wrapper) :
             undefined;
+        // Connects to wrapper and emits SDK_READY event on main client
+        var connectPromise = wrapper.connect().then(function () {
+            if (isSyncronizer) {
+                // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
+                return wrapper.get(keys.buildHashKey()).then(function (hash) {
+                    var currentHash = getStorageHash(settings);
+                    if (hash !== currentHash) {
+                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
+                        return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
+                            return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
+                        }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
+                    }
+                }).then(function () {
+                    onReadyCb();
+                });
+            }
+            else {
+                // Start periodic flush of async storages if not running synchronizer (producer mode)
+                if (impressionCountsCache && impressionCountsCache.start)
+                    impressionCountsCache.start();
+                if (uniqueKeysCache && uniqueKeysCache.start)
+                    uniqueKeysCache.start();
+                if (telemetry && telemetry.recordConfig)
+                    telemetry.recordConfig();
+                onReadyCb();
+            }
+        }).catch(function (e) {
+            e = e || new Error('Error connecting wrapper');
+            onReadyCb(e);
+            return e; // Propagate error for shared clients
+        });
         return {
             splits: new SplitsCachePluggable(log, keys, wrapper, settings.sync.__splitFiltersValidation),
             segments: new SegmentsCachePluggable(log, keys, wrapper),
@@ -81,41 +111,6 @@ export function PluggableStorage(options) {
             events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
             telemetry: telemetry,
             uniqueKeys: uniqueKeysCache,
-            init: function () {
-                if (connectPromise)
-                    return connectPromise;
-                // Connects to wrapper and emits SDK_READY event on main client
-                return connectPromise = wrapper.connect().then(function () {
-                    if (isSyncronizer) {
-                        // In standalone or producer mode, clear storage if SDK key or feature flag filter has changed
-                        return wrapper.get(keys.buildHashKey()).then(function (hash) {
-                            var currentHash = getStorageHash(settings);
-                            if (hash !== currentHash) {
-                                log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
-                                return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
-                                    return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
-                                }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });
-                            }
-                        }).then(function () {
-                            onReadyCb();
-                        });
-                    }
-                    else {
-                        // Start periodic flush of async storages if not running synchronizer (producer mode)
-                        if (impressionCountsCache && impressionCountsCache.start)
-                            impressionCountsCache.start();
-                        if (uniqueKeysCache && uniqueKeysCache.start)
-                            uniqueKeysCache.start();
-                        if (telemetry && telemetry.recordConfig)
-                            telemetry.recordConfig();
-                        onReadyCb();
-                    }
-                }).catch(function (e) {
-                    e = e || new Error('Error connecting wrapper');
-                    onReadyCb(e);
-                    return e; // Propagate error for shared clients
-                });
-            },
             // Stop periodic flush and disconnect the underlying storage
             destroy: function () {
                 return Promise.all(isSyncronizer ? [] : [
@@ -125,7 +120,7 @@ export function PluggableStorage(options) {
             },
             // emits SDK_READY event on shared clients and returns a reference to the storage
             shared: function (_, onReadyCb) {
-                this.init().then(onReadyCb);
+                connectPromise.then(onReadyCb);
                 return __assign(__assign({}, this), { 
                     // no-op destroy, to disconnect the wrapper only when the main client is destroyed
                     destroy: function () { } });

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

package/esm/sync/polling/fetchers/mySegmentsFetcher.js

@@ -2,13 +2,16 @@
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMemberships) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
+export function mySegmentsFetcherFactory(fetchMySegments) {
+    return function mySegmentsFetcher(userMatchingKey, noCache, 
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
-        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
+        var mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
         if (decorator)
             mySegmentsPromise = decorator(mySegmentsPromise);
-        return mySegmentsPromise.then(function (resp) { return resp.json(); });
+        // Extract segment names
+        return mySegmentsPromise
+            .then(function (resp) { return resp.json(); })
+            .then(function (json) { return json.mySegments.map(function (segment) { return segment.name; }); });
     };
 }

package/esm/sync/polling/fetchers/segmentChangesFetcher.js

@@ -20,7 +20,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTil
  */
 export function segmentChangesFetcherFactory(fetchSegmentChanges) {
     return function segmentChangesFetcher(since, segmentName, noCache, till, 
-    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
         var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
         if (decorator)

package/esm/sync/polling/pollingManagerCS.js

@@ -43,7 +43,7 @@ export function pollingManagerCSFactory(params) {
         }
     });
     function add(matchingKey, readiness, storage) {
-        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
             if (!readiness.isReady() && !storage.splits.usesSegments())

package/esm/sync/polling/pollingManagerSS.js

@@ -1,6 +1,5 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 /**
  * Expose start / stop mechanism for pulling data from services.
@@ -19,9 +18,10 @@ export function pollingManagerSSFactory(params) {
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Splits will be refreshed each " + settings.scheduler.featuresRefreshRate + " millis"));
             log.debug(LOG_PREFIX_SYNC_POLLING + ("Segments will be refreshed each " + settings.scheduler.segmentsRefreshRate + " millis"));
             var startingUp = splitsSyncTask.start();
-            if (thenable(startingUp)) {
+            if (startingUp) {
                 startingUp.then(function () {
-                    segmentsSyncTask.start();
+                    if (splitsSyncTask.isRunning())
+                        segmentsSyncTask.start();
                 });
             }
         },

package/esm/sync/polling/syncTasks/mySegmentsSyncTask.js

@@ -4,6 +4,6 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export function mySegmentsSyncTaskFactory(fetchMemberships, storage, readiness, settings, matchingKey) {
-    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMemberships), storage, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+export function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
+    return syncTaskFactory(settings.log, mySegmentsUpdaterFactory(settings.log, mySegmentsFetcherFactory(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -1,15 +1,13 @@
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
-import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
-    var splits = storage.splits, segments = storage.segments, largeSegments = storage.largeSegments;
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -21,27 +19,36 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (segmentsData.type !== undefined) {
-            shouldNotifyUpdate = segmentsData.type === MEMBERSHIPS_LS_UPDATE ?
-                largeSegments.resetSegments(segmentsData) :
-                segments.resetSegments(segmentsData);
+        if (Array.isArray(segmentsData)) {
+            // Update the list of segment names available
+            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
         }
         else {
-            shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
-            shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
+            // Add/Delete the segment
+            var name_1 = segmentsData.name, add = segmentsData.add;
+            if (mySegmentsCache.isInSegment(name_1) !== add) {
+                shouldNotifyUpdate = true;
+                if (add)
+                    mySegmentsCache.addToSegment(name_1);
+                else
+                    mySegmentsCache.removeFromSegment(name_1);
+            }
+            else {
+                shouldNotifyUpdate = false;
+            }
         }
         // Notify update if required
-        if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentsData, noCache, till) {
+    function _mySegmentsUpdater(retry, segmentsData, noCache) {
         var updaterPromise = segmentsData ?
             // If segmentsData is provided, there is no need to fetch mySegments
             new Promise(function (res) { updateSegments(segmentsData); res(true); }) :
             // If not provided, fetch mySegments
-            mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);
@@ -68,9 +75,8 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmen
      *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
      *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
      * @param {boolean | undefined} noCache true to revalidate data to fetch
-     * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function mySegmentsUpdater(segmentsData, noCache, till) {
-        return _mySegmentsUpdater(0, segmentsData, noCache, till);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }

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

@@ -20,9 +20,9 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
         return sincePromise.then(function (since) {
             // if fetchOnlyNew flag, avoid processing already fetched segments
-            if (fetchOnlyNew && since !== -1)
+            if (fetchOnlyNew && since !== undefined)
                 return -1;
-            return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+            return segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
                 var changeNumber = -1;
                 var results = [];
                 changes.forEach(function (x) {

package/esm/sync/polling/updaters/splitChangesUpdater.js

@@ -1,6 +1,6 @@
 import { _Set, setToArray } from '../../../utils/lang/sets';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
@@ -11,7 +11,7 @@ function checkAllSegmentsExist(segments) {
     var registeredSegments = Promise.resolve(segments.getRegisteredSegments());
     return registeredSegments.then(function (segmentNames) {
         return Promise.all(segmentNames.map(function (segmentName) { return segments.getChangeNumber(segmentName); }))
-            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== -1; }); });
+            .then(function (changeNumbers) { return changeNumbers.every(function (changeNumber) { return changeNumber !== undefined; }); });
     });
 }
 /**
@@ -121,7 +121,7 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            return Promise.resolve(splitUpdateNotification ?
+            var fetcherPromise = Promise.resolve(splitUpdateNotification ?
                 { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
                 splitChangesFetcher(since, noCache, till, _promiseDecorator))
                 .then(function (splitChanges) {
@@ -165,6 +165,15 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
                 }
                 return false;
             });
+            // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+            // Wrapping in a promise since checkCache can be async.
+            if (splitsEventEmitter && startingUp) {
+                Promise.resolve(splits.checkCache()).then(function (isCacheReady) {
+                    if (isCacheReady)
+                        splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+                });
+            }
+            return fetcherPromise;
         }
         var sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error
         return sincePromise.then(_splitChangesUpdater);

package/esm/sync/streaming/AuthClient/index.js

@@ -10,7 +10,7 @@ import { hash } from '../../../utils/murmur3/murmur3';
 export function authenticateFactory(fetchAuth) {
     /**
      * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-     * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
+     * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
      */
     return function authenticate(userKeys) {
         return fetchAuth(userKeys)

package/esm/sync/streaming/SSEHandler/index.js

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
 import { STREAMING_PARSING_ERROR_FAILS, ERROR_STREAMING_SSE, STREAMING_PARSING_MESSAGE_FAILS, STREAMING_NEW_MESSAGE } from '../../../logger/constants';
 import { ABLY_ERROR, NON_REQUESTED, SSE_CONNECTION_ERROR } from '../../../utils/constants';
 /**
@@ -65,18 +65,20 @@ export function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             }
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(STREAMING_NEW_MESSAGE, [data]);
-            // we only handle update events if streaming is up
+            // we only handle update events if streaming is up.
             if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case SPLIT_UPDATE:
                 case SEGMENT_UPDATE:
-                case MEMBERSHIPS_MS_UPDATE:
-                case MEMBERSHIPS_LS_UPDATE:
+                case MY_SEGMENTS_UPDATE_V2:
                 case SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;
+                case MY_SEGMENTS_UPDATE:
+                    pushEmitter.emit(parsedData.type, parsedData, channel);
+                    break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case OCCUPANCY:
                     notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);