@splitsoftware/splitio-commons 1.17.1-rc.2 → 2.0.0-rc.0

package/src/storages/KeyBuilderCS.ts

@@ -4,7 +4,6 @@ import { KeyBuilder } from './KeyBuilder';
 export interface MySegmentsKeyBuilder {
   buildSegmentNameKey(segmentName: string): string;
   extractSegmentName(builtSegmentKeyName: string): string | undefined;
-  extractOldSegmentKey(builtSegmentKeyName: string): string | undefined;
   buildTillKey(): string;
 }
 
@@ -33,14 +32,6 @@ 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
-  extractOldSegmentKey(builtSegmentKeyName: string) {
-    const prefix = `${this.matchingKey}.${this.prefix}.segment.`;
-
-    if (startsWith(builtSegmentKeyName, prefix))
-      return builtSegmentKeyName.substr(prefix.length);
-  }
-
   buildLastUpdatedKey() {
     return `${this.prefix}.splits.lastUpdated`;
   }
@@ -66,10 +57,6 @@ export function myLargeSegmentsKeyBuilder(prefix: string, matchingKey: string):
       if (startsWith(builtSegmentKeyName, p)) return builtSegmentKeyName.substr(p.length);
     },
 
-    extractOldSegmentKey() {
-      return undefined;
-    },
-
     buildTillKey() {
       return `${prefix}.${matchingKey}.largeSegments.till`;
     }

package/src/storages/dataLoader.ts

@@ -1,86 +1,55 @@
 import { SplitIO } from '../types';
-import { ISegmentsCacheSync, ISplitsCacheSync, IStorageSync } from './types';
-import { setToArray, ISet } from '../utils/lang/sets';
+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 }, userKey?: 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 (userKey) { // add mySegments data (client-side)
-    let mySegmentsData = preloadedData.mySegmentsData && preloadedData.mySegmentsData[userKey];
+    // 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 userKeys = segmentsData[segmentName];
-        return userKeys.indexOf(userKey) > -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 userKeys = segmentsData[segmentName];
-      storage.segments.addToSegment(segmentName, userKeys);
-    });
-  }
-}
-
-export function getSnapshot(storage: IStorageSync, userKeys?: string[]): SplitIO.PreloadedData {
-  return {
-    // lastUpdated: Date.now(),
-    // @ts-ignore accessing private prop
-    since: storage.splits.changeNumber,
-    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((prev, userKey) => {
-        // @ts-ignore accessing private prop
-        prev[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
   };
 }

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

@@ -51,27 +51,7 @@ export class MySegmentsCacheInLocal extends AbstractSegmentsCacheSync {
     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
-        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)) {
-              localStorage.setItem(newSegmentKey, DEFINED);
-              // we are migrating a segment, let's track it.
-              accum.push(segmentName);
-            }
-            localStorage.removeItem(key); // we migrated the current key, let's delete it.
-          } catch (e) {
-            this.log.error(e);
-          }
-        }
-      }
+      if (segmentName) accum.push(segmentName);
 
       return accum;
     }, [] as string[]);

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -4,7 +4,6 @@ import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { ISet, _Set, setToArray } from '../../utils/lang/sets';
 import { ISettings } from '../../types';
 import { getStorageHash } from '../KeyBuilder';
 
@@ -217,6 +216,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 +249,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);
@@ -250,12 +258,12 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
     // if the filter didn't change, nothing is done
   }
 
-  getNamesByFlagSets(flagSets: string[]): ISet<string>[] {
+  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
     return flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      return new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      return new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
     });
   }
 
@@ -270,10 +278,10 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
       const flagSetFromLocalStorage = localStorage.getItem(flagSetKey);
 
-      const flagSetCache = new _Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
+      const flagSetCache = new Set(flagSetFromLocalStorage ? JSON.parse(flagSetFromLocalStorage) : []);
       flagSetCache.add(featureFlag.name);
 
-      localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+      localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
     });
   }
 
