@splitsoftware/splitio-commons 1.0.1-rc.1 → 1.0.1-rc.2

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/inMemoryWrapper.ts

@@ -1,15 +1,15 @@
-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(connDelay?: number): ICustomStorageWrapper & { _cache: Record<string, string | string[] | ISet<string>>, _setConnDelay(connDelay: number): void } {
+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;
@@ -112,7 +112,7 @@ export function inMemoryWrapperFactory(connDelay?: number): ICustomStorageWrappe
       return Promise.reject('key is not a set');
     },
 
-    // always connects and close
+    // always connects and disconnects
     connect() {
       if (typeof _connDelay === 'number') {
         return new Promise(res => setTimeout(res, _connDelay));
@@ -120,7 +120,7 @@ export function inMemoryWrapperFactory(connDelay?: number): ICustomStorageWrappe
         return Promise.resolve();
       }
     },
-    close() { return Promise.resolve(); },
+    disconnect() { return Promise.resolve(); },
 
     // for testing
     _setConnDelay(connDelay: number) {

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
+import { IPluggableStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 
 import KeyBuilderSS from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -8,17 +8,17 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { validatePrefix } from '../KeyBuilder';
-import { CONSUMER_PARTIAL_MODE, STORAGE_CUSTOM } from '../../utils/constants';
+import { CONSUMER_PARTIAL_MODE, STORAGE_PLUGGABLE } from '../../utils/constants';
 import ImpressionsCacheInMemory from '../inMemory/ImpressionsCacheInMemory';
 import EventsCacheInMemory from '../inMemory/EventsCacheInMemory';
 import ImpressionCountsCacheInMemory from '../inMemory/ImpressionCountsCacheInMemory';
 
-const NO_VALID_WRAPPER = 'Expecting custom storage `wrapper` in options, but no valid wrapper instance was provided.';
+const NO_VALID_WRAPPER = 'Expecting pluggable storage `wrapper` in options, but no valid wrapper instance was provided.';
 const NO_VALID_WRAPPER_INTERFACE = 'The provided wrapper instance doesn’t follow the expected interface. Check our docs.';
 
 export interface PluggableStorageOptions {
   prefix?: string
-  wrapper: ICustomStorageWrapper
+  wrapper: IPluggableStorageWrapper
 }
 
 /**
@@ -36,7 +36,7 @@ function validatePluggableStorageOptions(options: any) {
 }
 
 // subscription to wrapper connect event in order to emit SDK_READY event
-function wrapperConnect(wrapper: ICustomStorageWrapper, onReadyCb: (error?: any) => void) {
+function wrapperConnect(wrapper: IPluggableStorageWrapper, onReadyCb: (error?: any) => void) {
   wrapper.connect().then(() => {
     onReadyCb();
   }).catch((e) => {
@@ -68,7 +68,7 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
     const wrapper = wrapperAdapter(log, options.wrapper);
     const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
 
-    // emit SDK_READY event on main client
+    // Connects to wrapper and emits SDK_READY event on main client
     wrapperConnect(wrapper, onReadyCb);
 
     return {
@@ -79,9 +79,9 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
       events: isPartialConsumer ? promisifyEventsTrack(new EventsCacheInMemory(eventsQueueSize)) : new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
       // @TODO add telemetry cache when required
 
-      // Disconnect the underlying storage, to release its resources (such as open files, database connections, etc).
+      // Disconnect the underlying storage
       destroy() {
-        return wrapper.close();
+        return wrapper.disconnect();
       },
 
       // emits SDK_READY event on shared clients and returns a reference to the storage
@@ -89,13 +89,13 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
         wrapperConnect(wrapper, onReadyCb);
         return {
           ...this,
-          // no-op destroy, to close the wrapper only when the main client is destroyed
+          // no-op destroy, to disconnect the wrapper only when the main client is destroyed
           destroy() { }
         };
       }
     };
   }
 
-  PluggableStorageFactory.type = STORAGE_CUSTOM;
+  PluggableStorageFactory.type = STORAGE_PLUGGABLE;
   return PluggableStorageFactory;
 }

package/src/storages/pluggable/wrapperAdapter.ts

@@ -1,5 +1,5 @@
 import { ILogger } from '../../logger/types';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { LOG_PREFIX } from './constants';
 
 export const METHODS_TO_PROMISE_WRAP: string[] = [
@@ -19,18 +19,18 @@ export const METHODS_TO_PROMISE_WRAP: string[] = [
   'removeItems',
   'getItems',
   'connect',
-  'close'
+  'disconnect'
 ];
 
 /**
- * Adapter of the Custom Storage Wrapper.
+ * Adapter of the Pluggable Storage Wrapper.
  * Used to handle exceptions as rejected promises, in order to simplify the error handling on storages.
  *
  * @param log logger instance
- * @param wrapper custom storage wrapper to adapt
+ * @param wrapper storage wrapper to adapt
  * @returns an adapted version of the given storage wrapper
  */
-export function wrapperAdapter(log: ILogger, wrapper: ICustomStorageWrapper): ICustomStorageWrapper {
+export function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper {
 
   const wrapperAdapter: Record<string, Function> = {};
 

package/src/storages/types.ts

@@ -4,9 +4,9 @@ import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/s
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
- * Interface of a custom storage wrapper.
+ * Interface of a pluggable storage wrapper.
  */
-export interface ICustomStorageWrapper {
+export interface IPluggableStorageWrapper {
 
   /** Key-Value operations */
 
@@ -177,15 +177,15 @@ export interface ICustomStorageWrapper {
    */
   connect: () => Promise<void>
   /**
-   * Disconnects the underlying storage.
+   * Disconnects from the underlying storage.
    * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
    * Note: will be called once on SplitFactory main client destroy.
    *
-   * @function close
+   * @function disconnect
    * @returns {Promise<void>} A promise that resolves when the operation ends.
    * The promise never rejects.
    */
-  close: () => Promise<void>
+  disconnect: () => Promise<void>
 }
 
 /** Splits cache */
@@ -430,7 +430,7 @@ export interface IStorageFactoryParams {
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,
 
-  // ATM, only used by CustomStorage. True for partial consumer mode
+  // ATM, only used by PluggableStorage
   mode?: SDKMode,
 
   // This callback is invoked when the storage is ready to be used. Error-first callback style: if an error is passed,
@@ -440,7 +440,7 @@ export interface IStorageFactoryParams {
   metadata: IMetadata,
 }
 
-export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+export type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 
 export type IStorageSyncFactory = {
   type: StorageType,

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

@@ -38,7 +38,7 @@ export function mySegmentsUpdaterFactory(
     // mySegmentsPromise = tracker.start(tracker.TaskNames.MY_SEGMENTS_FETCH, startingUp ? metricCollectors : false, mySegmentsPromise);
   }
 
-  // @TODO if allowing custom storages, handle async execution
+  // @TODO if allowing pluggable storages, handle async execution
   function updateSegments(segmentsData: SegmentsData) {
 
     let shouldNotifyUpdate;

package/src/sync/streaming/UpdateWorkers/SplitsUpdateWorker.ts

@@ -83,7 +83,6 @@ export default class SplitsUpdateWorker implements IUpdateWorker {
    * @param {string} defaultTreatment default treatment value
    */
   killSplit({ changeNumber, splitName, defaultTreatment }: ISplitKillData) {
-    // @TODO handle retry due to errors in storage, once we allow the definition of custom async storages
     if (this.splitsCache.killLocally(splitName, defaultTreatment, changeNumber)) {
       // trigger an SDK_UPDATE if Split was killed locally
       this.splitsEventEmitter.emit(SDK_SPLITS_ARRIVED, true);

package/src/trackers/impressionObserver/ImpressionObserver.ts

@@ -2,7 +2,7 @@ import { ImpressionDTO } from '../../types';
 import LRUCache from '../../utils/LRUCache';
 import { IImpressionObserver } from './types';
 
-export default class ImpressionObserver<K extends string | number> implements IImpressionObserver {
+export default class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
   private cache: LRUCache<K, number>;
   private hasher: (impression: ImpressionDTO) => K;
 

package/src/types.ts

@@ -93,7 +93,7 @@ export interface ISettings {
     auth: string,
     streaming: string
   },
-  readonly debug: boolean | LogLevel,
+  readonly debug: boolean | LogLevel | ILogger,
   readonly version: string,
   features: SplitIO.MockedFeaturesFilePath | SplitIO.MockedFeaturesMap,
   readonly streamingEnabled: boolean,

package/src/utils/constants/index.ts

@@ -31,4 +31,4 @@ export const CONSUMER_PARTIAL_MODE: SDKMode = 'consumer_partial';
 export const STORAGE_MEMORY: StorageType = 'MEMORY';
 export const STORAGE_LOCALSTORAGE: StorageType = 'LOCALSTORAGE';
 export const STORAGE_REDIS: StorageType = 'REDIS';
-export const STORAGE_CUSTOM: StorageType = 'CUSTOM';
+export const STORAGE_PLUGGABLE: StorageType = 'PLUGGABLE';

package/src/utils/settingsValidation/storage/storageCS.ts

@@ -1,8 +1,8 @@
 import { InMemoryStorageCSFactory } from '../../../storages/inMemory/InMemoryStorageCS';
 import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
-import { WARN_STORAGE_INVALID } from '../../../logger/constants';
-import { LOCALHOST_MODE, STANDALONE_MODE, STORAGE_CUSTOM, 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';
 import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
 
 export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
@@ -17,15 +17,17 @@ __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: { log: ILogger, storage?: any, mode: SDKMode }): ISettings['storage'] {
   let { storage = InMemoryStorageCSFactory, log, mode } = settings;
 
   // If an invalid storage is provided, fallback into MEMORY
-  if (typeof storage !== 'function' || [STORAGE_MEMORY, STORAGE_LOCALSTORAGE, STORAGE_CUSTOM].indexOf(storage.type) === -1) {
+  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
@@ -33,13 +35,15 @@ export function validateStorageCS(settings: { log: ILogger, storage?: any, mode:
     return __InLocalStorageMockFactory;
   }
 
-  // @TODO check behaviour
   if ([LOCALHOST_MODE, STANDALONE_MODE].indexOf(mode) === -1) {
     // Consumer modes require an async storage
-    if (storage.type !== STORAGE_CUSTOM) throw new Error('A CustomStorage instance is required on consumer modes');
+    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_CUSTOM) throw new Error('A CustomStorage instance cannot be used on standalone and localhost modes');
+    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

package/types/logger/constants.d.ts

@@ -89,9 +89,8 @@ export declare const WARN_INTEGRATION_INVALID = 218;
 export declare const WARN_SPLITS_FILTER_IGNORED = 219;
 export declare const WARN_SPLITS_FILTER_INVALID = 220;
 export declare const WARN_SPLITS_FILTER_EMPTY = 221;
-export declare const WARN_STORAGE_INVALID = 222;
-export declare const WARN_API_KEY = 223;
-export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
+export declare const WARN_API_KEY = 222;
+export declare const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 223;
 export declare const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export declare const ERROR_LOGLEVEL_INVALID = 301;
 export declare const ERROR_CLIENT_LISTENER = 302;
@@ -116,6 +115,7 @@ export declare const ERROR_EMPTY_ARRAY = 320;
 export declare const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export declare const ERROR_HTTP = 322;
 export declare const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
+export declare const ERROR_STORAGE_INVALID = 324;
 export declare const LOG_PREFIX_SETTINGS = "settings";
 export declare const LOG_PREFIX_INSTANTIATION = "Factory instantiation";
 export declare const LOG_PREFIX_ENGINE = "engine";

package/types/services/splitApi.d.ts

@@ -7,4 +7,4 @@ import { ISplitApi } from './types';
  * @param settings validated settings object
  * @param platform object containing environment-specific `getFetch` and `getOptions` dependencies
  */
-export declare function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;
+export declare function splitApiFactory(settings: Pick<ISettings, 'urls' | 'sync' | 'log' | 'version' | 'runtime' | 'core'>, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi;

package/types/storages/pluggable/EventsCachePluggable.d.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,7 +8,7 @@ export declare class EventsCachePluggable implements IEventsCacheAsync {
     private readonly wrapper;
     private readonly key;
     private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata);
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
     /**
      * Push given event to the storage.
      * @param eventData  Event item to push.

package/types/storages/pluggable/ImpressionsCachePluggable.d.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,7 +8,7 @@ export declare class ImpressionsCachePluggable implements IImpressionsCacheAsync
     private readonly key;
     private readonly wrapper;
     private readonly metadata;
-    constructor(log: ILogger, key: string, wrapper: ICustomStorageWrapper, metadata: IMetadata);
+    constructor(log: ILogger, key: string, wrapper: IPluggableStorageWrapper, metadata: IMetadata);
     /**
      * Push given impressions to the storage.
      * @param impressions  List of impresions to push.

package/types/storages/pluggable/SegmentsCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import KeyBuilderSS from '../KeyBuilderSS';
-import { ICustomStorageWrapper, ISegmentsCacheAsync } from '../types';
+import { IPluggableStorageWrapper, ISegmentsCacheAsync } from '../types';
 import { ILogger } from '../../logger/types';
 /**
  * ISegmentsCacheAsync implementation for pluggable storages.
@@ -8,7 +8,7 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
     private readonly log;
     private readonly keys;
     private readonly wrapper;
-    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: ICustomStorageWrapper);
+    constructor(log: ILogger, keys: KeyBuilderSS, wrapper: IPluggableStorageWrapper);
     /**
      * Add a list of `segmentKeys` to the given segment `name`.
      * The returned promise is resolved when the operation success

package/types/storages/pluggable/SplitsCachePluggable.d.ts

@@ -1,5 +1,5 @@
 import KeyBuilder from '../KeyBuilder';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { ILogger } from '../../logger/types';
 import AbstractSplitsCacheAsync from '../AbstractSplitsCacheAsync';
 /**
@@ -10,12 +10,12 @@ export declare class SplitsCachePluggable extends AbstractSplitsCacheAsync {
     private readonly keys;
     private readonly wrapper;
     /**
-     * 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);
     private _decrementCounts;
     private _incrementCounts;
     /**

package/types/storages/pluggable/inMemoryWrapper.d.ts

@@ -1,13 +1,13 @@
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 import { ISet } 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 declare function inMemoryWrapperFactory(connDelay?: number): ICustomStorageWrapper & {
+export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;
     _setConnDelay(connDelay: number): void;
 };

package/types/storages/pluggable/index.d.ts

@@ -1,7 +1,7 @@
-import { ICustomStorageWrapper, IStorageAsyncFactory } from '../types';
+import { IPluggableStorageWrapper, IStorageAsyncFactory } from '../types';
 export interface PluggableStorageOptions {
     prefix?: string;
-    wrapper: ICustomStorageWrapper;
+    wrapper: IPluggableStorageWrapper;
 }
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.

package/types/storages/pluggable/wrapperAdapter.d.ts

@@ -1,12 +1,12 @@
 import { ILogger } from '../../logger/types';
-import { ICustomStorageWrapper } from '../types';
+import { IPluggableStorageWrapper } from '../types';
 export declare const METHODS_TO_PROMISE_WRAP: string[];
 /**
- * Adapter of the Custom Storage Wrapper.
+ * Adapter of the Pluggable Storage Wrapper.
  * Used to handle exceptions as rejected promises, in order to simplify the error handling on storages.
  *
  * @param log logger instance
- * @param wrapper custom storage wrapper to adapt
+ * @param wrapper storage wrapper to adapt
  * @returns an adapted version of the given storage wrapper
  */
-export declare function wrapperAdapter(log: ILogger, wrapper: ICustomStorageWrapper): ICustomStorageWrapper;
+export declare function wrapperAdapter(log: ILogger, wrapper: IPluggableStorageWrapper): IPluggableStorageWrapper;

package/types/storages/types.d.ts

@@ -3,9 +3,9 @@ import { ILogger } from '../logger/types';
 import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/submitters/types';
 import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 /**
- * Interface of a custom storage wrapper.
+ * Interface of a pluggable storage wrapper.
  */
-export interface ICustomStorageWrapper {
+export interface IPluggableStorageWrapper {
     /** Key-Value operations */
     /**
      * Get the value of given `key`.
@@ -166,15 +166,15 @@ export interface ICustomStorageWrapper {
      */
     connect: () => Promise<void>;
     /**
-     * Disconnects the underlying storage.
+     * Disconnects from the underlying storage.
      * It is meant for storages that requires to be closed, in order to release resources. Otherwise it can just return a resolved promise.
      * Note: will be called once on SplitFactory main client destroy.
      *
-     * @function close
+     * @function disconnect
      * @returns {Promise<void>} A promise that resolves when the operation ends.
      * The promise never rejects.
      */
-    close: () => Promise<void>;
+    disconnect: () => Promise<void>;
 }
 /** Splits cache */
 export interface ISplitsCacheBase {
@@ -343,7 +343,7 @@ export interface IStorageFactoryParams {
     onReadyCb: (error?: any) => void;
     metadata: IMetadata;
 }
-export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'CUSTOM';
+export declare type StorageType = 'MEMORY' | 'LOCALSTORAGE' | 'REDIS' | 'PLUGGABLE';
 export declare type IStorageSyncFactory = {
     type: StorageType;
     (params: IStorageFactoryParams): IStorageSync;

package/types/trackers/impressionObserver/ImpressionObserver.d.ts

@@ -1,6 +1,6 @@
 import { ImpressionDTO } from '../../types';
 import { IImpressionObserver } from './types';
-export default class ImpressionObserver<K extends string | number> implements IImpressionObserver {
+export default class ImpressionObserver<K extends string | number = string> implements IImpressionObserver {
     private cache;
     private hasher;
     constructor(size: number, hasher: (impression: ImpressionDTO) => K);

package/types/types.d.ts

@@ -88,7 +88,7 @@ export interface ISettings {
         auth: string;
         streaming: string;
     };
-    readonly debug: boolean | LogLevel;
+    readonly debug: boolean | LogLevel | ILogger;
     readonly version: string;
     features: SplitIO.MockedFeaturesFilePath | SplitIO.MockedFeaturesMap;
     readonly streamingEnabled: boolean;

package/types/utils/constants/index.d.ts

@@ -19,4 +19,4 @@ export declare const CONSUMER_PARTIAL_MODE: SDKMode;
 export declare const STORAGE_MEMORY: StorageType;
 export declare const STORAGE_LOCALSTORAGE: StorageType;
 export declare const STORAGE_REDIS: StorageType;
-export declare const STORAGE_CUSTOM: StorageType;
+export declare const STORAGE_PLUGGABLE: StorageType;

package/types/utils/settingsValidation/storage/storageCS.d.ts

@@ -10,7 +10,9 @@ export declare namespace __InLocalStorageMockFactory {
  *
  * @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 declare function validateStorageCS(settings: {
     log: ILogger;