@splitsoftware/splitio-commons 0.1.1-rc.20 → 1.0.1-rc.2

package/src/storages/types.ts

@@ -1,12 +1,12 @@
 import { MaybeThenable, IMetadata, ISplitFiltersValidation } from '../dtos/types';
 import { ILogger } from '../logger/types';
 import { StoredEventWithMetadata, StoredImpressionWithMetadata } from '../sync/submitters/types';
-import { SplitIO, ImpressionDTO } from '../types';
+import { SplitIO, ImpressionDTO, SDKMode } from '../types';
 
 /**
- * Interface of a custom wrapper storage.
+ * Interface of a pluggable storage wrapper.
  */
-export interface ICustomStorageWrapper {
+export interface IPluggableStorageWrapper {
 
   /** Key-Value operations */
 
@@ -28,7 +28,7 @@ export interface ICustomStorageWrapper {
    * @returns {Promise<void>} A promise that resolves if the operation success, whether the key was added or updated.
    * The promise rejects if the operation fails.
    */
-  set: (key: string, value: string) => Promise<void | boolean>
+  set: (key: string, value: string) => Promise<boolean | void>
   /**
    * Add or update an item with a specified `key` and `value`.
    *
@@ -47,7 +47,7 @@ export interface ICustomStorageWrapper {
    * @returns {Promise<void>} A promise that resolves if the operation success, whether the key existed and was removed or it didn't exist.
    * The promise rejects if the operation fails, for example, if there is a connection error.
    */
-  del: (key: string) => Promise<void | boolean>
+  del: (key: string) => Promise<boolean | void>
   /**
    * Returns all keys matching the given prefix.
    *
@@ -140,20 +140,20 @@ export interface ICustomStorageWrapper {
    * @function addItems
    * @param {string} key Set key
    * @param {string} items Items to add
-   * @returns {Promise<void>} A promise that resolves if the operation success.
+   * @returns {Promise<boolean | void>} A promise that resolves if the operation success.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
    */
-  addItems: (key: string, items: string[]) => Promise<void>
+  addItems: (key: string, items: string[]) => Promise<boolean | void>
   /**
    * Remove the specified `items` from the set stored at `key`. Those items that are not part of the set are ignored.
    *
    * @function removeItems
    * @param {string} key Set key
    * @param {string} items Items to remove
-   * @returns {Promise<void>} A promise that resolves if the operation success. If key does not exist, the promise also resolves.
+   * @returns {Promise<boolean | void>} A promise that resolves if the operation success. If key does not exist, the promise also resolves.
    * The promise rejects if the operation fails, for example, if there is a connection error or the key holds a value that is not a set.
    */
-  removeItems: (key: string, items: string[]) => Promise<void>
+  removeItems: (key: string, items: string[]) => Promise<boolean | void>
   /**
    * Returns all the items of the `key` set.
    *
@@ -169,7 +169,7 @@ export interface ICustomStorageWrapper {
   /**
    * Connects to the underlying storage.
    * It is meant for storages that requires to be connected to some database or server. Otherwise it can just return a resolved promise.
-   * Note: will be called once on SplitFactory instantiation.
+   * Note: will be called once on SplitFactory instantiation and once per each shared client instantiation.
    *
    * @function connect
    * @returns {Promise<void>} A promise that resolves when the wrapper successfully connect to the underlying storage.
@@ -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 client destroy.
+   * 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 */
@@ -271,7 +271,7 @@ export interface ISegmentsCacheSync extends ISegmentsCacheBase {
 export interface ISegmentsCacheAsync extends ISegmentsCacheBase {
   addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
   removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>
-  isInSegment(name: string, key?: string): Promise<boolean>
+  isInSegment(name: string, key: string): Promise<boolean>
   registerSegments(names: string[]): Promise<boolean | void>
   getRegisteredSegments(): Promise<string[]>
   setChangeNumber(name: string, changeNumber: number): Promise<boolean | void>
@@ -395,7 +395,8 @@ export interface IStorageBase<
   events: TEventsCache,
   latencies?: TLatenciesCache,
   counts?: TCountsCache,
-  destroy(): void,
+  destroy(): void | Promise<void>,
+  shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this
 }
 
 export type IStorageSync = IStorageBase<
@@ -407,15 +408,11 @@ export type IStorageSync = IStorageBase<
   ICountsCacheSync
 >
 
-export interface IStorageSyncCS extends IStorageSync {
-  shared(matchingKey: string): IStorageSync
-}
-
 export type IStorageAsync = IStorageBase<
   ISplitsCacheAsync,
   ISegmentsCacheAsync,
-  IImpressionsCacheAsync,
-  IEventsCacheAsync,
+  IImpressionsCacheAsync | IImpressionsCacheSync,
+  IEventsCacheAsync | IEventsCacheSync,
   ILatenciesCacheAsync,
   ICountsCacheAsync
 >
@@ -433,14 +430,17 @@ export interface IStorageFactoryParams {
   matchingKey?: string, /* undefined on server-side SDKs */
   splitFiltersValidation?: ISplitFiltersValidation,
 
+  // 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,
   // it means that the storge fail to connect and shouldn't be used.
   // It is meant for emitting SDK_READY event in consumer mode, and for synchronizer to wait before using the storage.
-  onReadyCb?: (error?: any) => void,
+  onReadyCb: (error?: any) => void,
   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/sync/submitters/submitterManager.ts

@@ -0,0 +1,22 @@
+import { syncTaskComposite } from '../syncTaskComposite';
+import { eventsSyncTaskFactory } from './eventsSyncTask';
+import { impressionsSyncTaskFactory } from './impressionsSyncTask';
+import { impressionCountsSyncTaskFactory } from './impressionCountsSyncTask';
+import { ISplitApi } from '../../services/types';
+import { IStorageSync } from '../../storages/types';
+import { ISettings } from '../../types';
+
+export function submitterManagerFactory(
+  settings: ISettings,
+  storage: IStorageSync,
+  splitApi: ISplitApi,
+) {
+  const log = settings.log;
+  const submitters = [
+    impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
+    eventsSyncTaskFactory(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
+    // @TODO add telemetry submitter
+  ];
+  if (storage.impressionCounts) submitters.push(impressionCountsSyncTaskFactory(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
+  return syncTaskComposite(submitters);
+}

package/src/sync/syncManagerOnline.ts

@@ -1,8 +1,5 @@
-import { ISyncManager, ISyncManagerCS, ISyncManagerFactoryParams } from './types';
-import { syncTaskComposite } from './syncTaskComposite';
-import { eventsSyncTaskFactory } from './submitters/eventsSyncTask';
-import { impressionsSyncTaskFactory } from './submitters/impressionsSyncTask';
-import { impressionCountsSyncTaskFactory } from './submitters/impressionCountsSyncTask';
+import { ISyncManagerCS, ISyncManagerFactoryParams } from './types';
+import { submitterManagerFactory } from './submitters/submitterManager';
 import { IReadinessManager } from '../readiness/types';
 import { IStorageSync } from '../storages/types';
 import { IPushManagerFactoryParams, IPushManager, IPushManagerCS } from './streaming/types';
@@ -19,7 +16,7 @@ import { SYNC_START_POLLING, SYNC_CONTINUE_POLLING, SYNC_STOP_POLLING } from '..
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
 export function syncManagerOnlineFactory(
-  pollingManagerFactory: (...args: IPollingManagerFactoryParams) => IPollingManager,
+  pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager,
   pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined
 ): (params: ISyncManagerFactoryParams) => ISyncManagerCS {
 
@@ -37,30 +34,24 @@ export function syncManagerOnlineFactory(
     const log = settings.log;
 
     /** Polling Manager */
-    const pollingManager = pollingManagerFactory(splitApi, storage, readiness, settings);
+    const pollingManager = pollingManagerFactory && pollingManagerFactory(splitApi, storage, readiness, settings);
 
     /** Push Manager */
-    const pushManager = settings.streamingEnabled && pushManagerFactory ?
+    const pushManager = settings.streamingEnabled && pollingManager && pushManagerFactory ?
       pushManagerFactory(pollingManager, storage, readiness, splitApi.fetchAuth, platform, settings) :
       undefined;
 
     /** Submitter Manager */
-    // It is not inyected via a factory as push and polling managers, because at the moment it is mandatory and the same for server-side and client-side variants
-    const submitters = [
-      impressionsSyncTaskFactory(log, splitApi.postTestImpressionsBulk, storage.impressions, settings.scheduler.impressionsRefreshRate, settings.core.labelsEnabled),
-      eventsSyncTaskFactory(log, splitApi.postEventsBulk, storage.events, settings.scheduler.eventsPushRate, settings.startup.eventsFirstPushWindow)
-      // @TODO add telemetry submitter
-    ];
-    if (storage.impressionCounts) submitters.push(impressionCountsSyncTaskFactory(log, splitApi.postTestImpressionsCount, storage.impressionCounts));
-    const submitter = syncTaskComposite(submitters);
+    // It is not inyected as push and polling managers, because at the moment it is required
+    const submitter = submitterManagerFactory(settings, storage, splitApi);
 
 
     /** Sync Manager logic */
 
     function startPolling() {
-      if (!pollingManager.isRunning()) {
+      if (!pollingManager!.isRunning()) {
         log.info(SYNC_START_POLLING);
-        pollingManager.start();
+        pollingManager!.start();
       } else {
         log.info(SYNC_CONTINUE_POLLING);
       }
@@ -69,10 +60,10 @@ export function syncManagerOnlineFactory(
     function stopPollingAndSyncAll() {
       log.info(SYNC_STOP_POLLING);
       // if polling, stop
-      if (pollingManager.isRunning()) pollingManager.stop();
+      if (pollingManager!.isRunning()) pollingManager!.stop();
 
       // fetch splits and segments. There is no need to catch this promise (it is always resolved)
-      pollingManager.syncAll();
+      pollingManager!.syncAll();
     }
 
     if (pushManager) {
@@ -91,15 +82,17 @@ export function syncManagerOnlineFactory(
        */
       start() {
         // start syncing splits and segments
-        if (pushManager) {
-          // Doesn't call `syncAll` when the syncManager is resuming
-          if (startFirstTime) {
-            pollingManager.syncAll();
-            startFirstTime = false;
+        if (pollingManager) {
+          if (pushManager) {
+            // Doesn't call `syncAll` when the syncManager is resuming
+            if (startFirstTime) {
+              pollingManager.syncAll();
+              startFirstTime = false;
+            }
+            pushManager.start();
+          } else {
+            pollingManager.start();
           }
-          pushManager.start();
-        } else {
-          pollingManager.start();
         }
 
         // start periodic data recording (events, impressions, telemetry).
@@ -113,7 +106,7 @@ export function syncManagerOnlineFactory(
       stop() {
         // stop syncing
         if (pushManager) pushManager.stop();
-        if (pollingManager.isRunning()) pollingManager.stop();
+        if (pollingManager && pollingManager.isRunning()) pollingManager.stop();
 
         // stop periodic data recording (events, impressions, telemetry).
         if (submitter) submitter.stop();
@@ -130,8 +123,9 @@ export function syncManagerOnlineFactory(
       },
 
       // [Only used for client-side]
-      // It assumes that polling and push managers implement the interfaces for client-side
-      shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager {
+      // If polling and push managers are defined (standalone mode), they implement the interfaces for client-side
+      shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync) {
+        if (!pollingManager) return;
 
         const mySegmentsSyncTask = (pollingManager as IPollingManagerCS).add(matchingKey, readinessManager, storage);
 
@@ -139,7 +133,7 @@ export function syncManagerOnlineFactory(
           isRunning: mySegmentsSyncTask.isRunning,
           start() {
             if (pushManager) {
-              if (pollingManager.isRunning()) {
+              if (pollingManager!.isRunning()) {
                 // if doing polling, we must start the periodic fetch of data
                 if (storage.splits.usesSegments()) mySegmentsSyncTask.start();
               } else {

package/src/sync/types.ts

@@ -47,7 +47,7 @@ export interface ISyncManager extends ITask {
 }
 
 export interface ISyncManagerCS extends ISyncManager {
-  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager
+  shared(matchingKey: string, readinessManager: IReadinessManager, storage: IStorageSync): ISyncManager | undefined
 }
 
 export interface ISyncManagerFactoryParams {

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/trackers/impressionObserver/utils.ts

@@ -1,11 +1,11 @@
-import { OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
+import { CONSUMER_PARTIAL_MODE, OPTIMIZED, PRODUCER_MODE, STANDALONE_MODE } from '../../utils/constants';
 import { ISettings } from '../../types';
 
 /**
  * Checks if impressions previous time should be added or not.
  */
 export function shouldAddPt(settings: ISettings) {
-  return [PRODUCER_MODE, STANDALONE_MODE].indexOf(settings.mode) > -1 ? true : false;
+  return [PRODUCER_MODE, STANDALONE_MODE, CONSUMER_PARTIAL_MODE].indexOf(settings.mode) > -1 ? true : false;
 }
 
 /**

package/src/types.ts

@@ -3,7 +3,7 @@ import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
 /* eslint-disable no-use-before-define */
 
-import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync, IStorageSyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
 import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 
 /**
@@ -52,7 +52,7 @@ type EventConsts = {
  * SDK Modes.
  * @typedef {string} SDKMode
  */
-export type SDKMode = 'standalone' | 'consumer' | 'localhost';
+export type SDKMode = 'standalone' | 'consumer' | 'localhost' | 'consumer_partial';
 /**
  * Settings interface. This is a representation of the settings the SDK expose, that's why
  * most of it's props are readonly. Only features should be rewritten when localhost mode is active.
@@ -85,7 +85,7 @@ export interface ISettings {
     retriesOnFailureBeforeReady: number,
     eventsFirstPushWindow: number
   },
-  readonly storage: IStorageSyncFactory,
+  readonly storage: IStorageSyncFactory | IStorageAsyncFactory,
   readonly integrations?: Array<(params: IIntegrationFactoryParams) => IIntegration | void>,
   readonly urls: {
     events: string,
@@ -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,
@@ -841,7 +841,7 @@ export namespace SplitIO {
      * Defines which kind of storage we should instanciate.
      * @property {Object} storage
      */
-    storage?: (params: IStorageFactoryParams) => IStorageSyncCS,
+    storage?: (params: IStorageFactoryParams) => IStorageSync | IStorageAsync,
     /**
      * List of URLs that the SDK will use as base for it's synchronization functionalities, applicable only when running as standalone.
      * Do not change these settings unless you're working an advanced use case, like connecting to the Split proxy.

package/src/utils/constants/index.ts

@@ -1,4 +1,5 @@
 import { StorageType } from '../../storages/types';
+import { SDKMode } from '../../types';
 
 // Special treatments
 export const CONTROL = 'control';
@@ -20,13 +21,14 @@ export const DEBUG = 'DEBUG';
 export const OPTIMIZED = 'OPTIMIZED';
 
 // SDK Modes
-export const LOCALHOST_MODE = 'localhost';
-export const STANDALONE_MODE = 'standalone';
+export const LOCALHOST_MODE: SDKMode = 'localhost';
+export const STANDALONE_MODE: SDKMode = 'standalone';
 export const PRODUCER_MODE = 'producer';
-export const CONSUMER_MODE = 'consumer';
+export const CONSUMER_MODE: SDKMode = 'consumer';
+export const CONSUMER_PARTIAL_MODE: SDKMode = 'consumer_partial';
 
 // Storage types
 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/mode.ts

@@ -1,10 +1,10 @@
-import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE } from '../constants';
+import { LOCALHOST_MODE, STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE } from '../constants';
 
 export default function mode(key: string, mode: string) {
   // Leaving the comparison as is, in case we change the mode name but not the setting.
   if (key === 'localhost') return LOCALHOST_MODE;
 
-  if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE].indexOf(mode) === -1) throw Error('Invalid mode provided');
+  if ([STANDALONE_MODE, PRODUCER_MODE, CONSUMER_MODE, CONSUMER_PARTIAL_MODE].indexOf(mode) === -1) throw Error('Invalid mode provided');
 
   return mode;
 }

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

@@ -1,11 +1,11 @@
 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, STORAGE_LOCALSTORAGE, STORAGE_MEMORY } from '../../../utils/constants';
-import { IStorageFactoryParams, IStorageSyncCS } from '../../../storages/types';
+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): IStorageSyncCS {
+export function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync {
   const result = InMemoryStorageCSFactory(params);
   result.splits.checkCache = () => true; // to emit SDK_READY_FROM_CACHE
   return result;
@@ -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'] {
+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.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
@@ -33,6 +35,17 @@ export function validateStorageCS(settings: { log: ILogger, storage?: any, mode?
     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/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/inMemory/InMemoryStorageCS.d.ts

@@ -1,10 +1,10 @@
-import { IStorageSyncCS, IStorageFactoryParams } from '../types';
+import { IStorageSync, IStorageFactoryParams } from '../types';
 /**
  * InMemory storage factory for standalone client-side SplitFactory
  *
  * @param params parameters required by EventsCacheSync
  */
-export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS;
+export declare function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorageSync;
 export declare namespace InMemoryStorageCSFactory {
     var type: import("../types").StorageType;
 }

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,19 +8,19 @@ 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
      * or rejected if wrapper operation fails.
      */
-    addToSegment(name: string, segmentKeys: string[]): Promise<void>;
+    addToSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
     /**
      * Remove a list of `segmentKeys` from the given segment `name`.
      * The returned promise is resolved when the operation success
      * or rejected if wrapper operation fails.
      */
-    removeFromSegment(name: string, segmentKeys: string[]): Promise<void>;
+    removeFromSegment(name: string, segmentKeys: string[]): Promise<boolean | void>;
     /**
      * Returns a promise that resolves with a boolean value indicating if `key` is part of `name` segment.
      * Promise can be rejected if wrapper operation fails.
@@ -43,7 +43,7 @@ export declare class SegmentsCachePluggable implements ISegmentsCacheAsync {
      * The returned promise is resolved when the operation success,
      * or rejected if it fails (e.g., wrapper operation fails).
      */
-    registerSegments(segments: string[]): Promise<void>;
+    registerSegments(segments: string[]): Promise<boolean | void>;
     /**
      * Returns a promise that resolves with the set of registered segments in a list,
      * or rejected if it fails (e.g., wrapper operation fails).

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,10 +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(): ICustomStorageWrapper & {
+export declare function inMemoryWrapperFactory(connDelay?: number): IPluggableStorageWrapper & {
     _cache: Record<string, string | string[] | ISet<string>>;
+    _setConnDelay(connDelay: number): void;
 };