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

package/esm/storages/pluggable/SegmentsCachePluggable.js

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

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

package/esm/sync/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/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

@@ -1,5 +1,7 @@
+import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
+import { thenable } from '../../../utils/promise/thenable';
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -18,16 +20,27 @@ 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
-            return fetchOnlyNew && since !== -1 ?
-                false :
-                segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
-                    return Promise.all(changes.map(function (x) {
-                        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
-                        return segments.update(x.name, x.added, x.removed, x.till);
-                    })).then(function (updates) {
-                        return updates.some(function (update) { return update; });
-                    });
+            if (fetchOnlyNew && since !== undefined)
+                return -1;
+            return segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
+                var changeNumber = -1;
+                var results = [];
+                changes.forEach(function (x) {
+                    if (x.added.length > 0)
+                        results.push(segments.addToSegment(segmentName, x.added));
+                    if (x.removed.length > 0)
+                        results.push(segments.removeFromSegment(segmentName, x.removed));
+                    if (x.added.length > 0 || x.removed.length > 0) {
+                        results.push(segments.setChangeNumber(segmentName, x.till));
+                        changeNumber = x.till;
+                    }
+                    log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processed " + segmentName + " with till = " + x.till + ". Added: " + x.added.length + ". Removed: " + x.removed.length);
                 });
+                // If at least one storage operation result is a promise, join all in a single promise.
+                if (results.some(function (result) { return thenable(result); }))
+                    return Promise.all(results).then(function () { return changeNumber; });
+                return changeNumber;
+            });
         });
     }
     /**
@@ -46,11 +59,14 @@ export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segment
         // If not a segment name provided, read list of available segments names to be updated.
         var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
-            // Async fetchers
-            var updaters = segmentNames.map(function (segmentName) { return updateSegment(segmentName, noCache, till, fetchOnlyNew); });
+            // Async fetchers are collected here.
+            var updaters = [];
+            for (var index = 0; index < segmentNames.length; index++) {
+                updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
+            }
             return Promise.all(updaters).then(function (shouldUpdateFlags) {
                 // if at least one segment fetch succeeded, mark segments ready
-                if (shouldUpdateFlags.some(function (update) { return update; }) || readyOnAlreadyExistentState) {
+                if (findIndex(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(SDK_SEGMENTS_ARRIVED);

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

@@ -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; }); });
     });
 }
 /**

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

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

@@ -1,120 +1,61 @@
 import { Backoff } from '../../../utils/Backoff';
-import { MEMBERSHIPS } from '../../../utils/constants';
-import { FETCH_BACKOFF_MAX_RETRIES } from './constants';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../constants';
+import { MY_SEGMENT } from '../../../utils/constants';
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker) {
-    var _a;
-    var _delay;
-    var _delayTimeoutID;
-    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 backoff = new 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(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 < 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;
-                // Discard event if it is outdated or there is a pending fetch request (_delay is set), but update target change number
-                if (cn <= Math.max(currentChangeNumber, mySegmentsCache.getChangeNumber()) || cn <= maxChangeNumber)
-                    return;
-                maxChangeNumber = cn;
-                if (_delay)
-                    return;
-                handleNewEvent = true;
-                cdnBypass = false;
-                _segmentsData = payload && { type: type, cn: cn, added: payload.added, removed: payload.removed };
-                _delay = delay;
-                if (backoff.timeoutID || !isHandlingEvent)
+export function MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker) {
+    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 backoff = new Backoff(__handleMySegmentsUpdateCall);
+    function __handleMySegmentsUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > currentChangeNumber) {
+            handleNewEvent = false;
+            var currentMaxChangeNumber_1 = maxChangeNumber;
+            // fetch mySegments revalidating data if cached
+            mySegmentsSyncTask.execute(_segmentsData, true).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(MY_SEGMENT);
+                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                }
+                if (handleNewEvent) {
                     __handleMySegmentsUpdateCall();
-                backoff.reset();
-            },
-            stop: function () {
-                clearTimeout(_delayTimeoutID);
-                _delay = undefined;
-                isHandlingEvent = false;
-                backoff.reset();
-            }
-        };
+                }
+                else {
+                    backoff.scheduleCall();
+                }
+            });
+        }
+        else {
+            isHandlingEvent = false;
+        }
     }
-    var updateWorkers = (_a = {},
-        _a[MEMBERSHIPS_MS_UPDATE] = createUpdateWorker(storage.segments),
-        _a[MEMBERSHIPS_LS_UPDATE] = createUpdateWorker(storage.largeSegments),
-        _a);
     return {
-        put: function (mySegmentsData, payload, delay) {
-            updateWorkers[mySegmentsData.type].put(mySegmentsData, payload, delay);
+        /**
+         * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+         *
+         * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
+         * @param {SegmentsData | undefined} segmentsData might be undefined
+         */
+        put: function (changeNumber, segmentsData) {
+            if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
+                return;
+            maxChangeNumber = changeNumber;
+            handleNewEvent = true;
+            _segmentsData = segmentsData;
+            if (backoff.timeoutID || !isHandlingEvent)
+                __handleMySegmentsUpdateCall();
+            backoff.reset();
         },
         stop: function () {
-            updateWorkers[MEMBERSHIPS_MS_UPDATE].stop();
-            updateWorkers[MEMBERSHIPS_LS_UPDATE].stop();
+            isHandlingEvent = false;
+            backoff.reset();
         }
     };
 }

