@splitsoftware/splitio-commons 1.16.1-rc.10 → 1.16.1-rc.12

package/cjs/logger/constants.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ENGINE_VALUE_INVALID = exports.USER_CONSENT_INITIAL = exports.USER_CONSENT_NOT_UPDATED = exports.USER_CONSENT_UPDATED = exports.IMPRESSIONS_TRACKER_SUCCESS = exports.EVENTS_TRACKER_SUCCESS = exports.SYNC_STOP_POLLING = exports.SYNC_CONTINUE_POLLING = exports.SYNC_START_POLLING = exports.SUBMITTERS_PUSH = exports.SUBMITTERS_PUSH_FULL_QUEUE = exports.STREAMING_DISCONNECTING = exports.STREAMING_DISABLED = exports.STREAMING_CONNECTING = exports.STREAMING_RECONNECT = exports.STREAMING_REFRESH_TOKEN = exports.SYNC_SPLITS_FETCH_RETRY = exports.POLLING_STOP = exports.POLLING_START = exports.POLLING_SMART_PAUSING = exports.NEW_FACTORY = exports.NEW_SHARED_CLIENT = exports.IMPRESSION_QUEUEING = exports.IMPRESSION = exports.CLIENT_READY = exports.CLIENT_READY_FROM_CACHE = exports.ENGINE_MATCHER_RESULT = exports.SETTINGS_SPLITS_FILTER = exports.SYNC_TASK_STOP = exports.SYNC_TASK_EXECUTE = exports.SYNC_TASK_START = exports.STREAMING_NEW_MESSAGE = exports.SYNC_SPLITS_SEGMENTS = exports.SYNC_SPLITS_REMOVED = exports.SYNC_SPLITS_NEW = exports.SYNC_SPLITS_FETCH = exports.SYNC_OFFLINE_DATA = exports.RETRIEVE_MANAGER = exports.RETRIEVE_CLIENT_EXISTING = exports.RETRIEVE_CLIENT_DEFAULT = exports.CLEANUP_DEREGISTERING = exports.CLEANUP_REGISTERING = exports.ENGINE_SANITIZE = exports.ENGINE_VALUE = exports.ENGINE_MATCHER_DEPENDENCY_PRE = exports.ENGINE_MATCHER_DEPENDENCY = exports.ENGINE_BUCKET = exports.ENGINE_COMBINER_IFELSEIF_NO_TREATMENT = exports.ENGINE_COMBINER_IFELSEIF = exports.ENGINE_COMBINER_AND = void 0;
-exports.ERROR_INVALID_CONFIG_PARAM = exports.ERROR_EMPTY_ARRAY = exports.ERROR_EMPTY = exports.ERROR_INVALID = exports.ERROR_INVALID_KEY_OBJECT = exports.ERROR_TOO_LONG = exports.ERROR_NULL = exports.ERROR_CLIENT_DESTROYED = exports.ERROR_NOT_FINITE = exports.ERROR_SIZE_EXCEEDED = exports.ERROR_NOT_PLAIN_OBJECT = exports.ERROR_EVENT_TYPE_FORMAT = exports.ERROR_EVENTS_TRACKER = exports.ERROR_IMPRESSIONS_LISTENER = exports.ERROR_IMPRESSIONS_TRACKER = exports.ERROR_STREAMING_AUTH = exports.ERROR_STREAMING_SSE = exports.ERROR_SYNC_OFFLINE_LOADING = exports.ERROR_CLIENT_CANNOT_GET_READY = exports.ERROR_CLIENT_LISTENER = exports.ERROR_LOGLEVEL_INVALID = exports.ERROR_ENGINE_COMBINER_IFELSEIF = exports.WARN_FLAGSET_WITHOUT_FLAGS = exports.WARN_FLAGSET_NOT_CONFIGURED = exports.WARN_LOWERCASE_FLAGSET = exports.WARN_INVALID_FLAGSET = exports.STREAMING_PARSING_SPLIT_UPDATE = exports.STREAMING_PARSING_MY_SEGMENTS_UPDATE = exports.WARN_SDK_KEY = exports.WARN_SPLITS_FILTER_EMPTY = exports.WARN_SPLITS_FILTER_INVALID = exports.WARN_SPLITS_FILTER_IGNORED = exports.WARN_INTEGRATION_INVALID = exports.WARN_NOT_EXISTENT_TT = exports.WARN_LOWERCASE_TRAFFIC_TYPE = exports.WARN_NOT_EXISTENT_SPLIT = exports.WARN_TRIMMING = exports.WARN_CONVERTING = exports.WARN_TRIMMING_PROPERTIES = exports.WARN_SETTING_NULL = exports.SUBMITTERS_PUSH_RETRY = exports.SUBMITTERS_PUSH_FAILS = exports.STREAMING_FALLBACK = exports.STREAMING_PARSING_MESSAGE_FAILS = exports.STREAMING_PARSING_ERROR_FAILS = exports.SYNC_SPLITS_FETCH_FAILS = exports.SYNC_MYSEGMENTS_FETCH_RETRY = exports.CLIENT_NOT_READY = exports.CLIENT_NO_LISTENER = exports.ENGINE_VALUE_NO_ATTRIBUTES = void 0;
+exports.ERROR_INVALID_CONFIG_PARAM = exports.ERROR_EMPTY_ARRAY = exports.ERROR_EMPTY = exports.ERROR_INVALID = exports.ERROR_INVALID_KEY_OBJECT = exports.ERROR_TOO_LONG = exports.ERROR_NULL = exports.ERROR_CLIENT_DESTROYED = exports.ERROR_NOT_FINITE = exports.ERROR_SIZE_EXCEEDED = exports.ERROR_NOT_PLAIN_OBJECT = exports.ERROR_EVENT_TYPE_FORMAT = exports.ERROR_EVENTS_TRACKER = exports.ERROR_IMPRESSIONS_LISTENER = exports.ERROR_IMPRESSIONS_TRACKER = exports.ERROR_STREAMING_AUTH = exports.ERROR_STREAMING_SSE = exports.ERROR_SYNC_OFFLINE_LOADING = exports.ERROR_CLIENT_CANNOT_GET_READY = exports.ERROR_CLIENT_LISTENER = exports.ERROR_LOGLEVEL_INVALID = exports.ERROR_ENGINE_COMBINER_IFELSEIF = exports.WARN_FLAGSET_WITHOUT_FLAGS = exports.WARN_FLAGSET_NOT_CONFIGURED = exports.WARN_LOWERCASE_FLAGSET = exports.WARN_INVALID_FLAGSET = exports.STREAMING_PARSING_SPLIT_UPDATE = exports.STREAMING_PARSING_MEMBERSHIPS_UPDATE = exports.WARN_SDK_KEY = exports.WARN_SPLITS_FILTER_EMPTY = exports.WARN_SPLITS_FILTER_INVALID = exports.WARN_SPLITS_FILTER_IGNORED = exports.WARN_INTEGRATION_INVALID = exports.WARN_NOT_EXISTENT_TT = exports.WARN_LOWERCASE_TRAFFIC_TYPE = exports.WARN_NOT_EXISTENT_SPLIT = exports.WARN_TRIMMING = exports.WARN_CONVERTING = exports.WARN_TRIMMING_PROPERTIES = exports.WARN_SETTING_NULL = exports.SUBMITTERS_PUSH_RETRY = exports.SUBMITTERS_PUSH_FAILS = exports.STREAMING_FALLBACK = exports.STREAMING_PARSING_MESSAGE_FAILS = exports.STREAMING_PARSING_ERROR_FAILS = exports.SYNC_SPLITS_FETCH_FAILS = exports.SYNC_MYSEGMENTS_FETCH_RETRY = exports.CLIENT_NOT_READY = exports.CLIENT_NO_LISTENER = exports.ENGINE_VALUE_NO_ATTRIBUTES = void 0;
 exports.LOG_PREFIX_CLEANUP = exports.LOG_PREFIX_UNIQUE_KEYS_TRACKER = exports.LOG_PREFIX_EVENTS_TRACKER = exports.LOG_PREFIX_IMPRESSIONS_TRACKER = exports.LOG_PREFIX_SYNC_SUBMITTERS = exports.LOG_PREFIX_SYNC_POLLING = exports.LOG_PREFIX_SYNC_MYSEGMENTS = exports.LOG_PREFIX_SYNC_SEGMENTS = exports.LOG_PREFIX_SYNC_SPLITS = exports.LOG_PREFIX_SYNC_STREAMING = exports.LOG_PREFIX_SYNC_OFFLINE = exports.LOG_PREFIX_SYNC_MANAGER = exports.LOG_PREFIX_SYNC = exports.LOG_PREFIX_ENGINE_VALUE = exports.LOG_PREFIX_ENGINE_MATCHER = exports.LOG_PREFIX_ENGINE_COMBINER = exports.LOG_PREFIX_ENGINE = exports.LOG_PREFIX_CLIENT_INSTANTIATION = exports.LOG_PREFIX_INSTANTIATION = exports.LOG_PREFIX_SETTINGS = exports.ENGINE_MATCHER_ERROR = exports.ERROR_SETS_FILTER_EXCLUSIVE = exports.ERROR_TOO_MANY_SETS = exports.ERROR_MIN_CONFIG_PARAM = exports.ERROR_NOT_BOOLEAN = exports.ERROR_STORAGE_INVALID = exports.ERROR_LOCALHOST_MODULE_REQUIRED = exports.ERROR_HTTP = void 0;
 /**
  * Message codes used to trim string log messages from commons and client-side API modules,
@@ -82,7 +82,7 @@ exports.WARN_SPLITS_FILTER_IGNORED = 219;
 exports.WARN_SPLITS_FILTER_INVALID = 220;
 exports.WARN_SPLITS_FILTER_EMPTY = 221;
 exports.WARN_SDK_KEY = 222;
-exports.STREAMING_PARSING_MY_SEGMENTS_UPDATE = 223;
+exports.STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
 exports.STREAMING_PARSING_SPLIT_UPDATE = 224;
 exports.WARN_INVALID_FLAGSET = 225;
 exports.WARN_LOWERCASE_FLAGSET = 226;

package/cjs/logger/messages/warn.js

@@ -34,7 +34,7 @@ exports.codesWarn = error_1.codesError.concat([
     [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS + ': feature flag filter at position %s is invalid. It must be an object with a valid filter type ("bySet", "byName" or "byPrefix") and a list of "values".'],
     [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS + ': feature flag filter configuration must be a non-empty array of filter objects.'],
     [c.WARN_SDK_KEY, c.LOG_PREFIX_SETTINGS + ': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
-    [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
+    [c.STREAMING_PARSING_MEMBERSHIPS_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching Memberships due to an error processing %s notification: %s'],
     [c.STREAMING_PARSING_SPLIT_UPDATE, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching SplitChanges due to an error processing SPLIT_UPDATE notification: %s'],
     [c.WARN_INVALID_FLAGSET, '%s: you passed %s, flag set must adhere to the regular expressions %s. This means a flag set must start with a letter or number, be in lowercase, alphanumeric and have a max length of 50 characters. %s was discarded.'],
     [c.WARN_LOWERCASE_FLAGSET, '%s: flag set %s should be all lowercase - converting string to lowercase.'],

package/cjs/services/splitApi.js

@@ -54,15 +54,15 @@ function splitApiFactory(settings, platform, telemetryTracker) {
             var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.SEGMENT));
         },
-        fetchMemberships: function (userMatchingKey, noCache) {
+        fetchMemberships: function (userMatchingKey, noCache, till) {
             /**
              * URI encoding of user keys in order to:
              *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
              *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
              *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
              */
