@splitsoftware/splitio-commons 1.17.0-rc.5 → 1.17.1-rc.0

package/types/dtos/types.d.ts

@@ -21,6 +21,9 @@ export interface IWhitelistMatcherData {
 export interface IInSegmentMatcherData {
     segmentName: string;
 }
+export interface IInLargeSegmentMatcherData {
+    largeSegmentName: string;
+}
 export interface IDependencyMatcherData {
     split: string;
     treatments: string[];
@@ -33,6 +36,7 @@ interface ISplitMatcherBase {
         attribute: string | null;
     };
     userDefinedSegmentMatcherData?: null | IInSegmentMatcherData;
+    userDefinedLargeSegmentMatcherData?: null | IInLargeSegmentMatcherData;
     whitelistMatcherData?: null | IWhitelistMatcherData;
     unaryNumericMatcherData?: null | IUnaryNumericMatcherData;
     betweenMatcherData?: null | IBetweenMatcherData;
@@ -48,6 +52,10 @@ interface IInSegmentMatcher extends ISplitMatcherBase {
     matcherType: 'IN_SEGMENT';
     userDefinedSegmentMatcherData: IInSegmentMatcherData;
 }
+interface IInLargeSegmentMatcher extends ISplitMatcherBase {
+    matcherType: 'IN_LARGE_SEGMENT';
+    userDefinedLargeSegmentMatcherData: IInLargeSegmentMatcherData;
+}
 interface IWhitelistMatcher extends ISplitMatcherBase {
     matcherType: 'WHITELIST';
     whitelistMatcherData: IWhitelistMatcherData;
@@ -128,7 +136,7 @@ interface IInListSemverMatcher extends ISplitMatcherBase {
     matcherType: 'IN_LIST_SEMVER';
     whitelistMatcherData: IWhitelistMatcherData;
 }
-export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher;
+export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher | IInLargeSegmentMatcher;
 /** Split object */
 export interface ISplitPartition {
     treatment: string;
@@ -173,13 +181,16 @@ export interface ISegmentChangesResponse {
     since: number;
     till: number;
 }
-export interface IMySegmentsResponseItem {
-    id: string;
-    name: string;
-}
-/** Interface of the parsed JSON response of `/mySegments/{userKey}` */
 export interface IMySegmentsResponse {
-    mySegments: IMySegmentsResponseItem[];
+    cn?: number;
+    k?: {
+        n: string;
+    }[];
+}
+/** Interface of the parsed JSON response of `/memberships/{userKey}` */
+export interface IMembershipsResponse {
+    ms?: IMySegmentsResponse;
+    ls?: IMySegmentsResponse;
 }
 /** Metadata internal type for storages */
 export interface IMetadata {

package/types/evaluator/matchersTransform/segment.d.ts

@@ -1,5 +1,5 @@
-import { IInSegmentMatcherData } from '../../dtos/types';
+import { IInSegmentMatcherData, IInLargeSegmentMatcherData } from '../../dtos/types';
 /**
  * Extract segment name as a plain string.
  */
-export declare function segmentTransform(segment?: IInSegmentMatcherData): string | undefined;
+export declare function segmentTransform(segment?: IInSegmentMatcherData | IInLargeSegmentMatcherData): string | undefined;

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_V2 = 223;
+export declare const STREAMING_PARSING_MEMBERSHIPS_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/readiness/readinessManager.d.ts

@@ -1,6 +1,6 @@
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { IReadinessManager, ISplitsEventEmitter } from './types';
 /**
  * Factory of readiness manager, which handles the ready / update event propagation.
  */
-export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, readyTimeout?: number, splits?: ISplitsEventEmitter): IReadinessManager;
+export declare function readinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, splits?: ISplitsEventEmitter): IReadinessManager;

package/types/readiness/sdkReadinessManager.d.ts

@@ -1,6 +1,5 @@
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter } from '../types';
-import { ILogger } from '../logger/types';
+import { IEventEmitter, ISettings } from '../types';
 /**
  * SdkReadinessManager factory, which provides the public status API of SDK clients and manager: ready promise, readiness event emitter and constants (SDK_READY, etc).
  * It also updates logs related warnings and errors.
@@ -8,4 +7,4 @@ import { ILogger } from '../logger/types';
  * @param readyTimeout time in millis to emit SDK_READY_TIME_OUT event
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
-export declare function sdkReadinessManagerFactory(log: ILogger, EventEmitter: new () => IEventEmitter, readyTimeout?: number, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;
+export declare function sdkReadinessManagerFactory(EventEmitter: new () => IEventEmitter, settings: ISettings, readinessManager?: import("./types").IReadinessManager): ISdkReadinessManager;

package/types/readiness/types.d.ts

@@ -47,7 +47,7 @@ export interface IReadinessManager {
     setDestroyed(): void;
     destroy(): void;
     /** for client-side */
-    shared(readyTimeout?: number): IReadinessManager;
+    shared(): IReadinessManager;
 }
 /** SDK readiness manager */
 export interface ISdkReadinessManager {
@@ -59,6 +59,6 @@ export interface ISdkReadinessManager {
      */
     incInternalReadyCbCount(): void;
     /** for client-side */
-    shared(readyTimeout?: number): ISdkReadinessManager;
+    shared(): ISdkReadinessManager;
 }
 export {};

package/types/services/splitApi.d.ts

@@ -9,4 +9,4 @@ import { ITelemetryTracker } from '../trackers/types';
  * @param platform object containing environment-specific dependencies
  * @param telemetryTracker telemetry tracker
  */
-export declare function splitApiFactory(settings: ISettings, platform: IPlatform, telemetryTracker: ITelemetryTracker): ISplitApi;
+export declare function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getOptions' | 'getFetch'>, telemetryTracker: ITelemetryTracker): ISplitApi;

package/types/services/splitHttpClient.d.ts

@@ -7,4 +7,4 @@ import { IPlatform } from '../sdkFactory/types';
  * @param settings SDK settings, used to access authorizationKey, logger instance and metadata (SDK version, ip and hostname) to set additional headers
  * @param platform object containing environment-specific dependencies
  */
-export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient;
+export declare function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient;

package/types/services/types.d.ts

@@ -18,7 +18,7 @@ export declare type ISplitHttpClient = (url: string, options?: IRequestOptions,
 export declare type IFetchAuth = (userKeys?: string[]) => Promise<IResponse>;
 export declare type IFetchSplitChanges = (since: number, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>;
-export declare type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>;
+export declare type IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>;
 export declare type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
 export declare type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>;
@@ -32,7 +32,7 @@ export interface ISplitApi {
     fetchAuth: IFetchAuth;
     fetchSplitChanges: IFetchSplitChanges;
     fetchSegmentChanges: IFetchSegmentChanges;
-    fetchMySegments: IFetchMySegments;
+    fetchMemberships: IFetchMemberships;
     postEventsBulk: IPostEventsBulk;
     postUniqueKeysBulkCs: IPostUniqueKeysBulkCs;
     postUniqueKeysBulkSs: IPostUniqueKeysBulkSs;

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,18 +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.
-     */
-    setChangeNumber(name: string, changeNumber: number): boolean;
-    /**
-     * For server-side synchronizer: get 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.
      */
-    getChangeNumber(name: string): number;
+    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[]): 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/KeyBuilderCS.d.ts

@@ -1,5 +1,11 @@
 import { KeyBuilder } from './KeyBuilder';
-export declare class KeyBuilderCS extends KeyBuilder {
+export interface MySegmentsKeyBuilder {
+    buildSegmentNameKey(segmentName: string): string;
+    extractSegmentName(builtSegmentKeyName: string): string | undefined;
+    extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
+    buildTillKey(): string;
+}
+export declare class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     protected readonly regexSplitsCacheKey: RegExp;
     protected readonly matchingKey: string;
     constructor(prefix: string, matchingKey: string);
@@ -8,8 +14,9 @@ export declare class KeyBuilderCS extends KeyBuilder {
      */
     buildSegmentNameKey(segmentName: string): string;
     extractSegmentName(builtSegmentKeyName: string): string | undefined;
-    buildOldSegmentNameKey(segmentName: string): string;
     extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
     buildLastUpdatedKey(): string;
     isSplitsCacheKey(key: string): boolean;
+    buildTillKey(): string;
 }
+export declare function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder;

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

@@ -1,25 +1,15 @@
 import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 export declare class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     private readonly keys;
     private readonly log;
-    constructor(log: ILogger, keys: KeyBuilderCS);
-    /**
-     * Removes list of segments from localStorage
-     * @NOTE this method is not being used at the moment.
-     */
-    clear(): void;
+    constructor(log: ILogger, keys: MySegmentsKeyBuilder);
     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[]} segmentNames 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;
     getRegisteredSegments(): string[];
     getKeysCount(): number;
+    setChangeNumber(name?: string, changeNumber?: number): void;
+    getChangeNumber(): number;
 }

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

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

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

@@ -10,7 +10,7 @@ export declare class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     private splitsCache;
     private ttCache;
     private changeNumber;
-    private splitsWithSegmentsCount;
+    private segmentsCount;
     private flagSetsCache;
     constructor(splitFiltersValidation?: ISplitFiltersValidation);
     clear(): void;

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

@@ -1,4 +1,4 @@
-import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum } from '../../sync/submitters/types';
+import { ImpressionDataType, EventDataType, StreamingEvent, Method, OperationType, TelemetryUsageStatsPayload, UpdatesFromSSEEnum, UpdatesFromSSE } from '../../sync/submitters/types';
 import { ISegmentsCacheSync, ISplitsCacheSync, IStorageFactoryParams, ITelemetryCacheSync } from '../types';
 export declare const MAX_LATENCY_BUCKET_COUNT = 23;
 export declare function newBuckets(): number[];
@@ -10,7 +10,8 @@ export declare function shouldRecordTelemetry({ settings }: IStorageFactoryParam
 export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     private splits?;
     private segments?;
-    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined);
+    private largeSegments?;
+    constructor(splits?: ISplitsCacheSync | undefined, segments?: ISegmentsCacheSync | undefined, largeSegments?: ISegmentsCacheSync | undefined);
     private e;
     isEmpty(): boolean;
     clear(): void;
@@ -65,9 +66,6 @@ export declare class TelemetryCacheInMemory implements ITelemetryCacheSync {
     popLatencies(): Partial<Record<Method, number[]>>;
     recordLatency(method: Method, latencyMs: number): void;
     private updatesFromSSE;
-    popUpdatesFromSSE(): {
-        sp: number;
-        ms: number;
-    };
+    popUpdatesFromSSE(): UpdatesFromSSE;
     recordUpdatesFromSSE(type: UpdatesFromSSEEnum): void;
 }

package/types/storages/pluggable/inMemoryWrapper.d.ts

@@ -5,7 +5,7 @@ import { ISet } 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 declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;

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;
-    getChangeNumber(name: string): number;
-    resetSegments(names: string[]): boolean;
+    setChangeNumber(name: string, changeNumber: number): boolean | void;
+    getChangeNumber(name?: string): number;
+    resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean;
     clear(): void;
 }
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
@@ -388,6 +389,7 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
 export interface IStorageSync extends IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IImpressionCountsCacheSync, IEventsCacheSync, ITelemetryCacheSync, IUniqueKeysCacheSync> {
+    largeSegments?: ISegmentsCacheSync;
 }
 export interface IStorageAsync extends IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IImpressionCountsCacheBase, IEventsCacheAsync | IEventsCacheSync, ITelemetryCacheAsync | ITelemetryCacheSync, IUniqueKeysCacheBase> {
 }

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

@@ -1,7 +1,7 @@
-import { IFetchMySegments } from '../../../services/types';
+import { IFetchMemberships } from '../../../services/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 declare function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher;
+export declare function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher;

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

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

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

@@ -1,9 +1,9 @@
 import { IStorageSync } from '../../../storages/types';
 import { IReadinessManager } from '../../../readiness/types';
 import { IMySegmentsSyncTask } from '../types';
-import { IFetchMySegments } from '../../../services/types';
+import { IFetchMemberships } from '../../../services/types';
 import { ISettings } from '../../../types';
 /**
  * Creates a sync task that periodically executes a `mySegmentsUpdater` task
  */
-export declare function mySegmentsSyncTaskFactory(fetchMySegments: IFetchMySegments, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;
+export declare function mySegmentsSyncTaskFactory(fetchMemberships: IFetchMemberships, storage: IStorageSync, readiness: IReadinessManager, settings: ISettings, matchingKey: string): IMySegmentsSyncTask;

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

@@ -1,6 +1,7 @@
 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;
@@ -9,11 +10,13 @@ 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 = string[] | {
-    name: string;
-    add: boolean;
+export declare 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/types/sync/polling/updaters/mySegmentsUpdater.d.ts

@@ -1,13 +1,14 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
+import { IStorageSync } from '../../../storages/types';
 import { ISegmentsEventEmitter } from '../../../readiness/types';
 import { ILogger } from '../../../logger/types';
-declare type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>;
+import { MySegmentsData } from '../types';
+declare type IMySegmentsUpdater = (segmentsData?: MySegmentsData, noCache?: boolean, till?: number) => Promise<boolean>;
 /**
  * factory of MySegments updater, a task that:
  *  - fetches mySegments using `mySegmentsFetcher`
  *  - updates `mySegmentsCache`
  *  - uses `segmentsEventEmitter` to emit events related to segments data updates
  */
-export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, splitsCache: ISplitsCacheSync, mySegmentsCache: ISegmentsCacheSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
+export declare function mySegmentsUpdaterFactory(log: ILogger, mySegmentsFetcher: IMySegmentsFetcher, storage: IStorageSync, segmentsEventEmitter: ISegmentsEventEmitter, requestTimeoutBeforeReady: number, retriesOnFailureBeforeReady: number, matchingKey: string): IMySegmentsUpdater;
 export {};

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

@@ -1,11 +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 declare enum Compression {
     None = 0,
     Gzip = 1,
@@ -21,13 +15,20 @@ export interface KeyList {
     a?: string[];
     r?: string[];
 }
-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;
+    h?: number;
+    s?: number;
+}
+export interface IMembershipMSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_MS_UPDATE> {
+}
+export interface IMembershipLSUpdateData extends IMembershipUpdateData<MEMBERSHIPS_LS_UPDATE> {
 }
 export interface ISegmentUpdateData {
     type: SEGMENT_UPDATE;
@@ -57,7 +58,7 @@ export interface IOccupancyData {
         publishers: number;
     };
 }
-export declare type INotificationData = IMySegmentsUpdateData | IMySegmentsUpdateV2Data | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
+export declare type INotificationData = IMembershipMSUpdateData | IMembershipLSUpdateData | ISegmentUpdateData | ISplitUpdateData | ISplitKillData | IControlData | IOccupancyData;
 export declare type INotificationMessage = {
     parsedData: INotificationData;
     channel: string;
@@ -68,3 +69,4 @@ export declare type INotificationError = Event & {
     parsedData?: any;
     message?: string;
 };
+export {};

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

@@ -1,7 +1,9 @@
-import { IMySegmentsSyncTask } from '../../polling/types';
+import { IMySegmentsSyncTask, MySegmentsData } from '../../polling/types';
 import { IUpdateWorker } from './types';
 import { ITelemetryTracker } from '../../../trackers/types';
+import { IStorageSync } from '../../../storages/types';
+import { ILogger } from '../../../logger/types';
 /**
  * MySegmentsUpdateWorker factory
  */
-export declare function MySegmentsUpdateWorker(mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker;
+export declare function MySegmentsUpdateWorker(log: ILogger, storage: Pick<IStorageSync, 'segments' | 'largeSegments'>, mySegmentsSyncTask: IMySegmentsSyncTask, telemetryTracker: ITelemetryTracker): IUpdateWorker<[mySegmentsData?: Pick<MySegmentsData, 'type' | 'cn'>, payload?: Pick<MySegmentsData, 'added' | 'removed'>, delay?: number]>;

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

@@ -1,8 +1,9 @@
 import { ILogger } from '../../../logger/types';
 import { ISegmentsCacheSync } from '../../../storages/types';
 import { ISegmentsSyncTask } from '../../polling/types';
+import { ISegmentUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SegmentsUpdateWorker factory
  */
-export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker;
+export declare function SegmentsUpdateWorker(log: ILogger, segmentsSyncTask: ISegmentsSyncTask, segmentsCache: ISegmentsCacheSync): IUpdateWorker<[ISegmentUpdateData]>;

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

@@ -1,13 +1,14 @@
+import { ISplit } from '../../../dtos/types';
 import { ILogger } from '../../../logger/types';
 import { ISplitsEventEmitter } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ITelemetryTracker } from '../../../trackers/types';
 import { ISegmentsSyncTask, ISplitsSyncTask } from '../../polling/types';
-import { ISplitKillData } from '../SSEHandler/types';
+import { ISplitKillData, ISplitUpdateData } from '../SSEHandler/types';
 import { IUpdateWorker } from './types';
 /**
  * SplitsUpdateWorker factory
  */
-export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker & {
+export declare function SplitsUpdateWorker(log: ILogger, splitsCache: ISplitsCacheSync, splitsSyncTask: ISplitsSyncTask, splitsEventEmitter: ISplitsEventEmitter, telemetryTracker: ITelemetryTracker, segmentsSyncTask?: ISegmentsSyncTask): IUpdateWorker<[updateData: ISplitUpdateData, payload?: ISplit]> & {
     killSplit(event: ISplitKillData): void;
 };

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

@@ -1,4 +1,4 @@
-export interface IUpdateWorker {
+export interface IUpdateWorker<T extends any[]> {
     stop(): void;
-    put(...args: any[]): void;
+    put(...args: T): void;
 }

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

@@ -19,8 +19,8 @@ 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 = "MY_SEGMENTS_UPDATE";
-export declare const MY_SEGMENTS_UPDATE_V2 = "MY_SEGMENTS_UPDATE_V2";
+export declare const MEMBERSHIPS_MS_UPDATE = "MEMBERSHIPS_MS_UPDATE";
+export declare const MEMBERSHIPS_LS_UPDATE = "MEMBERSHIPS_LS_UPDATE";
 export declare const SEGMENT_UPDATE = "SEGMENT_UPDATE";
 export declare const SPLIT_KILL = "SPLIT_KILL";
 export declare const SPLIT_UPDATE = "SPLIT_UPDATE";

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

@@ -1,4 +1,5 @@
-import { Compression, 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
  *
@@ -28,8 +29,6 @@ export declare function parseBitmap(data: string, compression: Compression): Uin
 export declare function isInBitmap(bitmap: Uint8Array, hash64hex: string): boolean;
 /**
  * Parse feature flags notifications for instant feature flag updates
- *
- * @param {ISplitUpdateData} data
- * @returns {KeyList}
  */
-export declare function parseFFUpdatePayload(compression: Compression, data: string): KeyList | undefined;
+export declare function parseFFUpdatePayload(compression: Compression, data: string): ISplit | undefined;
+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 { IMySegmentsUpdateData, IMySegmentsUpdateV2Data, ISegmentUpdateData, ISplitUpdateData, ISplitKillData } 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,23 +7,23 @@ 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 = 'MY_SEGMENTS_UPDATE';
-export declare type MY_SEGMENTS_UPDATE_V2 = 'MY_SEGMENTS_UPDATE_V2';
+export declare type MEMBERSHIPS_MS_UPDATE = 'MEMBERSHIPS_MS_UPDATE';
+export declare type MEMBERSHIPS_LS_UPDATE = 'MEMBERSHIPS_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 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 | MY_SEGMENTS_UPDATE_V2 | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
-declare type IParsedData<T extends IPushEvent> = T extends MY_SEGMENTS_UPDATE ? IMySegmentsUpdateData : T extends MY_SEGMENTS_UPDATE_V2 ? IMySegmentsUpdateV2Data : T extends SEGMENT_UPDATE ? ISegmentUpdateData : T extends SPLIT_UPDATE ? ISplitUpdateData : T extends SPLIT_KILL ? ISplitKillData : undefined;
+export declare type IPushEvent = PUSH_SUBSYSTEM_UP | PUSH_SUBSYSTEM_DOWN | PUSH_NONRETRYABLE_ERROR | PUSH_RETRYABLE_ERROR | MEMBERSHIPS_MS_UPDATE | MEMBERSHIPS_LS_UPDATE | SEGMENT_UPDATE | SPLIT_UPDATE | SPLIT_KILL | ControlType.STREAMING_RESET;
+declare type IParsedData<T extends IPushEvent> = T extends MEMBERSHIPS_MS_UPDATE ? IMembershipMSUpdateData : T extends MEMBERSHIPS_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
  */
 export interface IPushEventEmitter extends IEventEmitter {
-    once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
-    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>, channel: T extends MY_SEGMENTS_UPDATE ? string : undefined) => void): this;
-    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>, channel?: T extends MY_SEGMENTS_UPDATE ? string : undefined): boolean;
+    once<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
+    on<T extends IPushEvent>(event: T, listener: (parsedData: IParsedData<T>) => void): this;
+    emit<T extends IPushEvent>(event: T, parsedData?: IParsedData<T>): boolean;
 }
 /**
  * PushManager