@splitsoftware/splitio-commons 1.16.0 → 1.16.1-rc.0

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,5 +1,5 @@
 import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
@@ -7,6 +7,7 @@ import { LOG_PREFIX } from './constants';
 import { ISet, _Set, setToArray } from '../../utils/lang/sets';
 import { ISettings } from '../../types';
 import { getStorageHash } from '../KeyBuilder';
+import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * ISplitsCacheSync implementation that stores split definitions in browser LocalStorage.
@@ -50,10 +51,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         this._decrementCount(ttKey);
 
-        if (usesSegments(split)) {
+        if (usesMatcher(split, IN_SEGMENT)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
           this._decrementCount(segmentsCountKey);
         }
+
+        if (usesMatcher(split, IN_LARGE_SEGMENT)) {
+          const segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
+          this._decrementCount(segmentsCountKey);
+        }
       }
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -67,11 +73,17 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         // @ts-expect-error
         localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
 
-        if (usesSegments(split)) {
+        if (usesMatcher(split, IN_SEGMENT)) {
           const segmentsCountKey = this.keys.buildSplitsWithSegmentCountKey();
           // @ts-expect-error
           localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
         }
+
+        if (usesMatcher(split, IN_LARGE_SEGMENT)) {
+          const segmentsCountKey = this.keys.buildSplitsWithLargeSegmentCountKey();
+          // @ts-expect-error
+          localStorage.setItem(segmentsCountKey, toNumber(localStorage.getItem(segmentsCountKey)) + 1);
+        }
       }
     } catch (e) {
       this.log.error(LOG_PREFIX + e);
@@ -203,11 +215,14 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return isFiniteNumber(ttCount) && ttCount > 0;
   }
 