-            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey);
-            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MY_SEGMENT));
+            var url = urls.sdk + "/memberships/" + encodeURIComponent(userMatchingKey) + (till ? '?till=' + till : '');
+            return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(constants_1.MEMBERSHIPS));
         },
         /**
          * Post events.

package/cjs/storages/AbstractSegmentsCacheSync.js

@@ -9,20 +9,54 @@ var AbstractSegmentsCacheSync = /** @class */ (function () {
     function AbstractSegmentsCacheSync() {
     }
     /**
-     * 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.
+     * clear the cache.
      */
-    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
+    AbstractSegmentsCacheSync.prototype.clear = function () {
+        this.resetSegments({});
+    };
     /**
-     * For server-side synchronizer: set the change number of `name` segment.
+     * 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.setChangeNumber = function (name, changeNumber) { return true; };
+    AbstractSegmentsCacheSync.prototype.registerSegments = function (names) { return false; };
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: reset the cache with the given list of segments.
+     * For client-side synchronizer: it resets or updates the cache.
      */
-    AbstractSegmentsCacheSync.prototype.resetSegments = function (names, changeNumber) { return true; };
+    AbstractSegmentsCacheSync.prototype.resetSegments = function (segmentsData) {
+        var _this = this;
+        this.setChangeNumber(undefined, 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;
+            });
+            removed.forEach(function (segment) {
+                isDiff_1 = _this.removeFromSegment(segment) || isDiff_1;
+            });
+            return isDiff_1;
+        }
+        var names = (segmentsData.k || []).map(function (s) { return s.n; }).sort();
+        var storedSegmentKeys = this.getRegisteredSegments().sort();
+        // Extreme fast => everything is empty
+        if (!names.length && !storedSegmentKeys.length)
+            return false;
+        var index = 0;
+        while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index])
+            index++;
+        // Quick path => no changes
+        if (index === names.length && index === storedSegmentKeys.length)
+            return false;
+        // Slowest path => add and/or remove segments
+        for (var removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+            this.removeFromSegment(storedSegmentKeys[removeIndex]);
+        }
+        for (var addIndex = index; addIndex < names.length; addIndex++) {
+            this.addToSegment(names[addIndex]);
+        }
+        return true;
+    };
     return AbstractSegmentsCacheSync;
 }());
 exports.AbstractSegmentsCacheSync = AbstractSegmentsCacheSync;

