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

package/src/readiness/readinessManager.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { SDK_SPLITS_ARRIVED, SDK_SPLITS_CACHE_LOADED, SDK_SEGMENTS_ARRIVED, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE, SDK_READY } from './constants';
 import { IReadinessEventEmitter, IReadinessManager, ISegmentsEventEmitter, ISplitsEventEmitter } from './types';
 
@@ -10,7 +10,7 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   });
 
   // `isSplitKill` condition avoids an edge-case of wrongly emitting SDK_READY if:
-  // - `/mySegments` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
+  // - `/memberships` fetch and SPLIT_KILL occurs before `/splitChanges` fetch, and
   // - storage has cached splits (for which case `splitsStorage.killLocally` can return true)
   splitsEventEmitter.on(SDK_SPLITS_ARRIVED, (isSplitKill: boolean) => { if (!isSplitKill) splitsEventEmitter.splitsArrived = true; });
   splitsEventEmitter.once(SDK_SPLITS_CACHE_LOADED, () => { splitsEventEmitter.splitsCacheLoaded = true; });
@@ -33,9 +33,11 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISe
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  readyTimeout = 0,
+  settings: ISettings,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
+  const readyTimeout = settings.startup.readyTimeout;
+
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
   const gate: IReadinessEventEmitter = new EventEmitter();
 
