@splitsoftware/splitio-commons 1.17.0 → 1.17.1-rc.1

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -9,11 +9,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING, LOG_PREFIX_CLIENT_INSTANTIATION } from '../logger/constants';
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
-
-function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
-  // @ts-ignore
-  return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
-}
+import { buildInstanceId } from './identity';
 
 /**
  * Factory of client method for the client-side (browser) variant of the Isomorphic JS SDK,
@@ -21,7 +17,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 { clients, storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
@@ -34,8 +30,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
-  clientInstances[defaultInstanceId] = mainClientInstance;
+  clients[defaultInstanceId] = mainClientInstance;
 
   return function client(key?: SplitIO.SplitKey, trafficType?: string) {
     if (key === undefined) {
@@ -58,10 +53,10 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
     }
     const instanceId = buildInstanceId(validKey, validTrafficType);
 
-    if (!clientInstances[instanceId]) {
+    if (!clients[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();
@@ -80,13 +75,12 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
-      clientInstances[instanceId] = clientCSDecorator(
+      clients[instanceId] = clientCSDecorator(
         log,
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
-          signalListener: undefined, // only the main client "destroy" method stops the signal listener
         }), true) as SplitIO.IClient,
         validKey,
         validTrafficType
@@ -99,6 +93,6 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
       log.debug(RETRIEVE_CLIENT_EXISTING);
     }
 
-    return clientInstances[instanceId];
+    return clients[instanceId] as SplitIO.ICsClient;
   };
 }

package/src/sdkFactory/index.ts

@@ -3,7 +3,7 @@ import { sdkReadinessManagerFactory } from '../readiness/sdkReadinessManager';
 import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
-import { SplitIO } from '../types';
+import { IBasicClient, SplitIO } from '../types';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
 import { createLoggerAPI } from '../logger/sdkLogger';
 import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
@@ -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({
@@ -48,7 +48,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     },
   });
   // @TODO add support for dataloader: `if (params.dataLoader) params.dataLoader(storage);`
-
+  const clients: Record<string, IBasicClient> = {};
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage, telemetryTracker });
 
@@ -73,7 +73,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { clients, splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;
@@ -105,5 +105,9 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     Logger: createLoggerAPI(log),
 
     settings,
+
+    destroy() {
+      return Promise.all(Object.keys(clients).map(key => clients[key].destroy())).then(() => {});
+    }
   }, extraProps && extraProps(ctx));
 }

package/src/sdkFactory/types.ts

@@ -8,7 +8,7 @@ import { IStorageAsync, IStorageSync, IStorageFactoryParams } from '../storages/
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter } from '../types';
+import { SplitIO, ISettings, IEventEmitter, IBasicClient } from '../types';
 
 /**
  * Environment related dependencies.
@@ -49,6 +49,7 @@ export interface ISdkFactoryContext {
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
+  clients: Record<string, IBasicClient>,
 }
 
 export interface ISdkFactoryContextSync extends ISdkFactoryContext {

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();
         }
       };
     },