@splitsoftware/splitio-commons 1.6.2-rc.5 → 1.6.2-rc.6

package/src/storages/inLocalStorage/index.ts

@@ -12,9 +12,8 @@ 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 { LOCALHOST_MODE, NONE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from '../inMemory/TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from '../inMemory/uniqueKeysCacheInMemoryCS';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -46,7 +45,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
       impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
       events: new EventsCacheInMemory(params.eventsQueueSize),
       telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-      uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS() : undefined,
 
       destroy() {
         this.splits = new SplitsCacheInMemory();
@@ -54,7 +52,6 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
         this.impressions.clear();
         this.impressionCounts && this.impressionCounts.clear();
         this.events.clear();
-        this.uniqueKeys?.clear();
       },
 
       // When using shared instanciation with MEMORY we reuse everything but segments (they are customer per key).

package/src/storages/inMemory/ImpressionCountsCacheInMemory.ts

@@ -1,16 +1,8 @@
 import { truncateTimeFrame } from '../../utils/time';
-import { DEFAULT_CACHE_SIZE } from '../inRedis/constants';
 import { IImpressionCountsCacheSync } from '../types';
 
 export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync {
-  protected cache: Record<string, number> = {};
-  private readonly maxStorage: number;
-  protected onFullQueue?: () => void;
-  private cacheSize = 0;
-  
-  constructor(impressionCountsCacheSize: number = DEFAULT_CACHE_SIZE) {
-    this.maxStorage = impressionCountsCacheSize;
-  }
+  private cache: Record<string, number> = {};
 
   /**
   * Builds key to be stored in the cache with the featureName and the timeFrame truncated.
@@ -26,13 +18,6 @@ export class ImpressionCountsCacheInMemory implements IImpressionCountsCacheSync
     const key = this._makeKey(featureName, timeFrame);
     const currentAmount = this.cache[key];
     this.cache[key] = currentAmount ? currentAmount + amount : amount;
-    if (this.onFullQueue) {
-      this.cacheSize = this.cacheSize + amount;
-      if (this.cacheSize >= this.maxStorage) {
-        this.onFullQueue();
-        this.cacheSize = 0;
-      }
-    }
   }
 
 

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,9 +4,8 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemory } from './uniqueKeysCacheInMemory';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -19,10 +18,9 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     splits: new SplitsCacheInMemory(),
     segments: new SegmentsCacheInMemory(),
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
     telemetry: params.mode !== LOCALHOST_MODE ? new TelemetryCacheInMemory() : undefined, // Always track telemetry in standalone mode on server-side
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemory(params.uniqueKeysCacheSize) : undefined,
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -31,7 +29,6 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
-      this.uniqueKeys?.clear();
     }
   };
 }

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,9 +4,8 @@ import { ImpressionsCacheInMemory } from './ImpressionsCacheInMemory';
 import { EventsCacheInMemory } from './EventsCacheInMemory';
 import { IStorageSync, IStorageFactoryParams } from '../types';
 import { ImpressionCountsCacheInMemory } from './ImpressionCountsCacheInMemory';
-import { DEBUG, LOCALHOST_MODE, NONE, STORAGE_MEMORY } from '../../utils/constants';
+import { LOCALHOST_MODE, STORAGE_MEMORY } from '../../utils/constants';
 import { shouldRecordTelemetry, TelemetryCacheInMemory } from './TelemetryCacheInMemory';
-import { UniqueKeysCacheInMemoryCS } from './uniqueKeysCacheInMemoryCS';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -19,11 +18,9 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     splits: new SplitsCacheInMemory(),
     segments: new MySegmentsCacheInMemory(),
     impressions: new ImpressionsCacheInMemory(params.impressionsQueueSize),
-    impressionCounts: params.impressionsMode !== DEBUG ? new ImpressionCountsCacheInMemory() : undefined,
+    impressionCounts: params.optimize ? new ImpressionCountsCacheInMemory() : undefined,
     events: new EventsCacheInMemory(params.eventsQueueSize),
     telemetry: params.mode !== LOCALHOST_MODE && shouldRecordTelemetry() ? new TelemetryCacheInMemory() : undefined,
-    uniqueKeys: params.impressionsMode === NONE ? new UniqueKeysCacheInMemoryCS(params.uniqueKeysCacheSize) : undefined,
-    
 
     // When using MEMORY we should clean all the caches to leave them empty
     destroy() {
@@ -32,7 +29,6 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
       this.impressions.clear();
       this.impressionCounts && this.impressionCounts.clear();
       this.events.clear();
-      this.uniqueKeys?.clear();
     },
 
     // When using shared instanciation with MEMORY we reuse everything but segments (they are unique per key)

package/src/storages/inMemory/SplitsCacheInMemory.ts

@@ -8,7 +8,7 @@ import { isFiniteNumber } from '../../utils/lang';
  */
 export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
 
-  private splitsCache: Record<string, string> = {};
+  private splitsCache: Record<string, ISplit> = {};
   private ttCache: Record<string, number> = {};
   private changeNumber: number = -1;
   private splitsWithSegmentsCount: number = 0;
@@ -20,10 +20,9 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     this.splitsWithSegmentsCount = 0;
   }
 
-  addSplit(name: string, split: string): boolean {
-    const splitFromMemory = this.getSplit(name);
-    if (splitFromMemory) { // We had this Split already
-      const previousSplit: ISplit = JSON.parse(splitFromMemory);
+  addSplit(name: string, split: ISplit): boolean {
+    const previousSplit = this.getSplit(name);
+    if (previousSplit) { // We had this Split already
 
       if (previousSplit.trafficTypeName) {
         const previousTtName = previousSplit.trafficTypeName;
@@ -36,20 +35,18 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
     }
 
-    const parsedSplit: ISplit = JSON.parse(split);
-
-    if (parsedSplit) {
+    if (split) {
       // Store the Split.
       this.splitsCache[name] = split;
       // Update TT cache
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
       if (ttName) { // safeguard
         if (!this.ttCache[ttName]) this.ttCache[ttName] = 0;
         this.ttCache[ttName]++;
       }
 
       // Add to segments count for the new version of the Split
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount++;
+      if (usesSegments(split)) this.splitsWithSegmentsCount++;
 
       return true;
     } else {
@@ -63,8 +60,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       // Delete the Split
       delete this.splitsCache[name];
 
-      const parsedSplit: ISplit = JSON.parse(split);
-      const ttName = parsedSplit.trafficTypeName;
+      const ttName = split.trafficTypeName;
 
       if (ttName) { // safeguard
         this.ttCache[ttName]--; // Update tt cache
@@ -72,7 +68,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
       }
 
       // Update the segments count.
-      if (usesSegments(parsedSplit)) this.splitsWithSegmentsCount--;
+      if (usesSegments(split)) this.splitsWithSegmentsCount--;
 
       return true;
     } else {
@@ -80,7 +76,7 @@ export class SplitsCacheInMemory extends AbstractSplitsCacheSync {
     }
   }
 
-  getSplit(name: string): string | null {
+  getSplit(name: string): ISplit | null {
     return this.splitsCache[name] || null;
   }
 

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -65,22 +65,22 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.redis.get(splitKey).then(splitFromStorage => {
 
       // handling parsing errors
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, newStringifiedSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        newStringifiedSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.redis.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.redis.set(splitKey, newStringifiedSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -92,7 +92,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., redis operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -104,8 +104,7 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   removeSplit(name: string): Promise<number> {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.redis.del(this.keys.buildSplitKey(name));
     });
@@ -124,14 +123,15 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Get split definition or null if it's not defined.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
+  getSplit(name: string): Promise<ISplit | null> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    return this.redis.get(this.keys.buildSplitKey(name));
+    return this.redis.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -169,10 +169,13 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * @TODO we need to benchmark which is the maximun number of commands we could
    *       pipeline without kill redis performance.
    */
-  getAll(): Promise<string[]> {
-    return this.redis.keys(this.keys.searchPatternForSplitKeys()).then(
-      (listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec()
-    ).then(processPipelineAnswer);
+  getAll(): Promise<ISplit[]> {
+    return this.redis.keys(this.keys.searchPatternForSplitKeys())
+      .then((listOfKeys) => this.redis.pipeline(listOfKeys.map(k => ['get', k])).exec())
+      .then(processPipelineAnswer)
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**
@@ -226,19 +229,20 @@ export class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
    * Fetches multiple splits definitions.
    * Returned promise is rejected if redis operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     if (this.redisError) {
       this.log.error(LOG_PREFIX + this.redisError);
 
       return Promise.reject(this.redisError);
     }
 
-    const splits: Record<string, string | null> = {};
+    const splits: Record<string, ISplit | null> = {};
     const keys = names.map(name => this.keys.buildSplitKey(name));
     return this.redis.mget(...keys)
       .then(splitDefinitions => {
         names.forEach((name, idx) => {
-          splits[name] = splitDefinitions[idx];
+          const split = splitDefinitions[idx];
+          splits[name] = split && JSON.parse(split);
         });
         return Promise.resolve(splits);
       })

package/src/storages/inRedis/constants.ts

@@ -1,4 +1 @@
 export const LOG_PREFIX = 'storage:redis: ';
-export const DEFAULT_CACHE_SIZE = 30000;
-export const REFRESH_RATE = 300000; // 300.000 ms = start after 5 mins
-export const TTL_REFRESH = 3600; // 1hr

package/src/storages/inRedis/index.ts

@@ -6,10 +6,8 @@ import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
+import { STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
-import { UniqueKeysCacheInRedis } from './uniqueKeysCacheInRedis';
-import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -24,18 +22,15 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: IStorageFactoryParams): IStorageAsync {
+  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
+
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
     const telemetry = new TelemetryCacheInRedis(log, keys, redisClient);
-    const impressionCountsCache = impressionsMode !== DEBUG ? new ImpressionCountsCacheInRedis(log, keys.buildImpressionsCountKey(), redisClient) : undefined;
-    const uniqueKeysCache = impressionsMode === NONE ? new UniqueKeysCacheInRedis(log, keys.buildUniqueKeysKey(), redisClient) : undefined;
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
       onReadyCb();
-      if (impressionCountsCache) impressionCountsCache.start();
-      if (uniqueKeysCache) uniqueKeysCache.start();
 
       // Synchronize config
       telemetry.recordConfig();
@@ -45,17 +40,13 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
       splits: new SplitsCacheInRedis(log, keys, redisClient),
       segments: new SegmentsCacheInRedis(log, keys, redisClient),
       impressions: new ImpressionsCacheInRedis(log, keys.buildImpressionsKey(), redisClient, metadata),
-      impressionCounts: impressionCountsCache,
       events: new EventsCacheInRedis(log, keys.buildEventsKey(), redisClient, metadata),
       telemetry,
-      uniqueKeys: uniqueKeysCache,
 
       // When using REDIS we should:
       // 1- Disconnect from the storage
       destroy() {
         redisClient.disconnect();
-        if (impressionCountsCache) impressionCountsCache.stop();
-        if (uniqueKeysCache) uniqueKeysCache.stop();
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -49,22 +49,22 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplit(name: string, split: string): Promise<boolean> {
+  addSplit(name: string, split: ISplit): Promise<boolean> {
     const splitKey = this.keys.buildSplitKey(name);
     return this.wrapper.get(splitKey).then(splitFromStorage => {
 
       // handling parsing error
-      let parsedPreviousSplit, parsedSplit;
+      let parsedPreviousSplit, stringifiedNewSplit;
       try {
         parsedPreviousSplit = splitFromStorage ? JSON.parse(splitFromStorage) : undefined;
-        parsedSplit = JSON.parse(split);
+        stringifiedNewSplit = JSON.stringify(split);
       } catch (e) {
         throw new Error('Error parsing split definition: ' + e);
       }
 
       return Promise.all([
-        this.wrapper.set(splitKey, split),
-        this._incrementCounts(parsedSplit),
+        this.wrapper.set(splitKey, stringifiedNewSplit),
+        this._incrementCounts(split),
         // If it's an update, we decrement the traffic type and segment count of the existing split,
         parsedPreviousSplit && this._decrementCounts(parsedPreviousSplit)
       ]);
@@ -76,7 +76,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved when the operation success
    * or rejected if it fails (e.g., wrapper operation fails)
    */
-  addSplits(entries: [string, string][]): Promise<boolean[]> {
+  addSplits(entries: [string, ISplit][]): Promise<boolean[]> {
     return Promise.all(entries.map(keyValuePair => this.addSplit(keyValuePair[0], keyValuePair[1])));
   }
 
@@ -88,8 +88,7 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   removeSplit(name: string) {
     return this.getSplit(name).then((split) => {
       if (split) {
-        const parsedSplit = JSON.parse(split);
-        this._decrementCounts(parsedSplit);
+        this._decrementCounts(split);
       }
       return this.wrapper.del(this.keys.buildSplitKey(name));
     });
@@ -109,8 +108,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplit(name: string): Promise<string | null> {
-    return this.wrapper.get(this.keys.buildSplitKey(name));
+  getSplit(name: string): Promise<ISplit | null> {
+    return this.wrapper.get(this.keys.buildSplitKey(name))
+      .then(maybeSplit => maybeSplit && JSON.parse(maybeSplit));
   }
 
   /**
@@ -118,13 +118,14 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with a map of split names to their split definition or null if it's not defined,
    * or rejected if wrapper operation fails.
    */
-  getSplits(names: string[]): Promise<Record<string, string | null>> {
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>> {
     const keys = names.map(name => this.keys.buildSplitKey(name));
 
     return this.wrapper.getMany(keys).then(splitDefinitions => {
-      const splits: Record<string, string | null> = {};
+      const splits: Record<string, ISplit | null> = {};
       names.forEach((name, idx) => {
-        splits[name] = splitDefinitions[idx];
+        const split = splitDefinitions[idx];
+        splits[name] = split && JSON.parse(split);
       });
       return Promise.resolve(splits);
     });
@@ -135,10 +136,12 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
    * The returned promise is resolved with the list of split definitions,
    * or rejected if wrapper operation fails.
    */
-  getAll(): Promise<string[]> {
-    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix()).then(
-      (listOfKeys) => Promise.all(listOfKeys.map(this.wrapper.get) as Promise<string>[])
-    );
+  getAll(): Promise<ISplit[]> {
+    return this.wrapper.getKeysByPrefix(this.keys.buildSplitKeyPrefix())
+      .then((listOfKeys) => this.wrapper.getMany(listOfKeys))
+      .then((splitDefinitions) => splitDefinitions.map((splitDefinition) => {
+        return JSON.parse(splitDefinition as string);
+      }));
   }
 
   /**

package/src/storages/types.ts

@@ -1,6 +1,6 @@
-import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation, ISplit } from '../dtos/types';
 import { ILogger } from '../logger/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent, UniqueKeysPayloadCs, UniqueKeysPayloadSs } from '../sync/submitters/types';
+import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
@@ -191,14 +191,14 @@ export interface IPluggableStorageWrapper {
 /** Splits cache */
 
 export interface ISplitsCacheBase {
-  addSplits(entries: [string, string][]): MaybeThenable<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): MaybeThenable<boolean[] | void>,
   removeSplits(names: string[]): MaybeThenable<boolean[] | void>,
-  getSplit(name: string): MaybeThenable<string | null>,
-  getSplits(names: string[]): MaybeThenable<Record<string, string | null>>, // `fetchMany` in spec
+  getSplit(name: string): MaybeThenable<ISplit | null>,
+  getSplits(names: string[]): MaybeThenable<Record<string, ISplit | null>>, // `fetchMany` in spec
   setChangeNumber(changeNumber: number): MaybeThenable<boolean | void>,
   // should never reject or throw an exception. Instead return -1 by default, assuming no splits are present in the storage.
   getChangeNumber(): MaybeThenable<number>,
-  getAll(): MaybeThenable<string[]>,
+  getAll(): MaybeThenable<ISplit[]>,
   getSplitNames(): MaybeThenable<string[]>,
   // should never reject or throw an exception. Instead return true by default, asssuming the TT might exist.
   trafficTypeExists(trafficType: string): MaybeThenable<boolean>,
@@ -211,13 +211,13 @@ export interface ISplitsCacheBase {
 }
 
 export interface ISplitsCacheSync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): boolean[],
+  addSplits(entries: [string, ISplit][]): boolean[],
   removeSplits(names: string[]): boolean[],
-  getSplit(name: string): string | null,
-  getSplits(names: string[]): Record<string, string | null>,
+  getSplit(name: string): ISplit | null,
+  getSplits(names: string[]): Record<string, ISplit | null>,
   setChangeNumber(changeNumber: number): boolean,
   getChangeNumber(): number,
-  getAll(): string[],
+  getAll(): ISplit[],
   getSplitNames(): string[],
   trafficTypeExists(trafficType: string): boolean,
   usesSegments(): boolean,
@@ -227,13 +227,13 @@ export interface ISplitsCacheSync extends ISplitsCacheBase {
 }
 
 export interface ISplitsCacheAsync extends ISplitsCacheBase {
-  addSplits(entries: [string, string][]): Promise<boolean[] | void>,
+  addSplits(entries: [string, ISplit][]): Promise<boolean[] | void>,
   removeSplits(names: string[]): Promise<boolean[] | void>,
-  getSplit(name: string): Promise<string | null>,
-  getSplits(names: string[]): Promise<Record<string, string | null>>,
+  getSplit(name: string): Promise<ISplit | null>,
+  getSplits(names: string[]): Promise<Record<string, ISplit | null>>,
   setChangeNumber(changeNumber: number): Promise<boolean | void>,
   getChangeNumber(): Promise<number>,
-  getAll(): Promise<string[]>,
+  getAll(): Promise<ISplit[]>,
   getSplitNames(): Promise<string[]>,
   trafficTypeExists(trafficType: string): Promise<boolean>,
   usesSegments(): Promise<boolean>,
@@ -347,7 +347,7 @@ export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProdu
  * Only in memory. Named `ImpressionsCounter` in spec.
  */
 export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<Record<string, number>> {
-// Used by impressions tracker
+  // Used by impressions tracker
   track(featureName: string, timeFrame: number, amount: number): void
 
   // Used by impressions count submitter in standalone and producer mode
@@ -355,17 +355,6 @@ export interface IImpressionCountsCacheSync extends IRecorderCacheProducerSync<R
   pop(toMerge?: Record<string, number> ): Record<string, number> // pop cache data
 }
 
-export interface IUniqueKeysCacheBase {
-  // Used by unique Keys tracker
-  track(key: string, value: string): void
-
-  // Used by unique keys submitter in standalone and producer mode
-  isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(): UniqueKeysPayloadSs | UniqueKeysPayloadCs // pop cache data
-  /* Registers callback for full queue */
-  setOnFullQueueCb(cb: () => void): void,
-  clear(): void
-}
 
 /**
  * Telemetry storage interface for standalone and partial consumer modes.
@@ -455,18 +444,15 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
-  TImpressionsCountCache extends IImpressionCountsCacheSync,
   TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
-  TUniqueKeysCache extends IUniqueKeysCacheBase
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: TImpressionsCountCache,
+  impressionCounts?: IImpressionCountsCacheSync,
   events: TEventsCache,
-  telemetry?: TTelemetryCache,
-  uniqueKeys?: TUniqueKeysCache,
+  telemetry?: TTelemetryCache
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -475,20 +461,16 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
   IEventsCacheSync,
-  ITelemetryCacheSync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheSync
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
-  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync,
-  IUniqueKeysCacheBase
+  ITelemetryCacheAsync
   > { }
 
 /** StorageFactory */
@@ -498,11 +480,10 @@ export type DataLoader = (storage: IStorageSync, matchingKey: string) => void
 export interface IStorageFactoryParams {
   log: ILogger,
   impressionsQueueSize?: number,
-  uniqueKeysCacheSize?: number;
   eventsQueueSize?: number,
   optimize?: boolean /* whether create the `impressionCounts` cache (OPTIMIZED impression mode) or not (DEBUG impression mode) */,
   mode: SDKMode,
-  impressionsMode?: string,
+
   // ATM, only used by InLocalStorage
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,

package/src/sync/offline/syncTasks/fromObjectSyncTask.ts

@@ -2,7 +2,7 @@ import { forOwn } from '../../../utils/lang';
 import { IReadinessManager } from '../../../readiness/types';
 import { ISplitsCacheSync } from '../../../storages/types';
 import { ISplitsParser } from '../splitsParser/types';
-import { ISplitPartial } from '../../../dtos/types';
+import { ISplit, ISplitPartial } from '../../../dtos/types';
 import { syncTaskFactory } from '../../syncTask';
 import { ISyncTask } from '../../types';
 import { ISettings } from '../../../types';
@@ -24,7 +24,7 @@ export function fromObjectUpdaterFactory(
   let startingUp = true;
 
   return function objectUpdater() {
-    const splits: [string, string][] = [];
+    const splits: [string, ISplit][] = [];
     let loadError = null;
     let splitsMock: false | Record<string, ISplitPartial> = {};
     try {
@@ -38,9 +38,8 @@ export function fromObjectUpdaterFactory(
       log.debug(SYNC_OFFLINE_DATA, [JSON.stringify(splitsMock)]);
 
       forOwn(splitsMock, function (val, name) {
-        splits.push([
-          name,
-          JSON.stringify({
+        splits.push([ // @ts-ignore Split changeNumber and seed is undefined in localhost mode
+          name, {
             name,
             status: 'ACTIVE',
             killed: false,
@@ -49,7 +48,7 @@ export function fromObjectUpdaterFactory(
             conditions: val.conditions || [],
             configurations: val.configurations,
             trafficTypeName: val.trafficTypeName
-          })
+          }
         ]);
       });
 

package/src/sync/polling/updaters/splitChangesUpdater.ts

@@ -40,7 +40,7 @@ export function parseSegments({ conditions }: ISplit): ISet<string> {
 }
 
 interface ISplitMutations {
-  added: [string, string][],
+  added: [string, ISplit][],
   removed: string[],
   segments: string[]
 }
@@ -54,7 +54,7 @@ export function computeSplitsMutation(entries: ISplit[]): ISplitMutations {
   const segments = new _Set<string>();
   const computed = entries.reduce((accum, split) => {
     if (split.status === 'ACTIVE') {
-      accum.added.push([split.name, JSON.stringify(split)]);
+      accum.added.push([split.name, split]);
 
       parseSegments(split).forEach((segmentName: string) => {
         segments.add(segmentName);