package/cjs/storages/dataLoader.js

@@ -45,7 +45,7 @@ function dataLoaderFactory(preloadedData) {
                 return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
             });
         }
-        storage.segments.resetSegments(mySegmentsData);
+        storage.segments.resetSegments({ k: mySegmentsData.map(function (s) { return ({ n: s }); }) });
     };
 }
 exports.dataLoaderFactory = dataLoaderFactory;

package/cjs/storages/inLocalStorage/MySegmentsCacheInLocal.js

@@ -14,19 +14,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(constants_1.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) === constants_1.DEFINED)
+                return false;
             localStorage.setItem(segmentKey, constants_1.DEFINED);
             return true;
         }
@@ -38,6 +30,8 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.removeFromSegment = function (name) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
         try {
+            if (localStorage.getItem(segmentKey) !== constants_1.DEFINED)
+                return false;
             localStorage.removeItem(segmentKey);
             return true;
         }
@@ -49,41 +43,22 @@ var MySegmentsCacheInLocal = /** @class */ (function (_super) {
     MySegmentsCacheInLocal.prototype.isInSegment = function (name) {
         return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === constants_1.DEFINED;
     };
-    /**
-     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-     *
-     * @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)
-     */
-    MySegmentsCacheInLocal.prototype.resetSegments = function (names, changeNumber) {
+    MySegmentsCacheInLocal.prototype.getRegisteredSegments = function () {
         var _this = this;
-        try {
-            if (changeNumber) {
-                localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
-            }
-            else {
-                localStorage.removeItem(this.keys.buildTillKey());
-            }
-        }
-        catch (e) {
-            this.log.error(e);
-        }
-        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, constants_1.DEFINED);
                             // we are migrating a segment, let's track it.
                             accum.push(segmentName);
@@ -97,40 +72,21 @@ 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());

package/cjs/storages/inMemory/MySegmentsCacheInMemory.js

@@ -14,58 +14,23 @@ 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, changeNumber) {
-        var _this = this;
+    MySegmentsCacheInMemory.prototype.setChangeNumber = function (name, changeNumber) {
         this.cn = changeNumber;
-        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.getChangeNumber = function () {
         return this.cn || -1;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -62,7 +62,7 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
             lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(constants_1.QUEUED),

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

@@ -6,10 +6,10 @@ exports.mySegmentsFetcherFactory = void 0;
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
 function mySegmentsFetcherFactory(fetchMemberships) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, 
+    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
     // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator) {
-        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache);
+        var mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
         if (decorator)
             mySegmentsPromise = decorator(mySegmentsPromise);
         return mySegmentsPromise.then(function (resp) { return resp.json(); });

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

@@ -4,6 +4,7 @@ exports.mySegmentsUpdaterFactory = void 0;
 var timeout_1 = require("../../../utils/promise/timeout");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
+var constants_3 = require("../../streaming/constants");
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
@@ -22,26 +23,15 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
     }
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
-        var _a, _b, _c, _d;
         var shouldNotifyUpdate;
-        if (Array.isArray(segmentsData)) {
-            // Add/Delete the segment names
-            segmentsData.forEach(function (_a) {
-                var isLS = _a.isLS, name = _a.name, add = _a.add;
-                var cache = isLS ? largeSegments : segments;
-                if (cache.isInSegment(name) !== add) {
-                    shouldNotifyUpdate = true;
-                    if (add)
-                        cache.addToSegment(name);
-                    else
-                        cache.removeFromSegment(name);
-                }
-            });
+        if (segmentsData.type !== undefined) {
+            shouldNotifyUpdate = segmentsData.type === constants_3.MEMBERSHIPS_LS_UPDATE ?
+                largeSegments.resetSegments(segmentsData) :
+                segments.resetSegments(segmentsData);
         }
         else {
-            // Reset the list of segment names
-            shouldNotifyUpdate = segments.resetSegments((((_a = segmentsData.ms) === null || _a === void 0 ? void 0 : _a.k) || []).map(function (segment) { return segment.n; }), (_b = segmentsData.ms) === null || _b === void 0 ? void 0 : _b.cn);
-            shouldNotifyUpdate = largeSegments.resetSegments((((_c = segmentsData.ls) === null || _c === void 0 ? void 0 : _c.k) || []).map(function (segment) { return segment.n; }), (_d = segmentsData.ls) === null || _d === void 0 ? void 0 : _d.cn) || shouldNotifyUpdate;
+            shouldNotifyUpdate = segments.resetSegments(segmentsData.ms || {});
+            shouldNotifyUpdate = largeSegments.resetSegments(segmentsData.ls || {}) || shouldNotifyUpdate;
         }
         // Notify update if required
         if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
@@ -49,12 +39,12 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
             segmentsEventEmitter.emit(constants_1.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);
@@ -81,9 +71,10 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
      *  (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);
     };
 }
 exports.mySegmentsUpdaterFactory = mySegmentsUpdaterFactory;

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

@@ -13,7 +13,7 @@ var murmur3_1 = require("../../../utils/murmur3/murmur3");
 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/cjs/sync/streaming/SSEHandler/index.js

@@ -69,18 +69,16 @@ function SSEHandlerFactory(log, pushEmitter, telemetryTracker) {
             var parsedData = messageWithParsedData.parsedData, data = messageWithParsedData.data, channel = messageWithParsedData.channel, timestamp = messageWithParsedData.timestamp;
             log.debug(constants_2.STREAMING_NEW_MESSAGE, [data]);
             // we only handle update events if streaming is up
-            // @ts-expect-error
-            var type = parsedData.type || parsedData.t;
-            if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(type) === -1)
+            if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(parsedData.type) === -1)
                 return;
