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

package/src/storages/pluggable/UniqueKeysCachePluggable.ts

@@ -4,6 +4,7 @@ import { DEFAULT_CACHE_SIZE, REFRESH_RATE } from '../inRedis/constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
@@ -27,7 +28,7 @@ export class UniqueKeysCachePluggable extends UniqueKeysCacheInMemory implements
     if (!featureNames.length) return Promise.resolve(false);
 
     const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = Array.from(this.uniqueKeysTracker[featureName]);
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
       const uniqueKeysPayload = {
         f: featureName,
         ks: featureKeys

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -1,5 +1,6 @@
 import { IPluggableStorageWrapper } from '../types';
 import { startsWith, toNumber } from '../../utils/lang';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * Creates a IPluggableStorageWrapper implementation that stores items in memory.
@@ -107,7 +108,7 @@ export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWra
     getItems(key: string) {
       const set = _cache[key];
       if (!set) return Promise.resolve([]);
-      if (set instanceof Set) return Promise.resolve(Array.from(set));
+      if (set instanceof Set) return Promise.resolve(setToArray(set));
       return Promise.reject('key is not a set');
     },
 

package/src/storages/types.ts

@@ -250,38 +250,32 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 /** Segments cache */
 
 export interface ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void> // different signature on Server and Client-Side
-  removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void> // different signature on Server and Client-Side
   isInSegment(name: string, key?: string): MaybeThenable<boolean> // different signature on Server and Client-Side
   registerSegments(names: string[]): MaybeThenable<boolean | void> // only for Server-Side
   getRegisteredSegments(): MaybeThenable<string[]> // only for Server-Side
-  setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void> // only for Server-Side
   getChangeNumber(name: string): MaybeThenable<number> // only for Server-Side
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean> // only for Server-Side
   clear(): MaybeThenable<boolean | void>
 }
 
 // Same API for both variants: SegmentsCache and MySegmentsCache (client-side API)
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys?: string[]): boolean
-  removeFromSegment(name: string, segmentKeys?: string[]): boolean
   isInSegment(name: string, key?: string): boolean
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean | void
   getChangeNumber(name?: string): number
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean // only for Server-Side
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
-  addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
-  removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
   isInSegment(name: string, key: string): Promise<boolean>
   registerSegments(names: string[]): Promise<boolean | void>
   getRegisteredSegments(): Promise<string[]>
-  setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>
   getChangeNumber(name: string): Promise<number>
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>
   clear(): Promise<boolean | void>
 }
 

package/src/sync/offline/syncManagerOffline.ts

@@ -1,4 +1,4 @@
-import { ISyncManager, ISyncManagerCS } from '../types';
+import { ISyncManagerCS } from '../types';
 import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { ISplitsParser } from './splitsParser/types';
