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

package/src/sync/streaming/pushManager.ts

@@ -11,14 +11,14 @@ import { authenticateFactory, hashUserKey } from './AuthClient';
 import { forOwn } from '../../utils/lang';
 import { SSEClient } from './SSEClient';
 import { getMatching } from '../../utils/key';
-import { MY_SEGMENTS_UPDATE_V3, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType, MY_LARGE_SEGMENTS_UPDATE } from './constants';
-import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MY_SEGMENTS_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
-import { IMyLargeSegmentsUpdateData, IMySegmentsUpdateV3Data, KeyList, UpdateStrategy } from './SSEHandler/types';
+import { MEMBERSHIP_MS_UPDATE, MEMBERSHIP_LS_UPDATE, PUSH_NONRETRYABLE_ERROR, PUSH_SUBSYSTEM_DOWN, SECONDS_BEFORE_EXPIRATION, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, PUSH_RETRYABLE_ERROR, PUSH_SUBSYSTEM_UP, ControlType } from './constants';
+import { STREAMING_FALLBACK, STREAMING_REFRESH_TOKEN, STREAMING_CONNECTING, STREAMING_DISABLED, ERROR_STREAMING_AUTH, STREAMING_DISCONNECTING, STREAMING_RECONNECT, STREAMING_PARSING_MEMBERSHIP_UPDATE, STREAMING_PARSING_SPLIT_UPDATE } from '../../logger/constants';
+import { IMembershipMSUpdateData, IMembershipLSUpdateData, KeyList, UpdateStrategy } from './SSEHandler/types';
 import { getDelay, isInBitmap, parseBitmap, parseFFUpdatePayload, parseKeyList } from './parseUtils';
 import { ISet, _Set } from '../../utils/lang/sets';
 import { Hash64, hash64 } from '../../utils/murmur3/murmur3_64';
 import { IAuthTokenPushEnabled } from './AuthClient/types';
