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

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -7,7 +7,7 @@ import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
 import { CONTROL } from '../../../utils/constants';
-import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { SYNC_OFFLINE_DATA, ERROR_SYNC_OFFLINE_LOADING } from '../../../logger/constants';
 
 /**
@@ -60,8 +60,12 @@ export function fromObjectUpdaterFactory(
 
         if (startingUp) {
           startingUp = false;
-          // Emits SDK_READY
-          readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          Promise.resolve(splitsCache.checkCache()).then(cacheReady => {
+            // Emits SDK_READY_FROM_CACHE
+            if (cacheReady) readiness.splits.emit(SDK_SPLITS_CACHE_LOADED);
+            // Emits SDK_READY
+            readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+          });
         }
         return true;
       });

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/pollingManagerSS.ts

@@ -1,7 +1,6 @@
 import { splitsSyncTaskFactory } from './syncTasks/splitsSyncTask';
 import { segmentsSyncTaskFactory } from './syncTasks/segmentsSyncTask';
 import { IPollingManager, ISegmentsSyncTask, ISplitsSyncTask } from './types';
-import { thenable } from '../../utils/promise/thenable';
 import { POLLING_START, POLLING_STOP, LOG_PREFIX_SYNC_POLLING } from '../../logger/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
@@ -29,9 +28,9 @@ export function pollingManagerSSFactory(
       log.debug(LOG_PREFIX_SYNC_POLLING + `Segments will be refreshed each ${settings.scheduler.segmentsRefreshRate} millis`);
 
       const startingUp = splitsSyncTask.start();
-      if (thenable(startingUp)) {
+      if (startingUp) {
         startingUp.then(() => {
-          segmentsSyncTask.start();
+          if (splitsSyncTask.isRunning()) segmentsSyncTask.start();
         });
       }
     },

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

@@ -36,9 +36,9 @@ export function segmentChangesUpdaterFactory(
 
     return sincePromise.then(since => {
       // if fetchOnlyNew flag, avoid processing already fetched segments
-      if (fetchOnlyNew && since !== -1) return -1;
+      if (fetchOnlyNew && since !== undefined) return -1;
 
-      return segmentChangesFetcher(since, segmentName, noCache, till).then(function (changes) {
+      return segmentChangesFetcher(since || -1, segmentName, noCache, till).then(function (changes) {
         let changeNumber = -1;
         const results: MaybeThenable<boolean | void>[] = [];
         changes.forEach(x => {

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

@@ -4,7 +4,7 @@ import { ISplitChangesFetcher } from '../fetchers/types';
 import { ISplit, ISplitChangesResponse, ISplitFiltersValidation } from '../../../dtos/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { timeout } from '../../../utils/promise/timeout';
-import { SDK_SPLITS_ARRIVED } from '../../../readiness/constants';
+import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/constants';
 import { ILogger } from '../../../logger/types';
 import { SYNC_SPLITS_FETCH, SYNC_SPLITS_NEW, SYNC_SPLITS_REMOVED, SYNC_SPLITS_SEGMENTS, SYNC_SPLITS_FETCH_FAILS, SYNC_SPLITS_FETCH_RETRY } from '../../../logger/constants';
 import { startsWith } from '../../../utils/lang';
@@ -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));
   });
 }
 
@@ -153,8 +153,7 @@ export function splitChangesUpdaterFactory(
      */
     function _splitChangesUpdater(since: number, retry = 0): Promise<boolean> {
       log.debug(SYNC_SPLITS_FETCH, [since]);
-
-      return Promise.resolve(splitUpdateNotification ?
+      const fetcherPromise = Promise.resolve(splitUpdateNotification ?
         { splits: [splitUpdateNotification.payload], till: splitUpdateNotification.changeNumber } :
         splitChangesFetcher(since, noCache, till, _promiseDecorator)
       )
@@ -201,6 +200,15 @@ export function splitChangesUpdaterFactory(
           }
           return false;
         });
+
+      // After triggering the requests, if we have cached splits information let's notify that to emit SDK_READY_FROM_CACHE.
+      // Wrapping in a promise since checkCache can be async.
+      if (splitsEventEmitter && startingUp) {
+        Promise.resolve(splits.checkCache()).then(isCacheReady => {
+          if (isCacheReady) splitsEventEmitter.emit(SDK_SPLITS_CACHE_LOADED);
+        });
+      }
+      return fetcherPromise;
     }
 
     let sincePromise = Promise.resolve(splits.getChangeNumber()); // `getChangeNumber` never rejects or throws error

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;
 

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, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MEMBERSHIPS_MS_UPDATE, MEMBERSHIPS_LS_UPDATE } from '../constants';
+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 { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -74,18 +74,21 @@ 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 MEMBERSHIPS_MS_UPDATE:
-        case MEMBERSHIPS_LS_UPDATE:
+        case MY_SEGMENTS_UPDATE_V2:
         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,5 +1,12 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIPS_LS_UPDATE, MEMBERSHIPS_MS_UPDATE } from '../types';
+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[]
+}
 
 export enum Compression {
   None = 0,
@@ -19,22 +26,15 @@ export interface KeyList {
   r?: string[], // decimal hash64 of user keys
 }
 
-interface IMembershipUpdateData<T extends string> {
-  type: T,
-  cn: number,
-  n?: string[],
-  c?: Compression,
-  d?: string,
+export interface IMySegmentsUpdateV2Data {
+  type: MY_SEGMENTS_UPDATE_V2,
+  changeNumber: number,
+  segmentName: 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 = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
+export type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData
 export type INotificationMessage = { parsedData: INotificationData, channel: string, timestamp: number, data: string }
 export type INotificationError = Event & { parsedData?: any, message?: string }