@splitsoftware/splitio-commons 1.0.0 → 1.0.1-rc.3

package/esm/utils/settingsValidation/storage/storageCS.js

@@ -1,6 +1,6 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
-import { WARN_STORAGE_INVALID } from '../../../logger/constants';
-import { LOCALHOST_MODE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
+import { ERROR_STORAGE_INVALID } from '../../../logger/constants';
+import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_PLUGGABLE, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
     result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
@@ -12,19 +12,33 @@ __InLocalStorageMockFactory.type = STORAGE_MEMORY;
  *
  * @param {any} settings config object provided by the user to initialize the sdk
  *
- * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ * @returns {Object} valid storage factory. Default to `InMemoryStorageCSFactory` if the provided storage is invalid or not compatible with the sdk mode if mode is standalone or localhost
+ *
+ * @throws error if mode is consumer and the provided storage is not compatible
  */
 export function validateStorageCS(settings) {
     var _a = settings.storage, storage = _a === void 0 ? InMemoryStorageCSFactory : _a, log = settings.log, mode = settings.mode;
     // If an invalid storage is provided, fallback into MEMORY
-    if (typeof storage !== 'function' || storage.type !== STORAGE_MEMORY && storage.type !== STORAGE_LOCALSTORAGE) {
+    if (typeof storage !== 'function' || [STORAGE_MEMORY, STORAGE_LOCALSTORAGE, STORAGE_PLUGGABLE].indexOf(storage.type) === -1) {
         storage = InMemoryStorageCSFactory;
-        log.warn(WARN_STORAGE_INVALID);
+        log.error(ERROR_STORAGE_INVALID);
     }
     // In localhost mode with InLocalStorage, fallback to a mock InLocalStorage to emit SDK_READY_FROM_CACHE
     if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
         return __InLocalStorageMockFactory;
     }
+    if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
+        // Consumer modes require an async storage
+        if (storage.type !== STORAGE_PLUGGABLE)
+            throw new Error('A PluggableStorage instance is required on consumer mode');
+    }
+    else {
+        // Standalone and localhost modes require a sync storage
+        if (storage.type === STORAGE_PLUGGABLE) {
+            storage = InMemoryStorageCSFactory;
+            log.error(ERROR_STORAGE_INVALID, [' It requires consumer mode.']);
+        }
+    }
     // return default InMemory storage if provided one is not valid
     return storage;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.0.0",
+  "version": "1.0.1-rc.3",
   "description": "Split Javascript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -49,10 +49,9 @@
   },
   "devDependencies": {
     "@types/google.analytics": "0.0.40",
-    "@types/ioredis": "^4.14.1",
+    "@types/ioredis": "^4.28.0",
     "@types/jest": "^27.0.0",
     "@types/lodash": "^4.14.162",
-    "@types/node": "^14.14.7",
     "@types/object-assign": "^4.0.30",
     "@typescript-eslint/eslint-plugin": "^4.2.0",
     "@typescript-eslint/parser": "^4.2.0",
@@ -61,7 +60,7 @@
     "eslint": "^7.32.0",
     "eslint-plugin-compat": "3.7.0",
     "fetch-mock": "^9.10.7",
-    "ioredis": "^4.26.0",
+    "ioredis": "^4.28.0",
     "jest": "^27.2.3",
     "jest-localstorage-mock": "^2.4.3",
     "js-yaml": "^3.14.0",

package/src/listeners/browser.ts

@@ -63,6 +63,8 @@ export default class BrowserSignalListener implements ISignalListener {
    * using beacon API if possible, or falling back to regular post transport.
    */
   flushData() {
+    if (!this.syncManager) return; // In consumer mode there is not sync manager and data to flush
+
     const eventsUrl = this.settings.urls.events;
     const extraMetadata = {
       // sim stands for Sync/Split Impressions Mode
@@ -74,7 +76,7 @@ export default class BrowserSignalListener implements ISignalListener {
     if (this.storage.impressionCounts) this._flushData(eventsUrl + '/testImpressions/count/beacon', this.storage.impressionCounts, this.serviceApi.postTestImpressionsCount, fromImpressionCountsCollector);
 
     // Close streaming connection
-    if (this.syncManager && this.syncManager.pushManager) this.syncManager.pushManager.stop();
+    if (this.syncManager.pushManager) this.syncManager.pushManager.stop();
   }
 
   private _flushData<TState>(url: string, cache: IRecorderCacheProducerSync<TState>, postService: (body: string) => Promise<IResponse>, fromCacheToPayload?: (cacheData: TState) => any, extraMetadata?: {}) {

package/src/logger/constants.ts

@@ -91,9 +91,8 @@ export const WARN_INTEGRATION_INVALID = 218;
 export const WARN_SPLITS_FILTER_IGNORED = 219;
 export const WARN_SPLITS_FILTER_INVALID = 220;
 export const WARN_SPLITS_FILTER_EMPTY = 221;
-export const WARN_STORAGE_INVALID = 222;
-export const WARN_API_KEY = 223;
-export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
+export const WARN_API_KEY = 222;
+export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 
 export const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export const ERROR_LOGLEVEL_INVALID = 301;
@@ -119,6 +118,7 @@ export const ERROR_EMPTY_ARRAY = 320;
 export const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export const ERROR_HTTP = 322;
 export const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
+export const ERROR_STORAGE_INVALID = 324;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/messages/error.ts

@@ -30,5 +30,6 @@ export const codesError: [number, string][] = [
   [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
   // initialization / settings validation
   [c.ERROR_INVALID_IMPRESSIONS_MODE, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'],
-  [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.']
+  [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': an invalid value was received for "sync.localhostMode" config. A valid entity should be provided for localhost mode.'],
+  [c.ERROR_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': The provided storage is invalid.%s Fallbacking into default MEMORY storage'],
 ];

package/src/logger/messages/warn.ts

@@ -29,7 +29,6 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_SPLITS_FILTER_IGNORED, c.LOG_PREFIX_SETTINGS+': split filters have been configured but will have no effect if mode is not "%s", since synchronization is being deferred to an external tool.'],
   [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': split filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
   [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS+': splitFilters configuration must be a non-empty array of filter objects.'],
-  [c.WARN_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': The provided storage is invalid. Fallbacking into default MEMORY storage'],
   [c.WARN_API_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
 
   [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],

package/src/sdkClient/sdkClient.ts

@@ -1,6 +1,6 @@
 import objectAssign from 'object-assign';
 import { IStatusInterface, SplitIO } from '../types';
-import { CONSUMER_MODE } from '../utils/constants';
+import { CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../utils/constants';
 import { releaseApiKey } from '../utils/inputValidation/apiKey';
 import clientFactory from './client';
 import clientInputValidationDecorator from './clientInputValidation';
@@ -21,8 +21,8 @@ export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClie
       settings.log,
       clientFactory(params),
       sdkReadinessManager.readinessManager,
-      // @TODO isStorageSync could be extracted from the storage itself (e.g. `storage.isSync`) to simplify interfaces
-      settings.mode === CONSUMER_MODE ? false : true,
+      // storage is async if and only if mode is consumer or partial consumer
+      [CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) === -1 ? true : false,
     ),
 
     // Sdk destroy
@@ -37,11 +37,11 @@ export function sdkClientFactory(params: ISdkClientFactoryParams): SplitIO.IClie
           sdkReadinessManager.readinessManager.destroy();
           signalListener && signalListener.stop();
 
-          // Cleanup storage
-          storage.destroy();
-
           // Release the API Key if it is the main client
           if (!sharedClient) releaseApiKey(settings.core.authorizationKey);
+
+          // Cleanup storage
+          return storage.destroy();
         });
       }
     }

package/src/sdkClient/sdkClientMethodCS.ts

@@ -4,10 +4,10 @@ import { SplitIO } from '../types';
 import { validateKey } from '../utils/inputValidation/key';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
-import { IStorageSyncCS } from '../storages/types';
 import { ISyncManagerCS } from '../sync/types';
 import objectAssign from 'object-assign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
+import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 
 function buildInstanceId(key: SplitIO.SplitKey) {
   // @ts-ignore
@@ -58,15 +58,25 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       const matchingKey = getMatching(validKey);
 
       const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
-      const sharedStorage = (storage as IStorageSyncCS).shared(matchingKey);
-      const sharedSyncManager = syncManager && (syncManager as ISyncManagerCS).shared(matchingKey, sharedSdkReadiness.readinessManager, sharedStorage);
+      const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
+        if (err) return;
+        // Emit SDK_READY in consumer mode for shared clients
+        sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+      });
+
+      // 3 possibilities:
+      // - Standalone mode: both syncManager and sharedSyncManager are defined
+      // - Consumer mode: both syncManager and sharedSyncManager are undefined
+      // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
+      // @ts-ignore
+      const sharedSyncManager = syncManager && sharedStorage && (syncManager as ISyncManagerCS).shared(matchingKey, sharedSdkReadiness.readinessManager, sharedStorage);
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
-          storage: sharedStorage,
+          storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
           sharedClient: true

package/src/sdkClient/sdkClientMethodCSWithTT.ts

@@ -5,10 +5,10 @@ import { validateKey } from '../utils/inputValidation/key';
 import { validateTrafficType } from '../utils/inputValidation/trafficType';
 import { getMatching, keyParser } from '../utils/key';
 import { sdkClientFactory } from './sdkClient';
-import { IStorageSyncCS } from '../storages/types';
 import { ISyncManagerCS } from '../sync/types';
 import objectAssign from 'object-assign';
 import { RETRIEVE_CLIENT_DEFAULT, NEW_SHARED_CLIENT, RETRIEVE_CLIENT_EXISTING } from '../logger/constants';
+import { SDK_SEGMENTS_ARRIVED } from '../readiness/constants';
 
 function buildInstanceId(key: SplitIO.SplitKey, trafficType?: string) {
   // @ts-ignore
@@ -72,15 +72,25 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
       const matchingKey = getMatching(validKey);
 
       const sharedSdkReadiness = sdkReadinessManager.shared(readyTimeout);
-      const sharedStorage = (storage as IStorageSyncCS).shared(matchingKey);
-      const sharedSyncManager = (syncManager as ISyncManagerCS).shared(matchingKey, sharedSdkReadiness.readinessManager, sharedStorage);
+      const sharedStorage = storage.shared && storage.shared(matchingKey, (err) => {
+        if (err) return;
+        // Emit SDK_READY in consumer mode for shared clients
+        sharedSdkReadiness.readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
+      });
+
+      // 3 possibilities:
+      // - Standalone mode: both syncManager and sharedSyncManager are defined
+      // - Consumer mode: both syncManager and sharedSyncManager are undefined
+      // - Consumer partial mode: syncManager is defined (only for submitters) but sharedSyncManager is undefined
+      // @ts-ignore
+      const sharedSyncManager = syncManager && sharedStorage && (syncManager as ISyncManagerCS).shared(matchingKey, sharedSdkReadiness.readinessManager, sharedStorage);
 
       // As shared clients reuse all the storage information, we don't need to check here if we
       // will use offline or online mode. We should stick with the original decision.
       clientInstances[instanceId] = clientCSDecorator(
         sdkClientFactory(objectAssign({}, params, {
           sdkReadinessManager: sharedSdkReadiness,
-          storage: sharedStorage,
+          storage: sharedStorage || storage,
           syncManager: sharedSyncManager,
           signalListener: undefined, // only the main client "destroy" method stops the signal listener
           sharedClient: true
@@ -89,7 +99,7 @@ export function sdkClientMethodCSFactory(params: ISdkClientFactoryParams): (key?
         validTrafficType
       );
 
-      sharedSyncManager.start();
+      sharedSyncManager && sharedSyncManager.start();
 
       log.info(NEW_SHARED_CLIENT);
     } else {

package/src/sdkFactory/index.ts

@@ -40,12 +40,16 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     matchingKey: getMatching(settings.core.key),
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
-    // Callback used in consumer mode (`syncManagerFactory` is undefined) to emit SDK_READY
-    onReadyCb: !syncManagerFactory ? (error) => {
+    // ATM, only used by PluggableStorage
+    mode: settings.mode,
+
+    // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined
+    // or only instantiates submitters, and therefore it is not able to emit readiness events.
+    onReadyCb: (error) => {
       if (error) return; // don't emit SDK_READY if storage failed to connect.
       readinessManager.splits.emit(SDK_SPLITS_ARRIVED);
       readinessManager.segments.emit(SDK_SEGMENTS_ARRIVED);
-    } : undefined,
+    },
     metadata: metadataBuilder(settings),
     log
   };

package/src/sdkFactory/types.ts

@@ -3,7 +3,7 @@ import { ISignalListener } from '../listeners/types';
 import { ILogger } from '../logger/types';
 import { ISdkReadinessManager } from '../readiness/types';
 import { ISdkClientFactoryParams } from '../sdkClient/types';
-import { IFetch, ISplitApi } from '../services/types';
+import { IFetch, ISplitApi, IEventSourceConstructor } from '../services/types';
 import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStorageFactoryParams } from '../storages/types';
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
@@ -16,7 +16,7 @@ import { SplitIO, ISettings, IEventEmitter } from '../types';
 export interface IPlatform {
   getOptions?: () => object
   getFetch?: () => (IFetch | undefined)
-  getEventSource?: () => (typeof EventSource | undefined)
+  getEventSource?: () => (IEventSourceConstructor | undefined)
   EventEmitter: new () => IEventEmitter
 }
 

package/src/services/splitApi.ts

@@ -16,7 +16,10 @@ function userKeyToQueryParam(userKey: string) {
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi {
+export function splitApiFactory(
+  settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>,
+  platform: Pick<IPlatform, 'getFetch' | 'getOptions'>
+): ISplitApi {
 
   const urls = settings.urls;
   const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;

package/src/services/types.ts

@@ -50,8 +50,8 @@ export type IPostMetricsCounters = (body: string) => Promise<IResponse>
 export type IPostMetricsTimes = (body: string) => Promise<IResponse>
 
 export interface ISplitApi {
-  getSdkAPIHealthCheck: IHealthCheckAPI
-  getEventsAPIHealthCheck: IHealthCheckAPI
+	getSdkAPIHealthCheck: IHealthCheckAPI
+	getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges
@@ -62,3 +62,17 @@ export interface ISplitApi {
 	postMetricsCounters: IPostMetricsCounters
 	postMetricsTimes: IPostMetricsTimes
 }
+
+// Minimal version of EventSource API used by the SDK
+interface EventSourceEventMap {
+	'error': Event
+	'message': MessageEvent
+	'open': Event
+}
+
+interface IEventSource {
+	addEventListener<K extends keyof EventSourceEventMap>(type: K, listener: (this: IEventSource, ev: EventSourceEventMap[K]) => any): void
+	close(): void
+}
+
+export type IEventSourceConstructor = new (url: string, eventSourceInitDict?: { headers?: object }) => IEventSource

package/src/storages/inLocalStorage/index.ts

@@ -1,7 +1,7 @@
 import ImpressionsCacheInMemory from '../inMemory/ImpressionsCacheInMemory';
 import ImpressionCountsCacheInMemory from '../inMemory/ImpressionCountsCacheInMemory';
 import EventsCacheInMemory from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSyncCS, IStorageSyncFactory } from '../types';
+import { IStorageFactoryParams, IStorageSync, IStorageSyncFactory } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import KeyBuilderCS from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
@@ -25,7 +25,7 @@ export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS {
+  function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
 
     // Fallback to InMemoryStorage if LocalStorage API is not available
     if (!isLocalStorageAvailable()) {

package/src/storages/inMemory/InMemoryStorage.ts

@@ -13,9 +13,6 @@ import { STORAGE_MEMORY } from '../../utils/constants';
  */
 export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageSync {
 
-  // InMemory storage is always ready
-  if (params.onReadyCb) setTimeout(params.onReadyCb);
-
   return {
     splits: new SplitsCacheInMemory(),
     segments: new SegmentsCacheInMemory(),

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -2,7 +2,7 @@ import SplitsCacheInMemory from './SplitsCacheInMemory';
 import MySegmentsCacheInMemory from './MySegmentsCacheInMemory';
 import ImpressionsCacheInMemory from './ImpressionsCacheInMemory';
 import EventsCacheInMemory from './EventsCacheInMemory';
-import { IStorageSyncCS, IStorageFactoryParams } from '../types';
+import { IStorageSync, IStorageFactoryParams } from '../types';
 import ImpressionCountsCacheInMemory from './ImpressionCountsCacheInMemory';
 import { STORAGE_MEMORY } from '../../utils/constants';
 
@@ -11,7 +11,7 @@ import { STORAGE_MEMORY } from '../../utils/constants';
  *
  * @param params parameters required by EventsCacheSync
  */
-export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS {
+export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync {
 
   return {
     splits: new SplitsCacheInMemory(),

package/src/storages/inRedis/index.ts

@@ -30,7 +30,7 @@ export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsy
 
     // subscription to Redis connect event in order to emit SDK_READY event on consumer mode
     redisClient.on('connect', () => {
-      if (onReadyCb) onReadyCb();
+      onReadyCb();
     });
 
     return {

package/src/storages/pluggable/EventsCachePluggable.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IEventsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IEventsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
@@ -8,11 +8,11 @@ import { StoredEventWithMetadata } from '../../sync/submitters/types';
 export class EventsCachePluggable implements IEventsCacheAsync {
 
   private readonly log: ILogger;
-  private readonly wrapper: ICustomStorageWrapper;
+  private readonly wrapper: IPluggableStorageWrapper;
   private readonly key: string;
   private readonly metadata: IMetadata;
 
-  constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata) {
+  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata) {
     this.log = log;
     this.key = key;
     this.wrapper = wrapper;

package/src/storages/pluggable/ImpressionsCachePluggable.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IImpressionsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, IImpressionsCacheAsync } from '../types';
 import { IMetadata } from '../../dtos/types';
 import { ImpressionDTO } from '../../types';
 import { ILogger } from '../../logger/types';
@@ -8,10 +8,10 @@ export class ImpressionsCachePluggable implements IImpressionsCacheAsync {
 
   private readonly log: ILogger;
   private readonly key: string;
-  private readonly wrapper: ICustomStorageWrapper;
+  private readonly wrapper: IPluggableStorageWrapper;
   private readonly metadata: IMetadata;
 
-  constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata) {
+  constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata) {
     this.log = log;
     this.key = key;
     this.wrapper = wrapper;

package/src/storages/pluggable/SegmentsCachePluggable.ts

@@ -2,7 +2,7 @@
 /* eslint-disable no-unused-vars */
 import { isNaNNumber } from '../../utils/lang';
 import KeyBuilderSS from '../KeyBuilderSS';
-import { ICustomStorageWrapper, ISegmentsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 import { LOG_PREFIX } from './constants';
 import { _Set } from '../../utils/lang/sets';
@@ -14,9 +14,9 @@ export class SegmentsCachePluggable implements ISegmentsCacheAsync {
 
   private readonly log: ILogger;
   private readonly keys: KeyBuilderSS;
-  private readonly wrapper: ICustomStorageWrapper;
+  private readonly wrapper: IPluggableStorageWrapper;
 
-  constructor(log: ILogger, keys: KeyBuilderSS, wrapper: ICustomStorageWrapper) {
+  constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper) {
     this.log = log;
     this.keys = keys;
     this.wrapper = wrapper;

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -1,6 +1,6 @@
 import { isFiniteNumber, isNaNNumber } from '../../utils/lang';
 import KeyBuilder from '../KeyBuilder';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
 import { ISplit } from '../../dtos/types';
 import { LOG_PREFIX } from './constants';
@@ -13,15 +13,15 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
 
   private readonly log: ILogger;
   private readonly keys: KeyBuilder;
-  private readonly wrapper: ICustomStorageWrapper;
+  private readonly wrapper: IPluggableStorageWrapper;
 
   /**
-   * Create a SplitsCache that uses a custom storage wrapper.
+   * Create a SplitsCache that uses a storage wrapper.
    * @param log  Logger instance.
    * @param keys  Key builder.
    * @param wrapper  Adapted wrapper storage.
    */
-  constructor(log: ILogger, keys: KeyBuilder, wrapper: ICustomStorageWrapper) {
+  constructor(log: ILogger, keys: KeyBuilder, wrapper: IPluggableStorageWrapper) {
     super();
     this.log = log;
     this.keys = keys;

package/src/storages/pluggable/constants.ts

@@ -1 +1 @@
-export const LOG_PREFIX = 'storage:pluggable:';
+export const LOG_PREFIX = 'storage:pluggable: ';

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -1,15 +1,18 @@
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { startsWith, toNumber } from '../../utils/lang';
 import { ISet, setToArray, _Set } from '../../utils/lang/sets';
 
 /**
- * Creates a ICustomStorageWrapper implementation that stores items in memory.
+ * Creates a IPluggableStorageWrapper implementation that stores items in memory.
  * The `_cache` property is the object were items are stored.
  * Intended for testing purposes.
+ *
+ * @param connDelay delay in millis for `connect` resolve. If not provided, `connect` resolves inmediatelly.
  */
-export function inMemoryWrapperFactory(): ICustomStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>> } {
+export function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
 
   let _cache: Record<string, string | string[] | ISet<string>> = {};
+  let _connDelay = connDelay;
 
   return {
     /** Holds items (for key-value operations), list of items (for list operations) and set of items (for set operations) */
@@ -109,8 +112,19 @@ export function inMemoryWrapperFactory(): ICustomStorageWrapper & { _cache: Reco
       return Promise.reject('key is not a set');
     },
 
-    // always connects and close
-    connect() { return Promise.resolve(); },
-    close() { return Promise.resolve(); },
+    // always connects and disconnects
+    connect() {
+      if (typeof _connDelay === 'number') {
+        return new Promise(res => setTimeout(res, _connDelay));
+      } else {
+        return Promise.resolve();
+      }
+    },
+    disconnect() { return Promise.resolve(); },
+
+    // for testing
+    _setConnDelay(connDelay: number) {
+      _connDelay = connDelay;
+    }
   };
 }