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

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,14 +8,17 @@ import { EventsCachePluggable } from './EventsCachePluggable';
 import { wrapperAdapter, METHODS_TO_PROMISE_WRAP } from './wrapperAdapter';
 import { isObject } from '../../utils/lang';
 import { validatePrefix } from '../KeyBuilder';
-import { 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
 }
 
 /**
@@ -32,6 +35,25 @@ function validatePluggableStorageOptions(options: any) {
   if (missingMethods.length) throw new Error(`${NO_VALID_WRAPPER_INTERFACE} The following methods are missing or invalid: ${missingMethods}`);
 }
 
+// subscription to wrapper connect event in order to emit SDK_READY event
+function wrapperConnect(wrapper: IPluggableStorageWrapper, onReadyCb: (error?: any) => void) {
+  wrapper.connect().then(() => {
+    onReadyCb();
+  }).catch((e) => {
+    onReadyCb(e || new Error('Error connecting wrapper'));
+  });
+}
+
+// Async return type in `client.track` method on consumer partial mode
+// No need to promisify impressions cache
+function promisifyEventsTrack(events: any) {
+  const origTrack = events.track;
+  events.track = function () {
+    return Promise.resolve(origTrack.apply(this, arguments));
+  };
+  return events;
+}
+
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
@@ -41,31 +63,39 @@ export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyn
 
   const prefix = validatePrefix(options.prefix);
 
-  function PluggableStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory({ log, metadata, onReadyCb, mode, eventsQueueSize, optimize }: IStorageFactoryParams): IStorageAsync {
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
+    const isPartialConsumer = mode === CONSUMER_PARTIAL_MODE;
 
-    // subscription to Wrapper connect event in order to emit SDK_READY event
-    wrapper.connect().then(() => {
-      if (onReadyCb) onReadyCb();
-    }).catch((e) => {
-      if (onReadyCb) onReadyCb(e || new Error('Error connecting wrapper'));
-    });
+    // Connects to wrapper and emits SDK_READY event on main client
+    wrapperConnect(wrapper, onReadyCb);
 
     return {
       splits: new SplitsCachePluggable(log, keys, wrapper),
       segments: new SegmentsCachePluggable(log, keys, wrapper),
-      impressions: new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
-      events: new EventsCachePluggable(log, keys.buildEventsKey(), wrapper, metadata),
+      impressions: isPartialConsumer ? new ImpressionsCacheInMemory() : new ImpressionsCachePluggable(log, keys.buildImpressionsKey(), wrapper, metadata),
+      impressionCounts: optimize ? new ImpressionCountsCacheInMemory() : undefined,
+      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
+      shared(_, onReadyCb) {
+        wrapperConnect(wrapper, onReadyCb);
+        return {
+          ...this,
+          // 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

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

@@ -1,3 +1,4 @@
+import { IEventSourceConstructor } from '../../../services/types';
 import { ISettings } from '../../../types';
 import { IAuthTokenPushEnabled } from '../AuthClient/types';
 import { ISSEClient, ISseEventHandler } from './types';
@@ -31,9 +32,9 @@ function buildSSEHeaders(settings: ISettings) {
  */
 export default class SSEClient implements ISSEClient {
   // Instance properties:
-  eventSource: typeof EventSource;
+  eventSource?: IEventSourceConstructor;
   streamingUrl: string;
-  connection?: InstanceType<typeof EventSource>;
+  connection?: InstanceType<IEventSourceConstructor>;
   handler?: ISseEventHandler;
   useHeaders?: boolean;
   headers: Record<string, string>;
@@ -46,8 +47,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)) {
-    // @ts-expect-error
+  constructor(settings: ISettings, useHeaders?: boolean, getEventSource?: () => (IEventSourceConstructor | undefined)) {
     this.eventSource = getEventSource && getEventSource();
     // if eventSource is not available, throw an exception
     if (!this.eventSource) throw new Error('EventSource API is not available. ');
@@ -79,7 +79,7 @@ export default class SSEClient implements ISSEClient {
     ).join(',');
     const url = `${this.streamingUrl}?channels=${channelsQueryParam}&accessToken=${authToken.token}&v=${VERSION}&heartbeats=true`; // same results using `&heartbeats=false`
 
-    this.connection = new this.eventSource(
+    this.connection = new this.eventSource!(
       // For client-side SDKs, SplitSDKClientKey and SplitSDKClientKey metadata is passed as query params,
       // because native EventSource implementations for browser doesn't support headers.
       this.useHeaders ? url : url + `&SplitSDKVersion=${this.headers.SplitSDKVersion}&SplitSDKClientKey=${this.headers.SplitSDKClientKey}`,

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,19 +3,20 @@ 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';
 
 /**
- * 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
 }
 
@@ -52,7 +53,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 +86,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 +94,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 +842,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/MinEventEmitter.ts

@@ -18,7 +18,7 @@ export default class EventEmitter implements IEventEmitter {
     boolean // whether it is a one-time listener or not
   ]>> = {};
 
-  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean): EventEmitter {
+  private registerListener(type: string, listener: (...args: any[]) => void, oneTime: boolean) {
     checkListener(listener);
 
     // To avoid recursion in the case that type === "newListener" before
@@ -33,27 +33,27 @@ export default class EventEmitter implements IEventEmitter {
     return this;
   }
 
-  addListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  addListener(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, false);
   }
 
   // alias of addListener
-  on(type: string, listener: (...args: any[]) => void): EventEmitter {
+  on(type: string, listener: (...args: any[]) => void) {
     return this.addListener(type, listener);
   }
 
-  once(type: string, listener: (...args: any[]) => void): EventEmitter {
+  once(type: string, listener: (...args: any[]) => void) {
     return this.registerListener(type, listener, true);
   }
 
-  // eslint-disable-next-line
-  removeListener(type: string, listener: (...args: any[]) => void): EventEmitter {
+  // @ts-ignore
+  removeListener(/* type: string, listener: (...args: any[]) => void */) {
     throw new Error('Method not implemented.');
   }
 
-  // alias of removeListener
-  off(type: string, listener: (...args: any[]) => void): EventEmitter {
-    return this.removeListener(type, listener);
+  // @ts-ignore alias of removeListener
+  off(/* type: string, listener: (...args: any[]) => void */) {
+    return this.removeListener(/* type, listener */);
   }
 
   emit(type: string, ...args: any[]): boolean {
@@ -68,7 +68,7 @@ export default class EventEmitter implements IEventEmitter {
     return true;
   }
 
-  removeAllListeners(type?: string): EventEmitter {
+  removeAllListeners(type?: string) {
     if (!this.listeners[REMOVE_LISTENER_EVENT]) {
       // if not listening for `removeListener`, no need to emit
       if (type) {