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

package/src/storages/inMemory/uniqueKeysCacheInMemoryCS.ts

@@ -0,0 +1,88 @@
+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';
+
+export class UniqueKeysCacheInMemoryCS implements IUniqueKeysCacheBase {
+
+  private onFullQueue?: () => void;
+  private readonly maxStorage: number;
+  private uniqueTrackerSize = 0;
+  private uniqueKeysTracker: { [keys: string]: ISet<string> };
+
+  /**
+   *
+   * @param impressionsQueueSize number of queued impressions to call onFullQueueCb.
+   * Default value is 0, that means no maximum value, in case we want to avoid this being triggered.
+   */
+  constructor(uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {   
+    this.maxStorage = uniqueKeysQueueSize;
+    this.uniqueKeysTracker = {};
+  }
+
+  setOnFullQueueCb(cb: () => void) {
+    this.onFullQueue = cb;
+  }
+
+  /**
+   * Store unique keys in sequential order
+   * key: string = key.
+   * value: HashSet<string> = set of split names. 
+   */
+  track(key: string, featureName: string) {
+    
+    if (!this.uniqueKeysTracker[key]) this.uniqueKeysTracker[key] = new _Set();
+    const tracker = this.uniqueKeysTracker[key];
+    if (!tracker.has(featureName)) {
+      tracker.add(featureName);
+      this.uniqueTrackerSize++;
+    }
+    if (this.uniqueTrackerSize >= this.maxStorage && this.onFullQueue) {
+      this.uniqueTrackerSize = 0;
+      this.onFullQueue();
+    }
+  }
+
+  /**
+   * Clear the data stored on the cache.
+   */
+  clear() {
+    this.uniqueKeysTracker = {};
+  }
+
+  /**
+   * Pop the collected data, used as payload for posting.
+   */
+  pop() {
+    const data = this.uniqueKeysTracker;
+    this.uniqueKeysTracker = {};
+    return this.fromUniqueKeysCollector(data);
+  }
+
+  /**
+   * Check if the cache is empty.
+   */
+  isEmpty() {
+    return Object.keys(this.uniqueKeysTracker).length === 0;
+  }
+  
+  /**
+   * Converts `uniqueKeys` data from cache into request payload.
+   */
+  private fromUniqueKeysCollector(uniqueKeys: { [featureName: string]: ISet<string> }): UniqueKeysPayloadCs {
+    const payload = [];
+    const featureKeys = Object.keys(uniqueKeys);
+    for (let k = 0; k < featureKeys.length; k++) {
+      const featureKey = featureKeys[k];
+      const featureNames = setToArray(uniqueKeys[featureKey]);
+      const uniqueKeysPayload = {
+        k: featureKey,
+        fs: featureNames
+      };
+
+      payload.push(uniqueKeysPayload);
+    }
+    return { keys: payload };
+  }
+  
+}

package/src/storages/inRedis/EventsCacheInRedis.ts

@@ -1,8 +1,8 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { Redis } from 'ioredis';
-import { EventData } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 
@@ -24,7 +24,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
    * Add a new event object into the queue.
    * Unlike `impressions::track`, result promise is never rejected.
    */
-  track(eventData: EventData): Promise<boolean> {
+  track(eventData: SplitIO.EventData): Promise<boolean> {
     return this.redis.rpush(
       this.key,
       this._toJSON(eventData)
@@ -40,7 +40,7 @@ export class EventsCacheInRedis implements IEventsCacheAsync {
   /**
    * Generates the JSON as we'll store it on Redis.
    */
-  private _toJSON(eventData: EventData): string {
+  private _toJSON(eventData: SplitIO.EventData): string {
     return JSON.stringify({
       m: this.metadata,
       e: eventData

package/src/storages/inRedis/ImpressionCountsCacheInRedis.ts

@@ -0,0 +1,48 @@
+import { Redis } from 'ioredis';
+import { ILogger } from '../../logger/types';
+import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
+import { LOG_PREFIX, REFRESH_RATE, TTL_REFRESH } from './constants';
+
+export class ImpressionCountsCacheInRedis extends ImpressionCountsCacheInMemory {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private handle: any;
+  
+  constructor(log: ILogger, key: string, redis: Redis, impressionCountsCacheSize?: number) {
+    super(impressionCountsCacheSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.onFullQueue = () => { this.postImpressionCountsInRedis(); };
+  }
+  
+  postImpressionCountsInRedis(){
+    const counts = this.pop();
+    const keys = Object.keys(counts);
+    const pipeline = this.redis.pipeline();
+    keys.forEach(key => {
+      pipeline.hincrby(this.key, key, counts[key]);
+    });
+    return pipeline.exec()
+      .then(data => {
+        // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+        if (data.length && data.length === keys.length) {
+          return this.redis.expire(this.key, TTL_REFRESH);
+        }
+      })
+      .catch(err => {
+        this.log.error(`${LOG_PREFIX}Error in impression counts pipeline: ${err}.`);
+        return false;
+      });
+  }
+  
+  start(refreshRate: number = REFRESH_RATE) {
+    this.handle = setInterval(this.postImpressionCountsInRedis.bind(this), refreshRate);
+  }
+  
+  stop() {
+    clearInterval(this.handle);
+  }
+}

package/src/storages/inRedis/ImpressionsCacheInRedis.ts

@@ -3,7 +3,7 @@ import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
 import { Redis } from 'ioredis';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 
 const IMPRESSIONS_TTL_REFRESH = 3600; // 1 hr
 

package/src/storages/inRedis/RedisAdapter.ts

@@ -1,5 +1,5 @@
 import ioredis from 'ioredis';
-import { ILogger } from '../../types';
+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';

package/src/storages/inRedis/SegmentsCacheInRedis.ts

@@ -1,5 +1,5 @@
 import { Redis } from 'ioredis';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { isNaNNumber } from '../../utils/lang';
 import { LOG_PREFIX } from '../inLocalStorage/constants';
 import { KeyBuilderSS } from '../KeyBuilderSS';

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -1,7 +1,7 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { Redis } from 'ioredis';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';

package/src/storages/inRedis/TelemetryCacheInRedis.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';

package/src/storages/inRedis/constants.ts

@@ -1 +1,4 @@
 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

@@ -1,14 +1,15 @@
 import { RedisAdapter } from './RedisAdapter';
-import { IStorageAsync, IStorageFactoryParams } from '../types';
-import { StorageAsyncFactory } from '../../types';
+import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCacheInRedis } from './SplitsCacheInRedis';
 import { SegmentsCacheInRedis } from './SegmentsCacheInRedis';
 import { ImpressionsCacheInRedis } from './ImpressionsCacheInRedis';
 import { EventsCacheInRedis } from './EventsCacheInRedis';
-import { STORAGE_REDIS } from '../../utils/constants';
+import { DEBUG, NONE, STORAGE_REDIS } from '../../utils/constants';
 import { TelemetryCacheInRedis } from './TelemetryCacheInRedis';
+import { UniqueKeysCacheInRedis } from './uniqueKeysCacheInRedis';
+import { ImpressionCountsCacheInRedis } from './ImpressionCountsCacheInRedis';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -19,19 +20,22 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export function InRedisStorage(options: InRedisStorageOptions = {}): StorageAsyncFactory {
+export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
-  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
-
+  function InRedisStorageFactory({ log, metadata, onReadyCb, impressionsMode }: 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();
@@ -41,13 +45,17 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): StorageAsyn
       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/inRedis/uniqueKeysCacheInRedis.ts

@@ -0,0 +1,61 @@
+import { IUniqueKeysCacheBase } from '../types';
+import { Redis } from 'ioredis';
+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';
+
+export class UniqueKeysCacheInRedis extends UniqueKeysCacheInMemory implements IUniqueKeysCacheBase {
+
+  private readonly log: ILogger;
+  private readonly key: string;
+  private readonly redis: Redis;
+  private handle: any;
+  
+  constructor(log: ILogger, key: string, redis: Redis, uniqueKeysQueueSize: number = DEFAULT_CACHE_SIZE) {
+    super(uniqueKeysQueueSize);
+    this.log = log;
+    this.key = key;
+    this.redis = redis;
+    this.onFullQueue = () => {this.postUniqueKeysInRedis();};
+  }
+  
+  postUniqueKeysInRedis() {
+    const pipeline = this.redis.pipeline();
+    
+    const featureNames = Object.keys(this.uniqueKeysTracker);
+    for (let i = 0; i < featureNames.length; i++) {
+      const featureName = featureNames[i];
+      const featureKeys = setToArray(this.uniqueKeysTracker[featureName]);
+      const uniqueKeysPayload = {
+        f: featureName,
+        ks: featureKeys
+      };
+
+      pipeline.rpush(this.key, JSON.stringify(uniqueKeysPayload));
+    }
+    this.clear();
+    return pipeline.exec()
+      .then(data => {
+        // If this is the creation of the key on Redis, set the expiration for it in 3600 seconds.
+        if (data.length && data.length === featureNames.length) {
+          return this.redis.expire(this.key, TTL_REFRESH);
+        }
+      })
+      .catch(err => {
+        this.log.error(`${LOG_PREFIX}Error in uniqueKeys pipeline: ${err}.`);
+        return false;
+      });
+  }
+  
+    
+  start(refreshRate: number = REFRESH_RATE) {
+    this.handle = setInterval(this.postUniqueKeysInRedis.bind(this), refreshRate);
+  }
+  
+  stop() {
+    clearInterval(this.handle);
+  }
+  
+}

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { EventData } from '../../types';
-import { ILogger } from '../../types';
+import { SplitIO } from '../../types';
+import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { StoredEventWithMetadata } from '../../sync/submitters/types';
 
@@ -25,7 +25,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
    * @returns  A promise that is resolved with a boolean value indicating if the push operation succeeded or failed.
    * Unlike `impressions::track`, The promise will never be rejected.
    */
-  track(eventData: EventData): Promise<boolean> {
+  track(eventData: SplitIO.EventData): Promise<boolean> {
     return this.wrapper.pushItems(
       this.key,
       [this._toJSON(eventData)]
@@ -38,7 +38,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
       });
   }
 
-  private _toJSON(eventData: EventData): string {
+  private _toJSON(eventData: SplitIO.EventData): string {
     return JSON.stringify({
       m: this.metadata,
       e: eventData

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 
 export class ImpressionsCachePluggable implements IImpressionsCacheAsync {

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -3,7 +3,7 @@
 import { isNaNNumber } from '../../utils/lang';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { _Set } from '../../utils/lang/sets';
 

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilder } from '../KeyBuilder';
 import { IPluggableStorageWrapper } from '../types';
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
 import { AbstractSplitsCacheAsync } from '../AbstractSplitsCacheAsync';

package/src/storages/pluggable/TelemetryCachePluggable.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { IPluggableStorageWrapper, ITelemetryCacheAsync } from '../types';

package/src/storages/pluggable/index.ts

@@ -1,5 +1,5 @@
-import { IPluggableStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
-import { StorageAsyncFactory } from '../../types';
+import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
 import { SegmentsCachePluggable } from './SegmentsCachePluggable';
@@ -58,7 +58,7 @@ function promisifyEventsTrack(events: any) {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export function PluggableStorage(options: PluggableStorageOptions): StorageAsyncFactory {
+export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory {
 
   validatePluggableStorageOptions(options);
 

package/src/storages/pluggable/wrapperAdapter.ts

@@ -1,4 +1,4 @@
-import { ILogger } from '../../types';
+import { ILogger } from '../../logger/types';
 import { IPluggableStorageWrapper } from '../types';
 import { LOG_PREFIX } from './constants';
 

package/src/storages/types.ts

@@ -1,6 +1,7 @@
-import { MaybeThenable, IMetadata } from '../dtos/types';
-import { EventDataType, HttpErrors, HttpLatencies, ImpressionDataType, LastSync, Method, MethodExceptions, MethodLatencies, OperationType, StoredEventWithMetadata, StoredImpressionWithMetadata, StreamingEvent } from '../sync/submitters/types';
-import { ImpressionDTO, SDKMode, ILogger, EventData, ISplitFiltersValidation } from '../types';
+import { MaybeThenable, IMetadata, ISplitFiltersValidation } 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 { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
  * Interface of a pluggable storage wrapper.
@@ -288,7 +289,7 @@ export interface IImpressionsCacheBase {
 
 export interface IEventsCacheBase {
   // Consumer API method, used by events tracker, in standalone and consumer modes, to push events into the storage.
-  track(data: EventData, size?: number): MaybeThenable<boolean>
+  track(data: SplitIO.EventData, size?: number): MaybeThenable<boolean>
 }
 
 /** Impressions and events cache for standalone mode (sync) */
@@ -311,8 +312,8 @@ export interface IImpressionsCacheSync extends IImpressionsCacheBase, IRecorderC
   setOnFullQueueCb(cb: () => void): void
 }
 
-export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<EventData[]> {
-  track(data: EventData, size?: number): boolean
+export interface IEventsCacheSync extends IEventsCacheBase, IRecorderCacheProducerSync<SplitIO.EventData[]> {
+  track(data: SplitIO.EventData, size?: number): boolean
   /* Registers callback for full queue */
   setOnFullQueueCb(cb: () => void): void
 }
@@ -338,7 +339,7 @@ export interface IImpressionsCacheAsync extends IImpressionsCacheBase, IRecorder
 export interface IEventsCacheAsync extends IEventsCacheBase, IRecorderCacheProducerAsync<StoredEventWithMetadata[]> {
   // Consumer API method, used by events tracker (in standalone and consumer modes) to push data into.
   // The result promise cannot reject.
-  track(data: EventData, size?: number): Promise<boolean>
+  track(data: SplitIO.EventData, size?: number): Promise<boolean>
 }
 
 /**
@@ -346,14 +347,25 @@ 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
   isEmpty(): boolean // check if cache is empty. Return true if the cache was just created or cleared.
-  pop(toMerge?: Record<string, number>): Record<string, number> // pop cache data
+  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.
@@ -443,15 +455,18 @@ export interface IStorageBase<
   TSplitsCache extends ISplitsCacheBase,
   TSegmentsCache extends ISegmentsCacheBase,
   TImpressionsCache extends IImpressionsCacheBase,
+  TImpressionsCountCache extends IImpressionCountsCacheSync,
   TEventsCache extends IEventsCacheBase,
-  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync
+  TTelemetryCache extends ITelemetryCacheSync | ITelemetryCacheAsync,
+  TUniqueKeysCache extends IUniqueKeysCacheBase
   > {
   splits: TSplitsCache,
   segments: TSegmentsCache,
   impressions: TImpressionsCache,
-  impressionCounts?: IImpressionCountsCacheSync,
+  impressionCounts?: TImpressionsCountCache,
   events: TEventsCache,
-  telemetry?: TTelemetryCache
+  telemetry?: TTelemetryCache,
+  uniqueKeys?: TUniqueKeysCache,
   destroy(): void | Promise<void>,
   shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
@@ -460,16 +475,20 @@ export interface IStorageSync extends IStorageBase<
   ISplitsCacheSync,
   ISegmentsCacheSync,
   IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheSync,
-  ITelemetryCacheSync
+  ITelemetryCacheSync,
+  IUniqueKeysCacheBase
   > { }
 
 export interface IStorageAsync extends IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
   IImpressionsCacheAsync | IImpressionsCacheSync,
+  IImpressionCountsCacheSync,
   IEventsCacheAsync | IEventsCacheSync,
-  ITelemetryCacheAsync
+  ITelemetryCacheAsync,
+  IUniqueKeysCacheBase
   > { }
 
 /** StorageFactory */
@@ -479,10 +498,11 @@ 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,
@@ -494,39 +514,14 @@ export interface IStorageFactoryParams {
   metadata: IMetadata,
 }
 
-/**
- * Defines the format of Split data to preload on the factory storage (cache).
- */
-export interface PreloadedData {
-  /**
-   * Timestamp of the last moment the data was synchronized with Split servers.
-   * If this value is older than 10 days ago (expiration time policy), the data is not used to update the storage content.
-   * @TODO configurable expiration time policy?
-   */
-  lastUpdated: number,
-  /**
-   * Change number of the preloaded data.
-   * If this value is older than the current changeNumber at the storage, the data is not used to update the storage content.
-   */
-  since: number,
-  /**
-   * Map of splits to their serialized definitions.
-   */
-  splitsData: {
-    [splitName: string]: string
-  },
-  /**
-   * Optional map of user keys to their list of segments.
-   * @TODO remove when releasing first version
-   */
-  mySegmentsData?: {
-    [key: string]: string[]
-  },
-  /**
-   * Optional map of segments to their serialized definitions.
-   * This property is ignored if `mySegmentsData` was provided.
-   */
-  segmentsData?: {
-    [segmentName: string]: string
-  },
+export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
+
+export type IStorageSyncFactory = {
+  readonly type: StorageType,
+  (params: IStorageFactoryParams): IStorageSync
+}
+
+export type IStorageAsyncFactory = {
+  type: StorageType,
+  (params: IStorageFactoryParams): IStorageAsync
 }

package/src/sync/offline/LocalhostFromObject.ts

@@ -1,12 +1,12 @@
 import { splitsParserFromSettingsFactory } from './splitsParser/splitsParserFromSettings';
 import { syncManagerOfflineFactory } from './syncManagerOffline';
-import { LocalhostFactory } from '../../types';
+import { SplitIO } from '../../types';
 
 // Singleton instance of the factory function for offline SyncManager from object (a.k.a. localhostFromObject)
 // SDK instances instantiate their SyncManagers with the same factory
-const localhostFromObject: any = syncManagerOfflineFactory(splitsParserFromSettingsFactory);
+const localhostFromObject = syncManagerOfflineFactory(splitsParserFromSettingsFactory) as SplitIO.LocalhostFactory;
 localhostFromObject.type = 'LocalhostFromObject';
 
-export function LocalhostFromObject() {
-  return localhostFromObject as LocalhostFactory;
+export function LocalhostFromObject(): SplitIO.LocalhostFactory {
+  return localhostFromObject;
 }