@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.1

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -7,18 +7,19 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private segmentCache: Record<string, boolean> = {};
-
-  clear() {
-    this.segmentCache = {};
-  }
+  private cn?: number;
 
   addToSegment(name: string): boolean {
+    if (this.segmentCache[name]) return false;
+
     this.segmentCache[name] = true;
 
     return true;
   }
 
   removeFromSegment(name: string): boolean {
+    if (!this.segmentCache[name]) return false;
+
     delete this.segmentCache[name];
 
     return true;
@@ -28,48 +29,13 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return this.segmentCache[name] === true;
   }
 
-  /**
-   * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-   * @NOTE based on the way we use segments in the browser, this way is the best option
-   *
-   * @param {string[]} names list of segment names
-   * @returns boolean indicating if the cache was updated (i.e., given list was different from the cached one)
-   */
-  resetSegments(names: string[]): boolean {
-    let isDiff = false;
-    let index;
-
-    const storedSegmentKeys = Object.keys(this.segmentCache);
 
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentKeys.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentKeys.length !== names.length) {
-      isDiff = true;
-
-      this.segmentCache = {};
-      names.forEach(s => {
-        this.addToSegment(s);
-      });
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        this.segmentCache = {};
-        names.forEach(s => {
-          this.addToSegment(s);
-        });
-      }
-    }
+  setChangeNumber(name?: string, changeNumber?: number) {
+    this.cn = changeNumber;
+  }
 
-    return isDiff;
+  getChangeNumber() {
+    return this.cn || -1;
   }
 
   getRegisteredSegments() {

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -13,7 +13,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
-  private splitsWithSegmentsCount: number = 0;
+  private segmentsCount: number = 0;
   private flagSetsCache: Record<string, ISet<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
@@ -25,7 +25,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsCache = {};
     this.ttCache = {};
     this.changeNumber = -1;
-    this.splitsWithSegmentsCount = 0;
+    this.segmentsCount = 0;
   }
 
   addSplit(name: string, split: ISplit): boolean {
@@ -38,9 +38,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
 
-      if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
-        this.splitsWithSegmentsCount--;
-      }
+      // Subtract from segments count for the previous version of this Split
+      if (usesSegments(previousSplit)) this.segmentsCount--;
     }
 
     if (split) {
@@ -52,7 +51,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(split)) this.splitsWithSegmentsCount++;
+      if (usesSegments(split)) this.segmentsCount++;
 
       return true;
     } else {
@@ -72,7 +71,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
-      if (usesSegments(split)) this.splitsWithSegmentsCount--;
+      if (usesSegments(split)) this.segmentsCount--;
 
       return true;
     } else {
@@ -102,7 +101,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   }
 
   usesSegments(): boolean {
-    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
+    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
   }
 
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, LastSync, HttpErrors, HttpLatencies, StreamingEvent, Method, OperationType, MethodExceptions, MethodLatencies, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
 import { DEDUPED, DROPPED, LOCALHOST_MODE, QUEUED } from '../../utils/constants';
 import { findLatencyIndex } from '../findLatencyIndex';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
