@splitsoftware/splitio-commons 1.5.1-rc.0 → 1.5.1-rc.1

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

@@ -3,80 +3,96 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SplitsUpdateWorker = void 0;
 var constants_1 = require("../../../readiness/constants");
 var Backoff_1 = require("../../../utils/Backoff");
+var constants_2 = require("./constants");
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-var SplitsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} splitsCache splits data cache
-     * @param {Object} splitsSyncTask task for syncing splits data
-     * @param {Object} splitsEventEmitter emitter for splits data events
-     */
-    function SplitsUpdateWorker(splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
-        this.splitsCache = splitsCache;
-        this.splitsSyncTask = splitsSyncTask;
-        this.splitsEventEmitter = splitsEventEmitter;
-        this.segmentsSyncTask = segmentsSyncTask;
-        this.maxChangeNumber = 0;
-        this.handleNewEvent = false;
-        this.put = this.put.bind(this);
-        this.killSplit = this.killSplit.bind(this);
-        this.__handleSplitUpdateCall = this.__handleSplitUpdateCall.bind(this);
-        this.backoff = new Backoff_1.Backoff(this.__handleSplitUpdateCall);
-    }
-    // Private method
-    // Preconditions: this.splitsSyncTask.isSynchronizingSplits === false
-    SplitsUpdateWorker.prototype.__handleSplitUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.splitsCache.getChangeNumber()) {
-            this.handleNewEvent = false;
+function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+    var maxChangeNumber = 0;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var cdnBypass;
+    var backoff = new Backoff_1.Backoff(__handleSplitUpdateCall, constants_2.FETCH_BACKOFF_BASE, constants_2.FETCH_BACKOFF_MAX_WAIT);
+    function __handleSplitUpdateCall() {
+        isHandlingEvent = true;
+        if (maxChangeNumber > splitsCache.getChangeNumber()) {
+            handleNewEvent = false;
             // fetch splits revalidating data if cached
-            this.splitsSyncTask.execute(true).then(function () {
-                if (_this.handleNewEvent) {
-                    _this.__handleSplitUpdateCall();
+            splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(function () {
+                if (!isHandlingEvent)
+                    return; // halt if `stop` has been called
+                if (handleNewEvent) {
+                    __handleSplitUpdateCall();
                 }
                 else {
                     // fetch new registered segments for server-side API. Not retrying on error
-                    if (_this.segmentsSyncTask)
-                        _this.segmentsSyncTask.execute(undefined, false, true);
-                    _this.backoff.scheduleCall();
+                    if (segmentsSyncTask)
+                        segmentsSyncTask.execute(true);
+                    var attempts = backoff.attempts + 1;
+                    if (maxChangeNumber <= splitsCache.getChangeNumber()) {
+                        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;
+                        __handleSplitUpdateCall();
+                    }
                 }
             });
         }
-    };
+        else {
+            isHandlingEvent = false;
+        }
+    }
     /**
      * Invoked by NotificationProcessor on SPLIT_UPDATE event
      *
      * @param {number} changeNumber change number of the SPLIT_UPDATE notification
      */
-    SplitsUpdateWorker.prototype.put = function (_a) {
+    function put(_a) {
         var changeNumber = _a.changeNumber;
-        var currentChangeNumber = this.splitsCache.getChangeNumber();
-        if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        if (this.splitsSyncTask.isExecuting())
+        var currentChangeNumber = splitsCache.getChangeNumber();
+        if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber)
             return;
-        this.__handleSplitUpdateCall();
-    };
-    /**
-     * Invoked by NotificationProcessor on SPLIT_KILL event
-     *
-     * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-     * @param {string} splitName name of split to kill
-     * @param {string} defaultTreatment default treatment value
-     */
-    SplitsUpdateWorker.prototype.killSplit = function (_a) {
-        var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-        if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
-            // trigger an SDK_UPDATE if Split was killed locally
-            this.splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
+        maxChangeNumber = changeNumber;
+        handleNewEvent = true;
+        cdnBypass = false;
+        if (backoff.timeoutID || !isHandlingEvent)
+            __handleSplitUpdateCall();
+        backoff.reset();
+    }
+    return {
+        put: put,
+        /**
+         * Invoked by NotificationProcessor on SPLIT_KILL event
+         *
+         * @param {number} changeNumber change number of the SPLIT_UPDATE notification
+         * @param {string} splitName name of split to kill
+         * @param {string} defaultTreatment default treatment value
+         */
+        killSplit: function (_a) {
+            var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
+            if (splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
+                // trigger an SDK_UPDATE if Split was killed locally
+                splitsEventEmitter.emit(constants_1.SDK_SPLITS_ARRIVED, true);
+            }
+            // queues the SplitChanges fetch (only if changeNumber is newer)
+            put({ changeNumber: changeNumber });
+        },
+        stop: function () {
+            isHandlingEvent = false;
+            backoff.reset();
         }
-        // queues the SplitChanges fetch (only if changeNumber is newer)
-        this.put({ changeNumber: changeNumber });
     };
-    return SplitsUpdateWorker;
-}());
+}
 exports.SplitsUpdateWorker = SplitsUpdateWorker;

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

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FETCH_BACKOFF_MAX_RETRIES = exports.FETCH_BACKOFF_MAX_WAIT = exports.FETCH_BACKOFF_BASE = void 0;
+exports.FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds
+exports.FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute
+exports.FETCH_BACKOFF_MAX_RETRIES = 10; // max retries