-            switch (type) {
+            switch (parsedData.type) {
                 /* update events */
                 case constants_1.SPLIT_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
-                case constants_1.MY_SEGMENTS_UPDATE_V3:
-                case constants_1.MY_LARGE_SEGMENTS_UPDATE:
+                case constants_1.MEMBERSHIPS_MS_UPDATE:
+                case constants_1.MEMBERSHIPS_LS_UPDATE:
                 case constants_1.SPLIT_KILL:
-                    pushEmitter.emit(type, parsedData);
+                    pushEmitter.emit(parsedData.type, parsedData);
                     break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case constants_1.OCCUPANCY:

package/cjs/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.js

@@ -2,77 +2,120 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MySegmentsUpdateWorker = void 0;
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_1 = require("../../../utils/constants");
+var constants_2 = require("./constants");
+var constants_3 = require("../constants");
 /**
  * MySegmentsUpdateWorker factory
  */
-function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, updateType) {
-    var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-    var currentChangeNumber = -1;
-    var handleNewEvent = false;
-    var isHandlingEvent;
-    var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-    var _delay;
-    var _delayTimeoutID;
-    var backoff = new Backoff_1.Backoff(__handleMySegmentsUpdateCall);
-    function __handleMySegmentsUpdateCall() {
-        isHandlingEvent = true;
-        if (maxChangeNumber > currentChangeNumber) {
-            handleNewEvent = false;
-            var currentMaxChangeNumber_1 = maxChangeNumber;
-            // fetch mySegments revalidating data if cached
-            var syncTask = _delay ?
-                new Promise(function (res) {
-                    _delayTimeoutID = setTimeout(function () {
-                        _delay = undefined;
-                        mySegmentsSyncTask.execute(_segmentsData, true).then(res);
-                    }, _delay);
-                }) :
-                mySegmentsSyncTask.execute(_segmentsData, true);
-            syncTask.then(function (result) {
-                if (!isHandlingEvent)
-                    return; // halt if `stop` has been called
-                if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-                    if (_segmentsData)
-                        telemetryTracker.trackUpdatesFromSSE(updateType);
-                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
-                }
-                if (handleNewEvent) {
-                    __handleMySegmentsUpdateCall();
-                }
-                else {
-                    backoff.scheduleCall();
-                }
-            });
-        }
-        else {
-            isHandlingEvent = false;
+function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker) {
+    var _a;
+    function createUpdateWorker(mySegmentsCache) {
+        var maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+        var currentChangeNumber = -1;
+        var handleNewEvent = false;
+        var isHandlingEvent;
+        var cdnBypass;
+        var _segmentsData; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+        var _delay;
+        var _delayTimeoutID;
+        var backoff = new Backoff_1.Backoff(__handleMySegmentsUpdateCall);
+        function __handleMySegmentsUpdateCall() {
+            isHandlingEvent = true;
+            if (maxChangeNumber > Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber())) {
+                handleNewEvent = false;
+                var currentMaxChangeNumber_1 = maxChangeNumber;
+                // fetch mySegments revalidating data if cached
+                var syncTask = _delay ?
+                    new Promise(function (res) {
+                        _delayTimeoutID = setTimeout(function () {
+                            _delay = undefined;
+                            mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined).then(res);
+                        }, _delay);
+                    }) :
+                    mySegmentsSyncTask.execute(_segmentsData, true, cdnBypass ? maxChangeNumber : undefined);
+                syncTask.then(function (result) {
+                    if (!isHandlingEvent)
+                        return; // halt if `stop` has been called
+                    if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, `mySegmentsCache.getChangeNumber` can be -1, since `/memberships` change number is optional
+                        var storageChangeNumber = mySegmentsCache.getChangeNumber();
+                        currentChangeNumber = storageChangeNumber > -1 ?
+                            storageChangeNumber :
+                            Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                    }
+                    if (handleNewEvent) {
+                        __handleMySegmentsUpdateCall();
+                    }
+                    else {
+                        if (_segmentsData)
+                            telemetryTracker.trackUpdatesFromSSE(constants_1.MEMBERSHIPS);
+                        var attempts = backoff.attempts + 1;
+                        if (maxChangeNumber <= currentChangeNumber) {
+                            log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
+                            isHandlingEvent = false;
+                            return;
+                        }
+                        if (attempts < constants_2.FETCH_BACKOFF_MAX_RETRIES) {
+                            backoff.scheduleCall();
+                            return;
+                        }
+                        if (cdnBypass) {
+                            log.debug("No changes fetched after " + attempts + " attempts with CDN bypassed.");
+                            isHandlingEvent = false;
+                        }
+                        else {
+                            backoff.reset();
+                            cdnBypass = true;
+                            __handleMySegmentsUpdateCall();
+                        }
+                    }
+                });
+            }
+            else {
+                isHandlingEvent = false;
+            }
         }
+        return {
+            /**
+             * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
+             *
+             * @param changeNumber change number of the notification
+             * @param segmentsData data for KeyList or SegmentRemoval instant updates
+             * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
+             */
+            put: function (mySegmentsData, payload, delay) {
+                var type = mySegmentsData.type, cn = mySegmentsData.cn;
+                // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+                if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber || _delay)
+                    return;
+                maxChangeNumber = cn;
+                handleNewEvent = true;
+                cdnBypass = false;
+                _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
+                _delay = delay;
+                if (backoff.timeoutID || !isHandlingEvent)
+                    __handleMySegmentsUpdateCall();
+                backoff.reset();
+            },
+            stop: function () {
+                clearTimeout(_delayTimeoutID);
+                _delay = undefined;
+                isHandlingEvent = false;
+                backoff.reset();
+            }
+        };
     }
+    var updateWorkers = (_a = {},
+        _a[constants_3.MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
+        _a[constants_3.MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
+        _a);
     return {
-        /**
-         * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
-         *
-         * @param changeNumber change number of the notification
-         * @param segmentsData data for KeyList or SegmentRemoval instant updates
-         * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
-         */
-        put: function (changeNumber, segmentsData, delay) {
-            // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
-            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber || _delay)
-                return;
-            maxChangeNumber = changeNumber;
-            handleNewEvent = true;
-            _segmentsData = segmentsData;
-            _delay = delay;
-            if (backoff.timeoutID || !isHandlingEvent)
-                __handleMySegmentsUpdateCall();
-            backoff.reset();
+        put: function (mySegmentsData, payload, delay) {
+            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
         },
         stop: function () {
-            clearTimeout(_delayTimeoutID);
-            _delay = undefined;
-            isHandlingEvent = false;
-            backoff.reset();
+            updateWorkers[constants_3.MEMBERSHIPS_MS_UPDATE].stop();
+            updateWorkers[constants_3.MEMBERSHIPS_LS_UPDATE].stop();
         }
     };
 }