package/esm/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.js

@@ -13,7 +13,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         var backoff = new Backoff(__handleSegmentUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
         function __handleSegmentUpdateCall() {
             isHandlingEvent = true;
-            if (maxChangeNumber > segmentsCache.getChangeNumber(segment)) {
+            if (maxChangeNumber > (segmentsCache.getChangeNumber(segment) || -1)) {
                 handleNewEvent = false;
                 // fetch segments revalidating data if cached
                 segmentsSyncTask.execute(false, segment, true, cdnBypass ? maxChangeNumber : undefined).then(function () {
@@ -24,7 +24,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
                     }
                     else {
                         var attempts = backoff.attempts + 1;
-                        if (maxChangeNumber <= segmentsCache.getChangeNumber(segment)) {
+                        if (maxChangeNumber <= (segmentsCache.getChangeNumber(segment) || -1)) {
                             log.debug("Refresh completed" + (cdnBypass ? ' bypassing the CDN' : '') + " in " + attempts + " attempts.");
                             isHandlingEvent = false;
                             return;
@@ -51,7 +51,7 @@ export function SegmentsUpdateWorker(log, segmentsSyncTask, segmentsCache) {
         }
         return {
             put: function (changeNumber) {
-                var currentChangeNumber = segmentsCache.getChangeNumber(segment);
+                var currentChangeNumber = segmentsCache.getChangeNumber(segment) || -1;
                 if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
                     return;
                 maxChangeNumber = changeNumber;

package/esm/sync/streaming/constants.js

@@ -22,8 +22,8 @@ export var PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
  */
 export var PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 // Update-type push notifications, handled by NotificationProcessor
-export var MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
-export var MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_LS_UPDATE';
+export var MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
+export var MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
 export var SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export var SPLIT_KILL = 'SPLIT_KILL';
 export var SPLIT_UPDATE = 'SPLIT_UPDATE';

package/esm/sync/streaming/parseUtils.js

@@ -1,6 +1,5 @@
 import { algorithms } from '../../utils/decompress';
 import { decodeFromBase64 } from '../../utils/base64';
-import { hash } from '../../utils/murmur3/murmur3';
 var GZIP = 1;
 var ZLIB = 2;
 function Uint8ArrayToString(myUint8Arr) {
@@ -75,17 +74,14 @@ export function isInBitmap(bitmap, hash64hex) {
 }
 /**
  * Parse feature flags notifications for instant feature flag updates
+ *
+ * @param {ISplitUpdateData} data
+ * @returns {KeyList}
  */
 export function parseFFUpdatePayload(compression, data) {
-    return compression > 0 ?
-        parseKeyList(data, compression, false) :
-        JSON.parse(decodeFromBase64(data));
-}
-var DEFAULT_MAX_INTERVAL = 60000;
-export function getDelay(parsedData, matchingKey) {
-    if (parsedData.h === 0)
-        return 0;
-    var interval = parsedData.i || DEFAULT_MAX_INTERVAL;
-    var seed = parsedData.s || 0;
-    return hash(matchingKey, seed) % interval;
+    var avoidPrecisionLoss = false;
+    if (compression > 0)
+        return parseKeyList(data, compression, avoidPrecisionLoss);
+    else
+        return JSON.parse(decodeFromBase64(data));
 }