package/cjs/sync/streaming/pushManager.js

@@ -45,9 +45,9 @@ function pushManagerFactory(params, pollingManager) {
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker_1.SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+    var segmentsUpdateWorker = userKey ? undefined : (0, SegmentsUpdateWorker_1.SegmentsUpdateWorker)(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = new SplitsUpdateWorker_1.SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = (0, SplitsUpdateWorker_1.SplitsUpdateWorker)(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
     // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
     var userKeyHashes = {};
     // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
@@ -140,21 +140,20 @@ function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.backoff.reset();
+        splitsUpdateWorker.stop();
         if (userKey)
             (0, lang_1.forOwn)(clients, function (_a) {
                 var worker = _a.worker;
-                return worker.backoff.reset();
+                return worker.stop();
             });
         else
-            segmentsUpdateWorker.backoff.reset();
+            segmentsUpdateWorker.stop();
     }
     pushEmitter.on(constants_1.PUSH_SUBSYSTEM_DOWN, stopWorkers);
     // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
     // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
     pushEmitter.on(constants_1.PUSH_SUBSYSTEM_UP, function () {
         connectPushRetryBackoff.reset();
-        stopWorkers();
     });
     /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
     pushEmitter.on(constants_1.PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
@@ -290,7 +289,7 @@ function pushManagerFactory(params, pollingManager) {
             var hash = (0, AuthClient_1.hashUserKey)(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: new MySegmentsUpdateWorker_1.MySegmentsUpdateWorker(mySegmentsSyncTask) };
+                clients[userKey] = { hash64: (0, murmur3_64_1.hash64)(userKey), worker: (0, MySegmentsUpdateWorker_1.MySegmentsUpdateWorker)(mySegmentsSyncTask) };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.
                 // Run in next event-loop cycle to save authentication calls

package/cjs/sync/syncTask.js

@@ -3,9 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncTaskFactory = void 0;
 var constants_1 = require("../logger/constants");
 /**
- * Creates a syncTask that handles the periodic execution of a given task ("start" and "stop" methods).
- * The task can be also executed by calling the "execute" method. Multiple execute calls are chained to run secuentially and avoid race conditions.
- * For example, submitters executed on SDK destroy or full queue, while periodic execution is pending.
+ * Creates an object that handles the periodic execution of a given task via "start" and "stop" methods.
+ * The task can be also executed by calling the "execute" method. Multiple calls run sequentially to avoid race conditions (e.g., submitters executed on SDK destroy or full queue, while periodic execution is pending).
  *
  * @param log  Logger instance.
  * @param task  Task to execute that returns a promise that NEVER REJECTS. Otherwise, periodic execution can result in Unhandled Promise Rejections.
@@ -15,8 +14,10 @@ var constants_1 = require("../logger/constants");
  */
 function syncTaskFactory(log, task, period, taskName) {
     if (taskName === void 0) { taskName = 'task'; }
-    // Task promise while it is pending. Undefined once the promise is resolved
-    var pendingTask;
+    // Flag that indicates if the task is executing
+    var executing = 0;
+    // Promise chain to resolve tasks sequentially
+    var promiseChain;
     // flag that indicates if the task periodic execution has been started/stopped.
     var running = false;
     // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -30,19 +31,15 @@ function syncTaskFactory(log, task, period, taskName) {
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        // If task is executing, chain the new execution
-        if (pendingTask) {
-            return pendingTask.then(function () {
-                return execute.apply(void 0, args);
-            });
-        }
-        // Execute task
+        executing++;
         log.debug(constants_1.SYNC_TASK_EXECUTE, [taskName]);
-        pendingTask = task.apply(void 0, args).then(function (result) {
-            pendingTask = undefined;
+        // Update `promiseChain` with last promise, to run tasks serially
+        promiseChain = (promiseChain ? promiseChain.then(function () { return task.apply(void 0, args); }) : task.apply(void 0, args))
+            .then(function (result) {
+            executing--;
             return result;
         });
-        return pendingTask;
+        return promiseChain;
     }
     function periodicExecute(currentRunningId) {
         return execute.apply(void 0, runningArgs).then(function (result) {
@@ -56,7 +53,7 @@ function syncTaskFactory(log, task, period, taskName) {
     return {
         execute: execute,
         isExecuting: function () {
-            return pendingTask !== undefined;
+            return executing > 0;
         },
         start: function () {
             var args = [];

package/cjs/utils/Backoff.js

@@ -10,8 +10,8 @@ var Backoff = /** @class */ (function () {
      * @param {number} maxMillis
      */
     function Backoff(cb, baseMillis, maxMillis) {
-        this.baseMillis = baseMillis || Backoff.DEFAULT_BASE_MILLIS;
-        this.maxMillis = maxMillis || Backoff.DEFAULT_MAX_MILLIS;
+        this.baseMillis = Backoff.__TEST__BASE_MILLIS || baseMillis || Backoff.DEFAULT_BASE_MILLIS;
+        this.maxMillis = Backoff.__TEST__MAX_MILLIS || maxMillis || Backoff.DEFAULT_MAX_MILLIS;
         this.attempts = 0;
         this.cb = cb;
     }
@@ -25,6 +25,7 @@ var Backoff = /** @class */ (function () {
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
         this.timeoutID = setTimeout(function () {
+            _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
         this.attempts++;

package/esm/integrations/ga/GaToSplit.js

@@ -7,24 +7,23 @@ var logNameMapper = 'ga-to-split:mapper';
 /**
  * Provides a plugin to use with analytics.js, accounting for the possibility
  * that the global command queue has been renamed or not yet defined.
- * @param window Reference to global object.
- * @param pluginName The plugin name identifier.
- * @param pluginConstructor The plugin constructor function.
- * @param log Logger instance.
- * @param autoRequire If true, log error when auto-require script is not detected
+ * @param {string} pluginName The plugin name identifier.
+ * @param {Function} pluginConstructor The plugin constructor function.
  */
-function providePlugin(window, pluginName, pluginConstructor, log, autoRequire) {
+function providePlugin(pluginName, pluginConstructor) {
     // get reference to global command queue. Init it if not defined yet.
+    // @ts-expect-error
     var gaAlias = window.GoogleAnalyticsObject || 'ga';
     window[gaAlias] = window[gaAlias] || function () {
-        (window[gaAlias].q = window[gaAlias].q || []).push(arguments);
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        (window[gaAlias].q = window[gaAlias].q || []).push(args);
     };
     // provides the plugin for use with analytics.js.
+    // @ts-expect-error
     window[gaAlias]('provide', pluginName, pluginConstructor);
-    if (autoRequire && (!window[gaAlias].q || window[gaAlias].q.push === [].push)) {
-        // Expecting spy on ga.q push method but not found
-        log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run.');
-    }
 }
 // Default mapping: object used for building the default mapper from hits to Split events
 var defaultMapping = {
@@ -241,5 +240,5 @@ export function GaToSplit(sdkOptions, params) {
         return SplitTracker;
     }());
     // Register the plugin, even if config is invalid, since, if not provided, it will block `ga` command queue.
-    providePlugin(window, 'splitTracker', SplitTracker, log, sdkOptions.autoRequire);
+    providePlugin('splitTracker', SplitTracker);
 }

package/esm/services/splitApi.js

@@ -34,12 +34,12 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             }
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
-        fetchSplitChanges: function (since, noCache) {
-            var url = urls.sdk + "/splitChanges?since=" + since + (filterQueryString || '');
+        fetchSplitChanges: function (since, noCache, till) {
+            var url = urls.sdk + "/splitChanges?since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
         },
-        fetchSegmentChanges: function (since, segmentName, noCache) {
-            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since;
+        fetchSegmentChanges: function (since, segmentName, noCache, till) {
+            var url = urls.sdk + "/segmentChanges/" + segmentName + "?since=" + since + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
         },
         fetchMySegments: function (userMatchingKey, noCache) {

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

@@ -1,6 +1,6 @@
 import { __spreadArray } from "tslib";
-function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
-    return fetchSegmentChanges(since, segmentName, noCache)
+function greedyFetch(fetchSegmentChanges, since, segmentName, noCache, targetTill) {
+    return fetchSegmentChanges(since, segmentName, noCache, targetTill)
         .then(function (resp) { return resp.json(); })
         .then(function (json) {
         var since = json.since, till = json.till;
@@ -8,7 +8,7 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
             return [json];
         }
         else {
-            return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(function (flatMe) {
+            return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(function (flatMe) {
                 return __spreadArray([flatMe[0]], flatMe[1], true);
             });
         }
@@ -19,10 +19,10 @@ function greedyFetch(fetchSegmentChanges, since, segmentName, noCache) {
  * SegmentChanges fetcher is a wrapper around `segmentChanges` API service that parses the response and handle errors and retries.
  */
 export function segmentChangesFetcherFactory(fetchSegmentChanges) {
-    return function segmentChangesFetcher(since, segmentName, noCache, 
+    return function segmentChangesFetcher(since, segmentName, noCache, till, 
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator) {
-        var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache);
+        var segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
         if (decorator)
             segmentsPromise = decorator(segmentsPromise);
         return segmentsPromise;

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

@@ -3,10 +3,10 @@
  * SplitChanges fetcher is a wrapper around `splitChanges` API service that parses the response and handle errors.
  */
 export function splitChangesFetcherFactory(fetchSplitChanges) {
-    return function splitChangesFetcher(since, noCache, 
+    return function splitChangesFetcher(since, noCache, till, 
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator) {
-        var splitsPromise = fetchSplitChanges(since, noCache);
+        var splitsPromise = fetchSplitChanges(since, noCache, till);
         if (decorator)
             splitsPromise = decorator(splitsPromise);
         return splitsPromise.then(function (resp) { return resp.json(); });

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

@@ -15,54 +15,54 @@ import { thenable } from '../../../utils/promise/thenable';
  */
 export function segmentChangesUpdaterFactory(log, segmentChangesFetcher, segments, readiness) {
     var readyOnAlreadyExistentState = true;
+    function updateSegment(segmentName, noCache, till, fetchOnlyNew) {
+        log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
+        var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
+        return sincePromise.then(function (since) {
+            // if fetchOnlyNew flag, avoid processing already fetched segments
+            if (fetchOnlyNew && since !== -1)
+                return -1;
+            return segmentChangesFetcher(since, 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;
+            });
+        });
+    }
     /**
      * Segments updater returns a promise that resolves with a `false` boolean value if it fails at least to fetch a segment or synchronize it with the storage.
      * Thus, a false result doesn't imply that SDK_SEGMENTS_ARRIVED was not emitted.
      * Returned promise will not be rejected.
      *
-     * @param {string[] | undefined} segmentNames list of segment names to fetch. By passing `undefined` it fetches the list of segments registered at the storage
-     * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
      * @param {boolean | undefined} fetchOnlyNew if true, only fetch the segments that not exists, i.e., which `changeNumber` is equal to -1.
      * This param is used by SplitUpdateWorker on server-side SDK, to fetch new registered segments on SPLIT_UPDATE notifications.
+     * @param {string | undefined} segmentName segment name to fetch. By passing `undefined` it fetches the list of segments registered at the storage
+     * @param {boolean | undefined} noCache true to revalidate data to fetch on a SEGMENT_UPDATE notifications.
+     * @param {number | undefined} till till target for the provided segmentName, for CDN bypass.
      */
-    return function segmentChangesUpdater(segmentNames, noCache, fetchOnlyNew) {
+    return function segmentChangesUpdater(fetchOnlyNew, segmentName, noCache, till) {
         log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Started segments update");
         // If not a segment name provided, read list of available segments names to be updated.
-        var segmentsPromise = Promise.resolve(segmentNames ? segmentNames : segments.getRegisteredSegments());
+        var segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
         return segmentsPromise.then(function (segmentNames) {
             // Async fetchers are collected here.
             var updaters = [];
-            var _loop_1 = function (index) {
-                var segmentName = segmentNames[index];
-                log.debug(LOG_PREFIX_SYNC_SEGMENTS + "Processing segment " + segmentName);
-                var sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
-                updaters.push(sincePromise.then(function (since) {
-                    // if fetchOnlyNew flag, avoid processing already fetched segments
-                    if (fetchOnlyNew && since !== -1)
-                        return -1;
-                    return segmentChangesFetcher(since, segmentName, noCache).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;
-                    });
-                }));
-            };
             for (var index = 0; index < segmentNames.length; index++) {
-                _loop_1(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

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

@@ -79,16 +79,17 @@ export function splitChangesUpdaterFactory(log, splitChangesFetcher, splits, seg
      * Returned promise will not be rejected.
      *
      * @param {boolean | undefined} noCache true to revalidate data to fetch
+     * @param {boolean | undefined} till query param to bypass CDN requests
      */
-    return function splitChangesUpdater(noCache) {
+    return function splitChangesUpdater(noCache, till) {
         /**
          * @param {number} since current changeNumber at splitsCache
-         * @param {number} retry current number of retry attemps
+         * @param {number} retry current number of retry attempts
          */
         function _splitChangesUpdater(since, retry) {
             if (retry === void 0) { retry = 0; }
             log.debug(SYNC_SPLITS_FETCH, [since]);
-            var fetcherPromise = splitChangesFetcher(since, noCache, _promiseDecorator)
+            var fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
                 .then(function (splitChanges) {
                 startingUp = false;
                 var mutation = computeSplitsMutation(splitChanges.splits);

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

@@ -1,58 +1,57 @@
 import { Backoff } from '../../../utils/Backoff';
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-var MySegmentsUpdateWorker = /** @class */ (function () {
-    /**
-     * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-     */
-    function MySegmentsUpdateWorker(mySegmentsSyncTask) {
-        this.mySegmentsSyncTask = mySegmentsSyncTask;
-        this.maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
-        this.handleNewEvent = false;
-        this.segmentsData = undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
-        this.currentChangeNumber = -1; // @TODO: remove once `/mySegments` endpoint provides the changeNumber
-        this.put = this.put.bind(this);
-        this.__handleMySegmentsUpdateCall = this.__handleMySegmentsUpdateCall.bind(this);
-        this.backoff = new Backoff(this.__handleMySegmentsUpdateCall);
-    }
-    // Private method
-    // Precondition: this.mySegmentsSyncTask.isSynchronizingMySegments === false
-    MySegmentsUpdateWorker.prototype.__handleMySegmentsUpdateCall = function () {
-        var _this = this;
-        if (this.maxChangeNumber > this.currentChangeNumber) {
-            this.handleNewEvent = false;
-            var currentMaxChangeNumber_1 = this.maxChangeNumber;
+export function MySegmentsUpdateWorker(mySegmentsSyncTask) {
+    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
-            this.mySegmentsSyncTask.execute(this.segmentsData, true).then(function (result) {
+            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.
-                    _this.currentChangeNumber = Math.max(_this.currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-                if (_this.handleNewEvent) {
-                    _this.__handleMySegmentsUpdateCall();
+                    currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber_1); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+                if (handleNewEvent) {
+                    __handleMySegmentsUpdateCall();
                 }
                 else {
-                    _this.backoff.scheduleCall();
+                    backoff.scheduleCall();
                 }
             });
         }
+        else {
+            isHandlingEvent = false;
+        }
+    }
+    return {
+        /**
+         * 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 () {
+            isHandlingEvent = false;
+            backoff.reset();
+        }
     };
-    /**
-     * 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
-     */
-    MySegmentsUpdateWorker.prototype.put = function (changeNumber, segmentsData) {
-        if (changeNumber <= this.currentChangeNumber || changeNumber <= this.maxChangeNumber)
-            return;
-        this.maxChangeNumber = changeNumber;
-        this.handleNewEvent = true;
-        this.backoff.reset();
-        this.segmentsData = segmentsData;
-        if (this.mySegmentsSyncTask.isExecuting())
-            return;
-        this.__handleMySegmentsUpdateCall();
-    };
-    return MySegmentsUpdateWorker;
-}());
-export { MySegmentsUpdateWorker };
+}