@splitsoftware/splitio-commons 1.16.1-rc.1 → 1.16.1-rc.11

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

@@ -1,31 +1,24 @@
-import { IFetchMySegments, IResponse } from '../../../services/types';
-import { IMySegmentsResponse, IMyLargeSegmentsResponse } 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
+    // 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);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
-    // Extract segment names
-    return mySegmentsPromise
-      .then(resp => resp.json())
-      .then((json: IMySegmentsResponse | IMyLargeSegmentsResponse) => {
-        return (json as IMySegmentsResponse).mySegments ?
-          (json as IMySegmentsResponse).mySegments.map((segment) => segment.name) :
-          (json as IMyLargeSegmentsResponse).myLargeSegments;
-      });
+    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 = (
@@ -20,4 +20,4 @@ export type IMySegmentsFetcher = (
   userMatchingKey: string,
   noCache?: boolean,
   decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-) => Promise<string[]>
+) => Promise<IMembershipsResponse>

package/src/sync/polling/pollingManagerCS.ts

@@ -6,9 +6,8 @@ import { mySegmentsSyncTaskFactory } from './syncTasks/mySegmentsSyncTask';
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { getMatching } from '../../utils/key';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../readiness/constants';
-import { POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { POLLING_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
-import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * Expose start / stop mechanism for polling data from services.
@@ -23,92 +22,62 @@ export function pollingManagerCSFactory(
 
   const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
-  const mySegmentsSyncTasks: Record<string, { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }> = {};
+  // Map of matching keys to their corresponding MySegmentsSyncTask.
+  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
 
   const matchingKey = getMatching(settings.core.key);
-  const { msSyncTask, mlsSyncTask } = add(matchingKey, readiness, storage);
+  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    const splitsHaveSegments = storage.splits.usesMatcher(IN_SEGMENT);
-    const splitsHaveLargeSegments = storage.splits.usesMatcher(IN_LARGE_SEGMENT);
-
-    forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
-      if (splitsHaveSegments) msSyncTask.start();
-      else msSyncTask.stop(); // smart pausing
-
-      if (mlsSyncTask) {
-        if (splitsHaveLargeSegments) mlsSyncTask.start();
-        else mlsSyncTask.stop(); // smart pausing
-      }
+    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+      mySegmentsSyncTask.start();
     });
   }
 
   function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
-      msSyncTask.stop();
-      mlsSyncTask && mlsSyncTask.stop();
+    forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
     });
   }
 
+  // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    if (splitsSyncTask.isRunning()) startMySegmentsSyncTasks();
+    if (!splitsSyncTask.isRunning()) return; // noop if not doing polling
+    const splitsHaveSegments = storage.splits.usesSegments();
+    if (splitsHaveSegments !== mySegmentsSyncTask.isRunning()) {
+      log.info(POLLING_SMART_PAUSING, [splitsHaveSegments ? 'ON' : 'OFF']);
+      if (splitsHaveSegments) {
+        startMySegmentsSyncTasks();
+      } else {
+        stopMySegmentsSyncTasks();
+      }
+    }
   });
 
   function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const msSyncTask = mySegmentsSyncTaskFactory(
-      splitApi.fetchMySegments,
-      storage.segments,
-      () => { if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED); },
-      settings,
-      matchingKey,
-      settings.scheduler.segmentsRefreshRate,
-      'mySegmentsUpdater'
-    );
-
-    let mlsSyncTask;
-    if (settings.sync.largeSegmentsEnabled) {
-      mlsSyncTask = mySegmentsSyncTaskFactory(
-        splitApi.fetchMyLargeSegments,
-        storage.largeSegments!,
-        () => { if (readiness.largeSegments && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED); },
-        settings,
-        matchingKey,
-        settings.scheduler.largeSegmentsRefreshRate,
-        'myLargeSegmentsUpdater'
-      );
-    }
+    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMemberships, storage, readiness, settings, matchingKey);
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady()) {
-        if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
-        if (!storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
-      }
+      if (!readiness.isReady() && !storage.splits.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
     }
+    if (!storage.splits.usesSegments()) setTimeout(smartReady, 0);
+    else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
-    if (storage.splits.usesMatcher(IN_SEGMENT) && storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
-    else setTimeout(smartReady, 0);
-
-    mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
-
-    return {
-      msSyncTask,
-      mlsSyncTask
-    };
+    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
+    return mySegmentsSyncTask;
   }
 
   return {
     splitsSyncTask,
-    segmentsSyncTask: msSyncTask,
-    largeSegmentsSyncTask: mlsSyncTask,
+    segmentsSyncTask: mySegmentsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      startMySegmentsSyncTasks();
+      if (storage.splits.usesSegments()) startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)
@@ -125,9 +94,8 @@ export function pollingManagerCSFactory(
     // fetch splits and segments
     syncAll() {
       const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, function ({ msSyncTask, mlsSyncTask }) {
-        promises.push(msSyncTask.execute());
-        mlsSyncTask && promises.push(mlsSyncTask.execute());
+      forOwn(mySegmentsSyncTasks, (mySegmentsSyncTask) => {
+        promises.push(mySegmentsSyncTask.execute());
       });
       return Promise.all(promises);
     },

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

@@ -1,7 +1,8 @@
-import { ISegmentsCacheSync } from '../../../storages/types';
+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';
@@ -10,26 +11,24 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
 export function mySegmentsSyncTaskFactory(
-  fetchMySegments: IFetchMySegments,
-  mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  fetchMemberships: IFetchMemberships,
+  storage: IStorageSync,
+  readiness: IReadinessManager,
   settings: ISettings,
-  matchingKey: string,
-  segmentsRefreshRate: number,
-  NAME: string
+  matchingKey: string
 ): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
-      mySegmentsFetcherFactory(fetchMySegments),
-      mySegmentsCache,
-      notifyUpdate,
+      mySegmentsFetcherFactory(fetchMemberships),
+      storage,
+      readiness.segments,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       matchingKey
     ),
-    segmentsRefreshRate,
-    NAME,
+    settings.scheduler.segmentsRefreshRate,
+    'mySegmentsUpdater',
   );
 }

