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

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,23 +13,16 @@ 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;
-  const impressionsMode = settings.sync.impressionsMode;
 
   // @TODO handle non-recoverable errors, such as, global `fetch` not available, invalid API Key, etc.
   // On non-recoverable errors, we should mark the SDK as destroyed and not start synchronization.
@@ -48,6 +41,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
     // ATM, only used by InLocalStorage
     matchingKey: getMatching(settings.core.key),
+    // @ts-ignore
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
     // ATM, only used by PluggableStorage
@@ -69,19 +63,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
 
   const integrationsManager = integrationsManagerFactory && integrationsManagerFactory({ settings, storage });
 
-  const observer = impressionsObserverFactory();
-  const uniqueKeysTracker = impressionsMode === NONE ? uniqueKeysTrackerFactory(log, filterAdapterFactory && filterAdapterFactory()) : undefined;
-  const strategy = (storageFactoryParams.optimize) ? strategyOptimizedFactory(observer, storage.impressionCounts!) :
-    (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}/api/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}/api/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';
@@ -22,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);
 

package/src/storages/inMemory/AttributesCacheInMemory.ts

@@ -1,35 +1,36 @@
+import { AttributeType } from '../../types';
 import { objectAssign } from '../../utils/lang/objectAssign';
 
 export class AttributesCacheInMemory {
 
-  private attributesCache: Record<string, Object> = {};
+  private attributesCache: Record<string, AttributeType> = {};
 
 
   /**
    * Create or update the value for the given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @param {Object} attributeValue attribute value
-   * @returns {boolean} the attribute was stored 
+   * @returns {boolean} the attribute was stored
    */
-  setAttribute(attributeName: string, attributeValue: Object): boolean {
+  setAttribute(attributeName: string, attributeValue: AttributeType): boolean {
     this.attributesCache[attributeName] = attributeValue;
     return true;
   }
 
   /**
    * Retrieves the value of a given attribute
-   * 
+   *
    * @param {string} attributeName attribute name
    * @returns {Object?} stored attribute value
    */
-  getAttribute(attributeName: string): Object {
+  getAttribute(attributeName: string): AttributeType {
     return this.attributesCache[attributeName];
   }
 
   /**
    * Create or update all the given attributes
-   * 
+   *
    * @param {[string, Object]} attributes attributes to create or update
    * @returns {boolean} attributes were stored
    */
@@ -40,16 +41,16 @@ export class AttributesCacheInMemory {
 
   /**
    * Retrieve the full attributes map
-   * 
-   * @returns {Map<string, Object>} stored attributes
+   *
+   * @returns {Map<string, AttributeType>} stored attributes
    */
-  getAll(): Record<string, Object> {
+  getAll(): Record<string, AttributeType> {
     return this.attributesCache;
   }
 
   /**
    * Removes a given attribute from the map
-   * 
+   *
    * @param {string} attributeName attribute to remove
    * @returns {boolean} attribute removed
    */
@@ -63,7 +64,7 @@ export class AttributesCacheInMemory {
 
   /**
    * Clears all attributes stored in the SDK
-   * 
+   *
    */
   clear() {
     this.attributesCache = {};

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/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 {

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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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 '../../logger/types';
+import { ILogger } from '../../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, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
-
+import { IPluggableStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
+import { StorageAsyncFactory } 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): IStorageAsyncFactory {
+export function PluggableStorage(options: PluggableStorageOptions): StorageAsyncFactory {
 
   validatePluggableStorageOptions(options);
 

package/src/storages/pluggable/wrapperAdapter.ts

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