@splitsoftware/splitio-commons 1.4.2-rc.5 → 1.5.1-rc.1

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/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const FETCH_BACKOFF_BASE = 10000;
+export declare const FETCH_BACKOFF_MAX_WAIT = 60000;
+export declare const FETCH_BACKOFF_MAX_RETRIES = 10;

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/src/integrations/ga/autoRequire.js

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