@@ -25,7 +25,7 @@ export function shouldRecordTelemetry({ settings }: IStorageFactoryParams) {
 
 export class TelemetryCacheInMemory implements ITelemetryCacheSync {
 
-  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync) { }
+  constructor(private splits?: ISplitsCacheSync, private segments?: ISegmentsCacheSync, private largeSegments?: ISegmentsCacheSync) { }
 
   // isEmpty flag
   private e = true;
@@ -51,6 +51,8 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
       spC: this.splits && this.splits.getSplitNames().length,
       seC: this.segments && this.segments.getRegisteredSegments().length,
       skC: this.segments && this.segments.getKeysCount(),
+      lsC: this.largeSegments && this.largeSegments.getRegisteredSegments().length,
+      lskC: this.largeSegments && this.largeSegments.getKeysCount(),
       sL: this.getSessionLength(),
       eQ: this.getEventStats(QUEUED),
       eD: this.getEventStats(DROPPED),
@@ -245,22 +247,16 @@ export class TelemetryCacheInMemory implements ITelemetryCacheSync {
     this.e = false;
   }
 
-  private updatesFromSSE = {
-    sp: 0,
-    ms: 0
-  };
+  private updatesFromSSE: UpdatesFromSSE = {};
 
   popUpdatesFromSSE() {
     const result = this.updatesFromSSE;
-    this.updatesFromSSE = {
-      sp: 0,
-      ms: 0,
-    };
+    this.updatesFromSSE = {};
     return result;
   }
 
   recordUpdatesFromSSE(type: UpdatesFromSSEEnum) {
-    this.updatesFromSSE[type]++;
+    this.updatesFromSSE[type] = (this.updatesFromSSE[type] || 0) + 1;
     this.e = false;
   }
 

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 inmediatelly.
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves immediately.
  */
 export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
 

package/src/storages/types.ts

@@ -1,4 +1,5 @@
-import { MaybeThenable, ISplit } from '../dtos/types';
+import { MaybeThenable, ISplit, IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/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';
@@ -204,7 +205,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
+  // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
   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.
@@ -218,7 +219,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,
+  setChangeNumber(changeNumber: number): boolean | void,
   getChangeNumber(): number,
   getAll(): ISplit[],
   getSplitNames(): string[],
@@ -268,9 +269,9 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean
-  getChangeNumber(name: string): number
-  resetSegments(names: string[]): boolean // only for Sync Client-Side
+  setChangeNumber(name: string, changeNumber: number): boolean | void
+  getChangeNumber(name?: string): number
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 
@@ -477,7 +478,10 @@ export interface IStorageSync extends IStorageBase<
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
-> { }
+> {
+  // Defined in client-side
+  largeSegments?: ISegmentsCacheSync,
+}
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,

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

@@ -1,27 +1,25 @@
-import { IFetchMySegments, IResponse } from '../../../services/types';
-import { IMySegmentsResponseItem } from '../../../dtos/types';
+import { IFetchMemberships, IResponse } from '../../../services/types';
+import { IMembershipsResponse } 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(fetchMySegments: IFetchMySegments): IMySegmentsFetcher {
+export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher {
 
   return function mySegmentsFetcher(
     userMatchingKey: string,
     noCache?: boolean,
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+    till?: number,
+    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<string[]> {
+  ): Promise<IMembershipsResponse> {
 
-    let mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
+    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache, till);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
-    // Extract segment names
-    return mySegmentsPromise
-      .then(resp => resp.json())
-      .then(json => json.mySegments.map((segment: IMySegmentsResponseItem) => segment.name));
+    return mySegmentsPromise.then(resp => resp.json());
   };
 
 }

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 `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchSegmentChanges` 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 } from '../../../dtos/types';
+import { ISplitChangesResponse, ISegmentChangesResponse, IMembershipsResponse } from '../../../dtos/types';
 import { IResponse } from '../../../services/types';
 
 export type ISplitChangesFetcher = (
@@ -19,5 +19,6 @@ export type ISegmentChangesFetcher = (
 export type IMySegmentsFetcher = (
   userMatchingKey: string,
   noCache?: boolean,
+  till?: number,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-) => Promise<string[]>
+) => Promise<IMembershipsResponse>

package/src/sync/polling/pollingManagerCS.ts

@@ -29,13 +29,13 @@ export function pollingManagerCSFactory(
   const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
       mySegmentsSyncTask.start();
     });
   }
 
   function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
+    forOwn(mySegmentsSyncTasks, (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.fetchMySegments, storage, readiness, settings, matchingKey);
+    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, 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, function (mySegmentsSyncTask) {
+      forOwn(mySegmentsSyncTasks, (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 { IFetchMySegments } from '../../../services/types';
+import { IFetchMemberships } 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(
-  fetchMySegments: IFetchMySegments,
+  fetchMemberships: IFetchMemberships,
   storage: IStorageSync,
   readiness: IReadinessManager,
   settings: ISettings,
@@ -21,9 +21,8 @@ export function mySegmentsSyncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
-      mySegmentsFetcherFactory(fetchMySegments),
-      storage.splits,
-      storage.segments,
+      mySegmentsFetcherFactory(fetchMemberships),
+      storage,
       readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,

package/src/sync/polling/types.ts

@@ -1,20 +1,21 @@
 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 = string[] | {
-  /* segment name */
-  name: string,
-  /* action: `true` for add, and `false` for delete */
-  add: boolean
+export type MySegmentsData = {
+  type: MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE
+  cn: number
+  added: string[]
+  removed: string[]
 }
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, till?: number], boolean> { }
 
 export interface IPollingManager extends ITask {
   syncAll(): Promise<any>

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

@@ -1,13 +1,15 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
+import { IStorageSync } 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 = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -18,14 +20,14 @@ type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  splitsCache: ISplitsCacheSync,
-  mySegmentsCache: ISegmentsCacheSync,
+  storage: IStorageSync,
   segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
 ): IMySegmentsUpdater {
 
+  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -36,37 +38,31 @@ export function mySegmentsUpdaterFactory(
   }
 
   // @TODO if allowing pluggable storages, handle async execution
-  function updateSegments(segmentsData: MySegmentsData) {
+  function updateSegments(segmentsData: IMembershipsResponse | MySegmentsData) {
 
     let shouldNotifyUpdate;
-    if (Array.isArray(segmentsData)) {
-      // Update the list of segment names available
-      shouldNotifyUpdate = mySegmentsCache.resetSegments(segmentsData);
+    if ((segmentsData as MySegmentsData).type !== undefined) {
+      shouldNotifyUpdate = (segmentsData as MySegmentsData).type === MEMBERSHIPS_LS_UPDATE ?
+        largeSegments!.resetSegments(segmentsData as MySegmentsData) :
+        segments.resetSegments(segmentsData as MySegmentsData);
     } else {
-      // 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;
-      }
+      shouldNotifyUpdate = segments.resetSegments((segmentsData as IMembershipsResponse).ms || {});
+      shouldNotifyUpdate = largeSegments!.resetSegments((segmentsData as IMembershipsResponse).ls || {}) || shouldNotifyUpdate;
     }
 
     // Notify update if required
-    if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
       segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 
-  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean): Promise<boolean> {
+  function _mySegmentsUpdater(retry: number, segmentsData?: MySegmentsData, noCache?: boolean, till?: number): 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, _promiseDecorator).then(segments => {
+      mySegmentsFetcher(matchingKey, noCache, till, _promiseDecorator).then(segments => {
         // Only when we have downloaded segments completely, we should not keep retrying anymore
         startingUp = false;
 
@@ -96,9 +92,10 @@ 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) {
-    return _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, till?: number) {
+    return _mySegmentsUpdater(0, segmentsData, noCache, till);
   };
 
 }

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 MY_SEGMENTS_CHANGES. It is undefined for server-side API.
+   * @param {string[] | undefined} userKeys set of user Keys to track membership updates. 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,12 +71,10 @@ export class SSEClient implements ISSEClient {
   open(authToken: IAuthTokenPushEnabled) {
     this.close(); // it closes connection if previously opened
 
-    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 channelsQueryParam = Object.keys(authToken.channels).map((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;
 

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -74,21 +74,18 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
       const { parsedData, data, channel, timestamp } = messageWithParsedData;
       log.debug(STREAMING_NEW_MESSAGE, [data]);
 
-      // we only handle update events if streaming is up.
-      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1)
-        return;
+      // we only handle update events if streaming is up
+      if (!notificationKeeper.isStreamingUp() && [OCCUPANCY, CONTROL].indexOf(parsedData.type) === -1) return;
 
       switch (parsedData.type) {
         /* update events */
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
-        case MY_SEGMENTS_UPDATE_V2:
+        case MEMBERSHIPS_MS_UPDATE:
+        case MEMBERSHIPS_LS_UPDATE:
         case SPLIT_KILL:
           pushEmitter.emit(parsedData.type, parsedData);
           break;
-        case MY_SEGMENTS_UPDATE:
-          pushEmitter.emit(parsedData.type, parsedData, channel);
-          break;
 
         /* occupancy & control events, handled by NotificationManagerKeeper */
         case OCCUPANCY:

package/src/sync/streaming/SSEHandler/types.ts

@@ -1,12 +1,5 @@
 import { ControlType } from '../constants';
-import { MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY } from '../types';
-
-export interface IMySegmentsUpdateData {
-  type: MY_SEGMENTS_UPDATE,
-  changeNumber: number,
-  includesPayload: boolean,
-  segmentList?: string[]
-}
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -26,15 +19,22 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-export interface IMySegmentsUpdateV2Data {
-  type: MY_SEGMENTS_UPDATE_V2,
-  changeNumber: number,
-  segmentName: string,
-  c: Compression,
-  d: string,
+interface IMembershipUpdateData<T extends string> {
+  type: T,
+  cn: number,
+  n?: string[],
+  c?: Compression,
+  d?: string,
   u: UpdateStrategy,
+  i?: number, // time interval in millis
+  h?: number, // hash function
+  s?: number, // seed for hash function
 }
 
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> { }
+
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> { }
+
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -68,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }