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

package/src/evaluator/index.ts

@@ -7,7 +7,7 @@ import { IStorageAsync, IStorageSync } from '../storages/types';
 import { IEvaluationResult } from './types';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
-import { returnSetsUnion } from '../utils/lang/sets';
+import { returnSetsUnion, setToArray } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
 const treatmentException = {
@@ -113,7 +113,7 @@ export function evaluateFeaturesByFlagSets(
     }
 
     return featureFlags.size ?
-      evaluateFeatures(log, key, Array.from(featureFlags), attributes, storage) :
+      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
       {};
   }
 

package/src/readiness/readinessManager.ts

@@ -7,6 +7,8 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   const splitsEventEmitter = objectAssign(new EventEmitter(), {
     splitsArrived: false,
     splitsCacheLoaded: false,
+    initialized: false,
+    initCallbacks: []
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
@@ -56,8 +58,8 @@ export function readinessManagerFactory(
   // emit SDK_READY_TIMED_OUT
   let hasTimedout = false;
 
-  function timeout() {
-    if (hasTimedout) return;
+  function timeout() { // eslint-disable-next-line no-use-before-define
+    if (hasTimedout || isReady) return;
     hasTimedout = true;
     syncLastUpdate();
     gate.emit(SDK_READY_TIMED_OUT, 'Split SDK emitted SDK_READY_TIMED_OUT event.');
@@ -65,7 +67,8 @@ export function readinessManagerFactory(
 
   let readyTimeoutId: ReturnType<typeof setTimeout>;
   if (readyTimeout > 0) {
-    readyTimeoutId = setTimeout(timeout, readyTimeout);
+    if (splits.initialized) readyTimeoutId = setTimeout(timeout, readyTimeout);
+    else splits.initCallbacks.push(() => { readyTimeoutId = setTimeout(timeout, readyTimeout); });
   }
 
   // emit SDK_READY and SDK_UPDATE
@@ -132,6 +135,12 @@ export function readinessManagerFactory(
     // tracking and evaluations, while keeping event listeners to emit SDK_READY_TIMED_OUT event
     setDestroyed() { isDestroyed = true; },
 
+    init() {
+      if (splits.initialized) return;
+      splits.initialized = true;
+      splits.initCallbacks.forEach(cb => cb());
+    },
+
     destroy() {
       isDestroyed = true;
       syncLastUpdate();

package/src/readiness/types.ts

@@ -12,6 +12,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 */
@@ -59,6 +61,7 @@ export interface IReadinessManager {
   timeout(): void,
   setDestroyed(): void,
   destroy(): void,
+  init(): void,
 
   /** for client-side */
   shared(): IReadinessManager,

package/src/sdkClient/sdkClientMethodCS.ts

@@ -75,8 +75,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
         validKey
       );
 
-      sharedSyncManager && sharedSyncManager.start();
-
       log.info(NEW_SHARED_CLIENT);
     } else {
       log.debug(RETRIEVE_CLIENT_EXISTING);

package/src/sdkFactory/index.ts

@@ -23,14 +23,20 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
     integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    filterAdapterFactory, lazyInit } = params;
   const { log, sync: { impressionsMode } } = settings;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid SDK Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
 
-  // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
-  validateAndTrackApiKey(log, settings.core.authorizationKey);
+  // initialization
+  let hasInit = false;
+  const initCallbacks: (() => void)[] = [];
+
+  function whenInit(cb: () => void) {
+    if (hasInit) cb();
+    else initCallbacks.push(cb);
+  }
 
   const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
@@ -67,8 +73,8 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
       strategy = strategyDebugFactory(observer);
   }
 
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
-  const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, whenInit, integrationsManager, storage.telemetry);
+  const eventTracker = eventTrackerFactory(settings, storage.events, whenInit, integrationsManager, storage.telemetry);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
@@ -85,8 +91,21 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory(ctx);
   const managerInstance = sdkManagerFactory(settings, storage.splits, sdkReadinessManager);
 
-  syncManager && syncManager.start();
-  signalListener && signalListener.start();
+
+  function init() {
+    if (hasInit) return;
+    hasInit = true;
+
+    // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
+    validateAndTrackApiKey(log, settings.core.authorizationKey);
+    readiness.init();
+    uniqueKeysTracker && uniqueKeysTracker.start();
+    syncManager && syncManager.start();
+    signalListener && signalListener.start();
+
+    initCallbacks.forEach((cb) => cb());
+    initCallbacks.length = 0;
+  }
 
   log.info(NEW_FACTORY);
 
@@ -107,7 +126,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     settings,
 
     destroy() {
-      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => {});
+      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => { });
     }
-  }, extraProps && extraProps(ctx));
+  }, extraProps && extraProps(ctx), lazyInit ? { init } : init());
 }

