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

package/src/storages/AbstractSplitsCacheSync.ts

@@ -2,6 +2,7 @@ import { ISplitsCacheSync } from './types';
 import { ISplit } from '../dtos/types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ISet } from '../utils/lang/sets';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -43,7 +44,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract trafficTypeExists(trafficType: string): boolean
 
-  abstract usesMatcher(matcherType: string): boolean
+  abstract usesSegments(): boolean
 
   abstract clear(): void
 
@@ -85,15 +86,16 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
 /**
  * Given a parsed split, it returns a boolean flagging if its conditions use segments matchers (rules & whitelists).
- * This util is intended to simplify the implementation of `splitsCache::usesMatcher` method
+ * This util is intended to simplify the implementation of `splitsCache::usesSegments` method
  */
-export function usesMatcher(split: ISplit, matcherType: string) {
+export function usesSegments(split: ISplit) {
   const conditions = split.conditions || [];
   for (let i = 0; i < conditions.length; i++) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     for (let j = 0; j < matchers.length; j++) {
-      if (matchers[j].matcherType === matcherType) return true;
+      const matcher = matchers[j].matcherType;
+      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
     }
   }
 

package/src/storages/KeyBuilder.ts

@@ -51,9 +51,6 @@ export class KeyBuilder {
   buildSplitsWithSegmentCountKey() {
     return `${this.prefix}.splits.usingSegments`;
   }
-  buildSplitsWithLargeSegmentCountKey() {
-    return `${this.prefix}.splits.usingLargeSegments`;
-  }
 
   buildSegmentNameKey(segmentName: string) {
     return `${this.prefix}.segment.${segmentName}`;

package/src/storages/KeyBuilderCS.ts

@@ -5,6 +5,7 @@ export interface MySegmentsKeyBuilder {
   buildSegmentNameKey(segmentName: string): string;
   extractSegmentName(builtSegmentKeyName: string): string | undefined;
   extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
+  buildTillKey(): string;
 }
 
 export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
@@ -47,6 +48,10 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
   isSplitsCacheKey(key: string) {
     return this.regexSplitsCacheKey.test(key);
   }
+
+  buildTillKey() {
+    return `${this.prefix}.${this.matchingKey}.segments.till`;
+  }
 }
 
 export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {
@@ -63,6 +68,10 @@ export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string):
 
     extractOldSegmentKey() {
       return undefined;
+    },
+
+    buildTillKey() {
+      return `${prefix}.${matchingKey}.largeSegments.till`;
     }
   };
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,4 +1,5 @@
 import { ILogger } from '../../logger/types';
+import { isNaNNumber } from '../../utils/lang';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
@@ -58,10 +59,20 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
   /**
    * Reset (update) the cached list of segments with the given list, removing and adding segments if necessary.
    *
-   * @param {string[]} segmentNames list of segment names
+   * @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 {
+  resetSegments(names: string[], changeNumber?: number): boolean {
+    try {
+      if (changeNumber) {
+        localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      } else {
+        localStorage.removeItem(this.keys.buildTillKey());
+      }
+    } catch (e) {
+      this.log.error(e);
+    }
+
     let isDiff = false;
     let index;
 
@@ -133,4 +144,17 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return 1;
   }
 
+  getChangeNumber() {
+    const n = -1;
+    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+
+    if (value !== null) {
+      value = parseInt(value, 10);
+
+      return isNaNNumber(value) ? n : value;
+    }
+
+    return n;
+  }
+
 }

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,5 +1,5 @@
 import { ISplit } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
@@ -7,7 +7,6 @@ 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.
@@ -51,15 +50,10 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
         this._decrementCount(ttKey);
 
-        if (usesMatcher(split, IN_SEGMENT)) {
+        if (usesSegments(split)) {
           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);
@@ -73,17 +67,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         // @ts-expect-error
         localStorage.setItem(ttKey, toNumber(localStorage.getItem(ttKey)) + 1);
 
-        if (usesMatcher(split, IN_SEGMENT)) {
+        if (usesSegments(split)) {
           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);
@@ -215,14 +203,11 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     return isFiniteNumber(ttCount) && ttCount > 0;
   }
 
-  usesMatcher(matcherType: string) {
+  usesSegments() {
     // If cache hasn't been synchronized with the cloud, assume we need them.
     if (!this.hasSync) return true;
 
-    const storedCount = localStorage.getItem(matcherType === IN_SEGMENT ?
-      this.keys.buildSplitsWithSegmentCountKey() :
-      this.keys.buildSplitsWithLargeSegmentCountKey()
-    );
+    const storedCount = localStorage.getItem(this.keys.buildSplitsWithSegmentCountKey());
     const splitsWithSegmentsCount = storedCount === null ? 0 : toNumber(storedCount);
 
     if (isFiniteNumber(splitsWithSegmentsCount)) {

package/src/storages/inMemory/MySegmentsCacheInMemory.ts

@@ -7,6 +7,7 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private segmentCache: Record<string, boolean> = {};
+  private cn?: number;
 
   clear() {
     this.segmentCache = {};
@@ -35,7 +36,8 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
    * @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 {
+  resetSegments(names: string[], changeNumber?: number): boolean {
+    this.cn = changeNumber;
     let isDiff = false;
     let index;
 
@@ -72,6 +74,10 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return isDiff;
   }
 
+  getChangeNumber() {
+    return this.cn || -1;
+  }
+
   getRegisteredSegments() {
     return Object.keys(this.segmentCache);
   }

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,8 +1,7 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
-import { AbstractSplitsCacheSync, usesMatcher } from '../AbstractSplitsCacheSync';
+import { AbstractSplitsCacheSync, usesSegments } 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.
@@ -15,7 +14,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private segmentsCount: number = 0;
-  private largeSegmentsCount: number = 0;
   private flagSetsCache: Record<string, ISet<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
@@ -28,7 +26,6 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.ttCache = {};
     this.changeNumber = -1;
     this.segmentsCount = 0;
-    this.largeSegmentsCount = 0;
   }
 
   addSplit(name: string, split: ISplit): boolean {
@@ -41,9 +38,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       this.removeFromFlagSets(previousSplit.name, previousSplit.sets);
 
-      // 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--;
+      // Subtract from segments count for the previous version of this Split
+      if (usesSegments(previousSplit)) this.segmentsCount--;
     }
 
     if (split) {
@@ -55,8 +51,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.addToFlagSets(split);
 
       // Add to segments count for the new version of the Split
-      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount++;
-      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount++;
+      if (usesSegments(split)) this.segmentsCount++;
 
       return true;
     } else {
@@ -76,8 +71,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       this.removeFromFlagSets(split.name, split.sets);
 
       // Update the segments count.
-      if (usesMatcher(split, IN_SEGMENT)) this.segmentsCount--;
-      if (usesMatcher(split, IN_LARGE_SEGMENT)) this.largeSegmentsCount--;
+      if (usesSegments(split)) this.segmentsCount--;
 
       return true;
     } else {
@@ -106,8 +100,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return isFiniteNumber(this.ttCache[trafficType]) && this.ttCache[trafficType] > 0;
   }
 
-  usesMatcher(matcherType: string): boolean {
-    return this.getChangeNumber() === -1 || (matcherType === IN_SEGMENT ? this.segmentsCount > 0 : this.largeSegmentsCount > 0);
+  usesSegments(): boolean {
+    return this.getChangeNumber() === -1 || this.segmentsCount > 0;
   }
 
   getNamesByFlagSets(flagSets: string[]): ISet<string>[] {

package/src/storages/types.ts

@@ -204,8 +204,8 @@ export interface ISplitsCacheBase {
   getSplitNames(): MaybeThenable<string[]>,
   // 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. Returns true if the storage is not synchronized yet (getChangeNumber() === 1) or contains a FF using the given matcher
-  usesMatcher(matcherType: string): MaybeThenable<boolean>,
+  // only for Client-Side. Returns true if the storage is not synchronized yet (getChangeNumber() === -1) or contains a FF using segments or large segments
+  usesSegments(): 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,
-  usesMatcher(matcherType: string): boolean,
+  usesSegments(): 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>,
-  usesMatcher(matcherType: string): Promise<boolean>,
+  usesSegments(): Promise<boolean>,
   clear(): Promise<boolean | void>,
   checkCache(): Promise<boolean>,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): Promise<boolean>,
@@ -270,7 +270,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   getKeysCount(): number // only used for telemetry
   setChangeNumber(name: string, changeNumber: number): boolean
   getChangeNumber(name: string): number
-  resetSegments(names: string[]): boolean // only for Sync Client-Side
+  resetSegments(names: string[], changeNumber?: number): boolean // only for Sync Client-Side
   clear(): void
 }
 
@@ -478,6 +478,7 @@ export interface IStorageSync extends IStorageBase<
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
 > {
+  // Defined in client-side
   largeSegments?: ISegmentsCacheSync,
 }
 

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

@@ -1,31 +1,24 @@
-import { IFetchMySegments, IResponse } from '../../../services/types';
-import { IMySegmentsResponse, IMyLargeSegmentsResponse } from '../../../dtos/types';
+import { IFetchMemberships, IResponse } from '../../../services/types';
+import { IMembershipsResponse } from '../../../dtos/types';
 import { IMySegmentsFetcher } from './types';
 
 /**
  * Factory of MySegments fetcher.
  * MySegments fetcher is a wrapper around `mySegments` API service that parses the response and handle errors.
  */
-export function mySegmentsFetcherFactory(fetchMySegments: IFetchMySegments): IMySegmentsFetcher {
+export function mySegmentsFetcherFactory(fetchMemberships: IFetchMemberships): IMySegmentsFetcher {
 
   return function mySegmentsFetcher(
     userMatchingKey: string,
     noCache?: boolean,
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchMemberships` promise, such as timeout or time tracker
     decorator?: (promise: Promise<IResponse>) => Promise<IResponse>
-  ): Promise<string[]> {
+  ): Promise<IMembershipsResponse> {
 
-    let mySegmentsPromise = fetchMySegments(userMatchingKey, noCache);
+    let mySegmentsPromise = fetchMemberships(userMatchingKey, noCache);
     if (decorator) mySegmentsPromise = decorator(mySegmentsPromise);
 
-    // Extract segment names
-    return mySegmentsPromise
-      .then(resp => resp.json())
-      .then((json: IMySegmentsResponse | IMyLargeSegmentsResponse) => {
-        return (json as IMySegmentsResponse).mySegments ?
-          (json as IMySegmentsResponse).mySegments.map((segment) => segment.name) :
-          (json as IMyLargeSegmentsResponse).myLargeSegments;
-      });
+    return mySegmentsPromise.then(resp => resp.json());
   };
 
 }

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

@@ -28,7 +28,7 @@ export function segmentChangesFetcherFactory(fetchSegmentChanges: IFetchSegmentC
     segmentName: string,
     noCache?: boolean,
     till?: number,
-    // Optional decorator for `fetchMySegments` promise, such as timeout or time tracker
+    // Optional decorator for `fetchSegmentChanges` promise, such as timeout or time tracker
     decorator?: (promise: Promise<ISegmentChangesResponse[]>) => Promise<ISegmentChangesResponse[]>
   ): Promise<ISegmentChangesResponse[]> {
 

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

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

package/src/sync/polling/pollingManagerCS.ts

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

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

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

package/src/sync/polling/types.ts

@@ -1,4 +1,4 @@
-import { ISplit } from '../../dtos/types';
+import { IMembershipsResponse, ISplit } from '../../dtos/types';
 import { IReadinessManager } from '../../readiness/types';
 import { IStorageSync } from '../../storages/types';
 import { ITask, ISyncTask } from '../types';
@@ -7,12 +7,14 @@ export interface ISplitsSyncTask extends ISyncTask<[noCache?: boolean, till?: nu
 
 export interface ISegmentsSyncTask extends ISyncTask<[fetchOnlyNew?: boolean, segmentName?: string, noCache?: boolean, till?: number], boolean> { }
 
-export type MySegmentsData = string[] | {
+export type MySegmentsData = IMembershipsResponse | {
+  /* segment type */
+  isLS?: boolean
   /* segment name */
-  name: string,
+  name: string
   /* action: `true` for add, and `false` for delete */
   add: boolean
-}
+}[]
 
 export interface IMySegmentsSyncTask extends ISyncTask<[segmentsData?: MySegmentsData, noCache?: boolean], boolean> { }
 
@@ -20,14 +22,13 @@ export interface IPollingManager extends ITask {
   syncAll(): Promise<any>
   splitsSyncTask: ISplitsSyncTask
   segmentsSyncTask: ISyncTask
-  largeSegmentsSyncTask?: ISyncTask
 }
 
 /**
  * PollingManager for client-side with support for multiple clients
  */
 export interface IPollingManagerCS extends IPollingManager {
-  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask }
+  add(matchingKey: string, readiness: IReadinessManager, storage: IStorageSync): IMySegmentsSyncTask
   remove(matchingKey: string): void;
-  get(matchingKey: string): { msSyncTask: IMySegmentsSyncTask, mlsSyncTask?: IMySegmentsSyncTask } | undefined
+  get(matchingKey: string): IMySegmentsSyncTask | undefined
 }