@@ -29,26 +29,34 @@ export function syncManagerOfflineFactory(
     storage,
   }: ISdkFactoryContextSync): ISyncManagerCS {
 
+    const mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
+    const mainStart = mainSyncManager.start;
+    const sharedStarts: Array<() => void> = [];
+
     return objectAssign(
-      fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings),
+      mainSyncManager,
       {
+        start() {
+          mainStart();
+          sharedStarts.forEach(cb => cb());
+          sharedStarts.length = 0;
+        },
         // fake flush, that resolves immediately
         flush,
 
         // [Only used for client-side]
-        shared(matchingKey: string, readinessManager: IReadinessManager): ISyncManager {
+        shared(matchingKey: string, readinessManager: IReadinessManager) {
+          // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
+          // SDK_READY cannot be emitted directly because this will not update the readiness status
+          function emitSdkReady() {
+            readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
+          }
+
+          if (mainSyncManager.isRunning()) setTimeout(emitSdkReady);
+          else sharedStarts.push(emitSdkReady);
+
           return {
-            start() {
-              // In LOCALHOST mode, shared clients are ready in the next event-loop cycle than created
-              // SDK_READY cannot be emitted directly because this will not update the readiness status
-              setTimeout(() => {
-                readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED); // SDK_SPLITS_ARRIVED emitted by main SyncManager
-              }, 0);
-            },
             stop() { },
-            isRunning() {
-              return true;
-            },
             flush,
           };
         }

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

@@ -1,12 +1,9 @@
 import { ISegmentChangesFetcher } from '../fetchers/types';
 import { ISegmentsCacheBase } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
-import { MaybeThenable } from '../../../dtos/types';
-import { findIndex } from '../../../utils/lang';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { LOG_PREFIX_INSTANTIATION, LOG_PREFIX_SYNC_SEGMENTS } from '../../../logger/constants';
-import { thenable } from '../../../utils/promise/thenable';
 
 type ISegmentChangesUpdater = (fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number) => Promise<boolean>
 
@@ -30,31 +27,22 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean) {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<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}`);
+      return fetchOnlyNew && since !== -1 ?
+        false :
+        segmentChangesFetcher(since, segmentName, noCache, till).then((changes) => {
+          return Promise.all(changes.map(x => {
+            log.debug(`${LOG_PREFIX_SYNC_SEGMENTS}Processing ${segmentName} with till = ${x.till}. Added: ${x.added.length}. Removed: ${x.removed.length}`);
+            return segments.update(x.name, x.added, x.removed, x.till);
+          })).then((updates) => {
+            return updates.some(update => update);
+          });
         });
-        // 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;
-      });
     });
   }
   /**
@@ -75,16 +63,12 @@ export function segmentChangesUpdaterFactory(
     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++) {
-        updaters.push(updateSegment(segmentNames[index], noCache, till, fetchOnlyNew));
-      }
+      // Async fetchers
+      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready
-        if (findIndex(shouldUpdateFlags, v => v !== -1) !== -1 || readyOnAlreadyExistentState) {
+        if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
           if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }

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

@@ -8,6 +8,7 @@ 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';
 import { startsWith } from '../../../utils/lang';
 import { IN_SEGMENT } from '../../../utils/constants';
+import { setToArray } from '../../../utils/lang/sets';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -88,7 +89,7 @@ export function computeSplitsMutation(entries: ISplit[], filters: ISplitFiltersV
     return accum;
   }, { added: [], removed: [], segments: [] } as ISplitMutations);
 
-  computed.segments = Array.from(segments);
+  computed.segments = setToArray(segments);
 
   return computed;
 }

package/src/sync/syncManagerOnline.ts

@@ -143,27 +143,27 @@ export function syncManagerOnlineFactory(
 
         const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
 
-        return {
-          isRunning: mySegmentsSyncTask.isRunning,
-          start() {
-            if (syncEnabled) {
-              if (pushManager) {
-                if (pollingManager!.isRunning()) {
-                  // if doing polling, we must start the periodic fetch of data
-                  if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
-                } else {
-                  // if not polling, we must execute the sync task for the initial fetch
-                  // of segments since `syncAll` was already executed when starting the main client
-                  mySegmentsSyncTask.execute();
-                }
-                pushManager.add(matchingKey, mySegmentsSyncTask);
-              } else {
+        if (running) {
+          if (syncEnabled) {
+            if (pushManager) {
+              if (pollingManager!.isRunning()) {
+                // if doing polling, we must start the periodic fetch of data
                 if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
+              } else {
+                // if not polling, we must execute the sync task for the initial fetch
+                // of segments since `syncAll` was already executed when starting the main client
+                mySegmentsSyncTask.execute();
               }
+              pushManager.add(matchingKey, mySegmentsSyncTask);
             } else {
-              if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
+              if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
             }
-          },
+          } else {
+            if (!readinessManager.isReady()) mySegmentsSyncTask.execute();
+          }
+        }
+
+        return {
           stop() {
             // check in case `client.destroy()` has been invoked more than once for the same client
             const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).get(matchingKey);

package/src/sync/types.ts

@@ -44,5 +44,5 @@ export interface ISyncManager extends ITask {
 }
 
 export interface ISyncManagerCS extends ISyncManager {
-  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined
+  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined
 }

package/src/trackers/eventTracker.ts

@@ -16,6 +16,7 @@ import { isConsumerMode } from '../utils/settingsValidation/mode';
 export function eventTrackerFactory(
   settings: ISettings,
   eventsCache: IEventsCacheBase,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IEventsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync
 ): IEventTracker {
@@ -31,14 +32,16 @@ export function eventTrackerFactory(
     if (tracked) {
       log.info(EVENTS_TRACKER_SUCCESS, [msg]);
       if (integrationsManager) {
-        // Wrap in a timeout because we don't want it to be blocking.
-        setTimeout(function () {
-          // copy of event, to avoid unexpected behaviour if modified by integrations
-          const eventDataCopy = objectAssign({}, eventData);
-          if (properties) eventDataCopy.properties = objectAssign({}, properties);
-          // integrationsManager does not throw errors (they are internally handled by each integration module)
-          integrationsManager.handleEvent(eventDataCopy);
-        }, 0);
+        whenInit(() => {
+          // Wrap in a timeout because we don't want it to be blocking.
+          setTimeout(() => {
+            // copy of event, to avoid unexpected behaviour if modified by integrations
+            const eventDataCopy = objectAssign({}, eventData);
+            if (properties) eventDataCopy.properties = objectAssign({}, properties);
+            // integrationsManager does not throw errors (they are internally handled by each integration module)
+            integrationsManager.handleEvent(eventDataCopy);
+          });
+        });
       }
     } else {
       log.error(ERROR_EVENTS_TRACKER, [msg]);

package/src/trackers/impressionsTracker.ts

@@ -19,6 +19,7 @@ export function impressionsTrackerFactory(
   settings: ISettings,
   impressionsCache: IImpressionsCacheBase,
   strategy: IStrategy,
+  whenInit: (cb: () => void) => void,
   integrationsManager?: IImpressionsHandler,
   telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync,
 ): IImpressionsTracker {
@@ -66,17 +67,19 @@ export function impressionsTrackerFactory(
             sdkLanguageVersion: version
           };
 
-          // Wrap in a timeout because we don't want it to be blocking.
-          setTimeout(function () {
-            // integrationsManager.handleImpression does not throw errors
-            if (integrationsManager) integrationsManager.handleImpression(impressionData);
+          whenInit(() => {
+            // Wrap in a timeout because we don't want it to be blocking.
+            setTimeout(() => {
+              // integrationsManager.handleImpression does not throw errors
+              if (integrationsManager) integrationsManager.handleImpression(impressionData);
 
-            try { // @ts-ignore. An exception on the listeners should not break the SDK.
-              if (impressionListener) impressionListener.logImpression(impressionData);
-            } catch (err) {
-              log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
-            }
-          }, 0);
+              try { // @ts-ignore. An exception on the listeners should not break the SDK.
+                if (impressionListener) impressionListener.logImpression(impressionData);
+              } catch (err) {
+                log.error(ERROR_IMPRESSIONS_LISTENER, [err]);
+              }
+            });
+          });
         }
       }
     }

package/src/trackers/types.ts

@@ -65,6 +65,7 @@ export interface IImpressionSenderAdapter {
 
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+  start(): void;
   stop(): void;
   track(key: string, featureName: string): void;
 }

package/src/trackers/uniqueKeysTracker.ts

@@ -25,10 +25,6 @@ export function uniqueKeysTrackerFactory(
 ): IUniqueKeysTracker {
   let intervalId: any;
 
-  if (filterAdapter.refreshRate) {
-    intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
-  }
-
   return {
 
     track(key: string, featureName: string): void {
@@ -39,6 +35,12 @@ export function uniqueKeysTrackerFactory(
       uniqueKeysCache.track(key, featureName);
     },
 
+    start(): void {
+      if (filterAdapter.refreshRate) {
+        intervalId = setInterval(filterAdapter.clear, filterAdapter.refreshRate);
+      }
+    },
+
     stop(): void {
       clearInterval(intervalId);
     }

package/src/utils/lang/sets.ts

@@ -1,5 +1,15 @@
+export function setToArray<T>(set: Set<T>): T[] {
+  if (Array.from) return Array.from(set);
+
+  const array: T[] = [];
+  set.forEach((value: T) => {
+    array.push(value);
+  });
+  return array;
+}
+
 export function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T> {
-  return new Set(Array.from(set).concat(Array.from(set2)));
+  return new Set(setToArray(set).concat(setToArray(set2)));
 }
 
 export function returnDifference<T>(list: T[] = [], list2: T[] = []): T[] {

package/types/readiness/types.d.ts

@@ -9,6 +9,8 @@ export interface ISplitsEventEmitter extends IEventEmitter {
     once(event: ISplitsEvent, listener: (...args: any[]) => void): this;
     splitsArrived: boolean;
     splitsCacheLoaded: boolean;
+    initialized: boolean;
+    initCallbacks: (() => void)[];
 }
 /** Segments data emitter */
 declare type SDK_SEGMENTS_ARRIVED = 'state::segments-arrived';
@@ -46,6 +48,7 @@ export interface IReadinessManager {
     timeout(): void;
     setDestroyed(): void;
     destroy(): void;
+    init(): void;
     /** for client-side */
     shared(): IReadinessManager;
 }

package/types/sdkFactory/types.d.ts

@@ -63,6 +63,7 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+    lazyInit?: boolean;
     settings: ISettings;
     platform: IPlatform;
     storageFactory: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync;

package/types/storages/inLocalStorage/MySegmentsCacheInLocal.d.ts

@@ -1,15 +1,15 @@
 import { ILogger } from '../../logger/types';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
-export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
     private readonly keys;
     private readonly log;
     constructor(log: ILogger, keys: MySegmentsKeyBuilder);
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
 }

package/types/storages/inMemory/MySegmentsCacheInMemory.d.ts

@@ -1,15 +1,15 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 /**
  * Default MySegmentsCacheInMemory implementation that stores MySegments in memory.
  * Supported by all JS runtimes.
  */
-export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
     private segmentCache;
     private cn?;
-    addToSegment(name: string): boolean;
-    removeFromSegment(name: string): boolean;
+    protected addSegment(name: string): boolean;
+    protected removeSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    setChangeNumber(name?: string, changeNumber?: number): void;
+    protected setChangeNumber(changeNumber?: number): void;
     getChangeNumber(): number;
     getRegisteredSegments(): string[];
     getKeysCount(): number;

package/types/storages/inMemory/SegmentsCacheInMemory.d.ts

@@ -1,19 +1,17 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { ISegmentsCacheSync } from '../types';
 /**
- * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
+ * Default ISplitsCacheSync implementation for server-side that stores segments definitions in memory.
  */
-export declare class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export declare class SegmentsCacheInMemory implements ISegmentsCacheSync {
     private segmentCache;
     private segmentChangeNumber;
-    addToSegment(name: string, segmentKeys: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys: string[]): boolean;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
     isInSegment(name: string, key: string): boolean;
     clear(): void;
     private _registerSegment;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean;
     getChangeNumber(name: string): number;
+    resetSegments(): boolean;
 }

package/types/storages/inMemory/SplitsCacheInMemory.d.ts

@@ -2,7 +2,6 @@ import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync } from '../AbstractSplitsCacheSync';
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private flagSetsFilter;

package/types/storages/inRedis/SegmentsCacheInRedis.d.ts

@@ -7,10 +7,13 @@ export declare class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     private readonly redis;
     private readonly keys;
     constructor(log: ILogger, keys: KeyBuilderSS, redis: RedisAdapter);
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean>;
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean>;
+    /**
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., Redis operation fails).
+     */
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     isInSegment(name: string, key: string): Promise<boolean>;
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean>;
     getChangeNumber(name: string): Promise<number>;
     registerSegments(segments: string[]): Promise<boolean>;
     getRegisteredSegments(): Promise<string[]>;

package/types/storages/pluggable/SegmentsCachePluggable.d.ts

@@ -10,28 +10,16 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
     private readonly wrapper;
     constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     /**
-     * Add a list of `segmentKeys` to the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
-     */
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    /**
-     * Remove a list of `segmentKeys` from the given segment `name`.
-     * The returned promise is resolved when the operation success
-     * or rejected if wrapper operation fails.
+     * Update the given segment `name` with the lists of `addedKeys`, `removedKeys` and `changeNumber`.
+     * The returned promise is resolved if the operation success, with `true` if the segment was updated (i.e., some key was added or removed),
+     * or rejected if it fails (e.g., wrapper operation fails).
      */
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
      * Promise can be rejected if wrapper operation fails.
      */
     isInSegment(name: string, key: string): Promise<boolean>;
-    /**
-     * Set till number for the given segment `name`.
-     * The returned promise is resolved when the operation success,
-     * or rejected if it fails (e.g., wrapper operation fails).
-     */
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
     /**
      * Get till number or -1 if it's not defined.
      * The returned promise is resolved with the changeNumber or -1 if it doesn't exist or a wrapper operation fails.

package/types/storages/types.d.ts

@@ -229,35 +229,29 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
 }
 /** Segments cache */
 export interface ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): MaybeThenable<boolean | void>;
     isInSegment(name: string, key?: string): MaybeThenable<boolean>;
     registerSegments(names: string[]): MaybeThenable<boolean | void>;
     getRegisteredSegments(): MaybeThenable<string[]>;
-    setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void>;
     getChangeNumber(name: string): MaybeThenable<number>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean>;
     clear(): MaybeThenable<boolean | void>;
 }
 export interface ISegmentsCacheSync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys?: string[]): boolean;
-    removeFromSegment(name: string, segmentKeys?: string[]): boolean;
     isInSegment(name: string, key?: string): boolean;
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean | void;
     getChangeNumber(name?: string): number;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): boolean;
     resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
     clear(): void;
 }
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
-    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
     isInSegment(name: string, key: string): Promise<boolean>;
     registerSegments(names: string[]): Promise<boolean | void>;
     getRegisteredSegments(): Promise<string[]>;
-    setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>;
     getChangeNumber(name: string): Promise<number>;
+    update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>;
     clear(): Promise<boolean | void>;
 }
 /** Recorder storages (impressions, events and telemetry) */

package/types/sync/types.d.ts

@@ -39,5 +39,5 @@ export interface ISyncManager extends ITask {
     submitterManager?: ISubmitterManager;
 }
 export interface ISyncManagerCS extends ISyncManager {
-    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined;
+    shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): Pick<ISyncManager, 'stop' | 'flush'> | undefined;
 }

package/types/trackers/eventTracker.d.ts

@@ -7,4 +7,4 @@ import { ISettings } from '../types';
  * @param eventsCache cache to save events
  * @param integrationsManager optional event handler used for integrations
  */
-export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;
+export declare function eventTrackerFactory(settings: ISettings, eventsCache: IEventsCacheBase, whenInit: (cb: () => void) => void, integrationsManager?: IEventsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IEventTracker;

package/types/trackers/impressionsTracker.d.ts

@@ -10,4 +10,4 @@ import { ISettings } from '../types';
  * @param integrationsManager optional integrations manager
  * @param strategy strategy for impressions tracking.
  */
-export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;
+export declare function impressionsTrackerFactory(settings: ISettings, impressionsCache: IImpressionsCacheBase, strategy: IStrategy, whenInit: (cb: () => void) => void, integrationsManager?: IImpressionsHandler, telemetryCache?: ITelemetryCacheSync | ITelemetryCacheAsync): IImpressionsTracker;

package/types/trackers/types.d.ts

@@ -54,6 +54,7 @@ export interface IImpressionSenderAdapter {
 }
 /** Unique keys tracker */
 export interface IUniqueKeysTracker {
+    start(): void;
     stop(): void;
     track(key: string, featureName: string): void;
 }

package/types/utils/lang/sets.d.ts

@@ -1,2 +1,3 @@
+export declare function setToArray<T>(set: Set<T>): T[];
 export declare function returnSetsUnion<T>(set: Set<T>, set2: Set<T>): Set<T>;
 export declare function returnDifference<T>(list?: T[], list2?: T[]): T[];