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

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/env/isNode.ts

@@ -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 const isNode: boolean = typeof process !== 'undefined' && typeof process.version !== 'undefined' && !!process.version ? true : false;

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/sdkFactory/types.d.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';
@@ -15,7 +15,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/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/services/types.d.ts

@@ -34,3 +34,16 @@ export interface ISplitApi {
     postMetricsCounters: IPostMetricsCounters;
     postMetricsTimes: IPostMetricsTimes;
 }
+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 declare type IEventSourceConstructor = new (url: string, eventSourceInitDict?: {
+    headers?: object;
+}) => IEventSource;
+export {};

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/constants.d.ts

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

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

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

@@ -1,11 +1,11 @@
 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 */
     /**
      * Get the value of given `key`.
@@ -25,7 +25,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`.
      *
@@ -44,7 +44,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.
      *
@@ -131,20 +131,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.
      *
@@ -158,7 +158,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.
@@ -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 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 */
 export interface ISplitsCacheBase {
@@ -247,7 +247,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>;
@@ -326,13 +326,11 @@ export interface IStorageBase<TSplitsCache extends ISplitsCacheBase, TSegmentsCa
     events: TEventsCache;
     latencies?: TLatenciesCache;
     counts?: TCountsCache;
-    destroy(): void;
+    destroy(): void | Promise<void>;
+    shared?: (matchingKey: string, onReadyCb: (error?: any) => void) => this;
 }
 export declare type IStorageSync = IStorageBase<ISplitsCacheSync, ISegmentsCacheSync, IImpressionsCacheSync, IEventsCacheSync, ILatenciesCacheSync, ICountsCacheSync>;
