@splitsoftware/splitio-commons 1.5.0 → 1.5.1-rc.2

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/listeners/browser.js

@@ -5,11 +5,12 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { CLEANUP_REGISTERING, CLEANUP_DEREGISTERING } from '../logger/constants';
 import { isConsentGranted } from '../consent';
 import { telemetryCacheStatsAdapter } from '../sync/submitters/telemetrySubmitter';
-// 'unload' event is used instead of 'beforeunload', since 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
-var UNLOAD_DOM_EVENT = 'unload';
+var VISIBILITYCHANGE_EVENT = 'visibilitychange';
+var PAGEHIDE_EVENT = 'pagehide';
+var UNLOAD_EVENT = 'unload';
 var EVENT_NAME = 'for unload page event.';
 /**
- * We'll listen for 'unload' event over the window object, since it's the standard way to listen page reload and close.
+ * We'll listen for events over the window object.
  */
 var BrowserSignalListener = /** @class */ (function () {
     function BrowserSignalListener(syncManager, settings, storage, serviceApi) {
@@ -18,33 +19,50 @@ var BrowserSignalListener = /** @class */ (function () {
         this.storage = storage;
         this.serviceApi = serviceApi;
         this.flushData = this.flushData.bind(this);
+        this.flushDataIfHidden = this.flushDataIfHidden.bind(this);
+        this.stopSync = this.stopSync.bind(this);
         this.fromImpressionsCollector = fromImpressionsCollector.bind(undefined, settings.core.labelsEnabled);
     }
     /**
      * start method.
-     * Called when SplitFactory is initialized.
-     * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
+     * Called when SplitFactory is initialized, it adds event listeners to close streaming and flush impressions and events.
      */
     BrowserSignalListener.prototype.start = function () {
+        this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
+        if (typeof document !== 'undefined' && document.addEventListener) {
+            // Flush data whenever the page is hidden or unloaded.
+            document.addEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+        }
         if (typeof window !== 'undefined' && window.addEventListener) {
-            this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
-            window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            // Some browsers like Safari does not fire the `visibilitychange` event when the page is being unloaded. So we also flush data in the `pagehide` event.
+            // If both events are triggered, the last one will find the storage empty, so no duplicated data will be submitted.
+            window.addEventListener(PAGEHIDE_EVENT, this.flushData);
+            // Stop streaming on 'unload' event. Used instead of 'beforeunload', because 'unload' is not a cancelable event, so no other listeners can stop the event from occurring.
+            window.addEventListener(UNLOAD_EVENT, this.stopSync);
         }
     };
     /**
      * stop method.
-     * Called when client is destroyed.
-     * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
+     * Called when client is destroyed, it removes event listeners.
      */
     BrowserSignalListener.prototype.stop = function () {
+        this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]);
+        if (typeof document !== 'undefined' && document.removeEventListener) {
+            document.removeEventListener(VISIBILITYCHANGE_EVENT, this.flushDataIfHidden);
+        }
         if (typeof window !== 'undefined' && window.removeEventListener) {
-            this.settings.log.debug(CLEANUP_DEREGISTERING, [EVENT_NAME]);
-            window.removeEventListener(UNLOAD_DOM_EVENT, this.flushData);
+            window.removeEventListener(PAGEHIDE_EVENT, this.flushData);
+            window.removeEventListener(UNLOAD_EVENT, this.stopSync);
         }
     };
+    BrowserSignalListener.prototype.stopSync = function () {
+        // Close streaming connection
+        if (this.syncManager && this.syncManager.pushManager)
+            this.syncManager.pushManager.stop();
+    };
     /**
      * flushData method.
-     * Called when unload event is triggered. It flushed remaining impressions and events to the backend,
+     * Called when pagehide event is triggered. It flushed remaining impressions and events to the backend,
      * using beacon API if possible, or falling back to regular post transport.
      */
     BrowserSignalListener.prototype.flushData = function () {
@@ -68,9 +86,11 @@ var BrowserSignalListener = /** @class */ (function () {
             var telemetryCacheAdapter = telemetryCacheStatsAdapter(this.storage.telemetry, this.storage.splits, this.storage.segments);
             this._flushData(telemetryUrl + '/v1/metrics/usage/beacon', telemetryCacheAdapter, this.serviceApi.postMetricsUsage);
         }
-        // Close streaming connection
-        if (this.syncManager.pushManager)
-            this.syncManager.pushManager.stop();
+    };
+    BrowserSignalListener.prototype.flushDataIfHidden = function () {
+        // Precondition: document defined
+        if (document.visibilityState === 'hidden')
+            this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
     };
     BrowserSignalListener.prototype._flushData = function (url, cache, postService, fromCacheToPayload, extraMetadata) {
         // if there is data in cache, send it to backend

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