-  usesSegments() {
+  usesMatcher(matcherType: string) {
     // If cache hasn't been synchronized with the cloud, assume we need them.
     if (!this.hasSync) return true;
 
-    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
+    const storedCount = localStorage.getItem(matcherType === IN_SEGMENT ?
+      this.keys.buildSplitsWithSegmentCountKey() :
+      this.keys.buildSplitsWithLargeSegmentCountKey()
+    );
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     if (isFiniteNumber(splitsWithSegmentsCount)) {

package/src/storages/inLocalStorage/index.ts

@@ -3,7 +3,7 @@ import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCache
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
 import { validatePrefix } from '../KeyBuilder';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import { KeyBuilderCS, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -38,15 +38,17 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
     const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
     const matchingKey = getMatching(settings.core.key);
-    const keys = new KeyBuilderCS(prefix, matchingKey as string);
+    const keys = new KeyBuilderCS(prefix, matchingKey);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
     const splits = new SplitsCacheInLocal(settings, keys, expirationTimestamp);
     const segments = new MySegmentsCacheInLocal(log, keys);
+    const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
     return {
       splits,
       segments,
+      largeSegments,
       impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
       impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(eventsQueueSize),
@@ -56,6 +58,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       destroy() {
         this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
         this.segments = new MySegmentsCacheInMemory();
+        this.largeSegments = new MySegmentsCacheInMemory();
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
         this.events.clear();
@@ -64,11 +67,11 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
       // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).
       shared(matchingKey: string) {
-        const childKeysBuilder = new KeyBuilderCS(prefix, matchingKey);
 
         return {
           splits: this.splits,
-          segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
+          segments: new MySegmentsCacheInLocal(log, new KeyBuilderCS(prefix, matchingKey)),
+          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
           impressions: this.impressions,
           impressionCounts: this.impressionCounts,
           events: this.events,
@@ -77,6 +80,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
           destroy() {
             this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
             this.segments = new MySegmentsCacheInMemory();
+            this.largeSegments = new MySegmentsCacheInMemory();
           }
         };
       },

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -18,10 +18,12 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
+  const largeSegments = new MySegmentsCacheInMemory();
 
   const storage = {
     splits,
     segments,
+    largeSegments,
     impressions: new ImpressionsCacheInMemory(impressionsQueueSize),
     impressionCounts: impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(eventsQueueSize),
@@ -32,6 +34,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     destroy() {
       this.splits.clear();
       this.segments.clear();
+      this.largeSegments.clear();
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
@@ -43,6 +46,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       return {
         splits: this.splits,
         segments: new MySegmentsCacheInMemory(),
+        largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -52,6 +56,7 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         destroy() {
           this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
           this.segments.clear();
+          this.largeSegments.clear();
         }
       };
     },

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,7 +1,8 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
 import { ISet, _Set } from '../../utils/lang/sets';
+import { IN_LARGE_SEGMENT, IN_SEGMENT } from '../../utils/constants';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -13,7 +14,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
-  private splitsWithSegmentsCount: number = 0;
+  private segmentsCount: number = 0;
+  private largeSegmentsCount: number = 0;
   private flagSetsCache: Record<string, ISet<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
@@ -25,7 +27,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsCache = {};
     this.ttCache = {};
     this.changeNumber = -1;
-    this.splitsWithSegmentsCount = 0;
+    this.segmentsCount = 0;
+    this.largeSegmentsCount = 0;
   }
 
   addSplit(name: string, split: ISplit): boolean {
@@ -38,9 +41,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
 
-      if (usesSegments(previousSplit)) { // Substract from segments count for the previous version of this Split.
-        this.splitsWithSegmentsCount--;
-      }
+      // Substract from segments count for the previous version of this Split.
+      if (usesMatcher(previousSplit, IN_SEGMENT)) this.segmentsCount--;
+      if (usesMatcher(previousSplit, IN_LARGE_SEGMENT)) this.largeSegmentsCount--;
     }
 
     if (split) {
@@ -52,7 +55,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(split)) this.splitsWithSegmentsCount++;
+      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount++;
+      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount++;
 
       return true;
     } else {
@@ -72,7 +76,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
-      if (usesSegments(split)) this.splitsWithSegmentsCount--;
+      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount--;
+      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount--;
 
       return true;
     } else {
@@ -101,8 +106,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
   }
 
-  usesSegments(): boolean {
-    return this.getChangeNumber() === -1 || this.splitsWithSegmentsCount > 0;
+  usesMatcher(matcherType: string): boolean {
+    return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
   }
 
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {

package/src/storages/inMemory/TelemetryCacheInMemory.ts

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

package/src/storages/types.ts

@@ -205,7 +205,7 @@ export interface ISplitsCacheBase {
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
   // only for Client-Side
-  usesSegments(): MaybeThenable<boolean>,
+  usesMatcher(matcherType: string): MaybeThenable<boolean>,
   clear(): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return false by default, to avoid emitting SDK_READY_FROM_CACHE.
   checkCache(): MaybeThenable<boolean>,
@@ -223,7 +223,7 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
   getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
-  usesSegments(): boolean,
+  usesMatcher(matcherType: string): boolean,
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
@@ -240,7 +240,7 @@ export interface ISplitsCacheAsync extends ISplitsCacheBase {
   getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
-  usesSegments(): Promise<boolean>,
+  usesMatcher(matcherType: string): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
@@ -477,7 +477,9 @@ export interface IStorageSync extends IStorageBase<
   IEventsCacheSync,
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
-> { }
+> {
+  largeSegments?: ISegmentsCacheSync,
+}
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,

package/src/sync/polling/pollingManagerCS.ts

@@ -6,8 +6,9 @@ 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_SMART_PAUSING, POLLING_START, POLLING_STOP } from '../../logger/constants';
+import { 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.
@@ -22,62 +23,95 @@ export function pollingManagerCSFactory(
 
   const splitsSyncTask = splitsSyncTaskFactory(splitApi.fetchSplitChanges, storage, readiness, settings, true);
 
-  // Map of matching keys to their corresponding MySegmentsSyncTask.
-  const mySegmentsSyncTasks: Record<string, IMySegmentsSyncTask> = {};
+  // Map of matching keys to their corresponding MySegmentsSyncTask for segments and large segments.
+  const mySegmentsSyncTasks: Record<string, { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }> = {};
 
   const matchingKey = getMatching(settings.core.key);
-  const mySegmentsSyncTask = add(matchingKey, readiness, storage);
+  const { msSyncTask, mlsSyncTask } = add(matchingKey, readiness, storage);
 
   function startMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-      mySegmentsSyncTask.start();
+    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();
+
+      if (mlsSyncTask) {
+        if (splitsHaveLargeSegments) mlsSyncTask.start();
+        else mlsSyncTask.stop();
+      }
     });
   }
 
   function stopMySegmentsSyncTasks() {
-    forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-      if (mySegmentsSyncTask.isRunning()) mySegmentsSyncTask.stop();
+    forOwn(mySegmentsSyncTasks, ({ msSyncTask, mlsSyncTask }) => {
+      msSyncTask.stop();
+      mlsSyncTask && mlsSyncTask.stop();
     });
   }
 
   // smart pausing
   readiness.splits.on(SDK_SPLITS_ARRIVED, () => {
-    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();
-      }
-    }
+    // smart pausing of mySegments polling
+    if (splitsSyncTask.isRunning()) startMySegmentsSyncTasks();
   });
 
   function add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync) {
-    const mySegmentsSyncTask = mySegmentsSyncTaskFactory(splitApi.fetchMySegments, storage, readiness, settings, matchingKey);
+    const msSyncTask = mySegmentsSyncTaskFactory(
+      splitApi.fetchMySegments,
+      storage.segments,
+      () => {
+        if (storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      },
+      settings,
+      matchingKey,
+      settings.scheduler.segmentsRefreshRate
+    );
+
+    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
+      );
+    }
 
     // smart ready
     function smartReady() {
-      if (!readiness.isReady() && !storage.splits.usesSegments()) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+      if (!readiness.isReady()) {
+        if (!storage.splits.usesMatcher(IN_SEGMENT)) readiness.segments.emit(SDK_SEGMENTS_ARRIVED);
+        if (readiness.largeSegments && !storage.splits.usesMatcher(IN_LARGE_SEGMENT)) readiness.largeSegments.emit(SDK_SEGMENTS_ARRIVED);
+      }
     }
-    if (!storage.splits.usesSegments()) setTimeout(smartReady, 0);
+    if (!storage.splits.usesMatcher(IN_SEGMENT) && !storage.splits.usesMatcher(IN_LARGE_SEGMENT)) setTimeout(smartReady, 0);
     else readiness.splits.once(SDK_SPLITS_ARRIVED, smartReady);
 
-    mySegmentsSyncTasks[matchingKey] = mySegmentsSyncTask;
-    return mySegmentsSyncTask;
+    mySegmentsSyncTasks[matchingKey] = { msSyncTask: msSyncTask, mlsSyncTask: mlsSyncTask };
+
+    return {
+      msSyncTask,
+      mlsSyncTask
+    };
   }
 
   return {
     splitsSyncTask,
-    segmentsSyncTask: mySegmentsSyncTask,
+    segmentsSyncTask: msSyncTask,
+    largeSegmentsSyncTask: mlsSyncTask,
 
     // Start periodic fetching (polling)
     start() {
       log.info(POLLING_START);
 
       splitsSyncTask.start();
-      if (storage.splits.usesSegments()) startMySegmentsSyncTasks();
+      startMySegmentsSyncTasks();
     },
 
     // Stop periodic fetching (polling)
@@ -94,8 +128,9 @@ export function pollingManagerCSFactory(
     // fetch splits and segments
     syncAll() {
       const promises = [splitsSyncTask.execute()];
-      forOwn(mySegmentsSyncTasks, function (mySegmentsSyncTask) {
-        promises.push(mySegmentsSyncTask.execute());
+      forOwn(mySegmentsSyncTasks, function ({ msSyncTask, mlsSyncTask }) {
+        promises.push(msSyncTask.execute());
+        mlsSyncTask && promises.push(mlsSyncTask.execute());
       });
       return Promise.all(promises);
     },

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

@@ -1,5 +1,4 @@
-import { IStorageSync } from '../../../storages/types';
-import { IReadinessManager } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/types';
 import { syncTaskFactory } from '../../syncTask';
 import { IMySegmentsSyncTask } from '../types';
 import { IFetchMySegments } from '../../../services/types';
@@ -12,24 +11,24 @@ import { mySegmentsUpdaterFactory } from '../updaters/mySegmentsUpdater';
  */
 export function mySegmentsSyncTaskFactory(
   fetchMySegments: IFetchMySegments,
-  storage: IStorageSync,
-  readiness: IReadinessManager,
+  mySegmentsCache: ISegmentsCacheSync,
+  notifyUpdate: () => void,
   settings: ISettings,
-  matchingKey: string
+  matchingKey: string,
+  segmentsRefreshRate: number
 ): IMySegmentsSyncTask {
   return syncTaskFactory(
     settings.log,
     mySegmentsUpdaterFactory(
       settings.log,
       mySegmentsFetcherFactory(fetchMySegments),
-      storage.splits,
-      storage.segments,
-      readiness.segments,
+      mySegmentsCache,
+      notifyUpdate,
       settings.startup.requestTimeoutBeforeReady,
       settings.startup.retriesOnFailureBeforeReady,
       matchingKey
     ),
-    settings.scheduler.segmentsRefreshRate,
+    segmentsRefreshRate,
     'mySegmentsUpdater',
   );
 }

package/src/sync/polling/types.ts

@@ -14,19 +14,20 @@ export type MySegmentsData = string[] | {
   add: boolean
 }
 
-export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
+export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean, delay?: number], boolean> { }
 
 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): IMySegmentsSyncTask
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
   remove(matchingKey: string): void;
-  get(matchingKey: string): IMySegmentsSyncTask | undefined
+  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
 }

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

@@ -1,13 +1,11 @@
 import { IMySegmentsFetcher } from '../fetchers/types';
-import { ISegmentsCacheSync, ISplitsCacheSync } from '../../../storages/types';
-import { ISegmentsEventEmitter } from '../../../readiness/types';
+import { ISegmentsCacheSync } from '../../../storages/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';
 
-type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise<boolean>
+type IMySegmentsUpdater = (segmentList?: MySegmentsData, noCache?: boolean) => Promise<boolean>
 
 /**
  * factory of MySegments updater, a task that:
@@ -18,9 +16,8 @@ type IMySegmentsUpdater = (segmentList?: string[], noCache?: boolean) => Promise
 export function mySegmentsUpdaterFactory(
   log: ILogger,
   mySegmentsFetcher: IMySegmentsFetcher,
-  splitsCache: ISplitsCacheSync,
   mySegmentsCache: ISegmentsCacheSync,
-  segmentsEventEmitter: ISegmentsEventEmitter,
+  notifyUpdate: () => void,
   requestTimeoutBeforeReady: number,
   retriesOnFailureBeforeReady: number,
   matchingKey: string
@@ -55,9 +52,9 @@ export function mySegmentsUpdaterFactory(
     }
 
     // Notify update if required
-    if (splitsCache.usesSegments() && (shouldNotifyUpdate || readyOnAlreadyExistentState)) {
+    if (shouldNotifyUpdate || readyOnAlreadyExistentState) {
       readyOnAlreadyExistentState = false;
-      segmentsEventEmitter.emit(SDK_SEGMENTS_ARRIVED);
+      notifyUpdate();
     }
   }
 
@@ -97,8 +94,14 @@ export function mySegmentsUpdaterFactory(
    *  (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
    */
-  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean) {
-    return _mySegmentsUpdater(0, segmentsData, noCache);
+  return function mySegmentsUpdater(segmentsData?: MySegmentsData, noCache?: boolean, delay?: number) {
+    return delay ?
+      new Promise(res => {
+        setTimeout(() => {
+          _mySegmentsUpdater(0, segmentsData, noCache).then(res);
+        }, delay);
+      }) :
+      _mySegmentsUpdater(0, segmentsData, noCache);
   };
 
 }

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

@@ -8,6 +8,7 @@ import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED } from '../../../readiness/
 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';
+import { IN_SEGMENT } from '../../../utils/constants';
 
 type ISplitChangesUpdater = (noCache?: boolean, till?: number, splitUpdateNotification?: { payload: ISplit, changeNumber: number }) => Promise<boolean>
 
@@ -33,7 +34,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
     const matchers = conditions[i].matcherGroup.matchers;
 
     matchers.forEach(matcher => {
-      if (matcher.matcherType === 'IN_SEGMENT') segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
+      if (matcher.matcherType === IN_SEGMENT) segments.add(matcher.userDefinedSegmentMatcherData.segmentName);
     });
   }
 
@@ -54,7 +55,7 @@ interface ISplitMutations {
  * @param filters splitFiltersValidation bySet | byName
  */
 function matchFilters(featureFlag: ISplit, filters: ISplitFiltersValidation) {
-  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter} = filters.groupedFilters;
+  const { bySet: setsFilter, byName: namesFilter, byPrefix: prefixFilter } = filters.groupedFilters;
   if (setsFilter.length > 0) return featureFlag.sets && featureFlag.sets.some((featureFlagSet: string) => setsFilter.indexOf(featureFlagSet) > -1);
 
   const namesFilterConfigured = namesFilter.length > 0;
@@ -129,7 +130,7 @@ export function splitChangesUpdaterFactory(
 
   /** Returns true if at least one split was updated */
   function isThereUpdate(flagsChange: [boolean | void, void | boolean[], void | boolean[], boolean | void] | [any, any, any]) {
-    const [, added, removed, ] = flagsChange;
+    const [, added, removed] = flagsChange;
     // There is at least one added or modified feature flag
     if (added && added.some((update: boolean) => update)) return true;
     // There is at least one removed feature flag

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

@@ -1,6 +1,6 @@
 import { errorParser, messageParser } from './NotificationParser';
 import { notificationKeeperFactory } from './NotificationKeeper';
-import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE } from '../constants';
+import { PUSH_RETRYABLE_ERROR, PUSH_NONRETRYABLE_ERROR, OCCUPANCY, CONTROL, MY_SEGMENTS_UPDATE, MY_SEGMENTS_UPDATE_V2, SEGMENT_UPDATE, SPLIT_KILL, SPLIT_UPDATE, MY_LARGE_SEGMENTS_UPDATE } from '../constants';
 import { IPushEventEmitter } from '../types';
 import { ISseEventHandler } from '../SSEClient/types';
 import { INotificationError, INotificationMessage } from './types';
@@ -83,6 +83,7 @@ export function SSEHandlerFactory(log: ILogger, pushEmitter: IPushEventEmitter,
         case SPLIT_UPDATE:
         case SEGMENT_UPDATE:
         case MY_SEGMENTS_UPDATE_V2:
+        case MY_LARGE_SEGMENTS_UPDATE:
         case SPLIT_KILL:
           pushEmitter.emit(parsedData.type, parsedData);
           break;