-export interface IStorageSyncCS extends IStorageSync {
-    shared(matchingKey: string): IStorageSync;
-}
-export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync, IEventsCacheAsync, ILatenciesCacheAsync, ICountsCacheAsync>;
+export declare type IStorageAsync = IStorageBase<ISplitsCacheAsync, ISegmentsCacheAsync, IImpressionsCacheAsync | IImpressionsCacheSync, IEventsCacheAsync | IEventsCacheSync, ILatenciesCacheAsync, ICountsCacheAsync>;
 /** StorageFactory */
 export declare type DataLoader = (storage: IStorageSync, matchingKey: string) => void;
 export interface IStorageFactoryParams {
@@ -341,10 +339,11 @@ export interface IStorageFactoryParams {
     optimize?: boolean;
     matchingKey?: string;
     splitFiltersValidation?: ISplitFiltersValidation;
-    onReadyCb?: (error?: any) => void;
+    mode?: SDKMode;
+    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/sync/streaming/SSEClient/index.d.ts

@@ -1,3 +1,4 @@
+import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
@@ -5,9 +6,9 @@ import { ISSEClient, ISseEventHandler } from './types';
  * Handles streaming connections with EventSource API
  */
 export default class SSEClient implements ISSEClient {
-    eventSource: typeof EventSource;
+    eventSource?: IEventSourceConstructor;
     streamingUrl: string;
-    connection?: InstanceType<typeof EventSource>;
+    connection?: InstanceType<IEventSourceConstructor>;
     handler?: ISseEventHandler;
     useHeaders?: boolean;
     headers: Record<string, string>;
@@ -19,7 +20,7 @@ export default class SSEClient implements ISSEClient {
      * @param getEventSource Function to get the EventSource constructor.
      * @throws 'EventSource API is not available. ' if EventSource is not available.
      */
-    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (typeof EventSource | undefined));
+    constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (IEventSourceConstructor | undefined));
     setEventHandler(handler: ISseEventHandler): void;
     /**
      * Open the connection with a given authToken

package/types/sync/submitters/submitterManager.d.ts

@@ -0,0 +1,4 @@
+import { ISplitApi } from '../../services/types';
+import { IStorageSync } from '../../storages/types';
+import { ISettings } from '../../types';
+export declare function submitterManagerFactory(settings: ISettings, storage: IStorageSync, splitApi: ISplitApi): import("../types").ISyncTask<[], any>;

package/types/sync/syncManagerOnline.d.ts

@@ -9,4 +9,4 @@ import { IPollingManager, IPollingManagerFactoryParams } from './polling/types';
  * `pollingManagerSSFactory` or `pollingManagerCSFactory` respectively.
  * @param pushManagerFactory optional to build a SyncManager with or without streaming support
  */
-export declare function syncManagerOnlineFactory(pollingManagerFactory: (...args: IPollingManagerFactoryParams) => IPollingManager, pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;
+export declare function syncManagerOnlineFactory(pollingManagerFactory?: (...args: IPollingManagerFactoryParams) => IPollingManager, pushManagerFactory?: (...args: IPushManagerFactoryParams) => IPushManager | undefined): (params: ISyncManagerFactoryParams) => ISyncManagerCS;

package/types/sync/types.d.ts

@@ -41,7 +41,7 @@ export interface ISyncManager extends ITask {
     pushManager?: IPushManager;
 }
 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 {
     settings: ISettings;

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

@@ -1,19 +1,19 @@
-/// <reference types="node" />
 import { ISplitFiltersValidation } from './dtos/types';
 import { IIntegration, IIntegrationFactoryParams } from './integrations/types';
 import { ILogger } from './logger/types';
-import { IStorageFactoryParams, IStorageSyncCS, IStorageSync, IStorageAsync, IStorageSyncFactory } from './storages/types';
+import { IStorageFactoryParams, IStorageSync, IStorageAsync, IStorageSyncFactory, IStorageAsyncFactory } from './storages/types';
 import { ISyncManagerFactoryParams, ISyncManagerCS } from './sync/types';
 /**
- * EventEmitter interface with the minimal methods used by the SDK
+ * Reduced version of NodeJS.EventEmitter interface with the minimal methods used by the SDK
+ * @see {@link https://nodejs.org/api/events.html}
  */
-export interface IEventEmitter extends Pick<NodeJS.EventEmitter, 'addListener' | 'on' | 'once' | 'removeListener' | 'off' | 'removeAllListeners' | 'emit'> {
-    addListener(event: string, listener: (...args: any[]) => void): any;
-    on(event: string, listener: (...args: any[]) => void): any;
-    once(event: string, listener: (...args: any[]) => void): any;
-    removeListener(event: string, listener: (...args: any[]) => void): any;
-    off(event: string, listener: (...args: any[]) => void): any;
-    removeAllListeners(event?: string): any;
+export interface IEventEmitter {
+    addListener(event: string, listener: (...args: any[]) => void): this;
+    on(event: string, listener: (...args: any[]) => void): this;
+    once(event: string, listener: (...args: any[]) => void): this;
+    removeListener(event: string, listener: (...args: any[]) => void): this;
+    off(event: string, listener: (...args: any[]) => void): this;
+    removeAllListeners(event?: string): this;
     emit(event: string, ...args: any[]): boolean;
 }
 /**
@@ -47,7 +47,7 @@ declare type EventConsts = {
  * SDK Modes.
  * @typedef {string} SDKMode
  */
-export declare type SDKMode = 'standalone' | 'consumer' | 'localhost';
+export declare 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.
@@ -80,7 +80,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;
@@ -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;
@@ -842,7 +842,7 @@ export declare 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/types/utils/MinEventEmitter.d.ts

@@ -2,11 +2,11 @@ import { IEventEmitter } from '../types';
 export default class EventEmitter implements IEventEmitter {
     private listeners;
     private registerListener;
-    addListener(type: string, listener: (...args: any[]) => void): EventEmitter;
-    on(type: string, listener: (...args: any[]) => void): EventEmitter;
-    once(type: string, listener: (...args: any[]) => void): EventEmitter;
-    removeListener(type: string, listener: (...args: any[]) => void): EventEmitter;
-    off(type: string, listener: (...args: any[]) => void): EventEmitter;
+    addListener(type: string, listener: (...args: any[]) => void): this;
+    on(type: string, listener: (...args: any[]) => void): this;
+    once(type: string, listener: (...args: any[]) => void): this;
+    removeListener(): void;
+    off(): void;
     emit(type: string, ...args: any[]): boolean;
-    removeAllListeners(type?: string): EventEmitter;
+    removeAllListeners(type?: string): this;
 }

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

@@ -1,4 +1,5 @@
 import { StorageType } from '../../storages/types';
+import { SDKMode } from '../../types';
 export declare const CONTROL = "control";
 export declare const CONTROL_WITH_CONFIG: {
     treatment: string;
@@ -10,11 +11,12 @@ export declare const SPLIT_IMPRESSION = "IMPRESSION";
 export declare const SPLIT_EVENT = "EVENT";
 export declare const DEBUG = "DEBUG";
 export declare const OPTIMIZED = "OPTIMIZED";
-export declare const LOCALHOST_MODE = "localhost";
-export declare const STANDALONE_MODE = "standalone";
+export declare const LOCALHOST_MODE: SDKMode;
+export declare const STANDALONE_MODE: SDKMode;
 export declare const PRODUCER_MODE = "producer";
-export declare const CONSUMER_MODE = "consumer";
+export declare const CONSUMER_MODE: SDKMode;
+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/env/isNode.d.ts

@@ -1 +1,5 @@
+/**
+ * 'true' if running in Node.js, or 'false' otherwise.
+ * We check for version truthiness since most shims will have that as empty string.
+ */
 export declare const isNode: boolean;