@@ -292,7 +300,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
 
     if (!flagSetFromLocalStorage) return;
 
-    const flagSetCache = new _Set(JSON.parse(flagSetFromLocalStorage));
+    const flagSetCache = new Set(JSON.parse(flagSetFromLocalStorage));
     flagSetCache.delete(featureFlagName);
 
     if (flagSetCache.size === 0) {
@@ -300,7 +308,7 @@ export class SplitsCacheInLocal extends AbstractSplitsCacheSync {
       return;
     }
 
-    localStorage.setItem(flagSetKey, JSON.stringify(setToArray(flagSetCache)));
+    localStorage.setItem(flagSetKey, JSON.stringify(Array.from(flagSetCache)));
   }
 
 }

package/src/storages/inLocalStorage/index.ts

@@ -12,7 +12,7 @@ import { SplitsCacheInMemory } from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from '../inMemory/UniqueKeysCacheInMemoryCS';
 import { getMatching } from '../../utils/key';
@@ -36,7 +36,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       return InMemoryStorageCSFactory(params);
     }
 
-    const { onReadyFromCacheCb, settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
+    const { settings, settings: { log, scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
     const matchingKey = getMatching(settings.core.key);
     const keys = new KeyBuilderCS(prefix, matchingKey);
     const expirationTimestamp = Date.now() - DEFAULT_CACHE_EXPIRATION_IN_MILLIS;
@@ -45,10 +45,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
     const segments = new MySegmentsCacheInLocal(log, keys);
     const largeSegments = new MySegmentsCacheInLocal(log, myLargeSegmentsKeyBuilder(prefix, matchingKey));
 
-    if (settings.mode === LOCALHOST_MODE || splits.getChangeNumber() > -1) {
-      Promise.resolve().then(onReadyFromCacheCb);
-    }
-
     return {
       splits,
       segments,

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -7,8 +7,6 @@ import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
 import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
 import { UniqueKeysCacheInMemoryCS } from './UniqueKeysCacheInMemoryCS';
-import { getMatching } from '../../utils/key';
-import { loadData } from '../dataLoader';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -16,7 +14,7 @@ import { loadData } from '../dataLoader';
  * @param params parameters required by EventsCacheSync
  */
 export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
-  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation }, preloadedData }, onReadyFromCacheCb } = params;
+  const { settings: { scheduler: { impressionsQueueSize, eventsQueueSize, }, sync: { impressionsMode, __splitFiltersValidation } } } = params;
 
   const splits = new SplitsCacheInMemory(__splitFiltersValidation);
   const segments = new MySegmentsCacheInMemory();
@@ -44,18 +42,11 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
 
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)
-    shared(matchingKey: string) {
-      const segments = new MySegmentsCacheInMemory();
-      const largeSegments = new MySegmentsCacheInMemory();
-
-      if (preloadedData) {
-        loadData(preloadedData, { segments, largeSegments }, matchingKey);
-      }
-
+    shared() {
       return {
         splits: this.splits,
-        segments,
-        largeSegments,
+        segments: new MySegmentsCacheInMemory(),
+        largeSegments: new MySegmentsCacheInMemory(),
         impressions: this.impressions,
         impressionCounts: this.impressionCounts,
         events: this.events,
@@ -81,12 +72,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     if (storage.uniqueKeys) storage.uniqueKeys.track = noopTrack;
   }
 
-
-  if (preloadedData) {
-    loadData(preloadedData, storage, getMatching(params.settings.core.key));
-    if (splits.getChangeNumber() > -1) onReadyFromCacheCb();
-  }
-
   return storage;
 }
 

package/src/storages/inMemory/SegmentsCacheInMemory.ts

@@ -1,5 +1,4 @@
 import { AbstractSegmentsCacheSync } from '../AbstractSegmentsCacheSync';
-import { ISet, _Set } from '../../utils/lang/sets';
 import { isIntegerNumber } from '../../utils/lang';
 
 /**
@@ -8,12 +7,12 @@ import { isIntegerNumber } from '../../utils/lang';
  */
 export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
-  private segmentCache: Record<string, ISet<string>> = {};
+  private segmentCache: Record<string, Set<string>> = {};
   private segmentChangeNumber: Record<string, number> = {};
 
   addToSegment(name: string, segmentKeys: string[]): boolean {
     const values = this.segmentCache[name];
-    const keySet = values ? values : new _Set<string>();
+    const keySet = values ? values : new Set<string>();
 
     segmentKeys.forEach(k => keySet.add(k));
 
@@ -24,7 +23,7 @@ export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   removeFromSegment(name: string, segmentKeys: string[]): boolean {
     const values = this.segmentCache[name];
-    const keySet = values ? values : new _Set<string>();
+    const keySet = values ? values : new Set<string>();
 
     segmentKeys.forEach(k => keySet.delete(k));
 
@@ -50,7 +49,7 @@ export class SegmentsCacheInMemory extends AbstractSegmentsCacheSync {
 
   private _registerSegment(name: string) {
     if (!this.segmentCache[name]) {
-      this.segmentCache[name] = new _Set<string>();
+      this.segmentCache[name] = new Set<string>();
     }
 
     return true;

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -1,7 +1,6 @@
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber } from '../../utils/lang';
-import { ISet, _Set } from '../../utils/lang/sets';
 
 /**
  * Default ISplitsCacheSync implementation that stores split definitions in memory.
@@ -14,7 +13,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private segmentsCount: number = 0;
-  private flagSetsCache: Record<string, ISet<string>> = {};
+  private flagSetsCache: Record<string, Set<string>> = {};
 
   constructor(splitFiltersValidation?: ISplitFiltersValidation) {
     super();
@@ -104,8 +103,8 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     return this.getChangeNumber() === -1 || this.segmentsCount > 0;
   }
 
-  getNamesByFlagSets(flagSets: string[]): ISet<string>[] {
-    return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new _Set());
+  getNamesByFlagSets(flagSets: string[]): Set<string>[] {
+    return flagSets.map(flagSet => this.flagSetsCache[flagSet] || new Set());
   }
 
   private addToFlagSets(featureFlag: ISplit) {
@@ -114,7 +113,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
       if (this.flagSetsFilter.length > 0 && !this.flagSetsFilter.some(filterFlagSet => filterFlagSet === featureFlagSet)) return;
 
-      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new _Set([]);
+      if (!this.flagSetsCache[featureFlagSet]) this.flagSetsCache[featureFlagSet] = new Set([]);
 
       this.flagSetsCache[featureFlagSet].add(featureFlag.name);
     });

package/src/storages/inMemory/UniqueKeysCacheInMemory.ts

@@ -1,17 +1,16 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadSs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
 /**
  * Converts `uniqueKeys` data from cache into request payload for SS.
  */
-export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadSs {
+export function fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: Set<string> }): UniqueKeysPayloadSs {
   const payload = [];
   const featureNames = Object.keys(uniqueKeys);
   for (let i = 0; i < featureNames.length; i++) {
     const featureName = featureNames[i];
-    const userKeys = setToArray(uniqueKeys[featureName]);
+    const userKeys = Array.from(uniqueKeys[featureName]);
     const uniqueKeysPayload = {
       f: featureName,
       ks: userKeys
@@ -27,7 +26,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
   protected onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  protected uniqueKeysTracker: { [featureName: string]: ISet<string> } = {};
+  protected uniqueKeysTracker: { [featureName: string]: Set<string> } = {};
 
   constructor(uniqueKeysQueueSize = DEFAULT_CACHE_SIZE) {
     this.maxStorage = uniqueKeysQueueSize;
@@ -41,7 +40,7 @@ export class UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
    * Store unique keys per feature.
    */
   track(userKey: string, featureName: string) {
-    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new _Set();
+    if (!this.uniqueKeysTracker[featureName]) this.uniqueKeysTracker[featureName] = new Set();
     const tracker = this.uniqueKeysTracker[featureName];
     if (!tracker.has(userKey)) {
       tracker.add(userKey);

package/src/storages/inMemory/UniqueKeysCacheInMemoryCS.ts

@@ -1,5 +1,4 @@
 import { IUniqueKeysCacheBase } from '../types';
-import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 import { UniqueKeysPayloadCs } from '../../sync/submitters/types';
 import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 
@@ -8,7 +7,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   private onFullQueue?: () => void;
   private readonly maxStorage: number;
   private uniqueTrackerSize = 0;
-  private uniqueKeysTracker: { [userKey: string]: ISet<string> } = {};
+  private uniqueKeysTracker: { [userKey: string]: Set<string> } = {};
 
   /**
    *
@@ -28,7 +27,7 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
    */
   track(userKey: string, featureName: string) {
 
-    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new _Set();
+    if (!this.uniqueKeysTracker[userKey]) this.uniqueKeysTracker[userKey] = new Set();
     const tracker = this.uniqueKeysTracker[userKey];
     if (!tracker.has(featureName)) {
       tracker.add(featureName);
@@ -66,12 +65,12 @@ export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
   /**
    * Converts `uniqueKeys` data from cache into request payload.
    */
-  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: ISet<string> }): UniqueKeysPayloadCs {
+  private fromUniqueKeysCollector(uniqueKeys: { [userKey: string]: Set<string> }): UniqueKeysPayloadCs {
     const payload = [];
     const userKeys = Object.keys(uniqueKeys);
     for (let k = 0; k < userKeys.length; k++) {
       const userKey = userKeys[k];
-      const featureNames = setToArray(uniqueKeys[userKey]);
+      const featureNames = Array.from(uniqueKeys[userKey]);
       const uniqueKeysPayload = {
         k: userKey,
         fs: featureNames

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,7 +1,6 @@
 import ioredis, { Pipeline } from 'ioredis';
 import { ILogger } from '../../logger/types';
 import { merge, isString } from '../../utils/lang';
-import { _Set, setToArray, ISet } from '../../utils/lang/sets';
 import { thenable } from '../../utils/promise/thenable';
 import { timeout } from '../../utils/promise/timeout';
 
@@ -37,7 +36,7 @@ export class RedisAdapter extends ioredis {
   private readonly log: ILogger;
   private _options: object;
   private _notReadyCommandsQueue?: IRedisCommand[];
-  private _runningCommands: ISet<Promise<any>>;
+  private _runningCommands: Set<Promise<any>>;
 
   constructor(log: ILogger, storageSettings: Record<string, any> = {}) {
     const options = RedisAdapter._defineOptions(storageSettings);
@@ -47,7 +46,7 @@ export class RedisAdapter extends ioredis {
     this.log = log;
     this._options = options;
     this._notReadyCommandsQueue = [];
-    this._runningCommands = new _Set();
+    this._runningCommands = new Set();
     this._listenToEvents();
     this._setTimeoutWrappers();
     this._setDisconnectWrapper();
@@ -150,7 +149,7 @@ export class RedisAdapter extends ioredis {
         if (instance._runningCommands.size > 0) {
           instance.log.info(LOG_PREFIX + `Attempting to disconnect but there are ${instance._runningCommands.size} commands still waiting for resolution. Defering disconnection until those finish.`);
 
-          Promise.all(setToArray(instance._runningCommands))
+          Promise.all(Array.from(instance._runningCommands))
             .then(() => {
               instance.log.debug(LOG_PREFIX + 'Pending commands finished successfully, disconnecting.');
               originalMethod.apply(instance, params);

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -4,7 +4,7 @@ import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 import type { RedisAdapter } from './RedisAdapter';
 
 /**
@@ -215,14 +215,14 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set,
    * or rejected if the pipelined redis operation fails (e.g., timeout).
   */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return this.redis.pipeline(flagSets.map(flagSet => ['smembers', this.keys.buildFlagSetKey(flagSet)])).exec()
       .then((results) => results.map(([e, value], index) => {
         if (e === null) return value;
 
         this.log.error(LOG_PREFIX + `Could not read result from get members of flag set ${flagSets[index]} due to an error: ${e}`);
       }))
-      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+      .then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -6,7 +6,6 @@ import { findLatencyIndex } from '../findLatencyIndex';
 import { getTelemetryConfigStats } from '../../sync/submitters/telemetrySubmitter';
 import { CONSUMER_MODE, STORAGE_REDIS } from '../../utils/constants';
 import { isNaNNumber, isString } from '../../utils/lang';
-import { _Map } from '../../utils/lang/maps';
 import { MAX_LATENCY_BUCKET_COUNT, newBuckets } from '../inMemory/TelemetryCacheInMemory';
 import { parseLatencyField, parseExceptionField, parseMetadata } from '../utils';
 import type { RedisAdapter } from './RedisAdapter';
@@ -46,7 +45,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popLatencies(): Promise<MultiMethodLatencies> {
     return this.redis.hgetall(this.keys.latencyPrefix).then(latencies => {
 
-      const result: MultiMethodLatencies = new _Map();
+      const result: MultiMethodLatencies = new Map();
 
       Object.keys(latencies).forEach(field => {
 
@@ -86,7 +85,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popExceptions(): Promise<MultiMethodExceptions> {
     return this.redis.hgetall(this.keys.exceptionPrefix).then(exceptions => {
 
-      const result: MultiMethodExceptions = new _Map();
+      const result: MultiMethodExceptions = new Map();
 
       Object.keys(exceptions).forEach(field => {
 
@@ -119,7 +118,7 @@ export class TelemetryCacheInRedis implements ITelemetryCacheAsync {
   popConfigs(): Promise<MultiConfigs> {
     return this.redis.hgetall(this.keys.initPrefix).then(configs => {
 
-      const result: MultiConfigs = new _Map();
+      const result: MultiConfigs = new Map();
 
       Object.keys(configs).forEach(field => {
 

package/src/storages/inRedis/UniqueKeysCacheInRedis.ts

@@ -1,6 +1,5 @@
 import { IUniqueKeysCacheBase } from '../types';
 import { UniqueKeysCacheInMemory } from '../inMemory/UniqueKeysCacheInMemory';
-import { setToArray } from '../../utils/lang/sets';
 import { DEFAULT_CACHE_SIZE, REFRESH_RATE, TTL_REFRESH } from './constants';
 import { LOG_PREFIX } from './constants';
 import { ILogger } from '../../logger/types';
@@ -29,7 +28,7 @@ export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements I
     if (!featureNames.length) return Promise.resolve(false);
 
     const uniqueKeysArray = featureNames.map((featureName) => {
-      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const featureKeys = Array.from(this.uniqueKeysTracker[featureName]);
       const uniqueKeysPayload = {
         f: featureName,
         ks: featureKeys

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -5,7 +5,6 @@ import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
-import { _Set } from '../../utils/lang/sets';
 
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -5,7 +5,7 @@ import { ILogger } from '../../logger/types';
 import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';
-import { ISet, _Set, returnDifference } from '../../utils/lang/sets';
+import { returnDifference } from '../../utils/lang/sets';
 
 /**
  * ISplitsCacheAsync implementation for pluggable storages.
@@ -181,11 +181,11 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of feature flag names per flag set.
    * It never rejects (If there is a wrapper error for some flag set, an empty set is returned for it).
    */
-  getNamesByFlagSets(flagSets: string[]): Promise<ISet<string>[]> {
+  getNamesByFlagSets(flagSets: string[]): Promise<Set<string>[]> {
     return Promise.all(flagSets.map(flagSet => {
       const flagSetKey = this.keys.buildFlagSetKey(flagSet);
       return this.wrapper.getItems(flagSetKey).catch(() => []);
-    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new _Set(namesByFlagSet)));
+    })).then(namesByFlagSets => namesByFlagSets.map(namesByFlagSet => new Set(namesByFlagSet)));
   }
 
   /**