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

package/cjs/storages/inMemory/SplitsCacheInMemory.js

@@ -7,6 +7,7 @@ var lang_1 = require("../../utils/lang");
 var sets_1 = require("../../utils/lang/sets");
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
+ * Supported by all JS runtimes.
  */
 var SplitsCacheInMemory = /** @class */ (function (_super) {
     (0, tslib_1.__extends)(SplitsCacheInMemory, _super);
@@ -15,7 +16,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         _this.splitsCache = {};
         _this.ttCache = {};
         _this.changeNumber = -1;
-        _this.segmentsCount = 0;
+        _this.splitsWithSegmentsCount = 0;
         _this.flagSetsCache = {};
         _this.flagSetsFilter = splitFiltersValidation ? splitFiltersValidation.groupedFilters.bySet : [];
         return _this;
@@ -24,7 +25,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         this.splitsCache = {};
         this.ttCache = {};
         this.changeNumber = -1;
-        this.segmentsCount = 0;
+        this.splitsWithSegmentsCount = 0;
     };
     SplitsCacheInMemory.prototype.addSplit = function (name, split) {
         var previousSplit = this.getSplit(name);
@@ -34,9 +35,9 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             if (!this.ttCache[previousTtName])
                 delete this.ttCache[previousTtName];
             this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
-            // Subtract from segments count for the previous version of this Split
-            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit))
-                this.segmentsCount--;
+            if ((0, AbstractSplitsCacheSync_1.usesSegments)(previousSplit)) { // Substract from segments count for the previous version of this Split.
+                this.splitsWithSegmentsCount--;
+            }
         }
         if (split) {
             // Store the Split.
@@ -47,7 +48,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.addToFlagSets(split);
             // Add to segments count for the new version of the Split
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
-                this.segmentsCount++;
+                this.splitsWithSegmentsCount++;
             return true;
         }
         else {
@@ -66,7 +67,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
             this.removeFromFlagSets(split.name, split.sets);
             // Update the segments count.
             if ((0, AbstractSplitsCacheSync_1.usesSegments)(split))
-                this.segmentsCount--;
+                this.splitsWithSegmentsCount--;
             return true;
         }
         else {
@@ -90,7 +91,7 @@ var SplitsCacheInMemory = /** @class */ (function (_super) {
         return (0, lang_1.isFiniteNumber)(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
     };
     SplitsCacheInMemory.prototype.usesSegments = function () {
-        return this.getChangeNumber() === -1 || this.segmentsCount > 0;
+        return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
     };
     SplitsCacheInMemory.prototype.getNamesByFlagSets = function (flagSets) {
         var _this = this;

package/cjs/storages/inMemory/TelemetryCacheInMemory.js

@@ -23,10 +23,9 @@ function shouldRecordTelemetry(_a) {
 }
 exports.shouldRecordTelemetry = shouldRecordTelemetry;
 var TelemetryCacheInMemory = /** @class */ (function () {
-    function TelemetryCacheInMemory(splits, segments, largeSegments) {
+    function TelemetryCacheInMemory(splits, segments) {
         this.splits = splits;
         this.segments = segments;
-        this.largeSegments = largeSegments;
         // isEmpty flag
         this.e = true;
         this.notReadyUsage = 0;
@@ -42,7 +41,10 @@ var TelemetryCacheInMemory = /** @class */ (function () {
         this.tags = [];
         this.exceptions = {};
         this.latencies = {};
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0
+        };
     }
     TelemetryCacheInMemory.prototype.isEmpty = function () { return this.e; };
     TelemetryCacheInMemory.prototype.clear = function () { };
@@ -62,8 +64,6 @@ var TelemetryCacheInMemory = /** @class */ (function () {
             spC: this.splits && this.splits.getSplitNames().length,
             seC: this.segments && this.segments.getRegisteredSegments().length,
             skC: this.segments && this.segments.getKeysCount(),
-            lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
-            lskC: this.largeSegments && this.largeSegments.getKeysCount(),
             sL: this.getSessionLength(),
             eQ: this.getEventStats(constants_1.QUEUED),
             eD: this.getEventStats(constants_1.DROPPED),
@@ -195,11 +195,14 @@ var TelemetryCacheInMemory = /** @class */ (function () {
     };
     TelemetryCacheInMemory.prototype.popUpdatesFromSSE = function () {
         var result = this.updatesFromSSE;
-        this.updatesFromSSE = {};
+        this.updatesFromSSE = {
+            sp: 0,
+            ms: 0,
+        };
         return result;
     };
     TelemetryCacheInMemory.prototype.recordUpdatesFromSSE = function (type) {
-        this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
+        this.updatesFromSSE[type]++;
         this.e = false;
     };
     return TelemetryCacheInMemory;

package/cjs/storages/inRedis/SegmentsCacheInRedis.js

@@ -9,32 +9,38 @@ var SegmentsCacheInRedis = /** @class */ (function () {
         this.redis = redis;
         this.keys = keys;
     }
-    /**
-     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
-     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
-     * or rejected if it fails (e.g., Redis operation fails).
-     */
-    SegmentsCacheInRedis.prototype.update = function (name, addedKeys, removedKeys, changeNumber) {
+    SegmentsCacheInRedis.prototype.addToSegment = function (name, segmentKeys) {
         var segmentKey = this.keys.buildSegmentNameKey(name);
-        return Promise.all([
-            addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
-            removedKeys.length && this.redis.srem(segmentKey, removedKeys),
-            this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
-        ]).then(function () {
-            return addedKeys.length > 0 || removedKeys.length > 0;
-        });
+        if (segmentKeys.length) {
+            return this.redis.sadd(segmentKey, segmentKeys).then(function () { return true; });
+        }
+        else {
+            return Promise.resolve(true);
+        }
+    };
+    SegmentsCacheInRedis.prototype.removeFromSegment = function (name, segmentKeys) {
+        var segmentKey = this.keys.buildSegmentNameKey(name);
+        if (segmentKeys.length) {
+            return this.redis.srem(segmentKey, segmentKeys).then(function () { return true; });
+        }
+        else {
+            return Promise.resolve(true);
+        }
     };
     SegmentsCacheInRedis.prototype.isInSegment = function (name, key) {
         return this.redis.sismember(this.keys.buildSegmentNameKey(name), key).then(function (matches) { return matches !== 0; });
     };
+    SegmentsCacheInRedis.prototype.setChangeNumber = function (name, changeNumber) {
+        return this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '').then(function (status) { return status === 'OK'; });
+    };
     SegmentsCacheInRedis.prototype.getChangeNumber = function (name) {
         var _this = this;
         return this.redis.get(this.keys.buildSegmentTillKey(name)).then(function (value) {
             var i = parseInt(value, 10);
-            return (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     SegmentsCacheInRedis.prototype.registerSegments = function (segments) {

package/cjs/storages/inRedis/index.js

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

package/cjs/storages/pluggable/SegmentsCachePluggable.js

@@ -15,19 +15,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.
@@ -36,6 +49,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.
@@ -45,10 +66,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 (0, lang_1.isNaNNumber)(i) ? -1 : i;
+            return (0, lang_1.isNaNNumber)(i) ? undefined : i;
         }).catch(function (e) {
             _this.log.error(constants_1.LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-            return -1;
+            return undefined;
         });
     };
     /**

package/cjs/storages/pluggable/inMemoryWrapper.js

@@ -8,7 +8,7 @@ var sets_1 = require("../../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.
  */
 function inMemoryWrapperFactory(connDelay) {
     var _cache = {};

package/cjs/sync/offline/syncManagerOffline.js

@@ -19,30 +19,23 @@ function syncManagerOfflineFactory(splitsParserFactory) {
      */
     return function (_a) {
         var settings = _a.settings, readiness = _a.readiness, storage = _a.storage;
-        var mainSyncManager = (0, fromObjectSyncTask_1.fromObjectSyncTaskFactory)(splitsParserFactory(), storage, readiness, settings);
-        var mainStart = mainSyncManager.start;
-        var sharedStarts = [];
-        return (0, objectAssign_1.objectAssign)(mainSyncManager, {
-            start: function () {
-                mainStart();
-                sharedStarts.forEach(function (cb) { return cb(); });
-                sharedStarts.length = 0;
-            },
+        return (0, objectAssign_1.objectAssign)((0, fromObjectSyncTask_1.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(constants_1.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(constants_1.SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+                        }, 0);
+                    },
                     stop: function () { },
+                    isRunning: function () {
+                        return true;
+                    },
                     flush: flush,
                 };
             }

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

@@ -5,14 +5,17 @@ exports.mySegmentsFetcherFactory = void 0;
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-function mySegmentsFetcherFactory(fetchMemberships) {
-    return function mySegmentsFetcher(userMatchingKey, noCache, till, 
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
+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; }); });
     };
 }
 exports.mySegmentsFetcherFactory = mySegmentsFetcherFactory;

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

@@ -23,7 +23,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTil
  */
 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/cjs/sync/polling/pollingManagerCS.js

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

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

@@ -7,7 +7,7 @@ var mySegmentsUpdater_1 = require("../updaters/mySegmentsUpdater");
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-function mySegmentsSyncTaskFactory(fetchMemberships, storage, readiness, settings, matchingKey) {
-    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMemberships), storage, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
+function mySegmentsSyncTaskFactory(fetchMySegments, storage, readiness, settings, matchingKey) {
+    return (0, syncTask_1.syncTaskFactory)(settings.log, (0, mySegmentsUpdater_1.mySegmentsUpdaterFactory)(settings.log, (0, mySegmentsFetcher_1.mySegmentsFetcherFactory)(fetchMySegments), storage.splits, storage.segments, readiness.segments, settings.startup.requestTimeoutBeforeReady, settings.startup.retriesOnFailureBeforeReady, matchingKey), settings.scheduler.segmentsRefreshRate, 'mySegmentsUpdater');
 }
 exports.mySegmentsSyncTaskFactory = mySegmentsSyncTaskFactory;

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

@@ -4,15 +4,13 @@ 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`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
-    var splits = storage.splits, segments = storage.segments, largeSegments = storage.largeSegments;
+function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, mySegmentsCache, segmentsEventEmitter, requestTimeoutBeforeReady, retriesOnFailureBeforeReady, matchingKey) {
     var readyOnAlreadyExistentState = true;
     var startingUp = true;
     /** timeout and telemetry decorator for `splitChangesFetcher` promise  */
@@ -24,27 +22,36 @@ function mySegmentsUpdaterFactory(log, mySegmentsFetcher, storage, segmentsEvent
     // @TODO if allowing pluggable storages, handle async execution
     function updateSegments(segmentsData) {
         var shouldNotifyUpdate;
-        if (segmentsData.type !== undefined) {
-            shouldNotifyUpdate = segmentsData.type === constants_3.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(constants_1.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);
@@ -71,10 +78,9 @@ 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, till) {
-        return _mySegmentsUpdater(0, segmentsData, noCache, till);
+    return function mySegmentsUpdater(segmentsData, noCache) {
+        return _mySegmentsUpdater(0, segmentsData, noCache);
     };
 }
 exports.mySegmentsUpdaterFactory = mySegmentsUpdaterFactory;

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

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.segmentChangesUpdaterFactory = void 0;
+var lang_1 = require("../../../utils/lang");
 var constants_1 = require("../../../readiness/constants");
 var constants_2 = require("../../../logger/constants");
+var thenable_1 = require("../../../utils/promise/thenable");
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`
@@ -21,16 +23,27 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         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(constants_2.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(constants_2.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 (0, thenable_1.thenable)(result); }))
+                    return Promise.all(results).then(function () { return changeNumber; });
+                return changeNumber;
+            });
         });
     }
     /**
@@ -49,11 +62,14 @@ function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, read
         // 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 ((0, lang_1.findIndex)(shouldUpdateFlags, function (v) { return v !== -1; }) !== -1 || readyOnAlreadyExistentState) {
                     readyOnAlreadyExistentState = false;
                     if (readiness)
                         readiness.segments.emit(constants_1.SDK_SEGMENTS_ARRIVED);

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

@@ -14,7 +14,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/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 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/cjs/sync/streaming/SSEHandler/index.js

@@ -68,18 +68,20 @@ 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
+            // we only handle update events if streaming is up.
             if (!notificationKeeper.isStreamingUp() && [constants_1.OCCUPANCY, constants_1.CONTROL].indexOf(parsedData.type) === -1)
                 return;
             switch (parsedData.type) {
                 /* update events */
                 case constants_1.SPLIT_UPDATE:
                 case constants_1.SEGMENT_UPDATE:
-                case constants_1.MEMBERSHIPS_MS_UPDATE:
-                case constants_1.MEMBERSHIPS_LS_UPDATE:
+                case constants_1.MY_SEGMENTS_UPDATE_V2:
                 case constants_1.SPLIT_KILL:
                     pushEmitter.emit(parsedData.type, parsedData);
                     break;
+                case constants_1.MY_SEGMENTS_UPDATE:
+                    pushEmitter.emit(parsedData.type, parsedData, channel);
+                    break;
                 /* occupancy & control events, handled by NotificationManagerKeeper */
                 case constants_1.OCCUPANCY:
                     notificationKeeper.handleOccupancyEvent(parsedData.metrics.publishers, channel, timestamp);