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

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

@@ -1,79 +1,94 @@
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { Backoff } from '../../../utils/Backoff';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './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(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;
+export function SplitsUpdateWorker(log, splitsCache, splitsSyncTask, splitsEventEmitter, segmentsSyncTask) {
+    var maxChangeNumber = 0;
+    var handleNewEvent = false;
+    var isHandlingEvent;
+    var cdnBypass;
+    var backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, 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 < 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(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(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;
-}());
-export { SplitsUpdateWorker };
+}

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

@@ -0,0 +1,3 @@
+export var FETCH_BACKOFF_BASE = 10000; // backoff base starting at 10 seconds
+export var FETCH_BACKOFF_MAX_WAIT = 60000; // don't wait for more than 1 minute
+export var FETCH_BACKOFF_MAX_RETRIES = 10; // max retries

package/esm/sync/streaming/pushManager.js

@@ -42,9 +42,9 @@ export function pushManagerFactory(params, pollingManager) {
     sseClient.setEventHandler(sseHandler);
     // init workers
     // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-    var segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+    var segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask, storage.segments);
     // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-    var splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+    var splitsUpdateWorker = 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.
@@ -137,21 +137,20 @@ export function pushManagerFactory(params, pollingManager) {
     }
     // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
     function stopWorkers() {
-        splitsUpdateWorker.backoff.reset();
+        splitsUpdateWorker.stop();
         if (userKey)
             forOwn(clients, function (_a) {
                 var worker = _a.worker;
-                return worker.backoff.reset();
+                return worker.stop();
             });
         else
-            segmentsUpdateWorker.backoff.reset();
+            segmentsUpdateWorker.stop();
     }
     pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
     // Only required when streaming connects after a PUSH_RETRYABLE_ERROR.
     // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
     pushEmitter.on(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(PUSH_NONRETRYABLE_ERROR, function handleNonRetryableError() {
@@ -287,7 +286,7 @@ export function pushManagerFactory(params, pollingManager) {
             var hash = hashUserKey(userKey);
             if (!userKeyHashes[hash]) {
                 userKeyHashes[hash] = userKey;
-                clients[userKey] = { hash64: hash64(userKey), worker: new MySegmentsUpdateWorker(mySegmentsSyncTask) };
+                clients[userKey] = { hash64: hash64(userKey), worker: 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/esm/sync/syncTask.js

@@ -1,8 +1,7 @@
 import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../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.
@@ -12,8 +11,10 @@ import { SYNC_TASK_EXECUTE, SYNC_TASK_START, SYNC_TASK_STOP } from '../logger/co
  */
 export 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
@@ -27,19 +28,15 @@ export 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(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) {
@@ -53,7 +50,7 @@ export function syncTaskFactory(log, task, period, taskName) {
     return {
         execute: execute,
         isExecuting: function () {
-            return pendingTask !== undefined;
+            return executing > 0;
         },
         start: function () {
             var args = [];

package/esm/utils/Backoff.js

@@ -7,8 +7,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;
     }
@@ -22,6 +22,7 @@ var Backoff = /** @class */ (function () {
         if (this.timeoutID)
             clearTimeout(this.timeoutID);
         this.timeoutID = setTimeout(function () {
+            _this.timeoutID = undefined;
             _this.cb();
         }, delayInMillis);
         this.attempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.5.1-rc.0",
+  "version": "1.5.1-rc.3",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -47,13 +47,9 @@
     "tslib": "^2.3.1"
   },
   "peerDependencies": {
-    "js-yaml": "^3.13.1",
     "ioredis": "^4.28.0"
   },
   "peerDependenciesMeta": {
-    "js-yaml": {
-      "optional": true
-    },
     "ioredis": {
       "optional": true
     }

package/src/integrations/ga/GaToSplit.ts

@@ -37,7 +37,7 @@ function providePlugin(window: any, pluginName: string, pluginConstructor: Funct
 
   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.');
+    log.error(logPrefix + 'integration is configured to autorequire the splitTracker plugin, but the necessary script does not seem to have run. Please check the docs.');
   }
 }
 

package/src/integrations/ga/autoRequire.js

@@ -2,31 +2,31 @@
 /**
  * Auto-require script to use with GoogleAnalyticsToSplit integration
  */
-(function (i, r, s) {
-  i[s] = i[s] || r;
-  i[r] = i[r] || function () { i[r].q.push(arguments); };
-  i[r].q = i[r].q || [];
+(function (w, g, o) {
+  w[o] = w[o] || g;
+  w[g] = w[g] || function () { w[g].q.push(arguments); };
+  w[g].q = w[g].q || [];
 
-  var ts = {}; // Tracker names
+  var trackerNames = {};
   function name(arg) { return typeof arg === 'object' && typeof arg.name === 'string' && arg.name; }
 
-  function processCommand(v) { // Queue a `require` command if v is a `create` command
-    if (v && v[0] === 'create') {
-      var t = name(v[1]) || name(v[2]) || name(v[3]) || (typeof v[3] === 'string' ? v[3] : undefined); // Get tracker name
+  function processCommand(command) { // Queue a `require` command if v is a `create` command
+    if (command && command[0] === 'create') {
+      var trackerName = name(command[1]) || name(command[2]) || name(command[3]) || (typeof command[3] === 'string' ? command[3] : undefined); // Get tracker name
 
-      if (!ts[t]) {
-        ts[t] = true;
-        i[r]((t ? t + '.' : '') + 'require', 'splitTracker'); // Auto-require
+      if (!trackerNames[trackerName]) {
+        trackerNames[trackerName] = true;
+        w[g]((trackerName ? trackerName + '.' : '') + 'require', 'splitTracker'); // Auto-require
       }
     }
   }
 
-  i[r].q.forEach(processCommand); // Process already queued commands
+  w[g].q.forEach(processCommand); // Process already queued commands
 
-  var o = i[r].q.push;
-  i[r].q.push = function (v) { // Spy new queued commands
-    var result = o.apply(this, arguments);
-    processCommand(v);
+  var originalPush = w[g].q.push;
+  w[g].q.push = function (command) { // Spy new queued commands
+    var result = originalPush.apply(this, arguments);
+    processCommand(command);
     return result;
   };
 

package/src/services/splitApi.ts

@@ -50,13 +50,13 @@ export function splitApiFactory(
       return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
     },
 
-    fetchSplitChanges(since: number, noCache?: boolean) {
-      const url = `${urls.sdk}/splitChanges?since=${since}${filterQueryString || ''}`;
+    fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/splitChanges?since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS));
     },
 
-    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean) {
-      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}`;
+    fetchSegmentChanges(since: number, segmentName: string, noCache?: boolean, till?: number) {
+      const url = `${urls.sdk}/segmentChanges/${segmentName}?since=${since}${till ? '&till=' + till : ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 

package/src/services/types.ts

@@ -35,9 +35,9 @@ export type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyT
 
 export type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>
 
-export type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>
+export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
 export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
 

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

@@ -2,15 +2,15 @@ import { IFetchSegmentChanges } from '../../../services/types';
 import { ISegmentChangesResponse } from '../../../dtos/types';
 import { ISegmentChangesFetcher } from './types';
 
-function greedyFetch(fetchSegmentChanges: IFetchSegmentChanges, since: number, segmentName: string, noCache?: boolean): Promise<ISegmentChangesResponse[]> {
-  return fetchSegmentChanges(since, segmentName, noCache)
+function greedyFetch(fetchSegmentChanges: IFetchSegmentChanges, since: number, segmentName: string, noCache?: boolean, targetTill?: number): Promise<ISegmentChangesResponse[]> {
+  return fetchSegmentChanges(since, segmentName, noCache, targetTill)
     .then(resp => resp.json())
     .then((json: ISegmentChangesResponse) => {
       let { since, till } = json;
       if (since === till) {
         return [json];
       } else {
-        return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache)]).then(flatMe => {
+        return Promise.all([json, greedyFetch(fetchSegmentChanges, till, segmentName, noCache, targetTill)]).then(flatMe => {
           return [flatMe[0], ...flatMe[1]];
         });
       }
@@ -27,11 +27,12 @@ export function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentC
     since: number,
     segmentName: string,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
   ): Promise<ISegmentChangesResponse[]> {
 
-    let segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache);
+    let segmentsPromise = greedyFetch(fetchSegmentChanges, since, segmentName, noCache, till);
     if (decorator) segmentsPromise = decorator(segmentsPromise);
 
     return segmentsPromise;

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

@@ -10,11 +10,12 @@ export function splitChangesFetcherFactory(fetchSplitChanges: IFetchSplitChanges
   return function splitChangesFetcher(
     since: number,
     noCache?: boolean,
+    till?: number,
     // Optional decorator for `fetchSplitChanges` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
   ) {
 
-    let splitsPromise = fetchSplitChanges(since, noCache);
+    let splitsPromise = fetchSplitChanges(since, noCache, till);
     if (decorator) splitsPromise = decorator(splitsPromise);
 
     return splitsPromise.then(resp => resp.json());

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

@@ -4,6 +4,7 @@ import { IResponse } from '../../../services/types';
 export type ISplitChangesFetcher = (
   since: number,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
 ) => Promise<ISplitChangesResponse>
 
@@ -11,6 +12,7 @@ export type ISegmentChangesFetcher = (
   since: number,
   segmentName: string,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
 ) => Promise<ISegmentChangesResponse[]>
 

package/src/sync/polling/pollingManagerCS.ts

@@ -1,4 +1,4 @@
-import { ISegmentsSyncTask, ISplitsSyncTask, IPollingManagerCS } from './types';
+import { IMySegmentsSyncTask, IPollingManagerCS } from './types';
 import { forOwn } from '../../utils/lang';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
@@ -20,13 +20,13 @@ export function pollingManagerCSFactory(
   const { splitApi, storage, readiness, settings } = params;
   const log = settings.log;
 
-  const splitsSyncTask: ISplitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
+  const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
   // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, ISegmentsSyncTask> = {};
+  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
 
   const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask: ISegmentsSyncTask = add(matchingKey, readiness, storage);
+  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
     forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
@@ -54,7 +54,7 @@ export function pollingManagerCSFactory(
     }
   });
 
-  function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): ISegmentsSyncTask {
+  function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
     const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
 
     // smart ready

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -1,7 +1,7 @@
 import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
-import { ISegmentsSyncTask } from '../types';
+import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
 import { mySegmentsFetcherFactory } from '../fetchers/mySegmentsFetcher';
 import { ISettings } from '../../../types';
@@ -16,7 +16,7 @@ export function mySegmentsSyncTaskFactory(
   readiness: IReadinessManager,
   settings: ISettings,
   matchingKey: string
-): ISegmentsSyncTask {
+): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(

package/src/sync/polling/types.ts

@@ -1,23 +1,31 @@
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
-import { SegmentsData } from '../streaming/SSEHandler/types';
 import { ITask, ISyncTask } from '../types';
 
-export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean], boolean> { }
+export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number], boolean> { }
 
-export interface ISegmentsSyncTask extends ISyncTask<[segmentNames?: SegmentsData, noCache?: boolean, fetchOnlyNew?: boolean], boolean> { }
+export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
+
+export type MySegmentsData = string[] | {
+  /* segment name */
+  name: string,
+  /* action: `true` for add, and `false` for delete */
+  add: boolean
+}
+
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
-  segmentsSyncTask: ISegmentsSyncTask
+  segmentsSyncTask: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): ISegmentsSyncTask
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
   remove(matchingKey: string): void;
-  get(matchingKey: string): ISegmentsSyncTask | undefined
+  get(matchingKey: string): IMySegmentsSyncTask | undefined
 }

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

@@ -5,7 +5,7 @@ import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
-import { SegmentsData } from '../../streaming/SSEHandler/types';
+import { MySegmentsData } from '../types';
 
 type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
 
@@ -36,7 +36,7 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: SegmentsData) {
+  function updateSegments(segmentsData: MySegmentsData) {
 
     let shouldNotifyUpdate;
     if (Array.isArray(segmentsData)) {
@@ -61,7 +61,7 @@ export function mySegmentsUpdaterFactory(
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentsData?: SegmentsData, noCache?: boolean): Promise<boolean> {
+  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean): 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); }) :
@@ -97,7 +97,7 @@ export function mySegmentsUpdaterFactory(
    *  (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
    */
-  return function mySegmentsUpdater(segmentsData?: SegmentsData, noCache?: boolean) {
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
     return _mySegmentsUpdater(0, segmentsData, noCache);
   };