package/src/sdkFactory/types.ts

@@ -68,6 +68,8 @@ export interface ISdkFactoryContextAsync extends ISdkFactoryContext {
  * Object parameter with the modules required to create an SDK factory instance
  */
 export interface ISdkFactoryParams {
+  // If true, the `sdkFactory` is pure (no side effects), and the SDK instance includes a `init` method to run initialization side effects
+  lazyInit?: boolean,
 
   // The settings must be already validated
   settings: ISettings,

package/src/storages/{AbstractSegmentsCacheSync.ts → AbstractMySegmentsCacheSync.ts}

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-unused-vars */
 import { IMySegmentsResponse } from '../dtos/types';
 import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
@@ -8,18 +6,11 @@ import { ISegmentsCacheSync } from './types';
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
  * to minimize the effort required to implement this interface.
  */
-export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
-  /**
-   * For server-side synchronizer: add `segmentKeys` list of keys to `name` segment.
-   * For client-side synchronizer: add `name` segment to the cache. `segmentKeys` is undefined.
-   */
-  abstract addToSegment(name: string, segmentKeys?: string[]): boolean
+export abstract class AbstractMySegmentsCacheSync implements ISegmentsCacheSync {
 
-  /**
-   * For server-side synchronizer: remove `segmentKeys` list of keys from `name` segment.
-   * For client-side synchronizer: remove `name` segment from the cache. `segmentKeys` is undefined.
-   */
-  abstract removeFromSegment(name: string, segmentKeys?: string[]): boolean
+  protected abstract addSegment(name: string): boolean
+  protected abstract removeSegment(name: string): boolean
+  protected abstract setChangeNumber(changeNumber?: number): boolean | void
 
   /**
    * For server-side synchronizer: check if `key` is in `name` segment.
@@ -34,11 +25,10 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
     this.resetSegments({});
   }
 
-  /**
-   * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
-   * For client-side synchronizer: the method is not used.
-   */
-  registerSegments(names: string[]): boolean { return false; }
+
+  // No-op. Not used in client-side.
+  registerSegments(): boolean { return false; }
+  update() { return false; }
 
   /**
    * For server-side synchronizer: get the list of segments to fetch changes.
@@ -52,11 +42,6 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
    */
   abstract getKeysCount(): number
 
-  /**
-   * For server-side synchronizer: change number of `name` segment.
-   * For client-side synchronizer: change number of mySegments.
-   */
-  abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void
   abstract getChangeNumber(name: string): number
 
   /**
@@ -64,7 +49,7 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
    * For client-side synchronizer: it resets or updates the cache.
    */
   resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
-    this.setChangeNumber(undefined, segmentsData.cn);
+    this.setChangeNumber(segmentsData.cn);
 
     const { added, removed } = segmentsData as MySegmentsData;
 
@@ -72,11 +57,11 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
       let isDiff = false;
 
       added.forEach(segment => {
-        isDiff = this.addToSegment(segment) || isDiff;
+        isDiff = this.addSegment(segment) || isDiff;
       });
 
       removed.forEach(segment => {
-        isDiff = this.removeFromSegment(segment) || isDiff;
+        isDiff = this.removeSegment(segment) || isDiff;
       });
 
       return isDiff;
@@ -97,11 +82,11 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
 
     // Slowest path => add and/or remove segments
     for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
-      this.removeFromSegment(storedSegmentKeys[removeIndex]);
+      this.removeSegment(storedSegmentKeys[removeIndex]);
     }
 
     for (let addIndex = index; addIndex < names.length; addIndex++) {
-      this.addToSegment(names[addIndex]);
+      this.addSegment(names[addIndex]);
     }
 
     return true;

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,10 +1,10 @@
 import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
+import { AbstractMySegmentsCacheSync } from '../AbstractMySegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 
-export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
+export class MySegmentsCacheInLocal extends AbstractMySegmentsCacheSync {
 
   private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
@@ -16,7 +16,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
-  addToSegment(name: string): boolean {
+  protected addSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
@@ -29,7 +29,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     }
   }
 
-  removeFromSegment(name: string): boolean {
+  protected removeSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
@@ -61,7 +61,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return 1;
   }
 
-  setChangeNumber(name?: string, changeNumber?: number) {
+  protected setChangeNumber(changeNumber?: number) {
     try {
       if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
       else localStorage.removeItem(this.keys.buildTillKey());

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -6,6 +6,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISettings } from '../../types';
 import { getStorageHash } from '../KeyBuilder';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -281,7 +282,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       const flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
       flagSetCache.add(featureFlag.name);
 
-      localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
+      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
     });
   }
 
@@ -308,7 +309,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       return;
     }
 