@@ -118,9 +120,9 @@ export function readinessManagerFactory(
     segments,
     gate,
 
-    shared(readyTimeout = 0) {
+    shared() {
       refCount++;
-      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
+      return readinessManagerFactory(EventEmitter, settings, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked

package/src/readiness/sdkReadinessManager.ts

@@ -2,9 +2,8 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter } from '../types';
+import { IEventEmitter, ISettings } from '../types';
 import { SDK_READY, SDK_READY_TIMED_OUT, SDK_READY_FROM_CACHE, SDK_UPDATE } from './constants';
-import { ILogger } from '../logger/types';
 import { ERROR_CLIENT_LISTENER, CLIENT_READY_FROM_CACHE, CLIENT_READY, CLIENT_NO_LISTENER } from '../logger/constants';
 
 const NEW_LISTENER_EVENT = 'newListener';
@@ -18,10 +17,11 @@ const REMOVE_LISTENER_EVENT = 'removeListener';
  * @param readinessManager optional readinessManager to use. only used internally for `shared` method
  */
 export function sdkReadinessManagerFactory(
-  log: ILogger,
   EventEmitter: new () => IEventEmitter,
-  readyTimeout = 0,
-  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
+  settings: ISettings,
+  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
+
+  const log = settings.log;
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared(readyTimeout = 0) {
-      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
+    shared() {
+      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
     },
 
     incInternalReadyCbCount() {

package/src/readiness/types.ts

@@ -61,7 +61,7 @@ export interface IReadinessManager {
   destroy(): void,
 
   /** for client-side */
-  shared(readyTimeout?: number): IReadinessManager,
+  shared(): IReadinessManager,
 }
 
 /** SDK readiness manager */
@@ -77,5 +77,5 @@ export interface ISdkReadinessManager {
   incInternalReadyCbCount(): void
 
   /** for client-side */
-  shared(readyTimeout?: number): ISdkReadinessManager
+  shared(): ISdkReadinessManager
 }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -19,7 +19,7 @@ function buildInstanceId(key: SplitIO.SplitKey) {
  * Therefore, clients don't have a bound TT for the track method.
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
-  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -51,7 +51,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
+      const sharedSdkReadiness = sdkReadinessManager.shared();
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -21,7 +21,7 @@ function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
  * (default client) or the client method (shared clients).
  */
 export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
-  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -61,7 +61,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     if (!clientInstances[instanceId]) {
       const matchingKey = getMatching(validKey);
 
-      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
+      const sharedSdkReadiness = sdkReadinessManager.shared();
       const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
         if (err) {
           sharedSdkReadiness.readinessManager.timeout();

package/src/sdkFactory/index.ts

@@ -32,7 +32,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   // We will just log and allow for the SDK to end up throwing an SDK_TIMEOUT event for devs to handle.
   validateAndTrackApiKey(log, settings.core.authorizationKey);
 
-  const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
+  const sdkReadinessManager = sdkReadinessManagerFactory(platform.EventEmitter, settings);
   const readiness = sdkReadinessManager.readinessManager;
 
   const storage = storageFactory({

package/src/services/splitApi.ts

@@ -4,7 +4,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MEMBERSHIPS } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -22,7 +22,7 @@ function userKeyToQueryParam(userKey: string) {
  */
 export function splitApiFactory(
   settings: ISettings,
-  platform: IPlatform,
+  platform: Pick<IPlatform, 'getOptions' | 'getFetch'>,
   telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
@@ -67,15 +67,15 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMySegments(userMatchingKey: string, noCache?: boolean) {
+    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
       /**
        * URI encoding of user keys in order to:
-       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
-       *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
+       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
+       *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
-      const url = `${urls.sdk}/mySegments/${encodeURIComponent(userMatchingKey)}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
+      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
     },
 
     /**

package/src/services/splitHttpClient.ts

@@ -13,7 +13,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, till?: number) => Promise<IResponse>
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
@@ -61,7 +61,7 @@ export interface ISplitApi {
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
-	fetchMySegments: 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/AbstractSplitsCacheSync.ts

@@ -2,7 +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 } from '../utils/constants';
+import { IN_SEGMENT, IN_LARGE_SEGMENT } from '../utils/constants';
 
 /**
  * This class provides a skeletal implementation of the ISplitsCacheSync interface
@@ -32,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
 
@@ -94,7 +94,8 @@ export function usesSegments(split: ISplit) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     for (let j = 0; j < matchers.length; j++) {
-      if (matchers[j].matcherType === IN_SEGMENT) return true;
+      const matcher = matchers[j].matcherType;
+      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
     }
   }
 

package/src/storages/KeyBuilderCS.ts

@@ -1,7 +1,14 @@
 import { startsWith } from '../utils/lang';
 import { KeyBuilder } from './KeyBuilder';
 
-export class KeyBuilderCS extends KeyBuilder {
+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 {
 
   protected readonly regexSplitsCacheKey: RegExp;
   protected readonly matchingKey: string;
@@ -26,10 +33,6 @@ export class KeyBuilderCS extends KeyBuilder {
       return builtSegmentKeyName.substr(prefix.length);
   }
 
-  // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
-  buildOldSegmentNameKey(segmentName: string) {
-    return `${this.matchingKey}.${this.prefix}.segment.${segmentName}`;
-  }
   // @BREAKING: The key used to start with the matching key instead of the prefix, this was changed on version 10.17.3
   extractOldSegmentKey(builtSegmentKeyName: string) {
     const prefix = `${this.matchingKey}.${this.prefix}.segment.`;
@@ -45,4 +48,30 @@ export class KeyBuilderCS extends KeyBuilder {
   isSplitsCacheKey(key: string) {
     return this.regexSplitsCacheKey.test(key);
   }
+
+  buildTillKey() {
+    return `${this.prefix}.${this.matchingKey}.segments.till`;
+  }
+}
+
+export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string): MySegmentsKeyBuilder {
+  return {
+    buildSegmentNameKey(segmentName: string) {
+      return `${prefix}.${matchingKey}.largeSegment.${segmentName}`;
+    },
+
+    extractSegmentName(builtSegmentKeyName: string) {
+      const p = `${prefix}.${matchingKey}.largeSegment.`;
+
+      if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
+    },
+
+    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,36 +1,26 @@
 import { ILogger } from '../../logger/types';
+import { isNaNNumber } from '../../utils/lang';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import { KeyBuilderCS } from '../KeyBuilderCS';
+import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 
 export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
-  private readonly keys: KeyBuilderCS;
+  private readonly keys: MySegmentsKeyBuilder;
   private readonly log: ILogger;
 
-  constructor(log: ILogger, keys: KeyBuilderCS) {
+  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
     super();
     this.log = log;
     this.keys = keys;
     // 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/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();
         }
       };
     },