package/src/sync/polling/types.ts

@@ -1,17 +1,18 @@
 import { ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
+import { MEMBERSHIP_LS_UPDATE, MEMBERSHIP_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: MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE
+  cn: number
+  added: string[]
+  removed: string[]
 }
 
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
@@ -20,14 +21,13 @@ export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
   segmentsSyncTask: ISyncTask
-  largeSegmentsSyncTask?: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
   remove(matchingKey: string): void;
-  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
+  get(matchingKey: string): IMySegmentsSyncTask | undefined
 }

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

@@ -1,9 +1,13 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync } 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 { MEMBERSHIP_LS_UPDATE } from '../../streaming/constants';
 
 type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
@@ -16,13 +20,14 @@ type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => P
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  mySegmentsCache: ISegmentsCacheSync,
-  notifyUpdate: () => void,
+  storage: IStorageSync,
+  segmentsEventEmitter: ISegmentsEventEmitter,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
 ): IMySegmentsUpdater {
 
+  const { splits, segments, largeSegments } = storage;
   let readyOnAlreadyExistentState = true;
   let startingUp = true;
 
@@ -33,28 +38,22 @@ 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 === MEMBERSHIP_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 (shouldNotifyUpdate || readyOnAlreadyExistentState) {
+    if (splits.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
       readyOnAlreadyExistentState = false;
-      notifyUpdate();
+      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
     }
   }
 

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

@@ -76,12 +76,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.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${ABLY_API_VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
 
     this.connection = new this.eventSource!(

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, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -74,22 +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 MY_LARGE_SEGMENTS_UPDATE:
+        case MEMBERSHIP_MS_UPDATE:
+        case MEMBERSHIP_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, MY_LARGE_SEGMENTS_UPDATE } from '../types';
-
-export interface IMySegmentsUpdateData {
-  type: MY_SEGMENTS_UPDATE,
-  changeNumber: number,
-  includesPayload: boolean,
-  segmentList?: string[]
-}
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../types';
 
 export enum Compression {
   None = 0,
@@ -26,27 +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,
-  u: UpdateStrategy,
-}
-
-export interface IMyLargeSegmentsUpdateData {
-  type: MY_LARGE_SEGMENTS_UPDATE,
-  changeNumber: number,
-  largeSegments: 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. 0 for murmur3_32, 1 for murmur3_64
+  h?: number, // hash function
   s?: number, // seed for hash function
 }
 
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIP_MS_UPDATE> { }
+
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIP_LS_UPDATE> { }
+
 export interface ISegmentUpdateData {
   type: SEGMENT_UPDATE,
   changeNumber: number,
@@ -80,6 +68,6 @@ export interface IOccupancyData {
   }
 }
 
-export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | IMyLargeSegmentsUpdateData | 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 }

package/src/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.ts

@@ -2,12 +2,12 @@ import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { Backoff } from '../../../utils/Backoff';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
-import { UpdatesFromSSEEnum } from '../../submitters/types';
+import { MEMBERSHIPS } from '../../../utils/constants';
 
 /**
  * MySegmentsUpdateWorker factory
  */
-export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker {
+export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]> {
 
   let maxChangeNumber = 0; // keeps the maximum changeNumber among queued events
   let currentChangeNumber = -1;
@@ -15,7 +15,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
   let isHandlingEvent: boolean;
   let _segmentsData: MySegmentsData | undefined; // keeps the segmentsData (if included in notification payload) from the queued event with maximum changeNumber
   let _delay: undefined | number;
-  let _delayTimeoutID: undefined | number;
+  let _delayTimeoutID: any;
   const backoff = new Backoff(__handleMySegmentsUpdateCall);
 
   function __handleMySegmentsUpdateCall() {
@@ -28,6 +28,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
       const syncTask = _delay ?
         new Promise(res => {
           _delayTimeoutID = setTimeout(() => {
+            _delay = undefined;
             mySegmentsSyncTask.execute(_segmentsData, true).then(res);
           }, _delay);
         }) :
@@ -35,8 +36,8 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
       syncTask.then((result) => {
         if (!isHandlingEvent) return; // halt if `stop` has been called
-        if (result !== false) {// Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
-          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(updateType);
+        if (result !== false) { // Unlike `Splits|SegmentsUpdateWorker`, we cannot use `mySegmentsCache.getChangeNumber` since `/mySegments` endpoint doesn't provide this value.
+          if (_segmentsData) telemetryTracker.trackUpdatesFromSSE(MEMBERSHIPS);
           currentChangeNumber = Math.max(currentChangeNumber, currentMaxChangeNumber); // use `currentMaxChangeNumber`, in case that `maxChangeNumber` was updated during fetch.
         }
         if (handleNewEvent) {
@@ -52,17 +53,20 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
   return {
     /**
-     * Invoked by NotificationProcessor on MY_SEGMENTS_UPDATE event
+     * Invoked by NotificationProcessor on MY_(LARGE)_SEGMENTS_UPDATE notifications
      *
-     * @param {number} changeNumber change number of the MY_SEGMENTS_UPDATE notification
-     * @param {SegmentsData | undefined} segmentsData might be undefined
+     * @param changeNumber change number of the notification
+     * @param segmentsData data for KeyList or SegmentRemoval instant updates
+     * @param delay optional time to wait for BoundedFetchRequest or BoundedFetchRequest updates
      */
-    put(changeNumber: number, segmentsData?: MySegmentsData, delay?: number) {
-      if (changeNumber <= currentChangeNumber || changeNumber <= maxChangeNumber) return;
+    put(mySegmentsData: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number) {
+      const { type, cn } = mySegmentsData;
+      // Ignore event if it is outdated or if there is a pending fetch request (_delay is set)
+      if (cn <= currentChangeNumber || cn <= maxChangeNumber || _delay) return;
 
-      maxChangeNumber = changeNumber;
+      maxChangeNumber = cn;
       handleNewEvent = true;
-      _segmentsData = segmentsData;
+      _segmentsData = payload && { type, cn, added: payload.added, removed: payload.removed };
       _delay = delay;
 
       if (backoff.timeoutID || !isHandlingEvent) __handleMySegmentsUpdateCall();
@@ -71,6 +75,7 @@ export function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask,
 
     stop() {
       clearTimeout(_delayTimeoutID);
+      _delay = undefined;
       isHandlingEvent = false;
       backoff.reset();
     }

package/src/sync/streaming/UpdateWorkers/SegmentsUpdateWorker.ts

@@ -9,7 +9,7 @@ import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker {
+export function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]> {
 
   // Handles retries with CDN bypass per segment name
   function SegmentUpdateWorker(segment: string) {

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -14,7 +14,7 @@ import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & { killSplit(event: ISplitKillData): void } {
+export function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & { killSplit(event: ISplitKillData): void } {
 
   let maxChangeNumber = 0;
   let handleNewEvent = false;

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
   stop(): void // clear scheduled tasks (backoff)
-  put(...args: any[]): void // handle new update event
+  put(...args: T): void // handle new update event
 }

package/src/sync/streaming/constants.ts

@@ -25,12 +25,11 @@ export const PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export const PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 
 // Update-type push notifications, handled by NotificationProcessor
-export const MY_SEGMENTS_UPDATE = 'MY_SEGMENTS_UPDATE';
-export const MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export const MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
+export const MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
 export const SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export const SPLIT_KILL = 'SPLIT_KILL';
 export const SPLIT_UPDATE = 'SPLIT_UPDATE';
-export const MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export const CONTROL = 'CONTROL';