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

package/src/services/splitHttpClient.ts

@@ -12,7 +12,7 @@ const messageNoFetch = 'Global fetch API is not available.';
  * @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 function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient {
+export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient {
 
   const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
   const options = getOptions && getOptions(settings);

package/src/services/types.ts

@@ -39,7 +39,7 @@ export type IFetchSplitChanges = (since: number, noCache?: boolean, till?: numbe
 
 export type IFetchSegmentChanges = (since: number, segmentName: string, noCache?: boolean, till?: number) => Promise<IResponse>
 
-export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
+export type IFetchMemberships = (userMatchingKey: string, noCache?: boolean) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
@@ -61,8 +61,7 @@ export interface ISplitApi {
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
-	fetchMySegments: IFetchMySegments
-	fetchMyLargeSegments: IFetchMySegments
+	fetchMemberships: IFetchMemberships
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
 	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -1,5 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable no-unused-vars */
+import { IMySegmentsResponse } from '../dtos/types';
+import { MySegmentsData } from '../sync/polling/types';
 import { ISegmentsCacheSync } from './types';
 
 /**
@@ -28,7 +30,9 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   /**
    * clear the cache.
    */
-  abstract clear(): void
+  clear() {
+    this.resetSegments({});
+  }
 
   /**
    * 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.
@@ -49,20 +53,57 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   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 { return true; }
-
-  /**
-   * 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 { return -1; }
+  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 { return true; }
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean {
+    this.setChangeNumber(undefined, segmentsData.cn);
+
+    const { added, removed } = segmentsData as MySegmentsData;
+
+    if (added && removed) {
+      let isDiff = false;
+
+      added.forEach(segment => {
+        isDiff = this.addToSegment(segment) || isDiff;
+      });
+
+      removed.forEach(segment => {
+        isDiff = this.removeFromSegment(segment) || isDiff;
+      });
+
+      return isDiff;
+    }
+
+    const names = ((segmentsData as IMySegmentsResponse).k || []).map(s => s.n).sort();
+    const storedSegmentKeys = this.getRegisteredSegments().sort();
+
+    // Extreme fast => everything is empty
+    if (!names.length && !storedSegmentKeys.length) return false;
+
+    let index = 0;
+
+    while (index < names.length && index < storedSegmentKeys.length && names[index] === storedSegmentKeys[index]) index++;
+
+    // Quick path => no changes
+    if (index === names.length && index === storedSegmentKeys.length) return false;
+
+    // Slowest path => add and/or remove segments
+    for (let removeIndex = index; removeIndex < storedSegmentKeys.length; removeIndex++) {
+      this.removeFromSegment(storedSegmentKeys[removeIndex]);
+    }
+
+    for (let addIndex = index; addIndex < names.length; addIndex++) {
+      this.addToSegment(names[addIndex]);
+    }
+
+    return true;
+  }
 }

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -22,9 +22,9 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
   abstract trafficTypeExists(trafficType: string): Promise<boolean>
   abstract clear(): Promise<boolean | void>
 
-  // @TODO revisit segment-related methods ('usesMatcher', 'getRegisteredSegments', 'registerSegments')
+  // @TODO revisit segment-related methods ('usesSegments', 'getRegisteredSegments', 'registerSegments')
   // noop, just keeping the interface. This is used by standalone client-side API only, and so only implemented by InMemory and InLocalStorage.
-  usesMatcher(): Promise<boolean> {
+  usesSegments(): Promise<boolean> {
     return Promise.resolve(true);
   }
 

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
@@ -31,7 +32,7 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
     return splits;
   }
 
-  abstract setChangeNumber(changeNumber: number): boolean
+  abstract setChangeNumber(changeNumber: number): boolean | void
 
   abstract getChangeNumber(): number
 
@@ -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/dataLoader.ts

@@ -50,6 +50,6 @@ export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoa
         return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
       });
     }
-    storage.segments.resetSegments(mySegmentsData);
+    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
   };
 }

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';
@@ -15,22 +16,11 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     // There is not need to flush segments cache like splits cache, since resetSegments receives the up-to-date list of active segments
   }
 
-  /**
-   * Removes list of segments from localStorage
-   * @NOTE this method is not being used at the moment.
-   */
-  clear() {
-    this.log.info(LOG_PREFIX + 'Flushing MySegments data from localStorage');
-
-    // We cannot simply call `localStorage.clear()` since that implies removing user items from the storage
-    // We could optimize next sentence, since it implies iterating over all localStorage items
-    this.resetSegments([]);
-  }
-
   addToSegment(name: string): boolean {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) === DEFINED) return false;
       localStorage.setItem(segmentKey, DEFINED);
       return true;
     } catch (e) {
@@ -43,6 +33,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     const segmentKey = this.keys.buildSegmentNameKey(name);
 
     try {
+      if (localStorage.getItem(segmentKey) !== DEFINED) return false;
       localStorage.removeItem(segmentKey);
       return true;
     } catch (e) {
@@ -55,31 +46,22 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  /**
-   * 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 {
-    let isDiff = false;
-    let index;
-
+  getRegisteredSegments(): string[] {
     // Scan current values from localStorage
-    const storedSegmentNames = Object.keys(localStorage).reduce((accum, key) => {
+    return Object.keys(localStorage).reduce((accum, key) => {
       let segmentName = this.keys.extractSegmentName(key);
 
       if (segmentName) {
         accum.push(segmentName);
       } else {
-        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block
         segmentName = this.keys.extractOldSegmentKey(key);
 
         if (segmentName) { // this was an old segment key, let's clean up.
           const newSegmentKey = this.keys.buildSegmentNameKey(segmentName);
           try {
             // If the new format key is not there, create it.
-            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
+            if (!localStorage.getItem(newSegmentKey)) {
               localStorage.setItem(newSegmentKey, DEFINED);
               // we are migrating a segment, let's track it.
               accum.push(segmentName);
@@ -93,44 +75,32 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
       return accum;
     }, [] as string[]);
+  }
 
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentNames.length === names.length)
-      return isDiff;
+  getKeysCount() {
+    return 1;
+  }
 
-    // Quick path
-    if (storedSegmentNames.length !== names.length) {
-      isDiff = true;
+  setChangeNumber(name?: string, changeNumber?: number) {
+    try {
+      if (changeNumber) localStorage.setItem(this.keys.buildTillKey(), changeNumber + '');
+      else localStorage.removeItem(this.keys.buildTillKey());
+    } catch (e) {
+      this.log.error(e);
+    }
+  }
 
-      storedSegmentNames.forEach(name => this.removeFromSegment(name));
-      names.forEach(name => this.addToSegment(name));
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && storedSegmentNames.indexOf(names[index]) !== -1; index++) {
-        // TODO: why empty statement?
-      }
+  getChangeNumber() {
+    const n = -1;
+    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
 
-      if (index < names.length) {
-        isDiff = true;
+    if (value !== null) {
+      value = parseInt(value, 10);
 
-        storedSegmentNames.forEach(name => this.removeFromSegment(name));
-        names.forEach(name => this.addToSegment(name));
-      }
+      return isNaNNumber(value) ? n : value;
     }
 
-    return isDiff;
-  }
-
-  getRegisteredSegments(): string[] {
-    return Object.keys(localStorage).reduce<string[]>((accum, key) => {
-      const segmentName = this.keys.extractSegmentName(key);
-      if (segmentName) accum.push(segmentName);
-      return accum;
-    }, []);
-  }
-
-  getKeysCount() {
-    return 1;
+    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,18 +7,19 @@ import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
 export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private segmentCache: Record<string, boolean> = {};
-
-  clear() {
-    this.segmentCache = {};
-  }
+  private cn?: number;
 
   addToSegment(name: string): boolean {
+    if (this.segmentCache[name]) return false;
+
     this.segmentCache[name] = true;
 
     return true;
   }
 
   removeFromSegment(name: string): boolean {
+    if (!this.segmentCache[name]) return false;
+
     delete this.segmentCache[name];
 
     return true;
@@ -28,48 +29,13 @@ export class MySegmentsCacheInMemory extends AbstractSegmentsCacheSync {
     return this.segmentCache[name] === true;
   }
 
-  /**
-   * 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 {
-    let isDiff = false;
-    let index;
-
-    const storedSegmentKeys = Object.keys(this.segmentCache);
 
-    // Extreme fast => everything is empty
-    if (names.length === 0 && storedSegmentKeys.length === names.length)
-      return isDiff;
-
-    // Quick path
-    if (storedSegmentKeys.length !== names.length) {
-      isDiff = true;
-
-      this.segmentCache = {};
-      names.forEach(s => {
-        this.addToSegment(s);
-      });
-    } else {
-      // Slowest path => we need to find at least 1 difference because
-      for (index = 0; index < names.length && this.isInSegment(names[index]); index++) {
-        // TODO: why empty statement?
-      }
-
-      if (index < names.length) {
-        isDiff = true;
-
-        this.segmentCache = {};
-        names.forEach(s => {
-          this.addToSegment(s);
-        });
-      }
-    }
+  setChangeNumber(name?: string, changeNumber?: number) {
+    this.cn = changeNumber;
+  }
 
-    return isDiff;
+  getChangeNumber() {
+    return this.cn || -1;
   }
 
   getRegisteredSegments() {

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

@@ -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';
@@ -204,8 +205,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>,
@@ -218,12 +219,12 @@ 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[],
   trafficTypeExists(trafficType: string): boolean,
-  usesMatcher(matcherType: string): boolean,
+  usesSegments(): boolean,
   clear(): void,
   checkCache(): boolean,
   killLocally(name: string, defaultTreatment: string, changeNumber: number): boolean,
@@ -240,7 +241,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>,
@@ -268,9 +269,9 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
   registerSegments(names: string[]): boolean
   getRegisteredSegments(): string[]
   getKeysCount(): number // only used for telemetry
-  setChangeNumber(name: string, changeNumber: number): boolean
+  setChangeNumber(name: string, changeNumber: number): boolean | void
   getChangeNumber(name: string): number
-  resetSegments(names: string[]): boolean // only for Sync Client-Side
+  resetSegments(segmentsData: MySegmentsData | IMySegmentsResponse): boolean // only for Sync Client-Side
   clear(): void
 }
 
@@ -478,6 +479,7 @@ export interface IStorageSync extends IStorageBase<
   ITelemetryCacheSync,
   IUniqueKeysCacheSync
 > {
+  // Defined in client-side
   largeSegments?: ISegmentsCacheSync,
 }