@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.0

package/esm/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -1,4 +1,5 @@
 import { __extends } from "tslib";
+import { isNaNNumber } from '../../utils/lang';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { LOG_PREFIX, DEFINED } from './constants';
 var MySegmentsCacheInLocal = /** @class */ (function (_super) {
@@ -10,19 +11,11 @@ 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
     }
-    /**
-     * Removes list of segments from localStorage
-     * @NOTE this method is not being used at the moment.
-     */
-    MySegmentsCacheInLocal.prototype.clear = function () {
-        this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
-        // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-        // We could optimize next sentence, since it implies iterating over all localStorage items
-        this.resetSegments([]);
-    };
     MySegmentsCacheInLocal.prototype.addToSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) === DEFINED)
+                return false;
             localStorage.setItem(segmentKey, DEFINED);
             return true;
         }
@@ -34,6 +27,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) !== DEFINED)
+                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -45,30 +40,22 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
     };
-    /**
-     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-     *
-     * @param {string[]} segmentNames list of segment names
-     * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-     */
-    MySegmentsCacheInLocal.prototype.resetSegments = function (names) {
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var _this = this;
-        var isDiff = false;
-        var index;
         // Scan current values from localStorage
-        var storedSegmentNames = Object.keys(localStorage).reduce(function (accum, key) {
+        return Object.keys(localStorage).reduce(function (accum, key) {
             var segmentName = _this.keys.extractSegmentName(key);
             if (segmentName) {
                 accum.push(segmentName);
             }
             else {
-                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
+                // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
                 segmentName = _this.keys.extractOldSegmentKey(key);
                 if (segmentName) { // this was an old segment key, let's clean up.
                     var newSegmentKey = _this.keys.buildSegmentNameKey(segmentName);
                     try {
                         // If the new format key is not there, create it.
-                        if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+                        if (!localStorage.getItem(newSegmentKey)) {
                             localStorage.setItem(newSegmentKey, DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -82,40 +69,30 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
             }
             return accum;
         }, []);
-        // Extreme fast => everything is empty
-        if (names.length === 0 && storedSegmentNames.length === names.length)
-            return isDiff;
-        // Quick path
-        if (storedSegmentNames.length !== names.length) {
-            isDiff = true;
-            storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
-            names.forEach(function (name) { return _this.addToSegment(name); });
-        }
-        else {
-            // Slowest path => we need to find at least 1 difference because
-            for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
-                // TODO: why empty statement?
-            }
-            if (index < names.length) {
-                isDiff = true;
-                storedSegmentNames.forEach(function (name) { return _this.removeFromSegment(name); });
-                names.forEach(function (name) { return _this.addToSegment(name); });
-            }
-        }
-        return isDiff;
-    };
-    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
-        var _this = this;
-        return Object.keys(localStorage).reduce(function (accum, key) {
-            var segmentName = _this.keys.extractSegmentName(key);
-            if (segmentName)
-                accum.push(segmentName);
-            return accum;
-        }, []);
     };
     MySegmentsCacheInLocal.prototype.getKeysCount = function () {
         return 1;
     };
+    MySegmentsCacheInLocal.prototype.setChangeNumber = function (name, changeNumber) {
+        try {
+            if (changeNumber)
+                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+            else
+                localStorage.removeItem(this.keys.buildTillKey());
+        }
+        catch (e) {
+            this.log.error(e);
+        }
+    };
+    MySegmentsCacheInLocal.prototype.getChangeNumber = function () {
+        var n = -1;
+        var value = localStorage.getItem(this.keys.buildTillKey());
+        if (value !== null) {
+            value = parseInt(value, 10);
+            return isNaNNumber(value) ? n : value;
+        }
+        return n;
+    };
     return MySegmentsCacheInLocal;
 }(AbstractSegmentsCacheSync));
 export { MySegmentsCacheInLocal };

package/esm/storages/inLocalStorage/index.js

@@ -2,7 +2,7 @@ import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -33,9 +33,11 @@ export function InLocalStorage(options) {
         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));
         return {
             splits: splits,
             segments: segments,
+            largeSegments: largeSegments,
             impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
             impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
             events: new EventsCacheInMemory(eventsQueueSize),
@@ -45,6 +47,7 @@ export function InLocalStorage(options) {
                 var _a;
                 this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                 this.segments = new MySegmentsCacheInMemory();
+                this.largeSegments = new MySegmentsCacheInMemory();
                 this.impressions.clear();
                 this.impressionCounts && this.impressionCounts.clear();
                 this.events.clear();
@@ -52,10 +55,10 @@ export function InLocalStorage(options) {
             },
             // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
             shared: function (matchingKey) {
-                var childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);
                 return {
                     splits: this.splits,
-                    segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
+                    segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
+                    largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
                     impressions: this.impressions,
                     impressionCounts: this.impressionCounts,
                     events: this.events,
@@ -63,6 +66,7 @@ export function InLocalStorage(options) {
                     destroy: function () {
                         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                         this.segments = new MySegmentsCacheInMemory();
+                        this.largeSegments = new MySegmentsCacheInMemory();
                     }
                 };
             },

package/esm/storages/inMemory/InMemoryStorageCS.js

@@ -15,9 +15,11 @@ export function InMemoryStorageCSFactory(params) {
     var _a = params.settings, _b = _a.scheduler, impressionsQueueSize = _b.impressionsQueueSize, eventsQueueSize = _b.eventsQueueSize, _c = _a.sync, impressionsMode = _c.impressionsMode, __splitFiltersValidation = _c.__splitFiltersValidation;
     var splits = new SplitsCacheInMemory(__splitFiltersValidation);
     var segments = new MySegmentsCacheInMemory();
+    var largeSegments = new MySegmentsCacheInMemory();
     var storage = {
         splits: splits,
         segments: segments,
+        largeSegments: largeSegments,
         impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
         impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
         events: new EventsCacheInMemory(eventsQueueSize),
@@ -27,6 +29,7 @@ export function InMemoryStorageCSFactory(params) {
         destroy: function () {
             this.splits.clear();
             this.segments.clear();
+            this.largeSegments.clear();
             this.impressions.clear();
             this.impressionCounts && this.impressionCounts.clear();
             this.events.clear();
@@ -37,6 +40,7 @@ export function InMemoryStorageCSFactory(params) {
             return {
                 splits: this.splits,
                 segments: new MySegmentsCacheInMemory(),
+                largeSegments: new MySegmentsCacheInMemory(),
                 impressions: this.impressions,
                 impressionCounts: this.impressionCounts,
                 events: this.events,
@@ -45,6 +49,7 @@ export function InMemoryStorageCSFactory(params) {
                 destroy: function () {
                     this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
                     this.segments.clear();
+                    this.largeSegments.clear();
                 }
             };
         },

package/esm/storages/inMemory/MySegmentsCacheInMemory.js

@@ -11,57 +11,26 @@ 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;
     };
-    /**
-     * 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.setChangeNumber = function (name, changeNumber) {
+        this.cn = changeNumber;
+    };
+    MySegmentsCacheInMemory.prototype.getChangeNumber = function () {
+        return this.cn || -1;
     };
     MySegmentsCacheInMemory.prototype.getRegisteredSegments = function () {
         return Object.keys(this.segmentCache);

package/esm/storages/inMemory/SplitsCacheInMemory.js

@@ -13,7 +13,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.splitsWithSegmentsCount = 0;
+        _this.segmentsCount = 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.splitsWithSegmentsCount = 0;
+        this.segmentsCount = 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);
-            if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
-                this.splitsWithSegmentsCount--;
-            }
+            // Subtract from segments count for the previous version of this Split
+            if (usesSegments(previousSplit))
+                this.segmentsCount--;
         }
         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.splitsWithSegmentsCount++;
+                this.segmentsCount++;
             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.splitsWithSegmentsCount--;
+                this.segmentsCount--;
             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.splitsWithSegmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/esm/storages/inMemory/TelemetryCacheInMemory.js

@@ -18,9 +18,10 @@ 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) {
+    function TelemetryCacheInMemory(splits, segments, largeSegments) {
         this.splits = splits;
         this.segments = segments;
+        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -36,10 +37,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0
-        };
+        this.updatesFromSSE = {};
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -59,6 +57,8 @@ 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,14 +190,11 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {
-            sp: 0,
-            ms: 0,
-        };
+        this.updatesFromSSE = {};
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type]++;
+        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
         this.e = false;
     };
     return TelemetryCacheInMemory;

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 inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

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

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

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 `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchSegmentChanges` 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.fetchMySegments, storage, readiness, settings, matchingKey);
+        var mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
         // smart ready
         function smartReady() {
             if (!readiness.isReady() && !storage.splits.usesSegments())

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(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');
+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');
 }

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

@@ -1,13 +1,15 @@
 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, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
+    var splits = storage.splits, segments = storage.segments, largeSegments = storage.largeSegments;
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -19,36 +21,27 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Update the list of segment names available
-            shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+        if (segmentsData.type !== undefined) {
+            shouldNotifyUpdate = segmentsData.type === MEMBERSHIPS_LS_UPDATE ?
+                largeSegments.resetSegments(segmentsData) :
+                segments.resetSegments(segmentsData);
         }
         else {
-            // 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;
-            }
+            shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
+            shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
-        if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+        if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
             readyOnAlreadyExistentState = false;
             segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
         }
     }
-    function _mySegmentsUpdater(retry, segmentsData, noCache) {
+    function _mySegmentsUpdater(retry, segmentsData, noCache, till) {
         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, _promiseDecorator).then(function (segments) {
+            mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(function (segments) {
                 // Only when we have downloaded segments completely, we should not keep retrying anymore
                 startingUp = false;
                 updateSegments(segments);
@@ -75,8 +68,9 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
      *  (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) {
-        return _mySegmentsUpdater(0, segmentsData, noCache);
+    return function mySegmentsUpdater(segmentsData, noCache, till) {
+        return _mySegmentsUpdater(0, segmentsData, noCache, till);
     };
 }

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 MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+     * @param {string[] | undefined} userKeys set of user Keys to track membership updates. 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, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_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,20 +65,18 @@ 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 MY_SEGMENTS_UPDATE_V2:
+                case MEMBERSHIPS_MS_UPDATE:
+                case MEMBERSHIPS_LS_UPDATE:
                 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);