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

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

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

package/esm/sync/streaming/constants.js

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

package/esm/sync/streaming/pushManager.js

@@ -8,8 +8,8 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIP_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIPS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
 import { UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { _Set } from '../../utils/lang/sets';
@@ -140,9 +140,8 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
-                var worker = _a.worker, workerLarge = _a.workerLarge;
-                worker.stop();
-                workerLarge.stop();
+                var worker = _a.worker;
+                return worker.stop();
             });
         else
             segmentsUpdateWorker.stop();
@@ -197,7 +196,6 @@ export function pushManagerFactory(params, pollingManager) {
         splitsUpdateWorker.put(parsedData);
     });
     function handleMySegmentsUpdate(parsedData) {
-        var isLS = parsedData.type === MEMBERSHIP_LS_UPDATE;
         switch (parsedData.u) {
             case UpdateStrategy.BoundedFetchRequest: {
                 var bitmap_1;
@@ -205,13 +203,13 @@ export function pushManagerFactory(params, pollingManager) {
                     bitmap_1 = parseBitmap(parsedData.d, parsedData.c);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['BoundedFetchRequest', e]);
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['BoundedFetchRequest', e]);
                     break;
                 }
                 forOwn(clients, function (_a, matchingKey) {
-                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    var hash64 = _a.hash64, worker = _a.worker;
                     if (isInBitmap(bitmap_1, hash64.hex)) {
-                        (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
+                        worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
                     }
                 });
                 return;
@@ -224,18 +222,18 @@ export function pushManagerFactory(params, pollingManager) {
                     removed_1 = new _Set(keyList.r);
                 }
                 catch (e) {
-                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', e]);
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', e]);
                     break;
                 }
                 if (!parsedData.n || !parsedData.n.length) {
-                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', 'No segment name was provided']);
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['KeyList', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
-                    var hash64 = _a.hash64, worker = _a.worker, workerLarge = _a.workerLarge;
+                    var hash64 = _a.hash64, worker = _a.worker;
                     var add = added_1.has(hash64.dec) ? true : removed_1.has(hash64.dec) ? false : undefined;
                     if (add !== undefined) {
-                        (isLS ? workerLarge : worker).put(parsedData, {
+                        worker.put(parsedData, {
                             added: add ? [parsedData.n[0]] : [],
                             removed: add ? [] : [parsedData.n[0]]
                         });
@@ -245,12 +243,12 @@ export function pushManagerFactory(params, pollingManager) {
             }
             case UpdateStrategy.SegmentRemoval:
                 if (!parsedData.n || !parsedData.n.length) {
-                    log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+                    log.warn(STREAMING_PARSING_MEMBERSHIPS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
                     break;
                 }
                 forOwn(clients, function (_a) {
-                    var worker = _a.worker, workerLarge = _a.workerLarge;
-                    (isLS ? workerLarge : worker).put(parsedData, {
+                    var worker = _a.worker;
+                    worker.put(parsedData, {
                         added: [],
                         removed: parsedData.n
                     });
@@ -259,13 +257,13 @@ export function pushManagerFactory(params, pollingManager) {
         }
         // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
         forOwn(clients, function (_a, matchingKey) {
-            var worker = _a.worker, workerLarge = _a.workerLarge;
-            (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
+            var worker = _a.worker;
+            worker.put(parsedData, undefined, getDelay(parsedData, matchingKey));
         });
     }
     if (userKey) {
-        pushEmitter.on(MEMBERSHIP_MS_UPDATE, handleMySegmentsUpdate);
-        pushEmitter.on(MEMBERSHIP_LS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIPS_MS_UPDATE, handleMySegmentsUpdate);
+        pushEmitter.on(MEMBERSHIPS_LS_UPDATE, handleMySegmentsUpdate);
     }
     else {
         pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker.put);
@@ -303,8 +301,7 @@ export function pushManagerFactory(params, pollingManager) {
                 userKeyHashes[hash] = userKey;
                 clients[userKey] = {
                     hash64: hash64(userKey),
-                    worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker),
-                    workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker)
+                    worker: MySegmentsUpdateWorker(log, storage, mySegmentsSyncTask, telemetryTracker)
                 };
                 connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
                 // Reconnects in case of a new client.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.16.1-rc.11",
+  "version": "1.16.1-rc.12",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/logger/constants.ts

@@ -79,7 +79,7 @@ export const WARN_SPLITS_FILTER_IGNORED = 219;
 export const WARN_SPLITS_FILTER_INVALID = 220;
 export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_SDK_KEY = 222;
-export const STREAMING_PARSING_MEMBERSHIP_UPDATE = 223;
+export const STREAMING_PARSING_MEMBERSHIPS_UPDATE = 223;
 export const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export const WARN_INVALID_FLAGSET = 225;
 export const WARN_LOWERCASE_FLAGSET = 226;

package/src/logger/messages/warn.ts

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

package/src/services/splitApi.ts

@@ -67,14 +67,14 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMemberships(userMatchingKey: string, noCache?: boolean) {
+    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
       /**
        * URI encoding of user keys in order to:
        *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
        *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
-      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}`;
+      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
     },
 

package/src/services/types.ts

@@ -39,7 +39,7 @@ export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: numbe
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -51,7 +51,7 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       spC: this.splits && this.splits.getSplitNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
-      lseC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+      lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
       lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),

package/src/storages/types.ts

@@ -270,7 +270,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
   setChangeNumber(name: string, changeNumber: number): boolean | void
-  getChangeNumber(name: string): number
+  getChangeNumber(name?: string): number
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }

package/src/sync/polling/fetchers/mySegmentsFetcher.ts

@@ -11,11 +11,12 @@ export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): I
   return function mySegmentsFetcher(
     userMatchingKey: string,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ): Promise<IMembershipsResponse> {
 
-    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache);
+    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
     return mySegmentsPromise.then(resp => resp.json());

package/src/sync/polling/fetchers/types.ts

@@ -19,5 +19,6 @@ export type ISegmentChangesFetcher = (
 export type IMySegmentsFetcher = (
   userMatchingKey: string,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<IMembershipsResponse>

package/src/sync/polling/types.ts

@@ -1,7 +1,7 @@
 import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../streaming/types';
+import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }], boolean> { }
@@ -9,13 +9,13 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
 export type MySegmentsData = {
-  type: MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE
+  type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE
   cn: number
   added: string[]
   removed: string[]
 }
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

package/src/sync/polling/updaters/mySegmentsUpdater.ts

@@ -7,9 +7,9 @@ import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
 import { IMembershipsResponse } from '../../../dtos/types';
-import { MEMBERSHIP_LS_UPDATE } from '../../streaming/constants';
+import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 
-type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -42,7 +42,7 @@ export function mySegmentsUpdaterFactory(
 
     let shouldNotifyUpdate;
     if ((segmentsData as MySegmentsData).type !== undefined) {
-      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIP_LS_UPDATE ?
+      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIPS_LS_UPDATE ?
         largeSegments!.resetSegments(segmentsData as MySegmentsData) :
         segments.resetSegments(segmentsData as MySegmentsData);
     } else {
@@ -57,12 +57,12 @@ export function mySegmentsUpdaterFactory(
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean): Promise<boolean> {
+  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean, till?: number): Promise<boolean> {
     const updaterPromise: Promise<boolean> = segmentsData ?
       // If segmentsData is provided, there is no need to fetch mySegments
       new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
-      mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 
@@ -92,9 +92,10 @@ export function mySegmentsUpdaterFactory(
    *  (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?: MySegmentsData, noCache?: boolean) {
-    return _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
+    return _mySegmentsUpdater(0, segmentsData, noCache, till);
   };
 
 }

package/src/sync/streaming/SSEHandler/index.ts

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -81,8 +81,8 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MEMBERSHIP_MS_UPDATE:
-        case MEMBERSHIP_LS_UPDATE:
+        case MEMBERSHIPS_MS_UPDATE:
+        case MEMBERSHIPS_LS_UPDATE:
         case SPLIT_KILL:
           pushEmitter.emit(parsedData.type, parsedData);
           break;

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -31,9 +31,9 @@ interface IMembershipUpdateData<T extends string> {
   s?: number, // seed for hash function
 }
 
-export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIP_MS_UPDATE> { }
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> { }
 
-export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIP_LS_UPDATE> { }
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> { }
 
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,