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

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

package/types/sync/streaming/types.d.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';
 export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
@@ -29,7 +29,7 @@ export interface IPushEventEmitter extends IEventEmitter {
  * PushManager
  */
 export interface IPushManager extends ITask, IPushEventEmitter {
-    add(userKey: string, mySegmentsSyncTask: ISegmentsSyncTask): void;
+    add(userKey: string, mySegmentsSyncTask: IMySegmentsSyncTask): void;
     remove(userKey: string): void;
 }
 export {};

package/types/sync/syncTask.d.ts

@@ -1,9 +1,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.

package/types/utils/Backoff.d.ts

@@ -1,4 +1,6 @@
 export declare class Backoff {
+    static __TEST__BASE_MILLIS?: number;
+    static __TEST__MAX_MILLIS?: number;
     static DEFAULT_BASE_MILLIS: number;
     static DEFAULT_MAX_MILLIS: number;
     baseMillis: number;

package/cjs/sync/offline/LocalhostFromFile.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalhostFromFile = void 0;
-var splitsParserFromFile_1 = require("./splitsParser/splitsParserFromFile");
-var syncManagerOffline_1 = require("./syncManagerOffline");
-// Singleton instance of the factory function for offline SyncManager from YAML file (a.k.a. localhostFromFile)
-// Requires Node 'fs' and 'path' APIs.
-var localhostFromFile = (0, syncManagerOffline_1.syncManagerOfflineFactory)(splitsParserFromFile_1.splitsParserFromFileFactory);
-localhostFromFile.type = 'LocalhostFromFile';
-function LocalhostFromFile() {
-    return localhostFromFile;
-}
-exports.LocalhostFromFile = LocalhostFromFile;

package/cjs/sync/offline/splitsParser/splitsParserFromFile.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitsParserFromFileFactory = void 0;
-var tslib_1 = require("tslib");
-/* eslint-disable no-undef */
-// @TODO consider moving it to Node-SDK and remove js-yaml dependency from Js-commons
-var fs_1 = (0, tslib_1.__importDefault)(require("fs"));
-var path_1 = (0, tslib_1.__importDefault)(require("path"));
-// @ts-ignore
-var js_yaml_1 = (0, tslib_1.__importDefault)(require("js-yaml"));
-var lang_1 = require("../../../utils/lang");
-var parseCondition_1 = require("./parseCondition");
-var logPrefix = 'sync:offline:splits-fetcher: ';
-var DEFAULT_FILENAME = '.split';
-function configFilesPath(configFilePath) {
-    if (configFilePath === DEFAULT_FILENAME || !(0, lang_1.isString)(configFilePath)) {
-        var root = process.env.HOME;
-        if (process.env.SPLIT_CONFIG_ROOT)
-            root = process.env.SPLIT_CONFIG_ROOT;
-        if (!root)
-            throw new Error('Missing split mock configuration root.');
-        configFilePath = path_1.default.join(root, DEFAULT_FILENAME);
-    }
-    // Validate the extensions
-    if (!((0, lang_1.endsWith)(configFilePath, '.yaml', true) || (0, lang_1.endsWith)(configFilePath, '.yml', true) || (0, lang_1.endsWith)(configFilePath, '.split', true)))
-        throw new Error("Invalid extension specified for Splits mock file. Accepted extensions are \".yml\" and \".yaml\". Your specified file is " + configFilePath);
-    if (!fs_1.default.existsSync(configFilePath))
-        throw new Error("Split configuration not found in " + configFilePath + " - Please review your Split file location.");
-    return configFilePath;
-}
-// This function is not pure nor meant to be. Here we apply modifications to cover
-// for behaviour that's ensured by the BE.
-function arrangeConditions(mocksData) {
-    // Iterate through each Split data
-    (0, lang_1.forOwn)(mocksData, function (data) {
-        var conditions = data.conditions;
-        // On the manager, as the split jsons come with all treatments on the partitions prop,
-        // we'll add all the treatments to the first condition.
-        var firstRolloutCondition = (0, lang_1.find)(conditions, function (cond) { return cond.conditionType === 'ROLLOUT'; });
-        // Malformed mocks may have
-        var treatments = (0, lang_1.uniq)(data.treatments);
-        // If they're only specifying a whitelist we add the treatments there.
-        var allTreatmentsCondition = firstRolloutCondition ? firstRolloutCondition : conditions[0];
-        var fullyAllocatedTreatment = allTreatmentsCondition.partitions[0].treatment;
-        treatments.forEach(function (treatment) {
-            if (treatment !== fullyAllocatedTreatment) {
-                allTreatmentsCondition.partitions.push({
-                    treatment: treatment,
-                    size: 0
-                });
-            }
-        });
-        // Don't need these anymore
-        // @ts-expect-error
-        delete data.treatments;
-    });
-}
-function splitsParserFromFileFactory() {
-    var previousMock = 'NO_MOCK_LOADED';
-    // Parse `.split` configuration file and return a map of "Split Objects"
-    function readSplitConfigFile(log, filePath) {
-        var SPLIT_POSITION = 0;
-        var TREATMENT_POSITION = 1;
-        var data;
-        try {
-            data = fs_1.default.readFileSync(filePath, 'utf-8');
-        }
-        catch (e) {
-            log.error(e && e.message);
-            return {};
-        }
-        if (data === previousMock)
-            return false;
-        previousMock = data;
-        var splitObjects = data.split(/\r?\n/).reduce(function (accum, line, index) {
-            var tuple = line.trim();
-            if (tuple === '' || tuple.charAt(0) === '#') {
-                log.debug(logPrefix + ("Ignoring empty line or comment at #" + index));
-            }
-            else {
-                tuple = tuple.split(/\s+/);
-                if (tuple.length !== 2) {
-                    log.debug(logPrefix + ("Ignoring line since it does not have exactly two columns #" + index));
-                }
-                else {
-                    var splitName = tuple[SPLIT_POSITION];
-                    var condition = (0, parseCondition_1.parseCondition)({ treatment: tuple[TREATMENT_POSITION] });
-                    accum[splitName] = { conditions: [condition], configurations: {}, trafficTypeName: 'localhost' };
-                }
-            }
-            return accum;
-        }, {});
-        return splitObjects;
-    }
-    // Parse `.yml` or `.yaml` configuration files and return a map of "Split Objects"
-    function readYAMLConfigFile(log, filePath) {
-        var data = '';
-        var yamldoc = null;
-        try {
-            data = fs_1.default.readFileSync(filePath, 'utf8');
-            if (data === previousMock)
-                return false;
-            previousMock = data;
-            yamldoc = js_yaml_1.default.safeLoad(data);
-        }
-        catch (e) {
-            log.error(e);
-            return {};
-        }
-        // Each entry will be mapped to a condition, but we'll also keep the configurations map.
-        var mocksData = yamldoc.reduce(function (accum, splitEntry) {
-            var splitName = Object.keys(splitEntry)[0];
-            if (!splitName || !(0, lang_1.isString)(splitEntry[splitName].treatment))
-                log.error(logPrefix + 'Ignoring entry on YAML since the format is incorrect.');
-            var mockData = splitEntry[splitName];
-            // "Template" for each split accumulated data
-            if (!accum[splitName]) {
-                accum[splitName] = {
-                    configurations: {}, conditions: [], treatments: [], trafficTypeName: 'localhost'
-                };
-            }
-            // Assign the config if there is one on the mock
-            if (mockData.config)
-                accum[splitName].configurations[mockData.treatment] = mockData.config;
-            // Parse the condition from the entry.
-            var condition = (0, parseCondition_1.parseCondition)(mockData);
-            accum[splitName].conditions[condition.conditionType === 'ROLLOUT' ? 'push' : 'unshift'](condition);
-            // Also keep track of the treatments, will be useful for manager functionality.
-            accum[splitName].treatments.push(mockData.treatment);
-            return accum;
-        }, {});
-        arrangeConditions(mocksData);
-        return mocksData;
-    }
-    // Load the content of a configuration file into an Object
-    return function splitsParserFromFile(_a) {
-        var features = _a.features, log = _a.log;
-        var filePath = configFilesPath(features);
-        var mockData;
-        // If we have a filePath, it means the extension is correct, choose the parser.
-        if ((0, lang_1.endsWith)(filePath, '.split')) {
-            log.warn(logPrefix + '.split mocks will be deprecated soon in favor of YAML files, which provide more targeting power. Take a look in our documentation.');
-            mockData = readSplitConfigFile(log, filePath);
-        }
-        else {
-            mockData = readYAMLConfigFile(log, filePath);
-        }
-        return mockData;
-    };
-}
-exports.splitsParserFromFileFactory = splitsParserFromFileFactory;

package/esm/sync/offline/LocalhostFromFile.js

@@ -1,9 +0,0 @@
-import { splitsParserFromFileFactory } from './splitsParser/splitsParserFromFile';
-import { syncManagerOfflineFactory } from './syncManagerOffline';
-// Singleton instance of the factory function for offline SyncManager from YAML file (a.k.a. localhostFromFile)
-// Requires Node 'fs' and 'path' APIs.
-var localhostFromFile = syncManagerOfflineFactory(splitsParserFromFileFactory);
-localhostFromFile.type = 'LocalhostFromFile';
-export function LocalhostFromFile() {
-    return localhostFromFile;
-}