@splitsoftware/splitio-commons 1.17.1-rc.3 → 1.17.1-rc.5

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, MEMBERSHIPS } 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 {
 
@@ -67,15 +67,15 @@ export function splitApiFactory(
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SEGMENT));
     },
 
-    fetchMemberships(userMatchingKey: string, noCache?: boolean, till?: number) {
+    fetchMySegments(userMatchingKey: string, noCache?: boolean) {
       /**
        * URI encoding of user keys in order to:
-       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/memberships/%'
-       *  - avoid 404 responses. E.g.: '/api/memberships/foo/bar'
+       *  - avoid 400 responses (due to URI malformed). E.g.: '/api/mySegments/%'
+       *  - avoid 404 responses. E.g.: '/api/mySegments/foo/bar'
        *  - match user keys with special characters. E.g.: 'foo%bar', 'foo/bar'
        */
-      const url = `${urls.sdk}/memberships/${encodeURIComponent(userMatchingKey)}${till ? '?till=' + till : ''}`;
-      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MEMBERSHIPS));
+      const url = `${urls.sdk}/mySegments/${encodeURIComponent(userMatchingKey)}`;
+      return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(MY_SEGMENT));
     },
 
     /**

package/src/services/splitHttpClient.ts

@@ -3,8 +3,10 @@ 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';
+import { decorateHeaders, removeNonISO88591 } from './decorateHeaders';
+import { timeout } from '../utils/promise/timeout';
 
+const PENDING_FETCH_ERROR_TIMEOUT = 100;
 const messageNoFetch = 'Global fetch API is not available.';
 
 /**
@@ -13,7 +15,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);
@@ -30,7 +32,7 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
   };
 
   if (ip) commonHeaders['SplitSDKMachineIP'] = ip;
-  if (hostname) commonHeaders['SplitSDKMachineName'] = hostname;
+  if (hostname) commonHeaders['SplitSDKMachineName'] = removeNonISO88591(hostname);
 
   return function httpClient(url: string, reqOpts: IRequestOptions = {}, latencyTracker: (error?: NetworkError) => void = () => { }, logErrorsAsInfo: boolean = false): Promise<IResponse> {
 
@@ -45,7 +47,8 @@ export function splitHttpClientFactory(settings: ISettings, { getOptions, getFet
       // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
       .then(response => {
         if (!response.ok) {
-          return response.text().then(message => Promise.reject({ response, message }));
+          // `text()` promise might not settle in some fetch implementations and cases (e.g. no content)
+          return timeout(PENDING_FETCH_ERROR_TIMEOUT, response.text()).then(message => Promise.reject({ response, message }), () => Promise.reject({ response }));
         }
         latencyTracker();
         return response;

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 IFetchMemberships = (userMatchingKey: string, noCache?: boolean, till?: number) => Promise<IResponse>
+export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => 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
-	fetchMemberships: IFetchMemberships
+	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
 	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
 	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs

package/src/storages/AbstractSegmentsCacheSync.ts

@@ -1,7 +1,5 @@
 /* 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';
 
 /**
@@ -30,9 +28,7 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   /**
    * clear the cache.
    */
-  clear() {
-    this.resetSegments({});
-  }
+  abstract clear(): void
 
   /**
    * 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.
@@ -53,57 +49,20 @@ export abstract class AbstractSegmentsCacheSync implements ISegmentsCacheSync {
   abstract getKeysCount(): number
 
   /**
-   * For server-side synchronizer: change number of `name` segment.
-   * For client-side synchronizer: change number of mySegments.
+   * For server-side synchronizer: set the change number of `name` segment.
+   * For client-side synchronizer: the method is not used.
    */
-  abstract setChangeNumber(name?: string, changeNumber?: number): boolean | void
-  abstract getChangeNumber(name: string): number
+  setChangeNumber(name: string, changeNumber: number): boolean { return true; }
 
   /**
-   * For server-side synchronizer: the method is not used.
-   * For client-side synchronizer: it resets or updates the cache.
+   * For server-side synchronizer: get the change number of `name` segment.
+   * For client-side synchronizer: the method is not used.
    */
-  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();
+  getChangeNumber(name: string): number | undefined { return -1; }
 
-    // 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;
-  }
+  /**
+   * For server-side synchronizer: the method is not used.
+   * For client-side synchronizer: reset the cache with the given list of segments.
+   */
+  resetSegments(names: string[]): boolean { return true; }
 }

package/src/storages/AbstractSplitsCacheAsync.ts

@@ -28,6 +28,14 @@ export abstract class AbstractSplitsCacheAsync implements ISplitsCacheAsync {
     return Promise.resolve(true);
   }
 
