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

package/src/listeners/browser.ts

@@ -14,12 +14,13 @@ import { ISyncManager } from '../sync/types';
 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.
-const UNLOAD_DOM_EVENT = 'unload';
+const VISIBILITYCHANGE_EVENT = 'visibilitychange';
+const PAGEHIDE_EVENT = 'pagehide';
+const UNLOAD_EVENT = 'unload';
 const 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.
  */
 export class BrowserSignalListener implements ISignalListener {
 
@@ -32,36 +33,53 @@ export class BrowserSignalListener implements ISignalListener {
     private serviceApi: ISplitApi,
   ) {
     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.
    */
   start() {
+    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.
    */
   stop() {
+    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);
     }
   }
 
+  stopSync() {
+    // 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.
    */
   flushData() {
@@ -86,9 +104,11 @@ export class BrowserSignalListener implements ISignalListener {
       const 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();
+  flushDataIfHidden() {
+    // Precondition: document defined
+    if (document.visibilityState === 'hidden') this.flushData(); // On a 'visibilitychange' event, flush data if state is hidden
   }
 
   private _flushData<T>(url: string, cache: IRecorderCacheProducerSync<T>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: T) => any, extraMetadata?: {}) {

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

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

@@ -8,7 +8,7 @@ import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
 import { thenable } from '../../../utils/promise/thenable';
 
-type ISegmentChangesUpdater = (segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean) => Promise<boolean>
+type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
 /**
  * Factory of SegmentChanges updater, a task that:
@@ -30,53 +30,56 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean) {
+    log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
+    let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
+
+    return sincePromise.then(since => {
+      // if fetchOnlyNew flag, avoid processing already fetched segments
+      if (fetchOnlyNew && since !== -1) return -1;
+
+      return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+        let changeNumber = -1;
+        const results: MaybeThenable<boolean | void>[] = [];
+        changes.forEach(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(result => thenable(result))) return Promise.all(results).then(() => 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?: string[], noCache?: boolean, fetchOnlyNew?: boolean) {
+  return function segmentChangesUpdater(fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) {
     log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Started segments update`);
 
     // If not a segment name provided, read list of available segments names to be updated.
-    let segmentsPromise = Promise.resolve(segmentNames ? segmentNames : segments.getRegisteredSegments());
+    let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
       // Async fetchers are collected here.
       const updaters: Promise<number>[] = [];
 
       for (let index = 0; index < segmentNames.length; index++) {
-        const segmentName = segmentNames[index];
-        log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing segment ${segmentName}`);
-        let sincePromise = Promise.resolve(segments.getChangeNumber(segmentName));
-
-        updaters.push(sincePromise.then(since => {
-          // if fetchOnlyNew flag, avoid processing already fetched segments
-          if (fetchOnlyNew && since !== -1) return -1;
-
-          return segmentChangesFetcher(since, segmentName, noCache).then(function (changes) {
-            let changeNumber = -1;
-            const results: MaybeThenable<boolean | void>[] = [];
-            changes.forEach(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(result => thenable(result))) return Promise.all(results).then(() => changeNumber);
-            return changeNumber;
-          });
-        }));
+        updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
 
       }
 
@@ -103,5 +106,4 @@ export function segmentChangesUpdaterFactory(
         return false;
       });
   };
-
 }

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

@@ -8,7 +8,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 
-type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>
+type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>
 
 // Checks that all registered segments have been fetched (changeNumber !== -1 for every segment).
 // Returns a promise that could be rejected.
@@ -109,17 +109,18 @@ export function splitChangesUpdaterFactory(
    * 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?: boolean) {
+  return function splitChangesUpdater(noCache?: boolean, till?: number) {
 
     /**
      * @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: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
 
-      const fetcherPromise = splitChangesFetcher(since, noCache, _promiseDecorator)
+      const fetcherPromise = splitChangesFetcher(since, noCache, till, _promiseDecorator)
         .then((splitChanges: ISplitChangesResponse) => {
           startingUp = false;
 

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

@@ -68,10 +68,3 @@ export interface IOccupancyData {
 export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }
-
-export type SegmentsData = string[] | {
-  /* segment name */
-  name: string,
-  /* action: `true` for add, and `false` for delete */
-  add: boolean
-}

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -1,71 +1,62 @@
-import { ISegmentsSyncTask } from '../../polling/types';
+import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
-import { SegmentsData } from '../SSEHandler/types';
 
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-export class MySegmentsUpdateWorker implements IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask): IUpdateWorker {
 
-  private readonly mySegmentsSyncTask: ISegmentsSyncTask;
-  private maxChangeNumber: number;
-  private handleNewEvent: boolean;
-  private segmentsData?: SegmentsData;
-  private currentChangeNumber: number;
-  readonly backoff: Backoff;
+  let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
+  let currentChangeNumber = -1;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
+  const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
-  /**
-   * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-   */
-  constructor(mySegmentsSyncTask: ISegmentsSyncTask) {
-    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
-  __handleMySegmentsUpdateCall() {
-    if (this.maxChangeNumber > this.currentChangeNumber) {
-      this.handleNewEvent = false;
-      const currentMaxChangeNumber = this.maxChangeNumber;
+  function __handleMySegmentsUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > currentChangeNumber) {
+      handleNewEvent = false;
+      const currentMaxChangeNumber = maxChangeNumber;
 
       // fetch mySegments revalidating data if cached
-      this.mySegmentsSyncTask.execute(this.segmentsData, true).then((result) => {
+      mySegmentsSyncTask.execute(_segmentsData, true).then((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); // use `currentMaxChangeNumber`, in case that `this.maxChangeNumber` was updated during fetch.
-        if (this.handleNewEvent) {
-          this.__handleMySegmentsUpdateCall();
+          currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
+        if (handleNewEvent) {
+          __handleMySegmentsUpdateCall();
         } else {
-          this.backoff.scheduleCall();
+          backoff.scheduleCall();
         }
       });
+    } else {
+      isHandlingEvent = false;
     }
   }
 
-  /**
-   * 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(changeNumber: number, segmentsData?: 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 {
+    /**
+     * 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(changeNumber: number, segmentsData?: MySegmentsData) {
+      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+
+      maxChangeNumber = changeNumber;
+      handleNewEvent = true;
+      _segmentsData = segmentsData;
+
+      if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
+      backoff.reset();
+    },
+
+    stop() {
+      isHandlingEvent = false;
+      backoff.reset();
+    }
+  };
 }