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

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/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

@@ -2,7 +2,7 @@
 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
@@ -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/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/settingsValidation/storage/storageCS.d.ts

@@ -1,7 +1,7 @@
 import { ISettings, SDKMode } from '../../../types';
 import { ILogger } from '../../../logger/types';
-import { IStorageFactoryParams, IStorageSyncCS } from '../../../storages/types';
-export declare function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSyncCS;
+import { IStorageFactoryParams, IStorageSync } from '../../../storages/types';
+export declare function __InLocalStorageMockFactory(params: IStorageFactoryParams): IStorageSync;
 export declare namespace __InLocalStorageMockFactory {
     var type: import("../../../storages/types").StorageType;
 }
@@ -10,10 +10,12 @@ export declare namespace __InLocalStorageMockFactory {
  *
  * @param {any} settings config object provided by the user to initialize the sdk
  *
- * @returns {Object} valid storage factory. It might be the default `InMemoryStorageCSFactory` if the provided storage is invalid.
+ * @returns {Object} valid storage factory. Default to `InMemoryStorageCSFactory` if the provided storage is invalid or not compatible with the sdk mode if mode is standalone or localhost
+ *
+ * @throws error if mode is consumer and the provided storage is not compatible
  */
 export declare function validateStorageCS(settings: {
     log: ILogger;
     storage?: any;
-    mode?: SDKMode;
+    mode: SDKMode;
 }): ISettings['storage'];