@splitsoftware/splitio-commons 1.17.1-rc.4 → 1.17.1-rc.5

package/src/storages/inRedis/index.ts

@@ -17,19 +17,25 @@ export interface InRedisStorageOptions {
   options?: Record<string, any>
 }
 
+let RD: typeof RedisAdapter | undefined;
+
+try {
+  // Using `require` to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
+  // Redis storage is not supported with .mjs files.
+  RD = require('./RedisAdapter').RedisAdapter;
+} catch (error) { /* empty */ }
+
 /**
- * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
+ * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.js
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
 export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
 
-  // Lazy loading to prevent error when bundling or importing the SDK in a .mjs file, since ioredis is a CommonJS module.
-  // Redis storage is not supported with .mjs files.
-  const RD = require('./RedisAdapter').RedisAdapter;
-
   const prefix = validatePrefix(options.prefix);
 
   function InRedisStorageFactory(params: IStorageFactoryParams): IStorageAsync {
+    if (!RD) throw new Error('The SDK Redis storage is unavailable. Make sure your runtime environment supports CommonJS (`require`) so the `ioredis` dependency can be imported.');
+
     const { onReadyCb, settings, settings: { log, sync: { impressionsMode } } } = params;
     const metadata = metadataBuilder(settings);
     const keys = new KeyBuilderSS(prefix, metadata);
@@ -38,7 +44,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
     const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
     const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
 
-    // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
+    // Subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
       if (impressionCountsCache) impressionCountsCache.start();

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -23,20 +23,33 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
   }
 
   /**
-   * 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).
+   * 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.
    */
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number) {
+  addToSegment(name: string, segmentKeys: string[]) {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
-    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;
-    });
+    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.
+   */
+  removeFromSegment(name: string, segmentKeys: string[]) {
+    const segmentKey = this.keys.buildSegmentNameKey(name);
+
+    if (segmentKeys.length) {
+      return this.wrapper.removeItems(segmentKey, segmentKeys);
+    } else {
+      return Promise.resolve();
+    }
   }
 
   /**
@@ -47,6 +60,17 @@ 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.
@@ -56,10 +80,10 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
     return this.wrapper.get(this.keys.buildSegmentTillKey(name)).then((value: string | null) => {
       const i = parseInt(value as string, 10);
 
-      return isNaNNumber(i) ? -1 : i;
+      return isNaNNumber(i) ? undefined : i;
     }).catch((e) => {
       this.log.error(LOG_PREFIX + 'Could not retrieve changeNumber from segments storage. Error: ' + e);
-      return -1;
+      return undefined;
     });
   }
 

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -7,7 +7,7 @@ import { ISet, setToArray, _Set } from '../../utils/lang/sets';
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
  *
- * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
 export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
 

package/src/storages/types.ts

@@ -1,5 +1,4 @@
-import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
-import { MySegmentsData } from '../sync/polling/types';
+import { MaybeThenable, ISplit } from '../dtos/types';
 import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, MultiMethodExceptions, MultiMethodLatencies, MultiConfigs, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, ISettings } from '../types';
 import { ISet } from '../utils/lang/sets';
@@ -205,7 +204,7 @@ export interface ISplitsCacheBase {
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
-  // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
+  // only for Client-Side
   usesSegments(): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
@@ -219,7 +218,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   removeSplits(names: string[]): boolean[],
   getSplit(name: string): ISplit | null,
   getSplits(names: string[]): Record<string, ISplit | null>,
-  setChangeNumber(changeNumber: number): boolean | void,
+  setChangeNumber(changeNumber: number): boolean,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -251,32 +250,38 @@ 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
-  getChangeNumber(name: string): MaybeThenable<number> // only for Server-Side
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): MaybeThenable<boolean> // only for Server-Side
+  setChangeNumber(name: string, changeNumber: number): MaybeThenable<boolean | void> // only for Server-Side
+  getChangeNumber(name: string): MaybeThenable<number | undefined> // 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
-  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
+  setChangeNumber(name: string, changeNumber: number): boolean
+  getChangeNumber(name: string): number | undefined
+  resetSegments(names: string[]): 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[]>
-  getChangeNumber(name: string): Promise<number>
-  update(name: string, addedKeys: string[], removedKeys: string[], changeNumber: number): Promise<boolean>
+  setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>
+  getChangeNumber(name: string): Promise<number | undefined>
   clear(): Promise<boolean | void>
 }
 
@@ -472,10 +477,7 @@ export interface IStorageSync extends IStorageBase<
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
-> {
-  // Defined in client-side
-  largeSegments?: ISegmentsCacheSync,
-}
+> { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,

package/src/sync/offline/syncManagerOffline.ts

@@ -1,4 +1,4 @@
-import { ISyncManagerCS } from '../types';
+import { ISyncManager, ISyncManagerCS } from '../types';
 import { fromObjectSyncTaskFactory } from './syncTasks/fromObjectSyncTask';
 import { objectAssign } from '../../utils/lang/objectAssign';
 import { ISplitsParser } from './splitsParser/types';
@@ -29,34 +29,26 @@ export function syncManagerOfflineFactory(
     storage,
   }: ISdkFactoryContextSync): ISyncManagerCS {
 
-    const mainSyncManager = fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings);
-    const mainStart = mainSyncManager.start;
-    const sharedStarts: Array<() => void> = [];
-
     return objectAssign(
-      mainSyncManager,
+      fromObjectSyncTaskFactory(splitsParserFactory(), storage, readiness, settings),
       {
-        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) {
-          // 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);
-
+        shared(matchingKey: string, readinessManager: IReadinessManager): ISyncManager {
           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/fetchers/mySegmentsFetcher.ts

@@ -1,25 +1,27 @@
-import { IFetchMemberships, IResponse } from '../../../services/types';
-import { IMembershipsResponse } from '../../../dtos/types';
+import { IFetchMySegments, IResponse } from '../../../services/types';
+import { IMySegmentsResponseItem } from '../../../dtos/types';
 import { IMySegmentsFetcher } from './types';
 
 /**
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher {
+export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher {
 
   return function mySegmentsFetcher(
     userMatchingKey: string,
     noCache?: boolean,
-    till?: number,
-    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<IMembershipsResponse> {
+  ): Promise<string[]> {
 
-    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
+    let mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
-    return mySegmentsPromise.then(resp => resp.json());
+    // Extract segment names
+    return mySegmentsPromise
+      .then(resp => resp.json())
+      .then(json => json.mySegments.map((segment: IMySegmentsResponseItem) => segment.name));
   };
 
 }

package/src/sync/polling/fetchers/segmentChangesFetcher.ts

@@ -28,7 +28,7 @@ export function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentC
     segmentName: string,
     noCache?: boolean,
     till?: number,
-    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
     decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
   ): Promise<ISegmentChangesResponse[]> {
 

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

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

package/src/sync/polling/pollingManagerCS.ts

@@ -29,13 +29,13 @@ export function pollingManagerCSFactory(
   const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
       mySegmentsSyncTask.start();
     });
   }
 
   function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
       if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
     });
   }
@@ -55,7 +55,7 @@ export function pollingManagerCSFactory(
   });
 
   function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
+    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
 
     // smart ready
     function smartReady() {
@@ -94,7 +94,7 @@ export function pollingManagerCSFactory(
     // fetch splits and segments
     syncAll() {
       const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+      forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
         promises.push(mySegmentsSyncTask.execute());
       });
       return Promise.all(promises);

package/src/sync/polling/syncTasks/mySegmentsSyncTask.ts

@@ -2,7 +2,7 @@ import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { syncTaskFactory } from '../../syncTask';
 import { IMySegmentsSyncTask } from '../types';
-import { IFetchMemberships } from '../../../services/types';
+import { IFetchMySegments } from '../../../services/types';
 import { mySegmentsFetcherFactory } from '../fetchers/mySegmentsFetcher';
 import { ISettings } from '../../../types';
 import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
@@ -11,7 +11,7 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 export function mySegmentsSyncTaskFactory(
-  fetchMemberships: IFetchMemberships,
+  fetchMySegments: IFetchMySegments,
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
@@ -21,8 +21,9 @@ export function mySegmentsSyncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
-      mySegmentsFetcherFactory(fetchMemberships),
-      storage,
+      mySegmentsFetcherFactory(fetchMySegments),
+      storage.splits,
+      storage.segments,
       readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,

package/src/sync/polling/types.ts

@@ -1,21 +1,20 @@
 import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
-import { MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../streaming/types';
 import { ITask, ISyncTask } from '../types';
 
 export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }], boolean> { }
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
-export type MySegmentsData = {
-  type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE
-  cn: number
-  added: string[]
-  removed: string[]
+export type MySegmentsData = string[] | {
+  /* segment name */
+  name: string,
+  /* action: `true` for add, and `false` for delete */
+  add: boolean
 }
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

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

