@splitsoftware/splitio-commons 1.6.2-rc.2 → 1.6.2-rc.3

package/src/sdkClient/sdkClientMethodCS.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { SplitIO } from '../types';
+import { IClientSS, IClientWithKey, SplitKey } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
@@ -9,7 +9,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitIO.SplitKey) {
+function buildInstanceId(key: SplitKey) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-`;
 }
@@ -20,23 +20,23 @@ const method = 'Client instantiation';
  * Factory of client method for the client-side API variant where TT is ignored and thus
  * clients don't have a binded TT for the track method.
  */
-export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey) => IClientWithKey {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient,
-    key
+    sdkClientFactory(params) as IClientSS,
+    key!
   );
 
-  const parsedDefaultKey = keyParser(key);
+  const parsedDefaultKey = keyParser(key!);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  const clientInstances: Record<string, IClientWithKey> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitIO.SplitKey) {
+  return function client(key?: SplitKey) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -76,7 +76,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as SplitIO.IClient,
+        }), true) as IClientSS,
         validKey
       );
 

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -1,5 +1,5 @@
 import { clientCSDecorator } from './clientCS';
-import { SplitIO } from '../types';
+import { IClientSS, IClientWithKeyLegacy, SplitKey } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
 import { getMatching, keyParser } from '../utils/key';
@@ -10,7 +10,7 @@ import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING }
 import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { ISdkFactoryContext } from '../sdkFactory/types';
 
-function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
+function buildInstanceId(key: SplitKey, trafficType?: string) {
   // @ts-ignore
   return `${key.matchingKey ? key.matchingKey : key}-${key.bucketingKey ? key.bucketingKey : key}-${trafficType !== undefined ? trafficType : ''}`;
 }
@@ -22,24 +22,24 @@ const method = 'Client instantiation';
  * where clients can have a binded TT for the track method, which is provided via the settings
  * (default client) or the client method (shared clients).
  */
-export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitIO.SplitKey, trafficType?: string) => SplitIO.ICsClient {
+export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: SplitKey, trafficType?: string) => IClientWithKeyLegacy {
   const { storage, syncManager, sdkReadinessManager, settings: { core: { key, trafficType }, startup: { readyTimeout }, log } } = params;
 
   const mainClientInstance = clientCSDecorator(
     log,
-    sdkClientFactory(params) as SplitIO.IClient,
-    key,
+    sdkClientFactory(params) as IClientSS,
+    key!,
     trafficType
   );
 
-  const parsedDefaultKey = keyParser(key);
+  const parsedDefaultKey = keyParser(key!);
   const defaultInstanceId = buildInstanceId(parsedDefaultKey, trafficType);
 
   // Cache instances created per factory.
-  const clientInstances: Record<string, SplitIO.ICsClient> = {};
+  const clientInstances: Record<string, IClientWithKeyLegacy> = {};
   clientInstances[defaultInstanceId] = mainClientInstance;
 
-  return function client(key?: SplitIO.SplitKey, trafficType?: string) {
+  return function client(key?: SplitKey, trafficType?: string) {
     if (key === undefined) {
       log.debug(RETRIEVE_CLIENT_DEFAULT);
       return mainClientInstance;
@@ -86,7 +86,7 @@ export function sdkClientMethodCSFactory(params: ISdkFactoryContext): (key?: Spl
           storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
-        }), true) as SplitIO.IClient,
+        }), true) as IClientSS,
         validKey,
         validTrafficType
       );

package/src/sdkFactory/index.ts

@@ -4,7 +4,7 @@ import { impressionsTrackerFactory } from '../trackers/impressionsTracker';
 import { eventTrackerFactory } from '../trackers/eventTracker';
 import { telemetryTrackerFactory } from '../trackers/telemetryTracker';
 import { IStorageFactoryParams } from '../storages/types';
-import { SplitIO } from '../types';
+import { IBasicSDK } from '../types';
 import { getMatching } from '../utils/key';
 import { shouldBeOptimized } from '../trackers/impressionObserver/utils';
 import { validateAndTrackApiKey } from '../utils/inputValidation/apiKey';
@@ -13,21 +13,15 @@ import { NEW_FACTORY, RETRIEVE_MANAGER } from '../logger/constants';
 import { metadataBuilder } from '../storages/metadataBuilder';
 import { SDK_SPLITS_ARRIVED, SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 import { objectAssign } from '../utils/lang/objectAssign';
-import { strategyDebugFactory } from '../trackers/strategy/strategyDebug';
-import { strategyOptimizedFactory } from '../trackers/strategy/strategyOptimized';
-import { strategyNoneFactory } from '../trackers/strategy/strategyNone';
-import { uniqueKeysTrackerFactory } from '../trackers/uniqueKeysTracker';
-import { NONE } from '../utils/constants';
 
 /**
  * Modular SDK factory
  */
-export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.ISDK | SplitIO.IAsyncSDK {
+export function sdkFactory(params: ISdkFactoryParams): IBasicSDK<any, any> {
 
   const { settings, platform, storageFactory, splitApiFactory, extraProps,
     syncManagerFactory, SignalListener, impressionsObserverFactory,
-    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory,
-    filterAdapterFactory } = params;
+    integrationsManagerFactory, sdkManagerFactory, sdkClientMethodFactory } = params;
   const log = settings.log;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
@@ -43,16 +37,15 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const storageFactoryParams: IStorageFactoryParams = {
     impressionsQueueSize: settings.scheduler.impressionsQueueSize,
     eventsQueueSize: settings.scheduler.eventsQueueSize,
-    uniqueKeysCacheSize: settings.scheduler.uniqueKeysCacheSize,
     optimize: shouldBeOptimized(settings),
 
     // ATM, only used by InLocalStorage
     matchingKey: getMatching(settings.core.key),
+    // @ts-ignore
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
     // ATM, only used by PluggableStorage
     mode: settings.mode,
-    impressionsMode: settings.sync.impressionsMode,
 
     // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined,
     // or partial consumer mode, where it only has submitters, and therefore it doesn't emit readiness events.
@@ -70,19 +63,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
 
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = storageFactoryParams.impressionsMode === NONE ? uniqueKeysTrackerFactory(log, storage.uniqueKeys!, filterAdapterFactory && filterAdapterFactory()) : undefined;
-  const strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts!) :
-    (storageFactoryParams.impressionsMode === NONE) ? strategyNoneFactory(storage.impressionCounts!, uniqueKeysTracker!) : strategyDebugFactory(observer);
-
-  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, strategy, integrationsManager, storage.telemetry);
+  // trackers
+  const observer = impressionsObserverFactory && impressionsObserverFactory();
+  const impressionsTracker = impressionsTrackerFactory(settings, storage.impressions, integrationsManager, observer, storage.impressionCounts, storage.telemetry);
   const eventTracker = eventTrackerFactory(settings, storage.events, integrationsManager, storage.telemetry);
   const telemetryTracker = telemetryTrackerFactory(storage.telemetry, platform.now);
 
   // splitApi is used by SyncManager and Browser signal listener
   const splitApi = splitApiFactory && splitApiFactory(settings, platform, telemetryTracker);
 
-  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, uniqueKeysTracker, sdkReadinessManager, readiness, settings, storage, platform };
+  const ctx: ISdkFactoryContext = { splitApi, eventTracker, impressionsTracker, telemetryTracker, sdkReadinessManager, readiness, settings, storage, platform };
 
   const syncManager = syncManagerFactory && syncManagerFactory(ctx as ISdkFactoryContextSync);
   ctx.syncManager = syncManager;

package/src/sdkFactory/types.ts

@@ -1,13 +1,13 @@
 import { IIntegrationManager, IIntegrationFactoryParams } from '../integrations/types';
 import { ISignalListener } from '../listeners/types';
-import { ILogger } from '../logger/types';
+import { IAsyncClientSS, IAsyncManager, IClientSS, IClientWithKey, ILogger, IManager, SplitKey } from '../types';
 import { IReadinessManager, ISdkReadinessManager } from '../readiness/types';
 import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
-import { IImpressionsTracker, IEventTracker, ITelemetryTracker, IFilterAdapter, IUniqueKeysTracker } from '../trackers/types';
-import { SplitIO, ISettings, IEventEmitter } from '../types';
+import { IImpressionsTracker, IEventTracker, ITelemetryTracker } from '../trackers/types';
+import { ISettings, IEventEmitter } from '../types';
 
 /**
  * Environment related dependencies.
@@ -44,7 +44,6 @@ export interface ISdkFactoryContext {
   eventTracker: IEventTracker,
   telemetryTracker: ITelemetryTracker,
   storage: IStorageSync | IStorageAsync,
-  uniqueKeysTracker?: IUniqueKeysTracker,
   signalListener?: ISignalListener
   splitApi?: ISplitApi
   syncManager?: ISyncManager,
@@ -91,16 +90,11 @@ export interface ISdkFactoryParams {
     log: ILogger,
     splits: ISplitsCacheSync | ISplitsCacheAsync,
     sdkReadinessManager: ISdkReadinessManager
-  ) => SplitIO.IManager | SplitIO.IAsyncManager,
+  ) => IManager | IAsyncManager,
 
   // Sdk client method factory (ISDK::client method).
   // It Allows to distinguish SDK clients with the client-side API (`ICsSDK`) or server-side API (`ISDK` or `IAsyncSDK`).
-  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): SplitIO.ICsClient; (key: SplitIO.SplitKey, trafficType?: string | undefined): SplitIO.ICsClient; } | (() => SplitIO.IClient) | (() => SplitIO.IAsyncClient))
-
-  // Impression observer factory. If provided, will be used for impressions dedupe
-  impressionsObserverFactory: () => IImpressionObserver
-  
-  filterAdapterFactory?: () => IFilterAdapter
+  sdkClientMethodFactory: (params: ISdkFactoryContext) => ({ (): IClientWithKey; (key: SplitKey, trafficType?: string | undefined): IClientWithKey; } | (() => IClientSS) | (() => IAsyncClientSS))
 
   // Optional signal listener constructor. Used to handle special app states, like shutdown, app paused or resumed.
   // Pass only if `syncManager` (used by Node listener) and `splitApi` (used by Browser listener) are passed.
@@ -113,6 +107,9 @@ export interface ISdkFactoryParams {
   // @TODO review impressionListener and integrations interfaces. What about handling impressionListener as an integration ?
   integrationsManagerFactory?: (params: IIntegrationFactoryParams) => IIntegrationManager | undefined,
 
+  // Impression observer factory. If provided, will be used for impressions dedupe
+  impressionsObserverFactory?: () => IImpressionObserver
+
   // Optional function to assign additional properties to the factory instance
   extraProps?: (params: ISdkFactoryContext) => object
 }

package/src/sdkManager/index.ts

@@ -5,8 +5,8 @@ import { validateSplit, validateSplitExistance, validateIfNotDestroyed, validate
 import { ISplitsCacheAsync, ISplitsCacheSync } from '../storages/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISplit } from '../dtos/types';
-import { SplitIO } from '../types';
-import { ILogger } from '../logger/types';
+import { IAsyncManager, IManager, SplitView } from '../types';
+import { ILogger } from '../types';
 
 function collectTreatments(splitObject: ISplit) {
   const conditions = splitObject.conditions;
@@ -18,7 +18,7 @@ function collectTreatments(splitObject: ISplit) {
   return allTreatmentsCondition ? allTreatmentsCondition.partitions.map(v => v.treatment) : [];
 }
 
-function objectToView(json: string | null): SplitIO.SplitView | null {
+function objectToView(json: string | null): SplitView | null {
   let splitObject: ISplit | null;
 
   try {
@@ -41,7 +41,7 @@ function objectToView(json: string | null): SplitIO.SplitView | null {
 }
 
 function objectsToViews(jsons: string[]) {
-  let views: SplitIO.SplitView[] = [];
+  let views: SplitView[] = [];
 
   jsons.forEach(split => {
     const view = objectToView(split);
@@ -55,7 +55,7 @@ export function sdkManagerFactory<TSplitCache extends ISplitsCacheSync | ISplits
   log: ILogger,
   splits: TSplitCache,
   { readinessManager, sdkStatus }: ISdkReadinessManager
-): TSplitCache extends ISplitsCacheAsync ? SplitIO.IAsyncManager : SplitIO.IManager {
+): TSplitCache extends ISplitsCacheAsync ? IAsyncManager : IManager {
   const SPLIT_FN_LABEL = 'split';
 
   return objectAssign(

package/src/services/splitApi.ts

@@ -25,6 +25,7 @@ export function splitApiFactory(
 ): ISplitApi {
 
   const urls = settings.urls;
+  // @ts-ignore
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);
@@ -106,28 +107,6 @@ export function splitApiFactory(
       const url = `${urls.events}/testImpressions/count`;
       return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(IMPRESSIONS_COUNT));
     },
-    
-    /**
-     * Post unique keys for client side.
-     *
-     * @param body  unique keys payload
-     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkCs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/cs`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
-    
-    /**
-     * Post unique keys for server side.
-     *
-     * @param body  unique keys payload
-     * @param headers  Optionals headers to overwrite default ones. For example, it is used in producer mode to overwrite metadata headers.
-     */
-    postUniqueKeysBulkSs(body: string, headers?: Record<string, string>) {
-      const url = `${urls.telemetry}/v1/keys/ss`;
-      return splitHttpClient(url, { method: 'POST', body, headers }, telemetryTracker.trackHttp(TELEMETRY));
-    },
 
     postMetricsConfig(body: string) {
       const url = `${urls.telemetry}/v1/metrics/config`;

package/src/services/types.ts

@@ -43,10 +43,6 @@ export type IFetchMySegments = (userMatchingKey: string, noCache?: boolean) => P
 
 export type IPostEventsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
-export type IPostUniqueKeysBulkCs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
-export type IPostUniqueKeysBulkSs = (body: string, headers?: Record<string, string>) => Promise<IResponse>
-
 export type IPostTestImpressionsBulk = (body: string, headers?: Record<string, string>) => Promise<IResponse>
 
 export type IPostTestImpressionsCount = (body: string, headers?: Record<string, string>) => Promise<IResponse>
@@ -63,8 +59,6 @@ export interface ISplitApi {
 	fetchSegmentChanges: IFetchSegmentChanges
 	fetchMySegments: IFetchMySegments
 	postEventsBulk: IPostEventsBulk
-	postUniqueKeysBulkCs: IPostUniqueKeysBulkCs
-	postUniqueKeysBulkSs: IPostUniqueKeysBulkSs
 	postTestImpressionsBulk: IPostTestImpressionsBulk
 	postTestImpressionsCount: IPostTestImpressionsCount
 	postMetricsConfig: IPostMetricsConfig

package/src/storages/dataLoader.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../types';
+import { PreloadedData } from './types';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../utils/constants/browser';
 import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
 
@@ -9,7 +9,7 @@ import { DataLoader, ISegmentsCacheSync, ISplitsCacheSync } from './types';
  * and extended with a `mySegmentsData` property.
  * @returns function to preload the storage
  */
-export function dataLoaderFactory(preloadedData: SplitIO.PreloadedData): DataLoader {
+export function dataLoaderFactory(preloadedData: PreloadedData): DataLoader {
 
   /**
    * Storage-agnostic adaptation of `loadDataIntoLocalStorage` function

package/src/storages/inLocalStorage/MySegmentsCacheInLocal.ts

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

package/src/storages/inLocalStorage/SplitsCacheInLocal.ts

@@ -1,8 +1,8 @@
-import { ISplit, ISplitFiltersValidation } from '../../dtos/types';
+import { ISplit } from '../../dtos/types';
 import { AbstractSplitsCacheSync, usesSegments } from '../AbstractSplitsCacheSync';
 import { isFiniteNumber, toNumber, isNaNNumber } from '../../utils/lang';
 import { KeyBuilderCS } from '../KeyBuilderCS';
-import { ILogger } from '../../logger/types';
+import { ILogger, ISplitFiltersValidation } from '../../types';
 import { LOG_PREFIX } from './constants';
 
 /**

package/src/storages/inLocalStorage/index.ts

@@ -1,7 +1,8 @@
 import { ImpressionsCacheInMemory } from '../inMemory/ImpressionsCacheInMemory';
 import { ImpressionCountsCacheInMemory } from '../inMemory/ImpressionCountsCacheInMemory';
 import { EventsCacheInMemory } from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
+import { IStorageFactoryParams, IStorageSync } from '../types';
+import { StorageSyncFactory } from '../../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderCS } from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
@@ -12,9 +13,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
@@ -23,7 +23,7 @@ export interface InLocalStorageOptions {
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
+export function InLocalStorage(options: InLocalStorageOptions = {}): StorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
@@ -46,7 +46,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 +53,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/EventsCacheInMemory.ts

@@ -1,4 +1,4 @@
-import { SplitIO } from '../../types';
+import { EventData } from '../../types';
 import { IEventsCacheSync } from '../types';
 
 const MAX_QUEUE_BYTE_SIZE = 5 * 1024 * 1024; // 5M
@@ -7,7 +7,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
 
   private onFullQueue?: () => void;
   private readonly maxQueue: number;
-  private queue: SplitIO.EventData[];
+  private queue: EventData[];
   private queueByteSize: number;
 
   /**
@@ -28,7 +28,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
   /**
    * Add a new event object at the end of the queue.
    */
-  track(data: SplitIO.EventData, size = 0) {
+  track(data: EventData, size = 0) {
     this.queueByteSize += size;
     this.queue.push(data);
 
@@ -48,7 +48,7 @@ export class EventsCacheInMemory implements IEventsCacheSync {
   /**
    * Pop the collected data, used as payload for posting.
    */
-  pop(toMerge?: SplitIO.EventData[]) {
+  pop(toMerge?: EventData[]) {
     const data = this.queue;
     this.clear();
     return toMerge ? toMerge.concat(data) : data;

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/inRedis/EventsCacheInRedis.ts

@@ -1,8 +1,8 @@
 import { IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { Redis } from 'ioredis';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { EventData } from '../../types';
+import { ILogger } from '../../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: SplitIO.EventData): Promise<boolean> {
+  track(eventData: 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: SplitIO.EventData): string {
+  private _toJSON(eventData: EventData): string {
     return JSON.stringify({
       m: this.metadata,
       e: eventData

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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../types';
 import { Method } from '../../sync/submitters/types';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { ITelemetryCacheAsync } from '../types';

package/src/storages/inRedis/index.ts

@@ -1,5 +1,6 @@
 import { RedisAdapter } from './RedisAdapter';
-import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+import { IStorageAsync, IStorageFactoryParams } from '../types';
+import { StorageAsyncFactory } from '../../types';
 import { validatePrefix } from '../KeyBuilder';
 import { KeyBuilderSS } from '../KeyBuilderSS';
 import { SplitsCacheInRedis } from './SplitsCacheInRedis';
@@ -18,7 +19,7 @@ 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 = {}): IStorageAsyncFactory {
+export function InRedisStorage(options: InRedisStorageOptions = {}): StorageAsyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,7 +1,7 @@
 import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
-import { SplitIO } from '../../types';
-import { ILogger } from '../../logger/types';
+import { EventData } from '../../types';
+import { ILogger } from '../../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: SplitIO.EventData): Promise<boolean> {
+  track(eventData: EventData): Promise<boolean> {
     return this.wrapper.pushItems(
       this.key,
       [this._toJSON(eventData)]
@@ -38,7 +38,7 @@ export class EventsCachePluggable implements IEventsCacheAsync {
       });
   }
 
-  private _toJSON(eventData: SplitIO.EventData): string {
+  private _toJSON(eventData: 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 '../../logger/types';
+import { ILogger } from '../../types';
 import { StoredImpressionWithMetadata } from '../../sync/submitters/types';
 
 export class ImpressionsCachePluggable implements IImpressionsCacheAsync {