-    localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
+    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
   }
 
 }

package/src/storages/inLocalStorage/index.ts

@@ -65,7 +65,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
         this.uniqueKeys?.clear();
       },
 
-      // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
+      // When using shared instantiation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
 
         return {

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -41,7 +41,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.uniqueKeys && this.uniqueKeys.clear();
     },
 
-    // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
+    // When using shared instantiation with MEMORY we reuse everything but segments (they are unique per key)
     shared() {
       return {
         splits: this.splits,
@@ -63,7 +63,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
   };
 
   // @TODO revisit storage logic in localhost mode
-  // No tracking data in localhost mode to avoid memory leaks
+  // No tracking in localhost mode to avoid memory leaks: https://github.com/splitio/javascript-commons/issues/181
   if (params.settings.mode === LOCALHOST_MODE) {
     const noopTrack = () => true;
     storage.impressions.track = noopTrack;

package/src/storages/inMemory/MySegmentsCacheInMemory.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 class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export class MySegmentsCacheInMemory extends AbstractMySegmentsCacheSync {
 
   private segmentCache: Record<string, boolean> = {};
   private cn?: number;
 
-  addToSegment(name: string): boolean {
+  protected addSegment(name: string): boolean {
     if (this.segmentCache[name]) return false;
 
     this.segmentCache[name] = true;
@@ -17,7 +17,7 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return true;
   }
 
-  removeFromSegment(name: string): boolean {
+  protected removeSegment(name: string): boolean {
     if (!this.segmentCache[name]) return false;
 
     delete this.segmentCache[name];
@@ -30,7 +30,7 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
   }
 
 
-  setChangeNumber(name?: string, changeNumber?: number) {
+  protected setChangeNumber(changeNumber?: number) {
     this.cn = changeNumber;
   }
 

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -1,35 +1,24 @@
-import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import { isIntegerNumber } from '../../utils/lang';
+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 class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
+export class SegmentsCacheInMemory implements ISegmentsCacheSync {
 
   private segmentCache: Record<string, Set<string>> = {};
   private segmentChangeNumber: Record<string, number> = {};
 
-  addToSegment(name: string, segmentKeys: string[]): boolean {
-    const values = this.segmentCache[name];
-    const keySet = values ? values : new Set<string>();
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
+    const keySet = this.segmentCache[name] || new Set<string>();
 
-    segmentKeys.forEach(k => keySet.add(k));
+    addedKeys.forEach(k => keySet.add(k));
+    removedKeys.forEach(k => keySet.delete(k));
 
     this.segmentCache[name] = keySet;
+    this.segmentChangeNumber[name] = changeNumber;
 
-    return true;
-  }
-
-  removeFromSegment(name: string, segmentKeys: string[]): boolean {
-    const values = this.segmentCache[name];
-    const keySet = values ? values : new Set<string>();
-
-    segmentKeys.forEach(k => keySet.delete(k));
-
-    this.segmentCache[name] = keySet;
-
-    return true;
+    return addedKeys.length > 0 || removedKeys.length > 0;
   }
 
   isInSegment(name: string, key: string): boolean {
@@ -73,16 +62,13 @@ export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     }, 0);
   }
 
-  setChangeNumber(name: string, changeNumber: number) {
-    this.segmentChangeNumber[name] = changeNumber;
-
-    return true;
-  }
-
   getChangeNumber(name: string) {
     const value = this.segmentChangeNumber[name];
 
     return isIntegerNumber(value) ? value : -1;
   }
 
+  // No-op. Not used in server-side
+  resetSegments() { return false; }
+
 }

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -4,7 +4,6 @@ import { isFiniteNumber } from '../../utils/lang';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
- * Supported by all JS runtimes.
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 

package/src/storages/inMemory/UniqueKeysCacheInMemory.ts

@@ -1,6 +1,7 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+import { setToArray } from '../../utils/lang/sets';
 
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
@@ -10,7 +11,7 @@ export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: Set
   const featureNames = Object.keys(uniqueKeys);
   for (let i = 0; i < featureNames.length; i++) {
     const featureName = featureNames[i];
-    const userKeys = Array.from(uniqueKeys[featureName]);
+    const userKeys = setToArray(uniqueKeys[featureName]);
     const uniqueKeysPayload = {
       f: featureName,
       ks: userKeys

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -1,6 +1,7 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
 
@@ -70,7 +71,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
     const userKeys = Object.keys(uniqueKeys);
     for (let k = 0; k < userKeys.length; k++) {
       const userKey = userKeys[k];
-      const featureNames = Array.from(uniqueKeys[userKey]);
+      const featureNames = setToArray(uniqueKeys[userKey]);
       const uniqueKeysPayload = {
         k: userKey,
         fs: featureNames

package/src/storages/inRedis/RedisAdapter.ts

@@ -3,6 +3,7 @@ import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
+import { setToArray } from '../../utils/lang/sets';
 
 const LOG_PREFIX = 'storage:redis-adapter: ';
 
@@ -149,7 +150,7 @@ export class RedisAdapter extends ioredis {
         if (instance._runningCommands.size > 0) {
           instance.log.info(LOG_PREFIX + `Attempting to disconnect but there are ${instance._runningCommands.size} commands still waiting for resolution. Defering disconnection until those finish.`);
 
-          Promise.all(Array.from(instance._runningCommands))
+          Promise.all(setToArray(instance._runningCommands))
             .then(() => {
               instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
               originalMethod.apply(instance, params);

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -17,24 +17,21 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     this.keys = keys;
   }
 
-  addToSegment(name: string, segmentKeys: string[]) {
+  /**
+   * 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) {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    if (segmentKeys.length) {
-      return this.redis.sadd(segmentKey, segmentKeys).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
-  }
-
-  removeFromSegment(name: string, segmentKeys: string[]) {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    if (segmentKeys.length) {
-      return this.redis.srem(segmentKey, segmentKeys).then(() => true);
-    } else {
-      return Promise.resolve(true);
-    }
+    return Promise.all([
+      addedKeys.length && this.redis.sadd(segmentKey, addedKeys),
+      removedKeys.length && this.redis.srem(segmentKey, removedKeys),
+      this.redis.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+    ]).then(() => {
+      return addedKeys.length > 0 || removedKeys.length > 0;
+    });
   }
 
   isInSegment(name: string, key: string) {
@@ -43,12 +40,6 @@ export class SegmentsCacheInRedis implements ISegmentsCacheAsync {
     ).then(matches => matches !== 0);
   }
 
-  setChangeNumber(name: string, changeNumber: number) {
-    return this.redis.set(
-      this.keys.buildSegmentTillKey(name), changeNumber + ''
-    ).then(status => status === 'OK');
-  }
-
   getChangeNumber(name: string) {
     return this.redis.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
       const i = parseInt(value as string, 10);

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -5,6 +5,7 @@ import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
 import { UniqueKeysItemSs } from '../../sync/submitters/types';
 import type { RedisAdapter } from './RedisAdapter';
+import { setToArray } from '../../utils/lang/sets';
 
 export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
 
@@ -28,7 +29,7 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     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/SegmentsCachePluggable.ts

@@ -22,33 +22,20 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
   }
 
   /**
-   * 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[]) {
-    const segmentKey = this.keys.buildSegmentNameKey(name);
-
-    if (segmentKeys.length) {
-      return this.wrapper.addItems(segmentKey, segmentKeys);
-    } else {
-      return Promise.resolve();
-    }
-  }
-
-  /**
-   * 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[]) {
+  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    if (segmentKeys.length) {
-      return this.wrapper.removeItems(segmentKey, segmentKeys);
-    } else {
-      return Promise.resolve();
-    }
+    return Promise.all<any>([
+      addedKeys.length && this.wrapper.addItems(segmentKey, addedKeys),
+      removedKeys.length && this.wrapper.removeItems(segmentKey, removedKeys),
+      this.wrapper.set(this.keys.buildSegmentTillKey(name), changeNumber + '')
+    ]).then(() => {
+      return addedKeys.length > 0 || removedKeys.length > 0;
+    });
   }
 
   /**
@@ -59,17 +46,6 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     return this.wrapper.itemContains(this.keys.buildSegmentNameKey(name), key);
   }
 
-  /**
-   * 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) {
-    return this.wrapper.set(
-      this.keys.buildSegmentTillKey(name), changeNumber + ''
-    );
-  }
-
   /**
    * 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.