@splitsoftware/splitio-commons 1.16.1-rc.8 → 1.17.0-rc.0

package/src/readiness/readinessManager.ts

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } 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';
 
@@ -18,8 +18,10 @@ function splitsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISpli
   return splitsEventEmitter;
 }
 
-function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter, segmentsArrived = false): ISegmentsEventEmitter {
-  const segmentsEventEmitter = objectAssign(new EventEmitter(), { segmentsArrived });
+function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter): ISegmentsEventEmitter {
+  const segmentsEventEmitter = objectAssign(new EventEmitter(), {
+    segmentsArrived: false
+  });
 
   segmentsEventEmitter.once(SDK_SEGMENTS_ARRIVED, () => { segmentsEventEmitter.segmentsArrived = true; });
 
@@ -31,13 +33,10 @@ function segmentsEventEmitterFactory(EventEmitter: new () => IEventEmitter, segm
  */
 export function readinessManagerFactory(
   EventEmitter: new () => IEventEmitter,
-  settings: ISettings,
+  readyTimeout = 0,
   splits: ISplitsEventEmitter = splitsEventEmitterFactory(EventEmitter)): IReadinessManager {
 
-  const { startup: { readyTimeout, waitForLargeSegments }, sync: { largeSegmentsEnabled } } = settings;
-
   const segments: ISegmentsEventEmitter = segmentsEventEmitterFactory(EventEmitter);
-  const largeSegments = largeSegmentsEnabled ? segmentsEventEmitterFactory(EventEmitter, !waitForLargeSegments) : undefined;
   const gate: IReadinessEventEmitter = new EventEmitter();
 
   // emit SDK_READY_FROM_CACHE
@@ -63,7 +62,6 @@ export function readinessManagerFactory(
   let isReady = false;
   splits.on(SDK_SPLITS_ARRIVED, checkIsReadyOrUpdate);
   segments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
-  if (largeSegments) largeSegments.on(SDK_SEGMENTS_ARRIVED, checkIsReadyOrUpdate);
 
   let isDestroyed = false;
 
@@ -89,7 +87,7 @@ export function readinessManagerFactory(
         setTimeout(() => { throw e; }, 0);
       }
     } else {
-      if (splits.splitsArrived && segments.segmentsArrived && (!largeSegments || largeSegments.segmentsArrived)) {
+      if (splits.splitsArrived && segments.segmentsArrived) {
         clearTimeout(readyTimeoutId);
         isReady = true;
         try {
@@ -107,12 +105,11 @@ export function readinessManagerFactory(
   return {
     splits,
     segments,
-    largeSegments,
     gate,
 
-    shared() {
+    shared(readyTimeout = 0) {
       refCount++;
-      return readinessManagerFactory(EventEmitter, settings, splits);
+      return readinessManagerFactory(EventEmitter, readyTimeout, splits);
     },
 
     // @TODO review/remove next methods when non-recoverable errors are reworked
@@ -126,7 +123,6 @@ export function readinessManagerFactory(
       isDestroyed = true;
 
       segments.removeAllListeners();
-      if (largeSegments) largeSegments.removeAllListeners();
       gate.removeAllListeners();
       clearTimeout(readyTimeoutId);
 

package/src/readiness/sdkReadinessManager.ts

@@ -2,8 +2,9 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { promiseWrapper } from '../utils/promise/wrapper';
 import { readinessManagerFactory } from './readinessManager';
 import { ISdkReadinessManager } from './types';
-import { IEventEmitter, ISettings } from '../types';
+import { IEventEmitter } 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';
@@ -17,11 +18,10 @@ 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,
-  settings: ISettings,
-  readinessManager = readinessManagerFactory(EventEmitter, settings)): ISdkReadinessManager {
-
-  const log = settings.log;
+  readyTimeout = 0,
+  readinessManager = readinessManagerFactory(EventEmitter, readyTimeout)): ISdkReadinessManager {
 
   /** Ready callback warning */
   let internalReadyCbCount = 0;
@@ -72,8 +72,8 @@ export function sdkReadinessManagerFactory(
   return {
     readinessManager,
 
-    shared() {
-      return sdkReadinessManagerFactory(EventEmitter, settings, readinessManager.shared());
+    shared(readyTimeout = 0) {
+      return sdkReadinessManagerFactory(log, EventEmitter, readyTimeout, readinessManager.shared(readyTimeout));
     },
 
     incInternalReadyCbCount() {

package/src/readiness/types.ts

@@ -45,7 +45,6 @@ export interface IReadinessManager {
   /** Event emitters */
   splits: ISplitsEventEmitter,
   segments: ISegmentsEventEmitter,
-  largeSegments?: ISegmentsEventEmitter, // Undefined if largeSegmentsEnabled or waitForLargeSegments are false
   gate: IReadinessEventEmitter,
 
   /** Readiness status */
@@ -60,7 +59,7 @@ export interface IReadinessManager {
   destroy(): void,
 
   /** for client-side */
-  shared(): IReadinessManager,
+  shared(readyTimeout?: number): IReadinessManager,
 }
 
 /** SDK readiness manager */
@@ -76,5 +75,5 @@ export interface ISdkReadinessManager {
   incInternalReadyCbCount(): void
 
   /** for client-side */
-  shared(): ISdkReadinessManager
+  shared(readyTimeout?: number): 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 }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, 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();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       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 }, log } } = params;
+  const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, 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();
+      const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
       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(platform.EventEmitter, settings);
+  const sdkReadinessManager = sdkReadinessManagerFactory(log, platform.EventEmitter, settings.startup.readyTimeout);
   const readiness = sdkReadinessManager.readinessManager;
 
   const storage = storageFactory({

package/src/services/decorateHeaders.ts

@@ -0,0 +1,40 @@
+import { objectAssign } from '../utils/lang/objectAssign';
+import { _Set } from '../utils/lang/sets';
+import { ISettings } from '../types';
+
+const FORBIDDEN_HEADERS = new _Set([
+  'splitsdkversion',
+  'splitsdkmachineip',
+  'splitsdkmachinename',
+  'splitsdkimpressionsmode',
+  'host',
+  'referrer',
+  'content-type',
+  'content-length',
+  'content-encoding',
+  'accept',
+  'keep-alive',
+  'x-fastly-debug'
+]);
+
+function convertKeysToLowerCase(obj: Record<string, string>) {
+  return Object.keys(obj).reduce<Record<string, string>>((acc, key) => {
+    acc[key.toLowerCase()] = obj[key];
+    return acc;
+  }, {});
+}
+
+export function decorateHeaders(settings: ISettings, headers: Record<string, string>) {
+  if (settings.sync.requestOptions?.getHeaderOverrides) {
+    headers = convertKeysToLowerCase(headers);
+    try {
+      const headerOverrides = convertKeysToLowerCase(settings.sync.requestOptions.getHeaderOverrides({ headers: objectAssign({}, headers) }));
+      Object.keys(headerOverrides)
+        .filter(key => !FORBIDDEN_HEADERS.has(key))
+        .forEach(key => headers[key] = headerOverrides[key]);
+    } catch (e) {
+      settings.log.error('Problem adding custom headers to request decorator: ' + e);
+    }
+  }
+  return headers;
+}

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, MY_LARGE_SEGMENT } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } 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: Pick<IPlatform, 'getOptions' | 'getFetch'>,
+  platform: IPlatform,
   telemetryTracker: ITelemetryTracker
 ): ISplitApi {
 
@@ -78,11 +78,6 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
     },
 
-    fetchMyLargeSegments(userMatchingKey: string, noCache?: boolean) {
-      const url = `${urls.sdk}/myLargeSegments/${encodeURIComponent(userMatchingKey)}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_LARGE_SEGMENT));
-    },
-
     /**
      * Post events.
      *

package/src/services/splitHttpClient.ts

@@ -3,6 +3,7 @@ import { objectAssign } from '../utils/lang/objectAssign';
 import { ERROR_HTTP, ERROR_CLIENT_CANNOT_GET_READY } from '../logger/constants';
 import { ISettings } from '../types';
 import { IPlatform } from '../sdkFactory/types';
+import { decorateHeaders } from './decorateHeaders';
 
 const messageNoFetch = 'Global fetch API is not available.';
 
@@ -12,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 }: Pick<IPlatform, 'getOptions' | 'getFetch'>): ISplitHttpClient {
+export function splitHttpClientFactory(settings: ISettings, { getOptions, getFetch }: IPlatform): ISplitHttpClient {
 
   const { log, core: { authorizationKey }, version, runtime: { ip, hostname } } = settings;
   const options = getOptions && getOptions(settings);
@@ -21,20 +22,20 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
   // if fetch is not available, log Error
   if (!fetch) log.error(ERROR_CLIENT_CANNOT_GET_READY, [messageNoFetch]);
 
-  const headers: Record<string, string> = {
+  const commonHeaders: Record<string, string> = {
     'Accept': 'application/json',
     'Content-Type': 'application/json',
     'Authorization': `Bearer ${authorizationKey}`,
     'SplitSDKVersion': version
   };
 
-  if (ip) headers['SplitSDKMachineIP'] = ip;
-  if (hostname) headers['SplitSDKMachineName'] = hostname;
+  if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
+  if (hostname) commonHeaders['SplitSDKMachineName'] = hostname;
 
   return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
     const request = objectAssign({
-      headers: reqOpts.headers ? objectAssign({}, headers, reqOpts.headers) : headers,
+      headers: decorateHeaders(settings, objectAssign({}, commonHeaders, reqOpts.headers || {})),
       method: reqOpts.method || 'GET',
       body: reqOpts.body
     }, options);

package/src/services/types.ts

@@ -62,7 +62,6 @@ export interface ISplitApi {
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMySegments: IFetchMySegments
-	fetchMyLargeSegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
 	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs

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 } 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,15 @@ 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;
+      if (matchers[j].matcherType === IN_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

@@ -1,13 +1,7 @@
 import { startsWith } from '../utils/lang';
 import { KeyBuilder } from './KeyBuilder';
 
-export interface MySegmentsKeyBuilder {
-  buildSegmentNameKey(segmentName: string): string;
-  extractSegmentName(builtSegmentKeyName: string): string | undefined;
-  extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
-}
-
-export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
+export class KeyBuilderCS extends KeyBuilder {
 
   protected readonly regexSplitsCacheKey: RegExp;
   protected readonly matchingKey: string;
@@ -32,6 +26,10 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
       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.`;
@@ -48,21 +46,3 @@ export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
     return this.regexSplitsCacheKey.test(key);
   }
 }
-
-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;
-    }
-  };
-}

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,14 +1,14 @@
 import { ILogger } from '../../logger/types';
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import type { MySegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { LOG_PREFIX, DEFINED } from './constants';
 
 export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
-  private readonly keys: MySegmentsKeyBuilder;
+  private readonly keys: KeyBuilderCS;
   private readonly log: ILogger;
 
-  constructor(log: ILogger, keys: MySegmentsKeyBuilder) {
+  constructor(log: ILogger, keys: KeyBuilderCS) {
     super();
     this.log = log;
     this.keys = keys;

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/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, myLargeSegmentsKeyBuilder } from '../KeyBuilderCS';
+import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
 import { SplitsCacheInLocal } from './SplitsCacheInLocal';
 import { MySegmentsCacheInLocal } from './MySegmentsCacheInLocal';
@@ -38,17 +38,15 @@ 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);
+    const keys = new KeyBuilderCS(prefix, matchingKey as string);
     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),
@@ -58,7 +56,6 @@ 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();
@@ -67,11 +64,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, new KeyBuilderCS(prefix, matchingKey)),
-          largeSegments: new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey)),
+          segments: new MySegmentsCacheInLocal(log, childKeysBuilder),
           impressions: this.impressions,
           impressionCounts: this.impressionCounts,
           events: this.events,
@@ -80,7 +77,6 @@ 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,12 +18,10 @@ 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),
@@ -34,7 +32,6 @@ 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();
@@ -46,7 +43,6 @@ 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,
@@ -56,7 +52,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
         destroy() {
           this.splits = new SplitsCacheInMemory(__splitFiltersValidation);
           this.segments.clear();
-          this.largeSegments.clear();
         }
       };
     },