-import { TOKEN_REFRESH, AUTH_REJECTION, MY_LARGE_SEGMENT, MY_SEGMENT } from '../../utils/constants';
+import { TOKEN_REFRESH, AUTH_REJECTION } from '../../utils/constants';
 import { ISdkFactoryContextSync } from '../../sdkFactory/types';
 
 /**
@@ -59,10 +59,10 @@ export function pushManagerFactory(
   // For server-side we pass the segmentsSyncTask, used by SplitsUpdateWorker to fetch new segments
   const splitsUpdateWorker = SplitsUpdateWorker(log, storage.splits, pollingManager.splitsSyncTask, readiness.splits, telemetryTracker, userKey ? undefined : pollingManager.segmentsSyncTask as ISegmentsSyncTask);
 
-  // [Only for client-side] map of hashes to user keys, to dispatch MY_SEGMENTS_UPDATE events to the corresponding MySegmentsUpdateWorker
+  // [Only for client-side] map of hashes to user keys, to dispatch membership update events to the corresponding MySegmentsUpdateWorker
   const userKeyHashes: Record<string, string> = {};
   // [Only for client-side] map of user keys to their corresponding hash64 and MySegmentsUpdateWorkers.
-  // Hash64 is used to process MY_SEGMENTS_UPDATE events and dispatch actions to the corresponding MySegmentsUpdateWorker.
+  // Hash64 is used to process membership update events and dispatch actions to the corresponding MySegmentsUpdateWorker.
   const clients: Record<string, { hash64: Hash64, worker: ReturnType<typeof MySegmentsUpdateWorker>, workerLarge: ReturnType<typeof MySegmentsUpdateWorker> }> = {};
 
   // [Only for client-side] variable to flag that a new client was added. It is needed to reconnect streaming.
@@ -238,8 +238,8 @@ export function pushManagerFactory(
     splitsUpdateWorker.put(parsedData);
   });
 
-  function handleMySegmentsUpdate(parsedData: IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData) {
-    const isLS = parsedData.t === MY_LARGE_SEGMENTS_UPDATE;
+  function handleMySegmentsUpdate(parsedData: IMembershipMSUpdateData | IMembershipLSUpdateData) {
+    const isLS = parsedData.type === MEMBERSHIP_LS_UPDATE;
 
     switch (parsedData.u) {
       case UpdateStrategy.BoundedFetchRequest: {
@@ -247,13 +247,13 @@ export function pushManagerFactory(
         try {
           bitmap = parseBitmap(parsedData.d!, parsedData.c!);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['BoundedFetchRequest', e]);
+          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['BoundedFetchRequest', e]);
           break;
         }
 
         forOwn(clients, ({ hash64, worker, workerLarge }, matchingKey) => {
           if (isInBitmap(bitmap, hash64.hex)) {
-            (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+            (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
           }
         });
         return;
@@ -265,53 +265,50 @@ export function pushManagerFactory(
           added = new _Set(keyList.a);
           removed = new _Set(keyList.r);
         } catch (e) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', e]);
+          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', e]);
           break;
         }
 
         if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['KeyList', 'No segment name was provided']);
+          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['KeyList', 'No segment name was provided']);
           break;
         }
 
         forOwn(clients, ({ hash64, worker, workerLarge }) => {
           const add = added.has(hash64.dec) ? true : removed.has(hash64.dec) ? false : undefined;
           if (add !== undefined) {
-            (isLS ? workerLarge : worker).put(parsedData.cn, [{
-              isLS,
-              name: parsedData.n![0],
-              add,
-            }]);
+            (isLS ? workerLarge : worker).put(parsedData, {
+              added: add ? [parsedData.n![0]] : [],
+              removed: add ? [] : [parsedData.n![0]]
+            });
           }
         });
         return;
       }
       case UpdateStrategy.SegmentRemoval:
         if (!parsedData.n || !parsedData.n.length) {
-          log.warn(STREAMING_PARSING_MY_SEGMENTS_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
+          log.warn(STREAMING_PARSING_MEMBERSHIP_UPDATE, ['SegmentRemoval', 'No segment name was provided']);
           break;
         }
 
         forOwn(clients, ({ worker, workerLarge }) => {
-          (isLS ? workerLarge : worker).put(parsedData.cn, parsedData.n!.map(largeSegment => ({
-            isLS,
-            name: largeSegment,
-            add: false,
-            cn: parsedData.cn
-          })));
+          (isLS ? workerLarge : worker).put(parsedData, {
+            added: [],
+            removed: parsedData.n!
+          });
         });
         return;
     }
 
     // `UpdateStrategy.UnboundedFetchRequest` and fallbacks of other cases
     forOwn(clients, ({ worker, workerLarge }, matchingKey) => {
-      (isLS ? workerLarge : worker).put(parsedData.cn, undefined, getDelay(parsedData, matchingKey));
+      (isLS ? workerLarge : worker).put(parsedData, undefined, getDelay(parsedData, matchingKey));
     });
   }
 
   if (userKey) {
-    pushEmitter.on(MY_SEGMENTS_UPDATE_V3, handleMySegmentsUpdate);
-    pushEmitter.on(MY_LARGE_SEGMENTS_UPDATE, handleMySegmentsUpdate);
+    pushEmitter.on(MEMBERSHIP_MS_UPDATE, handleMySegmentsUpdate);
+    pushEmitter.on(MEMBERSHIP_LS_UPDATE, handleMySegmentsUpdate);
   } else {
     pushEmitter.on(SEGMENT_UPDATE, segmentsUpdateWorker!.put);
   }
@@ -351,8 +348,8 @@ export function pushManagerFactory(
           userKeyHashes[hash] = userKey;
           clients[userKey] = {
             hash64: hash64(userKey),
-            worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_SEGMENT),
-            workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker, MY_LARGE_SEGMENT)
+            worker: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker),
+            workerLarge: MySegmentsUpdateWorker(mySegmentsSyncTask, telemetryTracker)
           };
           connectForNewClient = true; // we must reconnect on start, to listen the channel for the new user key
 

package/src/sync/streaming/types.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateV3Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData, INotificationData } from './SSEHandler/types';
+import { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -11,21 +11,21 @@ export type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR'
 export type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR'
 
 // Update-type push notifications, handled by NotificationProcessor
-export type MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
+export type MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
+export type MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
 export type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export type SPLIT_KILL = 'SPLIT_KILL';
 export type SPLIT_UPDATE = 'SPLIT_UPDATE';
-export type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 
 // Control-type push notifications, handled by NotificationKeeper
 export type CONTROL = 'CONTROL';
 export type OCCUPANCY = 'OCCUPANCY';
 
-export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE_V3 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET
+export type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET
 
 type IParsedData<T extends IPushEvent> =
-  T extends MY_SEGMENTS_UPDATE_V3 ? IMySegmentsUpdateV3Data :
-  T extends MY_LARGE_SEGMENTS_UPDATE ? IMyLargeSegmentsUpdateData :
+  T extends MEMBERSHIP_MS_UPDATE ? IMembershipMSUpdateData :
+  T extends MEMBERSHIP_LS_UPDATE ? IMembershipLSUpdateData :
   T extends SEGMENT_UPDATE ? ISegmentUpdateData :
   T extends SPLIT_UPDATE ? ISplitUpdateData :
   T extends SPLIT_KILL ? ISplitKillData : INotificationData;

package/src/sync/submitters/types.ts

@@ -103,7 +103,7 @@ export type DROPPED = 1;
 export type DEDUPED = 2;
 export type ImpressionDataType = QUEUED | DROPPED | DEDUPED
 export type EventDataType = QUEUED | DROPPED;
-export type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT | MY_LARGE_SEGMENT;
+export type UpdatesFromSSEEnum = SPLITS | MEMBERSHIPS;
 
 export type SPLITS = 'sp';
 export type IMPRESSIONS = 'im';
@@ -112,9 +112,8 @@ export type EVENTS = 'ev';
 export type TELEMETRY = 'te';
 export type TOKEN = 'to';
 export type SEGMENT = 'se';
-export type MY_SEGMENT = 'ms';
-export type MY_LARGE_SEGMENT = 'mls';
-export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+export type MEMBERSHIPS = 'ms';
+export type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MEMBERSHIPS;
 
 export type LastSync = Partial<Record<OperationType, number | undefined>>
 export type HttpErrors = Partial<Record<OperationType, { [statusCode: string]: number }>>

package/src/utils/constants/index.ts

@@ -75,8 +75,7 @@ export const EVENTS = 'ev';
 export const TELEMETRY = 'te';
 export const TOKEN = 'to';
 export const SEGMENT = 'se';
-export const MY_SEGMENT = 'ms';
-export const MY_LARGE_SEGMENT = 'mls';
+export const MEMBERSHIPS = 'ms';
 
 export const TREATMENT = 't';
 export const TREATMENTS = 'ts';

package/types/dtos/types.d.ts

@@ -177,20 +177,16 @@ export interface ISegmentChangesResponse {
     since: number;
     till: number;
 }
+export interface IMySegmentsResponse {
+    cn?: number;
+    k?: {
+        n: string;
+    }[];
+}
 /** Interface of the parsed JSON response of `/memberships/{userKey}` */
 export interface IMembershipsResponse {
-    ms?: {
-        cn?: number;
-        k?: Array<{
-            n: string;
-        }>;
-    };
-    ls?: {
-        cn?: number;
-        k?: Array<{
-            n: string;
-        }>;
-    };
+    ms?: IMySegmentsResponse;
+    ls?: IMySegmentsResponse;
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/logger/constants.d.ts

@@ -77,7 +77,7 @@ export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
 export declare const WARN_SDK_KEY = 222;
-export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE = 223;
+export declare const STREAMING_PARSING_MEMBERSHIP_UPDATE = 223;
 export declare const STREAMING_PARSING_SPLIT_UPDATE = 224;
 export declare const WARN_INVALID_FLAGSET = 225;
 export declare const WARN_LOWERCASE_FLAGSET = 226;

package/types/storages/AbstractSegmentsCacheSync.d.ts

@@ -1,3 +1,5 @@
+import { IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
 /**
  * This class provides a skeletal implementation of the ISegmentsCacheSync interface
@@ -22,7 +24,7 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
     /**
      * clear the cache.
      */
-    abstract clear(): void;
+    clear(): void;
     /**
      * For server-side synchronizer: add the given list of segments to the cache, with an empty list of keys. The segments that already exist are not modified.
      * For client-side synchronizer: the method is not used.
@@ -39,14 +41,14 @@ export declare abstract class AbstractSegmentsCacheSync implements ISegmentsCach
      */
     abstract getKeysCount(): number;
     /**
-     * For server-side synchronizer: set the change number of `name` segment.
-     * For client-side synchronizer: the method is not used.
+     * For server-side synchronizer: change number of `name` segment.
+     * For client-side synchronizer: change number of mySegments.
      */
-    setChangeNumber(name: string, changeNumber: number): boolean;
+    abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void;
     abstract getChangeNumber(name: string): number;
     /**
      * For server-side synchronizer: the method is not used.
-     * For client-side synchronizer: reset the cache with the given list of segments.
+     * For client-side synchronizer: it resets or updates the cache.
      */
-    resetSegments(names: string[], changeNumber?: number): boolean;
+    resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
 }

package/types/storages/AbstractSplitsCacheSync.d.ts

@@ -12,7 +12,7 @@ export declare abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
     removeSplits(names: string[]): boolean[];
     abstract getSplit(name: string): ISplit | null;
     getSplits(names: string[]): Record<string, ISplit | null>;
-    abstract setChangeNumber(changeNumber: number): boolean;
+    abstract setChangeNumber(changeNumber: number): boolean | void;
     abstract getChangeNumber(): number;
     getAll(): ISplit[];
     abstract getSplitNames(): string[];

package/types/storages/inLocalStorage/MySegmentsCacheInLocal.d.ts

@@ -5,22 +5,11 @@ export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     private readonly keys;
     private readonly log;
     constructor(log: ILogger, keys: MySegmentsKeyBuilder);
-    /**
-     * Removes list of segments from localStorage
-     * @NOTE this method is not being used at the moment.
-     */
-    clear(): void;
     addToSegment(name: string): boolean;
     removeFromSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    /**
-     * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
-     *
-     * @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[], changeNumber?: number): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
+    setChangeNumber(name?: string, changeNumber?: number): void;
     getChangeNumber(): number;
 }

package/types/storages/inMemory/MySegmentsCacheInMemory.d.ts

@@ -6,18 +6,10 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 export declare class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     private segmentCache;
     private cn?;
-    clear(): void;
     addToSegment(name: string): boolean;
     removeFromSegment(name: string): boolean;
     isInSegment(name: string): boolean;
-    /**
-     * 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[], changeNumber?: number): boolean;
+    setChangeNumber(name?: string, changeNumber?: number): void;
     getChangeNumber(): number;
     getRegisteredSegments(): string[];
     getKeysCount(): number;

package/types/storages/types.d.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';
@@ -200,7 +201,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[];
@@ -245,9 +246,9 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
     registerSegments(names: string[]): boolean;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
-    setChangeNumber(name: string, changeNumber: number): boolean;
+    setChangeNumber(name: string, changeNumber: number): boolean | void;
     getChangeNumber(name: string): number;
-    resetSegments(names: string[], changeNumber?: number): boolean;
+    resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
     clear(): void;
 }
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {

package/types/sync/polling/types.d.ts

@@ -1,6 +1,7 @@
-import { IMembershipsResponse, ISplit } from '../../dtos/types';
+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;
@@ -9,11 +10,12 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 }
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> {
 }
-export declare type MySegmentsData = IMembershipsResponse | {
-    isLS?: boolean;
-    name: string;
-    add: boolean;
-}[];
+export declare 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> {
 }
 export interface IPollingManager extends ITask {

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

@@ -1,5 +1,5 @@
 import { ControlType } from '../constants';
-import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MY_LARGE_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V3 } from '../types';
+import { SEGMENT_UPDATE, SPLIT_UPDATE, SPLIT_KILL, CONTROL, OCCUPANCY, MEMBERSHIP_LS_UPDATE, MEMBERSHIP_MS_UPDATE } from '../types';
 export declare enum Compression {
     None = 0,
     Gzip = 1,
@@ -15,8 +15,8 @@ export interface KeyList {
     a?: string[];
     r?: string[];
 }
-interface IMySegmentsUpdateData<T extends string> {
-    t: T;
+interface IMembershipUpdateData<T extends string> {
+    type: T;
     cn: number;
     n?: string[];
     c?: Compression;
@@ -26,9 +26,9 @@ interface IMySegmentsUpdateData<T extends string> {
     h?: number;
     s?: number;
 }
-export interface IMySegmentsUpdateV3Data extends IMySegmentsUpdateData<MY_SEGMENTS_UPDATE_V3> {
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIP_MS_UPDATE> {
 }
-export interface IMyLargeSegmentsUpdateData extends IMySegmentsUpdateData<MY_LARGE_SEGMENTS_UPDATE> {
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIP_LS_UPDATE> {
 }
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
@@ -58,7 +58,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateV3Data | IMyLargeSegmentsUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;

package/types/sync/streaming/UpdateWorkers/MySegmentsUpdateWorker.d.ts

@@ -1,8 +1,7 @@
 import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
-import { UpdatesFromSSEEnum } from '../../submitters/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker, updateType: UpdatesFromSSEEnum): IUpdateWorker<[changeNumber: number, segmentsData?: MySegmentsData, delay?: number]>;
+export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]>;

package/types/sync/streaming/constants.d.ts

@@ -19,11 +19,11 @@ export declare const PUSH_SUBSYSTEM_UP = "PUSH_SUBSYSTEM_UP";
  * triggers `startPolling` and `stopWorkers` calls
  */
 export declare const PUSH_SUBSYSTEM_DOWN = "PUSH_SUBSYSTEM_DOWN";
-export declare const MY_SEGMENTS_UPDATE_V3 = "MY_SEGMENTS_UPDATE_V3";
+export declare const MEMBERSHIP_MS_UPDATE = "MEMBERSHIP_MS_UPDATE";
+export declare const MEMBERSHIP_LS_UPDATE = "MEMBERSHIP_LS_UPDATE";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";
-export declare const MY_LARGE_SEGMENTS_UPDATE = "MY_LARGE_SEGMENTS_UPDATE";
 export declare const CONTROL = "CONTROL";
 export declare const OCCUPANCY = "OCCUPANCY";
 export declare enum ControlType {

package/types/sync/streaming/parseUtils.d.ts

@@ -1,4 +1,4 @@
-import { Compression, IMyLargeSegmentsUpdateData, KeyList } from './SSEHandler/types';
+import { Compression, IMembershipMSUpdateData, KeyList } from './SSEHandler/types';
 import { ISplit } from '../../dtos/types';
 /**
  * Decode, decompress and parse the provided 'data' into a KeyList object
@@ -31,4 +31,4 @@ export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boole
  * Parse feature flags notifications for instant feature flag updates
  */
 export declare function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined;
-export declare function getDelay(parsedData: Pick<IMyLargeSegmentsUpdateData, 'i' | 'h' | 's'>, matchingKey: string): number;
+export declare function getDelay(parsedData: Pick<IMembershipMSUpdateData, 'i' | 'h' | 's'>, matchingKey: string): number;

package/types/sync/streaming/types.d.ts

@@ -1,4 +1,4 @@
-import { IMySegmentsUpdateV3Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, IMyLargeSegmentsUpdateData, INotificationData } from './SSEHandler/types';
+import { IMembershipMSUpdateData, IMembershipLSUpdateData, ISegmentUpdateData, ISplitUpdateData, ISplitKillData, INotificationData } from './SSEHandler/types';
 import { ITask } from '../types';
 import { IMySegmentsSyncTask } from '../polling/types';
 import { IEventEmitter } from '../../types';
@@ -7,15 +7,15 @@ export declare type PUSH_SUBSYSTEM_UP = 'PUSH_SUBSYSTEM_UP';
 export declare type PUSH_SUBSYSTEM_DOWN = 'PUSH_SUBSYSTEM_DOWN';
 export declare type PUSH_NONRETRYABLE_ERROR = 'PUSH_NONRETRYABLE_ERROR';
 export declare type PUSH_RETRYABLE_ERROR = 'PUSH_RETRYABLE_ERROR';
-export declare type MY_SEGMENTS_UPDATE_V3 = 'MY_SEGMENTS_UPDATE_V3';
+export declare type MEMBERSHIP_MS_UPDATE = 'MEMBERSHIP_MS_UPDATE';
+export declare type MEMBERSHIP_LS_UPDATE = 'MEMBERSHIP_LS_UPDATE';
 export declare type SEGMENT_UPDATE = 'SEGMENT_UPDATE';
 export declare type SPLIT_KILL = 'SPLIT_KILL';
 export declare type SPLIT_UPDATE = 'SPLIT_UPDATE';
-export declare type MY_LARGE_SEGMENTS_UPDATE = 'MY_LARGE_SEGMENTS_UPDATE';
 export declare type CONTROL = 'CONTROL';
 export declare type OCCUPANCY = 'OCCUPANCY';
-export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MY_SEGMENTS_UPDATE_V3 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | MY_LARGE_SEGMENTS_UPDATE | ControlType.STREAMING_RESET;
-declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE_V3 ? IMySegmentsUpdateV3Data : T extends MY_LARGE_SEGMENTS_UPDATE ? IMyLargeSegmentsUpdateData : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : INotificationData;
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIP_MS_UPDATE | MEMBERSHIP_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MEMBERSHIP_MS_UPDATE ? IMembershipMSUpdateData : T extends MEMBERSHIP_LS_UPDATE ? IMembershipLSUpdateData : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : INotificationData;
 /**
  * EventEmitter used as Feedback Loop between the SyncManager and PushManager,
  * where the latter pushes messages and the former consumes it

package/types/sync/submitters/types.d.ts

@@ -90,7 +90,7 @@ export declare type DROPPED = 1;
 export declare type DEDUPED = 2;
 export declare type ImpressionDataType = QUEUED | DROPPED | DEDUPED;
 export declare type EventDataType = QUEUED | DROPPED;
-export declare type UpdatesFromSSEEnum = SPLITS | MY_SEGMENT | MY_LARGE_SEGMENT;
+export declare type UpdatesFromSSEEnum = SPLITS | MEMBERSHIPS;
 export declare type SPLITS = 'sp';
 export declare type IMPRESSIONS = 'im';
 export declare type IMPRESSIONS_COUNT = 'ic';
@@ -98,9 +98,8 @@ export declare type EVENTS = 'ev';
 export declare type TELEMETRY = 'te';
 export declare type TOKEN = 'to';
 export declare type SEGMENT = 'se';
-export declare type MY_SEGMENT = 'ms';
-export declare type MY_LARGE_SEGMENT = 'mls';
-export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MY_SEGMENT;
+export declare type MEMBERSHIPS = 'ms';
+export declare type OperationType = SPLITS | IMPRESSIONS | IMPRESSIONS_COUNT | EVENTS | TELEMETRY | TOKEN | SEGMENT | MEMBERSHIPS;
 export declare type LastSync = Partial<Record<OperationType, number | undefined>>;
 export declare type HttpErrors = Partial<Record<OperationType, {
     [statusCode: string]: number;

package/types/utils/constants/index.d.ts

@@ -52,8 +52,7 @@ export declare const EVENTS = "ev";
 export declare const TELEMETRY = "te";
 export declare const TOKEN = "to";
 export declare const SEGMENT = "se";
-export declare const MY_SEGMENT = "ms";
-export declare const MY_LARGE_SEGMENT = "mls";
+export declare const MEMBERSHIPS = "ms";
 export declare const TREATMENT = "t";
 export declare const TREATMENTS = "ts";
 export declare const TREATMENT_WITH_CONFIG = "tc";