@@ -1,15 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { IStorageSync } from '../../../storages/types';
+import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
 import { SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_MYSEGMENTS_FETCH_RETRY } from '../../../logger/constants';
 import { MySegmentsData } from '../types';
-import { IMembershipsResponse } from '../../../dtos/types';
-import { MEMBERSHIPS_LS_UPDATE } from '../../streaming/constants';
 
-type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
+type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -20,14 +18,14 @@ type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, til
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  storage: IStorageSync,
+  splitsCache: ISplitsCacheSync,
+  mySegmentsCache: ISegmentsCacheSync,
   segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
 ): IMySegmentsUpdater {
 
-  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -38,31 +36,37 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: IMembershipsResponse | MySegmentsData) {
+  function updateSegments(segmentsData: MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if ((segmentsData as MySegmentsData).type !== undefined) {
-      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIPS_LS_UPDATE ?
-        largeSegments!.resetSegments(segmentsData as MySegmentsData) :
-        segments.resetSegments(segmentsData as MySegmentsData);
+    if (Array.isArray(segmentsData)) {
+      // Update the list of segment names available
+      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
     } else {
-      shouldNotifyUpdate = segments.resetSegments((segmentsData as IMembershipsResponse).ms || {});
-      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
+      // Add/Delete the segment
+      const { name, add } = segmentsData;
+      if (mySegmentsCache.isInSegment(name) !== add) {
+        shouldNotifyUpdate = true;
+        if (add) mySegmentsCache.addToSegment(name);
+        else mySegmentsCache.removeFromSegment(name);
+      } else {
+        shouldNotifyUpdate = false;
+      }
     }
 
     // Notify update if required
-    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
       segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean, till?: number): Promise<boolean> {
+  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean): Promise<boolean> {
     const updaterPromise: Promise<boolean> = segmentsData ?
       // If segmentsData is provided, there is no need to fetch mySegments
       new Promise((res) => { updateSegments(segmentsData); res(true); }) :
       // If not provided, fetch mySegments
-      mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 
@@ -92,10 +96,9 @@ export function mySegmentsUpdaterFactory(
    *  (2) an object with a segment name and action (true: add, or false: delete) to update the storage,
    *  (3) or `undefined`, for which the updater will fetch mySegments in order to sync the storage.
    * @param {boolean | undefined} noCache true to revalidate data to fetch
-   * @param {boolean | undefined} till query param to bypass CDN requests
    */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
-    return _mySegmentsUpdater(0, segmentsData, noCache, till);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
+    return _mySegmentsUpdater(0, segmentsData, noCache);
   };
 
 }

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

@@ -1,9 +1,12 @@
 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>
 
@@ -27,22 +30,31 @@ export function segmentChangesUpdaterFactory(
 
   let readyOnAlreadyExistentState = true;
 
-  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: boolean): Promise<boolean> {
+  function updateSegment(segmentName: string, noCache?: boolean, till?: number, fetchOnlyNew?: 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
-      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 (fetchOnlyNew && since !== undefined) return -1;
+
+      return segmentChangesFetcher(since || -1, 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}`);
         });
+        // 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;
+      });
     });
   }
   /**
@@ -63,12 +75,16 @@ export function segmentChangesUpdaterFactory(
     let segmentsPromise = Promise.resolve(segmentName ? [segmentName] : segments.getRegisteredSegments());
 
     return segmentsPromise.then(segmentNames => {
-      // Async fetchers
-      const updaters = segmentNames.map(segmentName => updateSegment(segmentName, noCache, till, fetchOnlyNew));
+      // 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));
+      }
 
       return Promise.all(updaters).then(shouldUpdateFlags => {
         // if at least one segment fetch succeeded, mark segments ready
-        if (shouldUpdateFlags.some(update => update) || readyOnAlreadyExistentState) {
+        if (findIndex(shouldUpdateFlags, v => v !== -1) !== -1 || readyOnAlreadyExistentState) {
           readyOnAlreadyExistentState = false;
           if (readiness) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
         }

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

@@ -19,7 +19,7 @@ function checkAllSegmentsExist(segments: ISegmentsCacheBase): Promise<boolean> {
   let registeredSegments = Promise.resolve(segments.getRegisteredSegments());
   return registeredSegments.then(segmentNames => {
     return Promise.all(segmentNames.map(segmentName => segments.getChangeNumber(segmentName)))
-      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== -1));
+      .then(changeNumbers => changeNumbers.every(changeNumber => changeNumber !== undefined));
   });
 }
 

package/src/sync/streaming/AuthClient/index.ts

@@ -14,7 +14,7 @@ export function authenticateFactory(fetchAuth: IFetchAuth): IAuthenticate {
 
   /**
    * Run authentication requests to Auth Server, and returns a promise that resolves with the decoded JTW token.
-   * @param {string[] | undefined} userKeys set of user Keys to track membership updates. It is undefined for server-side API.
+   * @param {string[] | undefined} userKeys set of user Keys to track MY_SEGMENTS_CHANGES. It is undefined for server-side API.
    */
   return function authenticate(userKeys?: string[]): Promise<IAuthToken> {
     return fetchAuth(userKeys)

package/src/sync/streaming/SSEClient/index.ts

@@ -71,10 +71,12 @@ export class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    const channelsQueryParam = Object.keys(authToken.channels).map((channel) => {
-      const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
-      return encodeURIComponent(params + channel);
-    }).join(',');
+    const channelsQueryParam = Object.keys(authToken.channels).map(
+      function (channel) {
+        const params = CONTROL_CHANNEL_REGEX.test(channel) ? '[?occupancy=metrics.publishers]' : '';
+        return encodeURIComponent(params + channel);
+      }
+    ).join(',');
     const url = `${this.settings.urls.streaming}/sse?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
     const isServerSide = !this.settings.core.key;