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

package/esm/sync/polling/updaters/mySegmentsUpdater.js

@@ -19,7 +19,7 @@ export function mySegmentsUpdaterFactory(log, mySegmentsFetcher, splitsCache, my
         // NOTE: We only collect metrics on startup.
         // 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) {
         var shouldNotifyUpdate;
         if (Array.isArray(segmentsData)) {

package/esm/sync/streaming/SSEClient/index.js

@@ -32,7 +32,6 @@ var SSEClient = /** @class */ (function () {
      * @throws 'EventSource API is not available. ' if EventSource is not available.
      */
     function SSEClient(settings, useHeaders, getEventSource) {
-        // @ts-expect-error
         this.eventSource = getEventSource && getEventSource();
         // if eventSource is not available, throw an exception
         if (!this.eventSource)

package/esm/sync/streaming/UpdateWorkers/SplitsUpdateWorker.js

@@ -67,7 +67,6 @@ var SplitsUpdateWorker = /** @class */ (function () {
      */
     SplitsUpdateWorker.prototype.killSplit = function (_a) {
         var changeNumber = _a.changeNumber, splitName = _a.splitName, defaultTreatment = _a.defaultTreatment;
-        // @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/esm/utils/MinEventEmitter.js

@@ -33,13 +33,13 @@ var EventEmitter = /** @class */ (function () {
     EventEmitter.prototype.once = function (type, listener) {
         return this.registerListener(type, listener, true);
     };
-    // eslint-disable-next-line
-    EventEmitter.prototype.removeListener = function (type, listener) {
+    // @ts-ignore
+    EventEmitter.prototype.removeListener = function ( /* type: string, listener: (...args: any[]) => void */) {
         throw new Error('Method not implemented.');
     };
-    // alias of removeListener
-    EventEmitter.prototype.off = function (type, listener) {
-        return this.removeListener(type, listener);
+    // @ts-ignore alias of removeListener
+    EventEmitter.prototype.off = function ( /* type: string, listener: (...args: any[]) => void */) {
+        return this.removeListener( /* type, listener */);
     };
     EventEmitter.prototype.emit = function (type) {
         var args = [];

package/esm/utils/MinEvents.js

@@ -35,12 +35,9 @@ var ReflectApply = R && typeof R.apply === 'function'
     : function ReflectApply(target, receiver, args) {
         return Function.prototype.apply.call(target, receiver, args);
     };
-function EventEmitter() {
+export var EventEmitter = function EventEmitter() {
     EventEmitter.init.call(this);
-}
-export default EventEmitter;
-// Backwards-compat with node 0.10.x
-EventEmitter.EventEmitter = EventEmitter;
+};
 EventEmitter.prototype._events = undefined;
 EventEmitter.prototype._eventsCount = 0;
 function checkListener(listener) {

package/esm/utils/constants/index.js

@@ -23,4 +23,4 @@ export var CONSUMER_PARTIAL_MODE = 'consumer_partial';
 export var STORAGE_MEMORY = 'MEMORY';
 export var STORAGE_LOCALSTORAGE = 'LOCALSTORAGE';
 export var STORAGE_REDIS = 'REDIS';
-export var STORAGE_CUSTOM = 'CUSTOM';
+export var STORAGE_PLUGGABLE = 'PLUGGABLE';

package/esm/utils/env/isNode.js

@@ -1,3 +1,6 @@
-// We check for version truthiness since most shims will have that as empty string.
+/**
+ * 'true' if running in Node.js, or 'false' otherwise.
+ * We check for version truthiness since most shims will have that as empty string.
+ */
 // eslint-disable-next-line no-undef
 export var isNode = typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version ? true : false;

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, 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';
 export function __InLocalStorageMockFactory(params) {
     var result = InMemoryStorageCSFactory(params);
     result.splits.checkCache = function () { return true; }; // to emit SDK_READY_FROM_CACHE
@@ -12,29 +12,32 @@ __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_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
     if (mode === LOCALHOST_MODE && storage.type === STORAGE_LOCALSTORAGE) {
         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
     return storage;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.0.1-rc.1",
+  "version": "1.0.1-rc.5",
   "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/evaluator/index.ts

@@ -1,7 +1,6 @@
 import Engine from './Engine';
 import thenable from '../utils/promise/thenable';
 import * as LabelsConstants from '../utils/labels';
-import { get } from '../utils/lang';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
@@ -106,17 +105,17 @@ function getEvaluation(
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async, evaluation and changeNumber will return a thenable
+    // If the storage is async and the evaluated split uses segment, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();
-        result.config = get(splitJSON, `configurations.${result.treatment}`, null);
+        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
 
         return result;
       });
     } else {
       evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
-      evaluation.config = get(splitJSON, `configurations.${evaluation.treatment}`, null);
+      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
     }
   }
 

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/sdkFactory/index.ts

@@ -40,7 +40,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
     matchingKey: getMatching(settings.core.key),
     splitFiltersValidation: settings.sync.__splitFiltersValidation,
 
-    // ATM, only used by CustomStorage. true for partial consumer mode
+    // ATM, only used by PluggableStorage
     mode: settings.mode,
 
     // Callback used to emit SDK_READY in consumer mode, where `syncManagerFactory` is undefined

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?: any) => IEventSource

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,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;