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

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

@@ -1,58 +1,63 @@
+import { ILogger } from '../../../logger/types';
 import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
 import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
+import { FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT, FETCH_BACKOFF_MAX_RETRIES } from './constants';
 import { IUpdateWorker } from './types';
 
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-export class SplitsUpdateWorker implements IUpdateWorker {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
 
-  private readonly splitsCache: ISplitsCacheSync;
-  private readonly splitsSyncTask: ISplitsSyncTask;
-  private readonly splitsEventEmitter: ISplitsEventEmitter;
-  private readonly segmentsSyncTask?: ISegmentsSyncTask;
-  private maxChangeNumber: number;
-  private handleNewEvent: boolean;
-  readonly backoff: Backoff;
+  let maxChangeNumber = 0;
+  let handleNewEvent = false;
+  let isHandlingEvent: boolean;
+  let cdnBypass: boolean;
+  const backoff = new Backoff(__handleSplitUpdateCall, FETCH_BACKOFF_BASE, FETCH_BACKOFF_MAX_WAIT);
 
-  /**
-   * @param {Object} splitsCache splits data cache
-   * @param {Object} splitsSyncTask task for syncing splits data
-   * @param {Object} splitsEventEmitter emitter for splits data events
-   */
-  constructor(splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask) {
-    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
-  __handleSplitUpdateCall() {
-    if (this.maxChangeNumber > this.splitsCache.getChangeNumber()) {
-      this.handleNewEvent = false;
+  function __handleSplitUpdateCall() {
+    isHandlingEvent = true;
+    if (maxChangeNumber > splitsCache.getChangeNumber()) {
+      handleNewEvent = false;
 
       // fetch splits revalidating data if cached
-      this.splitsSyncTask.execute(true).then(() => {
-        if (this.handleNewEvent) {
-          this.__handleSplitUpdateCall();
+      splitsSyncTask.execute(true, cdnBypass ? maxChangeNumber : undefined).then(() => {
+        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);
+
+          const 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;
     }
   }
 
@@ -61,34 +66,41 @@ export class SplitsUpdateWorker implements IUpdateWorker {
    *
    * @param {number} changeNumber change number of the SPLIT_UPDATE notification
    */
-  put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
-    const currentChangeNumber = this.splitsCache.getChangeNumber();
-
-    if (changeNumber <= currentChangeNumber || changeNumber <= this.maxChangeNumber) return;
+  function put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>) {
+    const currentChangeNumber = splitsCache.getChangeNumber();
 
-    this.maxChangeNumber = changeNumber;
-    this.handleNewEvent = true;
-    this.backoff.reset();
+    if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
 
-    if (this.splitsSyncTask.isExecuting()) return;
+    maxChangeNumber = changeNumber;
+    handleNewEvent = true;
+    cdnBypass = false;
 
-    this.__handleSplitUpdateCall();
+    if (backoff.timeoutID || !isHandlingEvent) __handleSplitUpdateCall();
+    backoff.reset();
   }
 
-  /**
-   * 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({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-    if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
-      // trigger an SDK_UPDATE if Split was killed locally
-      this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);
-    }
-    // queues the SplitChanges fetch (only if changeNumber is newer)
-    this.put({ changeNumber });
-  }
+  return {
+    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({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
+      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 });
+    },
+
+    stop() {
+      isHandlingEvent = false;
+      backoff.reset();
+    }
+  };
 }

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

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

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

@@ -1,6 +1,4 @@
-import { Backoff } from '../../../utils/Backoff';
-
 export interface IUpdateWorker {
-  readonly backoff: Backoff,
-  put(...args: any[]): void
+  stop(): void // clear scheduled tasks (backoff)
+  put(...args: any[]): void // handle new update event
 }

package/src/sync/streaming/pushManager.ts

@@ -1,6 +1,6 @@
 import { IPushEventEmitter, IPushManager } from './types';
 import { ISSEClient } from './SSEClient/types';
-import { ISegmentsSyncTask, IPollingManager } from '../polling/types';
+import { IMySegmentsSyncTask, IPollingManager, ISegmentsSyncTask } from '../polling/types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { Backoff } from '../../utils/Backoff';
 import { SSEHandlerFactory } from './SSEHandler';
@@ -20,6 +20,7 @@ import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
 import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
+import { IUpdateWorker } from './UpdateWorkers/types';
 
 /**
  * PushManager factory:
@@ -55,15 +56,15 @@ export function pushManagerFactory(
 
   // init workers
   // MySegmentsUpdateWorker (client-side) are initiated in `add` method
-  const segmentsUpdateWorker = userKey ? undefined : new SegmentsUpdateWorker(pollingManager.segmentsSyncTask, storage.segments);
+  const segmentsUpdateWorker = userKey ? undefined : SegmentsUpdateWorker(log, pollingManager.segmentsSyncTask as ISegmentsSyncTask, storage.segments);
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
-  const splitsUpdateWorker = new SplitsUpdateWorker(storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask);
+  const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
   // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
   // Hash64 is used to process MY_SEGMENTS_UPDATE_V2 events and dispatch actions to the corresponding MySegmentsUpdateWorker.
-  const clients: Record<string, { hash64: Hash64, worker: MySegmentsUpdateWorker }> = {};
+  const clients: Record<string, { hash64: Hash64, worker: IUpdateWorker }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
   let connectForNewClient = false;
@@ -169,9 +170,9 @@ export function pushManagerFactory(
 
   // cancel scheduled fetch retries of Splits, Segments, and MySegments Update Workers
   function stopWorkers() {
-    splitsUpdateWorker.backoff.reset();
-    if (userKey) forOwn(clients, ({ worker }) => worker.backoff.reset());
-    else (segmentsUpdateWorker as SegmentsUpdateWorker).backoff.reset();
+    splitsUpdateWorker.stop();
+    if (userKey) forOwn(clients, ({ worker }) => worker.stop());
+    else segmentsUpdateWorker!.stop();
   }
 
   pushEmitter.on(PUSH_SUBSYSTEM_DOWN, stopWorkers);
@@ -180,7 +181,6 @@ export function pushManagerFactory(
   // Otherwise it is unnecessary (e.g, STREAMING_RESUMED).
   pushEmitter.on(PUSH_SUBSYSTEM_UP, () => {
     connectPushRetryBackoff.reset();
-    stopWorkers();
   });
 
   /** Fallback to polling without retry due to: STREAMING_DISABLED control event, or 'pushEnabled: false', or non-recoverable SSE and Authentication errors */
@@ -294,7 +294,7 @@ export function pushManagerFactory(
       });
     });
   } else {
-    pushEmitter.on(SEGMENT_UPDATE, (segmentsUpdateWorker as SegmentsUpdateWorker).put);
+    pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
 
   return objectAssign(
@@ -315,7 +315,7 @@ export function pushManagerFactory(
         if (disabled || disconnected === false) return;
         disconnected = false;
 
-        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask); // client-side
+        if (userKey) this.add(userKey, pollingManager.segmentsSyncTask as IMySegmentsSyncTask); // client-side
         else setTimeout(connectPush); // server-side runs in next cycle as in client-side, for consistency with client-side
       },
 
@@ -325,12 +325,12 @@ export function pushManagerFactory(
       },
 
       // [Only for client-side]
-      add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask) {
+      add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask) {
         const 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.

package/src/sync/streaming/types.ts

@@ -1,6 +1,6 @@
 import { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } from './SSEHandler/types';
 import { ITask } from '../types';
-import { ISegmentsSyncTask } from '../polling/types';
+import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
 import { ControlType } from './constants';
 
@@ -45,6 +45,6 @@ export interface IPushEventEmitter extends IEventEmitter {
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
   // Methods used in client-side, to support multiple clients
-  add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void,
+  add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void,
   remove(userKey: string): void
 }

package/src/sync/syncTask.ts

@@ -3,9 +3,8 @@ import { ILogger } from '../logger/types';
 import { ISyncTask } from './types';
 
 /**
- * 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 @@ import { ISyncTask } from './types';
  */
 export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger, task: (...args: Input) => Promise<Output>, period: number, taskName = 'task'): ISyncTask<Input, Output> {
 
-  // Task promise while it is pending. Undefined once the promise is resolved
-  let pendingTask: Promise<Output> | undefined;
+  // Flag that indicates if the task is executing
+  let executing = 0;
+  // Promise chain to resolve tasks sequentially
+  let promiseChain: Promise<Output> | undefined;
   // flag that indicates if the task periodic execution has been started/stopped.
   let running = false;
   // Auxiliar counter used to avoid race condition when calling `start` & `stop` intermittently
@@ -27,20 +28,17 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
   let timeoutID: any;
 
   function execute(...args: Input): Promise<Output> {
-    // If task is executing, chain the new execution
-    if (pendingTask) {
-      return pendingTask.then(() => {
-        return execute(...args);
+    executing++;
+    log.debug(SYNC_TASK_EXECUTE, [taskName]);
+
+    // Update `promiseChain` with last promise, to run tasks serially
+    promiseChain = (promiseChain ? promiseChain.then(() => task(...args)) : task(...args))
+      .then(result => {
+        executing--;
+        return result;
       });
-    }
 
-    // Execute task
-    log.debug(SYNC_TASK_EXECUTE, [taskName]);
-    pendingTask = task(...args).then(result => {
-      pendingTask = undefined;
-      return result;
-    });
-    return pendingTask;
+    return promiseChain;
   }
 
   function periodicExecute(currentRunningId: number) {
@@ -56,7 +54,7 @@ export function syncTaskFactory<Input extends any[], Output = any>(log: ILogger,
     execute,
 
     isExecuting() {
-      return pendingTask !== undefined;
+      return executing > 0;
     },
 
     start(...args: Input) {

package/src/utils/Backoff.ts

@@ -1,5 +1,9 @@
 export class Backoff {
 
+  // For testing purposes, assign to overwrite the provided value by param
+  static __TEST__BASE_MILLIS?: number;
+  static __TEST__MAX_MILLIS?: number;
+
   static DEFAULT_BASE_MILLIS = 1000; // 1 second
   static DEFAULT_MAX_MILLIS = 1800000; // 30 minutes
 
@@ -17,8 +21,8 @@ export class Backoff {
    * @param {number} maxMillis
    */
   constructor(cb: (...args: any[]) => any, baseMillis?: number, maxMillis?: number) {
-    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;
   }
@@ -32,6 +36,7 @@ export class Backoff {
 
     if (this.timeoutID) clearTimeout(this.timeoutID);
     this.timeoutID = setTimeout(() => {
+      this.timeoutID = undefined;
       this.cb();
     }, delayInMillis);
     this.attempts++;

package/types/integrations/ga/types.d.ts

@@ -52,23 +52,12 @@ export interface GoogleAnalyticsToSplitOptions {
      * If not provided, events are sent using the key and traffic type provided at SDK config
      */
     identities?: Identity[];
-    /**
-     * Optional flag to log an error if the `auto-require` script is not detected.
-     * The auto-require script automatically requires the `splitTracker` plugin for created trackers,
-     * and should be placed right after your Google Analytics, Google Tag Manager or gtag.js script tag.
-     *
-     * @see {@link https://help.split.io/hc/en-us/articles/360040838752#set-up-with-gtm-and-gtag.js}
-     *
-     * @property {boolean} autoRequire
-     * @default false
-     */
-    autoRequire?: boolean;
 }
 /**
  * Enable 'Google Analytics to Split' integration, to track Google Analytics hits as Split events.
  * Used by the browser variant of the isomorphic JS SDK.
  *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#google-analytics-to-split}
+ * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#google-analytics-to-split}
  */
 export interface IGoogleAnalyticsToSplitConfig extends GoogleAnalyticsToSplitOptions {
     type: 'GOOGLE_ANALYTICS_TO_SPLIT';
@@ -136,7 +125,7 @@ export interface SplitToGoogleAnalyticsOptions {
  * Enable 'Split to Google Analytics' integration, to track Split impressions and events as Google Analytics hits.
  * Used by the browser variant of the isomorphic JS SDK.
  *
- * @see {@link https://help.split.io/hc/en-us/articles/360040838752#split-to-google-analytics}
+ * @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#split-to-google-analytics}
  */
 export interface ISplitToGoogleAnalyticsConfig extends SplitToGoogleAnalyticsOptions {
     type: 'SPLIT_TO_GOOGLE_ANALYTICS';

package/types/services/types.d.ts

@@ -16,8 +16,8 @@ export declare type IFetch = (url: string, options?: IRequestOptions) => Promise
 export declare type IHealthCheckAPI = () => Promise<boolean>;
 export declare type ISplitHttpClient = (url: string, options?: IRequestOptions, latencyTracker?: (error?: NetworkError) => void, logErrorsAsInfo?: boolean) => Promise<IResponse>;
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
-export declare type IFetchSplitChanges = (since: number, noCache?: boolean) => Promise<IResponse>;
-export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean) => Promise<IResponse>;
+export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>;
+export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;

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

@@ -1,5 +1,5 @@
 import { ISplitChangesResponse, ISegmentChangesResponse } from '../../../dtos/types';
 import { IResponse } from '../../../services/types';
-export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
-export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
+export declare type ISplitChangesFetcher = (since: number, noCache?: boolean, till?: number, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<ISplitChangesResponse>;
+export declare type ISegmentChangesFetcher = (since: number, segmentName: string, noCache?: boolean, till?: number, decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>;
 export declare type IMySegmentsFetcher = (userMatchingKey: string, noCache?: boolean, decorator?: (promise: Promise<IResponse>) => Promise<IResponse>) => Promise<string[]>;

package/types/sync/polling/syncTasks/mySegmentsSyncTask.d.ts

@@ -1,9 +1,9 @@
 import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { ISegmentsSyncTask } from '../types';
+import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
 import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): ISegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;

package/types/sync/polling/types.d.ts

@@ -1,21 +1,26 @@
 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 declare type MySegmentsData = string[] | {
+    name: string;
+    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/types/sync/polling/updaters/segmentChangesUpdater.d.ts

@@ -2,7 +2,7 @@ import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
-declare type ISegmentChangesUpdater = (segmentNames?: string[], noCache?: boolean, fetchOnlyNew?: boolean) => Promise<boolean>;
+declare type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * Factory of SegmentChanges updater, a task that:
  *  - fetches segment changes using `segmentChangesFetcher`

package/types/sync/polling/updaters/splitChangesUpdater.d.ts

@@ -4,7 +4,7 @@ import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
-declare type ISplitChangesUpdater = (noCache?: boolean) => Promise<boolean>;
+declare type ISplitChangesUpdater = (noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * Collect segments from a raw split definition.
  * Exported for testing purposes.

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

@@ -65,7 +65,3 @@ export declare type INotificationError = Event & {
     parsedData?: any;
     message?: string;
 };
-export declare type SegmentsData = string[] | {
-    name: string;
-    add: boolean;
-};

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,27 +1,6 @@
-import { ISegmentsSyncTask } from '../../polling/types';
-import { Backoff } from '../../../utils/Backoff';
+import { IMySegmentsSyncTask } from '../../polling/types';
 import { IUpdateWorker } from './types';
-import { SegmentsData } from '../SSEHandler/types';
 /**
- * MySegmentsUpdateWorker class
+ * MySegmentsUpdateWorker factory
  */
-export declare class MySegmentsUpdateWorker implements IUpdateWorker {
-    private readonly mySegmentsSyncTask;
-    private maxChangeNumber;
-    private handleNewEvent;
-    private segmentsData?;
-    private currentChangeNumber;
-    readonly backoff: Backoff;
-    /**
-     * @param {Object} mySegmentsSyncTask task for syncing mySegments data
-     */
-    constructor(mySegmentsSyncTask: ISegmentsSyncTask);
-    __handleMySegmentsUpdateCall(): void;
-    /**
-     * 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): void;
-}
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask): IUpdateWorker;

package/types/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.d.ts

@@ -1,28 +1,8 @@
+import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
-import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask } from '../../polling/types';
-import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
- * SegmentUpdateWorker class
+ * SegmentsUpdateWorker factory
  */
-export declare class SegmentsUpdateWorker implements IUpdateWorker {
-    private readonly segmentsCache;
-    private readonly segmentsSyncTask;
-    private readonly maxChangeNumbers;
-    private handleNewEvent;
-    readonly backoff: Backoff;
-    /**
-     * @param {Object} segmentsCache segments data cache
-     * @param {Object} segmentsSyncTask task for syncing segments data
-     */
-    constructor(segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync);
-    __handleSegmentUpdateCall(): void;
-    /**
-     * Invoked by NotificationProcessor on SEGMENT_UPDATE event
-     *
-     * @param {number} changeNumber change number of the SEGMENT_UPDATE notification
-     * @param {string} segmentName segment name of the SEGMENT_UPDATE notification
-     */
-    put({ changeNumber, segmentName }: ISegmentUpdateData): void;
-}
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;

package/types/sync/streaming/UpdateWorkers/SplitsUpdateWorker.d.ts

@@ -1,39 +1,12 @@
+import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
-import { Backoff } from '../../../utils/Backoff';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
+import { ISplitKillData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
- * SplitsUpdateWorker class
+ * SplitsUpdateWorker factory
  */
-export declare class SplitsUpdateWorker implements IUpdateWorker {
-    private readonly splitsCache;
-    private readonly splitsSyncTask;
-    private readonly splitsEventEmitter;
-    private readonly segmentsSyncTask?;
-    private maxChangeNumber;
-    private handleNewEvent;
-    readonly backoff: Backoff;
-    /**
-     * @param {Object} splitsCache splits data cache
-     * @param {Object} splitsSyncTask task for syncing splits data
-     * @param {Object} splitsEventEmitter emitter for splits data events
-     */
-    constructor(splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask);
-    __handleSplitUpdateCall(): void;
-    /**
-     * Invoked by NotificationProcessor on SPLIT_UPDATE event
-     *
-     * @param {number} changeNumber change number of the SPLIT_UPDATE notification
-     */
-    put({ changeNumber }: Pick<ISplitUpdateData, 'changeNumber'>): void;
-    /**
-     * 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({ changeNumber, splitName, defaultTreatment }: ISplitKillData): void;
-}
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
+    killSplit(event: ISplitKillData): void;
+};

package/types/sync/streaming/UpdateWorkers/types.d.ts

@@ -1,5 +1,4 @@
-import { Backoff } from '../../../utils/Backoff';
 export interface IUpdateWorker {
-    readonly backoff: Backoff;
+    stop(): void;
     put(...args: any[]): void;
 }