+  /**
+   * Check if the splits information is already stored in cache.
+   * Noop, just keeping the interface. This is used by client-side implementations only.
+   */
+  checkCache(): Promise<boolean> {
+    return Promise.resolve(false);
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.

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, IN_LARGE_SEGMENT } from '../utils/constants';
+import { IN_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 | void
+  abstract setChangeNumber(changeNumber: number): boolean
 
   abstract getChangeNumber(): number
 
@@ -48,6 +48,14 @@ export abstract class AbstractSplitsCacheSync implements ISplitsCacheSync {
 
   abstract clear(): void
 
+  /**
+   * Check if the splits information is already stored in cache. This data can be preloaded.
+   * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
+   */
+  checkCache(): boolean {
+    return false;
+  }
+
   /**
    * Kill `name` split and set `defaultTreatment` and `changeNumber`.
    * Used for SPLIT_KILL push notifications.
@@ -86,8 +94,7 @@ export function usesSegments(split: ISplit) {
     const matchers = conditions[i].matcherGroup.matchers;
 
     for (let j = 0; j < matchers.length; j++) {
-      const matcher = matchers[j].matcherType;
-      if (matcher === IN_SEGMENT || matcher === IN_LARGE_SEGMENT) return true;
+      if (matchers[j].matcherType === IN_SEGMENT) return true;
     }
   }
 

package/src/storages/KeyBuilderCS.ts

@@ -1,14 +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;
-  buildTillKey(): string;
-}
-
-export class KeyBuilderCS extends KeyBuilder implements MySegmentsKeyBuilder {
+export class KeyBuilderCS extends KeyBuilder {
 
   protected readonly regexSplitsCacheKey: RegExp;
   protected readonly matchingKey: string;
@@ -33,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,30 +45,4 @@ 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 {
-  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

@@ -1,85 +1,55 @@
 import { SplitIO } from '../types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray, ISet } from '../utils/lang/sets';
-import { getMatching } from '../utils/key';
+import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
+import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
 /**
- * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
- * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+ * Factory of client-side storage loader
  *
- * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader and extended with a `mySegmentsData` property.
- * @param storage object containing `splits` and `segments` cache (client-side variant)
- * @param userKey user key (matching key) of the provided MySegmentsCache
- *
- * @TODO extend to load largeSegments
- * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
- * @TODO add logs, and input validation in this module, in favor of size reduction.
- * @TODO unit tests
+ * @param preloadedData validated data following the format proposed in https://github.com/godaddy/split-javascript-data-loader
+ * and extended with a `mySegmentsData` property.
+ * @returns function to preload the storage
  */
-export function loadData(preloadedData: SplitIO.PreloadedData, storage: { splits?: ISplitsCacheSync, segments: ISegmentsCacheSync, largeSegments?: ISegmentsCacheSync }, matchingKey?: string) {
-  // Do not load data if current preloadedData is empty
-  if (Object.keys(preloadedData).length === 0) return;
-
-  const { segmentsData = {}, since = -1, splitsData = [] } = preloadedData;
+export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+
+  /**
+   * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function
+   * (https://github.com/godaddy/split-javascript-data-loader/blob/master/src/load-data.js)
+   *
+   * @param storage object containing `splits` and `segments` cache (client-side variant)
+   * @param userId user key string of the provided MySegmentsCache
+   *
+   * @TODO extend to support SegmentsCache (server-side variant) by making `userId` optional and adding the corresponding logic.
+   * @TODO extend to load data on shared mySegments storages. Be specific when emitting SDK_READY_FROM_CACHE on shared clients. Maybe the serializer should provide the `useSegments` flag.
+   */
+  return function loadData(storage: { splits: ISplitsCacheSync, segments: ISegmentsCacheSync }, userId: string) {
+    // Do not load data if current preloadedData is empty
+    if (Object.keys(preloadedData).length === 0) return;
+
+    const { lastUpdated = -1, segmentsData = {}, since = -1, splitsData = {} } = preloadedData;
 
-  if (storage.splits) {
     const storedSince = storage.splits.getChangeNumber();
+    const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
 
-    // Do not load data if current data is more recent
-    if (storedSince > since) return;
+    // Do not load data if current localStorage data is more recent,
+    // or if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
+    if (storedSince > since || lastUpdated < expirationTimestamp) return;
 
     // cleaning up the localStorage data, since some cached splits might need be part of the preloaded data
     storage.splits.clear();
     storage.splits.setChangeNumber(since);
 
     // splitsData in an object where the property is the split name and the pertaining value is a stringified json of its data
-    storage.splits.addSplits(splitsData.map(split => ([split.name, split])));
-  }
+    storage.splits.addSplits(Object.keys(splitsData).map(splitName => JSON.parse(splitsData[splitName])));
 
-  if (matchingKey) { // add mySegments data (client-side)
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[matchingKey];
+    // add mySegments data
+    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userId];
     if (!mySegmentsData) {
       // segmentsData in an object where the property is the segment name and the pertaining value is a stringified object that contains the `added` array of userIds
       mySegmentsData = Object.keys(segmentsData).filter(segmentName => {
-        const matchingKeys = segmentsData[segmentName];
-        return matchingKeys.indexOf(matchingKey) > -1;
+        const userIds = JSON.parse(segmentsData[segmentName]).added;
+        return Array.isArray(userIds) && userIds.indexOf(userId) > -1;
       });
     }
-    storage.segments.resetSegments({ k: mySegmentsData.map(s => ({ n: s })) });
-  } else { // add segments data (server-side)
-    Object.keys(segmentsData).filter(segmentName => {
-      const matchingKeys = segmentsData[segmentName];
-      storage.segments.addToSegment(segmentName, matchingKeys);
-    });
-  }
-}
-
-export function getSnapshot(storage: IStorageSync, userKeys?: SplitIO.SplitKey[]): SplitIO.PreloadedData {
-  return {
-    // lastUpdated: Date.now(),
-    since: storage.splits.getChangeNumber(),
-    splitsData: storage.splits.getAll(),
-    segmentsData: userKeys ?
-      undefined : // @ts-ignore accessing private prop
-      Object.keys(storage.segments.segmentCache).reduce((prev, cur) => { // @ts-ignore accessing private prop
-        prev[cur] = setToArray(storage.segments.segmentCache[cur] as ISet<string>);
-        return prev;
-      }, {}),
-    mySegmentsData: userKeys ?
-      userKeys.reduce<Record<string, string[]>>((prev, userKey) => {
-        prev[getMatching(userKey)] = storage.shared ?
-          // Client-side segments
-          // @ts-ignore accessing private prop
-          Object.keys(storage.shared(userKey).segments.segmentCache) :
-          // Server-side segments
-          // @ts-ignore accessing private prop
-          Object.keys(storage.segments.segmentCache).reduce<string[]>((prev, segmentName) => { // @ts-ignore accessing private prop
-            return storage.segments.segmentCache[segmentName].has(userKey) ?
-              prev.concat(segmentName) :
-              prev;
-          }, []);
-        return prev;
-      }, {}) :
-      undefined
+    storage.segments.resetSegments(mySegmentsData);
   };
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -1,26 +1,36 @@
 import { ILogger } from '../../logger/types';
-import { isNaNNumber } from '../../utils/lang';
 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;
     // 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) {
@@ -33,7 +43,6 @@ 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) {
@@ -46,22 +55,31 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     return localStorage.getItem(this.keys.buildSegmentNameKey(name)) === DEFINED;
   }
 
-  getRegisteredSegments(): string[] {
+  /**
+   * 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;
+
     // Scan current values from localStorage
-    return Object.keys(localStorage).reduce((accum, key) => {
+    const storedSegmentNames = 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
+        // @TODO @BREAKING: This is only to clean up "old" keys. Remove this whole else code block and reuse `getRegisteredSegments` method.
         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)) {
+            if (!localStorage.getItem(newSegmentKey) && names.indexOf(segmentName) > -1) {
               localStorage.setItem(newSegmentKey, DEFINED);
               // we are migrating a segment, let's track it.
               accum.push(segmentName);
@@ -75,32 +93,44 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
 
       return accum;
     }, [] as string[]);
-  }
 
-  getKeysCount() {
-    return 1;
-  }
+    // Extreme fast => everything is empty
+    if (names.length === 0 && storedSegmentNames.length === names.length)
+      return isDiff;
 
-  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);
-    }
-  }
+    // Quick path
+    if (storedSegmentNames.length !== names.length) {
+      isDiff = true;
 
-  getChangeNumber() {
-    const n = -1;
-    let value: string | number | null = localStorage.getItem(this.keys.buildTillKey());
+      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?
+      }
 
-    if (value !== null) {
-      value = parseInt(value, 10);
+      if (index < names.length) {
+        isDiff = true;
 
-      return isNaNNumber(value) ? n : value;
+        storedSegmentNames.forEach(name => this.removeFromSegment(name));
+        names.forEach(name => this.addToSegment(name));
+      }
     }
 
-    return n;
+    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;
   }
 
 }

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -217,6 +217,15 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     }
   }
 
+  /**
+   * Check if the splits information is already stored in browser LocalStorage.
+   * In this function we could add more code to check if the data is valid.
+   * @override
+   */
+  checkCache(): boolean {
+    return this.getChangeNumber() > -1;
+  }
+
   /**
    * Clean Splits cache if its `lastUpdated` timestamp is older than the given `expirationTimestamp`,
    *
@@ -241,7 +250,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
         this.updateNewFilter = true;
 
         // if there is cache, clear it
-        if (this.getChangeNumber() > -1) this.clear();
+        if (this.checkCache()) this.clear();
 
       } catch (e) {
         this.log.error(LOG_PREFIX + e);