@splitsoftware/splitio-commons 0.1.1-canary.9 → 0.1.1-rc.18

package/src/evaluator/matchersTransform/index.ts

@@ -1,5 +1,5 @@
 import { findIndex } from '../../utils/lang';
-import { matcherTypes, mapper, dataTypes } from '../matchers/matcherTypes';
+import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
 import segmentTransform from './segment';
 import whitelistTransform from './whitelist';
 import setTransform from './set';
@@ -28,9 +28,9 @@ export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDt
     } = matcher;
 
     let attribute = keySelector && keySelector.attribute;
-    let type = mapper(matcherType);
+    let type = matcherTypesMapper(matcherType);
     // As default input data type we use string (even for ALL_KEYS)
-    let dataType = dataTypes.STRING;
+    let dataType = matcherDataTypes.STRING;
     let value = undefined;
 
     if (type === matcherTypes.IN_SEGMENT) {
@@ -39,29 +39,29 @@ export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDt
       value = whitelistTransform(whitelistObject as IWhitelistMatcherData);
     } else if (type === matcherTypes.EQUAL_TO) {
       value = numericTransform(unaryNumericObject as IUnaryNumericMatcherData);
-      dataType = dataTypes.NUMBER;
+      dataType = matcherDataTypes.NUMBER;
 
       if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
         value = zeroSinceHH(value);
-        dataType = dataTypes.DATETIME;
+        dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
       type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
       value = numericTransform(unaryNumericObject as IUnaryNumericMatcherData);
-      dataType = dataTypes.NUMBER;
+      dataType = matcherDataTypes.NUMBER;
 
       if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
         value = zeroSinceSS(value);
-        dataType = dataTypes.DATETIME;
+        dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN) {
       value = betweenObject as IBetweenMatcherData;
-      dataType = dataTypes.NUMBER;
+      dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
         value.start = zeroSinceSS(value.start);
         value.end = zeroSinceSS(value.end);
-        dataType = dataTypes.DATETIME;
+        dataType = matcherDataTypes.DATETIME;
       }
     } else if (
       type === matcherTypes.EQUAL_TO_SET ||
@@ -70,7 +70,7 @@ export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDt
       type === matcherTypes.PART_OF_SET
     ) {
       value = setTransform(whitelistObject as IWhitelistMatcherData);
-      dataType = dataTypes.SET;
+      dataType = matcherDataTypes.SET;
     } else if (
       type === matcherTypes.STARTS_WITH ||
       type === matcherTypes.ENDS_WITH ||
@@ -79,9 +79,9 @@ export default function matchersTransform(matchers: ISplitMatcher[]): IMatcherDt
       value = setTransform(whitelistObject as IWhitelistMatcherData);
     } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
       value = dependencyObject;
-      dataType = dataTypes.NOT_SPECIFIED;
+      dataType = matcherDataTypes.NOT_SPECIFIED;
     } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
-      dataType = dataTypes.BOOLEAN;
+      dataType = matcherDataTypes.BOOLEAN;
       value = booleanMatcherData;
     } else if (type === matcherTypes.MATCHES_STRING) {
       value = stringMatcherData;

package/src/evaluator/value/sanitize.ts

@@ -3,7 +3,7 @@ import { IDependencyMatcherValue } from '../types';
 import { ILogger } from '../../logger/types';
 import { isObject, uniq, toString, toNumber } from '../../utils/lang';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { matcherTypes, dataTypes } from '../matchers/matcherTypes';
+import { matcherTypes, matcherDataTypes } from '../matchers/matcherTypes';
 import { ENGINE_SANITIZE } from '../../logger/constants';
 
 function sanitizeNumber(val: any): number | undefined {
@@ -74,20 +74,20 @@ export default function sanitize(log: ILogger, matcherTypeID: number, value: str
   let sanitizedValue: string | number | boolean | Array<string | number> | IDependencyMatcherValue | undefined;
 
   switch (dataType) {
-    case dataTypes.NUMBER:
-    case dataTypes.DATETIME:
+    case matcherDataTypes.NUMBER:
+    case matcherDataTypes.DATETIME:
       sanitizedValue = sanitizeNumber(value);
       break;
-    case dataTypes.STRING:
+    case matcherDataTypes.STRING:
       sanitizedValue = sanitizeString(value);
       break;
-    case dataTypes.SET:
+    case matcherDataTypes.SET:
       sanitizedValue = sanitizeArray(value);
       break;
-    case dataTypes.BOOLEAN:
+    case matcherDataTypes.BOOLEAN:
       sanitizedValue = sanitizeBoolean(value);
       break;
-    case dataTypes.NOT_SPECIFIED:
+    case matcherDataTypes.NOT_SPECIFIED:
       sanitizedValue = value;
       break;
     default:

package/src/listeners/browser.ts

@@ -39,7 +39,6 @@ export default class BrowserSignalListener implements ISignalListener {
    * We add a handler on unload events. The handler flushes remaining impressions and events to the backend.
    */
   start() {
-    this.syncManager?.start();
     if (typeof window !== 'undefined' && window.addEventListener) {
       this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
       window.addEventListener(UNLOAD_DOM_EVENT, this.flushData);
@@ -49,6 +48,7 @@ export default class BrowserSignalListener implements ISignalListener {
   /**
    * stop method.
    * Called when client is destroyed.
+   * We need to remove the handler for unload events, since it can break if called when Split context was destroyed.
    */
   stop() {
     if (typeof window !== 'undefined' && window.removeEventListener) {

package/src/listeners/node.ts

@@ -22,7 +22,7 @@ export default class NodeSignalListener implements ISignalListener {
   private settings: ISettings;
 
   constructor(
-    private syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,
+    syncManager: ISyncManager | undefined, // private handler: () => MaybeThenable<void>,
     settings: ISettings
   ) {
     // @TODO review handler logic when implementing Node SDK
@@ -37,7 +37,6 @@ export default class NodeSignalListener implements ISignalListener {
   }
 
   start() {
-    this.syncManager?.start();
     this.settings.log.debug(CLEANUP_REGISTERING, [EVENT_NAME]);
     // eslint-disable-next-line no-undef
     process.on(SIGTERM, this._sigtermHandler);

package/src/logger/constants.ts

@@ -93,6 +93,7 @@ export const WARN_SPLITS_FILTER_INVALID = 220;
 export const WARN_SPLITS_FILTER_EMPTY = 221;
 export const WARN_STORAGE_INVALID = 222;
 export const WARN_API_KEY = 223;
+export const STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2 = 224;
 
 export const ERROR_ENGINE_COMBINER_IFELSEIF = 300;
 export const ERROR_LOGLEVEL_INVALID = 301;
@@ -117,6 +118,7 @@ export const ERROR_EMPTY = 319;
 export const ERROR_EMPTY_ARRAY = 320;
 export const ERROR_INVALID_IMPRESSIONS_MODE = 321;
 export const ERROR_HTTP = 322;
+export const ERROR_LOCALHOST_MODULE_REQUIRED = 323;
 
 // Log prefixes (a.k.a. tags or categories)
 export const LOG_PREFIX_SETTINGS = 'settings';

package/src/logger/messages/error.ts

@@ -11,8 +11,8 @@ export const codesError: [number, string][] = [
   [c.ERROR_EVENTS_TRACKER, c.LOG_PREFIX_EVENTS_TRACKER + 'Failed to queue %s'],
   // synchronizer
   [c.ERROR_SYNC_OFFLINE_LOADING, c.LOG_PREFIX_SYNC_OFFLINE + 'There was an issue loading the mock Splits data, no changes will be applied to the current cache. %s'],
-  [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Fail to connect to streaming, with error message: %s'],
-  [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: "%s".'],
+  [c.ERROR_STREAMING_SSE, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to connect or error on streaming connection, with error message: %s'],
+  [c.ERROR_STREAMING_AUTH, c.LOG_PREFIX_SYNC_STREAMING + 'Failed to authenticate for streaming. Error: %s.'],
   [c.ERROR_HTTP, ' Response status is not OK. Status: %s. URL: %s. Message: %s'],
   // client status
   [c.ERROR_CLIENT_LISTENER, 'A listener was added for %s on the SDK, which has already fired and won\'t be emitted again. The callback won\'t be executed.'],
@@ -30,4 +30,5 @@ export const codesError: [number, string][] = [
   [c.ERROR_EMPTY_ARRAY, '%s: %s must be a non-empty array.'],
   // initialization / settings validation
   [c.ERROR_INVALID_IMPRESSIONS_MODE, c.LOG_PREFIX_SETTINGS + ': you passed an invalid "impressionsMode". It should be one of the following values: %s. Defaulting to "%s" mode.'],
+  [c.ERROR_LOCALHOST_MODULE_REQUIRED, c.LOG_PREFIX_SETTINGS + ': you didn\'t pass a valid "sync.localhostMode". It should be defined for using the SDK in localhost mode']
 ];

package/src/logger/messages/info.ts

@@ -22,9 +22,9 @@ export const codesInfo: [number, string][] = codesWarn.concat([
   [c.SYNC_SPLITS_FETCH_RETRY, c.LOG_PREFIX_SYNC_SPLITS + 'Retrying download of splits #%s. Reason: %s'],
   [c.SUBMITTERS_PUSH_FULL_EVENTS_QUEUE, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Flushing full events queue and reseting timer.'],
   [c.SUBMITTERS_PUSH, c.LOG_PREFIX_SYNC_SUBMITTERS + 'Pushing %s %s.'],
-  [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds.'],
+  [c.STREAMING_REFRESH_TOKEN, c.LOG_PREFIX_SYNC_STREAMING + 'Refreshing streaming token in %s seconds, and connecting streaming in %s seconds.'],
   [c.STREAMING_RECONNECT, c.LOG_PREFIX_SYNC_STREAMING + 'Attempting to reconnect in %s seconds.'],
-  [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Connecting to streaming.'],
+  [c.STREAMING_CONNECTING, c.LOG_PREFIX_SYNC_STREAMING + '%sConnecting to streaming.'],
   [c.STREAMING_DISABLED, c.LOG_PREFIX_SYNC_STREAMING + 'Streaming is disabled for given Api key. Switching to polling mode.'],
   [c.STREAMING_DISCONNECTING, c.LOG_PREFIX_SYNC_STREAMING + 'Disconnecting from streaming.'],
   [c.SYNC_START_POLLING, c.LOG_PREFIX_SYNC_MANAGER + 'Streaming not available. Starting polling.'],

package/src/logger/messages/warn.ts

@@ -30,5 +30,7 @@ export const codesWarn: [number, string][] = codesError.concat([
   [c.WARN_SPLITS_FILTER_INVALID, c.LOG_PREFIX_SETTINGS+': split filter at position %s is invalid. It must be an object with a valid filter type ("byName" or "byPrefix") and a list of "values".'],
   [c.WARN_SPLITS_FILTER_EMPTY, c.LOG_PREFIX_SETTINGS+': splitFilters configuration must be a non-empty array of filter objects.'],
   [c.WARN_STORAGE_INVALID, c.LOG_PREFIX_SETTINGS+': The provided storage is invalid. Fallbacking into default MEMORY storage'],
-  [c.WARN_API_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application']
+  [c.WARN_API_KEY, c.LOG_PREFIX_SETTINGS+': You already have %s. We recommend keeping only one instance of the factory at all times (Singleton pattern) and reusing it throughout your application'],
+
+  [c.STREAMING_PARSING_MY_SEGMENTS_UPDATE_V2, c.LOG_PREFIX_SYNC_STREAMING + 'Fetching MySegments due to an error processing %s notification: %s'],
 ]);

package/src/readiness/readinessManager.ts

@@ -41,7 +41,7 @@ export function readinessManagerFactory(
 
   // emit SDK_READY_FROM_CACHE
   let isReadyFromCache = false;
-  if (splits.splitsCacheLoaded) setTimeout(checkIsReadyFromCache, 0); // don't check status inmediately, to allow attach listeners
+  if (splits.splitsCacheLoaded) isReadyFromCache = true; // ready from cache, but doesn't emit SDK_READY_FROM_CACHE
   else splits.once(SDK_SPLITS_CACHE_LOADED, checkIsReadyFromCache);
 
   // emit SDK_READY_TIMED_OUT
@@ -62,13 +62,15 @@ export function readinessManagerFactory(
   let isDestroyed = false;
 
   function checkIsReadyFromCache() {
-    // @TODO add condition to emit SDK_READY_FROM_CACHE only if SDK_READY has not been emitted
-    if (!isReadyFromCache && splits.splitsCacheLoaded) {
-      // Make it async, in case user callbacks throw an exception
-      setTimeout(() => {
-        isReadyFromCache = true;
+    isReadyFromCache = true;
+    // Don't emit SDK_READY_FROM_CACHE if SDK_READY has been emitted
+    if (!isReady) {
+      try {
         gate.emit(SDK_READY_FROM_CACHE);
-      }, 0);
+      } catch (e) {
+        // throws user callback exceptions in next tick
+        setTimeout(() => { throw e; }, 0);
+      }
     }
   }
 

package/src/sdkFactory/index.ts

@@ -78,9 +78,7 @@ export function sdkFactory(params: ISdkFactoryParams): SplitIO.ICsSDK | SplitIO.
   const clientMethod = sdkClientMethodFactory({ eventTracker, impressionsTracker, sdkReadinessManager, settings, storage, syncManager, signalListener });
   const managerInstance = sdkManagerFactory(log, storage.splits, sdkReadinessManager);
 
-  // If there is a signalListener, it is in charge of starting the syncManager.
-  // It is required for RN to consider the app state when the SDK is instantiated (foreground/background).
-  if (syncManager && !signalListener) syncManager.start();
+  syncManager && syncManager.start();
   signalListener && signalListener.start();
 
   log.info(NEW_FACTORY);

package/src/sdkFactory/types.ts

@@ -8,10 +8,10 @@ import { IStorageAsync, IStorageSync, ISplitsCacheSync, ISplitsCacheAsync, IStor
 import { ISyncManager, ISyncManagerFactoryParams } from '../sync/types';
 import { IImpressionObserver } from '../trackers/impressionObserver/types';
 import { SplitIO, ISettings, IEventEmitter } from '../types';
-import { ISettingsInternal } from '../utils/settingsValidation/types';
 
 /**
- * Environment related dependencies
+ * Environment related dependencies.
+ * These getters are called a fixed number of times per factory instantiation.
  */
 export interface IPlatform {
   getOptions?: () => object
@@ -26,7 +26,7 @@ export interface IPlatform {
 export interface ISdkFactoryParams {
 
   // The settings must be already validated
-  settings: ISettingsInternal,
+  settings: ISettings,
 
   // Platform dependencies
   platform: IPlatform,

package/src/services/splitApi.ts

@@ -2,7 +2,6 @@ import { IPlatform } from '../sdkFactory/types';
 import { ISettings } from '../types';
 import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
-import { ISettingsInternal } from '../utils/settingsValidation/types';
 import objectAssign from 'object-assign';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -20,7 +19,7 @@ function userKeyToQueryParam(userKey: string) {
 export function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, 'getFetch' | 'getOptions'>): ISplitApi {
 
   const urls = settings.urls;
-  const filterQueryString = (settings as ISettingsInternal).sync.__splitFiltersValidation && (settings as ISettingsInternal).sync.__splitFiltersValidation.queryString;
+  const filterQueryString = settings.sync.__splitFiltersValidation && settings.sync.__splitFiltersValidation.queryString;
   const SplitSDKImpressionsMode = settings.sync.impressionsMode;
   const splitHttpClient = splitHttpClientFactory(settings, platform.getFetch, platform.getOptions);
 
@@ -36,7 +35,7 @@ export function splitApiFactory(settings: ISettings, platform: Pick<IPlatform, '
     },
 
     fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/auth`;
+      let url = `${urls.auth}/v2/auth`;
       if (userMatchingKeys) { // accounting the possibility that `userMatchingKeys` is undefined (server-side API)
         const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
         if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty

package/src/services/splitHttpClient.ts

@@ -43,8 +43,8 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
     return fetch ? fetch(url, request)
       // https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch#Checking_that_the_fetch_was_successful
       .then(response => {
-        if (!response.ok) { // eslint-disable-next-line no-throw-literal
-          throw { response };
+        if (!response.ok) {
+          return response.text().then(message => Promise.reject({ response, message }));
         }
         return response;
       })
@@ -56,18 +56,19 @@ export function splitHttpClientFactory(settings: Pick<ISettings, 'log' | 'versio
           switch (resp.status) {
             case 404: msg = 'Invalid API key or resource not found.';
               break;
-            default: msg = resp.statusText;
+            // Don't use resp.statusText since reason phrase is removed in HTTP/2
+            default: msg = error.message;
               break;
           }
         } else { // Something else, either an error making the request or a Network error.
-          msg = error.message;
+          msg = error.message || 'Network Error';
         }
 
         if (!resp || resp.status !== 403) { // 403's log we'll be handled somewhere else.
           log[logErrorsAsInfo ? 'info' : 'error'](ERROR_HTTP, [resp ? resp.status : 'NO_STATUS', url, msg]);
         }
 
-        const networkError: Error & {statusCode?: number} = new Error(msg);
+        const networkError: Error & { statusCode?: number } = new Error(msg);
         // passes `undefined` as statusCode if not an HTTP error (resp === undefined)
         networkError.statusCode = resp && resp.status;
         throw networkError;

package/src/services/types.ts

@@ -7,12 +7,12 @@ export type IRequestOptions = {
 export type IResponse = {
 	ok: boolean,
 	status: number,
-	json: () => Promise<any>,
+	json: () => Promise<any>, // Used to parse OK response body. Promise rejects if body cannot be parsed
+	text: () => Promise<string>, // Used to read Not OK response body. Promise never rejects
 
 	/** Other available properties when using Unfetch */
-	// statusText: string,
+	// statusText: string, // `undefined` in Web fetch since HTTP/2 doesn't have reason phrases anymore. `node-fetch` overwrites it depending on the status code
 	// url: string,
-	// text: () => Promise<string>,
 	// blob: () => Promise<Blob>,
 	// clone: () => IResponse,
 	// headers: {
@@ -50,8 +50,8 @@ export type IPostMetricsCounters = (body: string) => Promise<IResponse>
 export type IPostMetricsTimes = (body: string) => Promise<IResponse>
 
 export interface ISplitApi {
-  getSdkAPIHealthCheck: IHealthCheckAPI;
-  getEventsAPIHealthCheck: IHealthCheckAPI;
+  getSdkAPIHealthCheck: IHealthCheckAPI
+  getEventsAPIHealthCheck: IHealthCheckAPI
 	fetchAuth: IFetchAuth
 	fetchSplitChanges: IFetchSplitChanges
 	fetchSegmentChanges: IFetchSegmentChanges

package/src/storages/AbstractSplitsCacheSync.ts

@@ -50,7 +50,7 @@ export default abstract class AbstractSplitsCacheSync implements ISplitsCacheSyn
    * It is used as condition to emit SDK_SPLITS_CACHE_LOADED, and then SDK_READY_FROM_CACHE.
    */
   checkCache(): boolean {
-    return this.getChangeNumber() > -1;
+    return false;
   }
 
   /**

package/src/storages/inLocalStorage/index.ts

@@ -1,7 +1,7 @@
 import ImpressionsCacheInMemory from '../inMemory/ImpressionsCacheInMemory';
 import ImpressionCountsCacheInMemory from '../inMemory/ImpressionCountsCacheInMemory';
 import EventsCacheInMemory from '../inMemory/EventsCacheInMemory';
-import { IStorageFactoryParams, IStorageSyncCS } from '../types';
+import { IStorageFactoryParams, IStorageSyncCS, IStorageSyncFactory } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import KeyBuilderCS from '../KeyBuilderCS';
 import { isLocalStorageAvailable } from '../../utils/env/isLocalStorageAvailable';
@@ -12,6 +12,7 @@ import SplitsCacheInMemory from '../inMemory/SplitsCacheInMemory';
 import { DEFAULT_CACHE_EXPIRATION_IN_MILLIS } from '../../utils/constants/browser';
 import { InMemoryStorageCSFactory } from '../inMemory/InMemoryStorageCS';
 import { LOG_PREFIX } from './constants';
+import { STORAGE_LOCALSTORAGE } from '../../utils/constants';
 
 export interface InLocalStorageOptions {
   prefix?: string
@@ -20,11 +21,11 @@ export interface InLocalStorageOptions {
 /**
  * InLocal storage factory for standalone client-side SplitFactory
  */
-export function InLocalStorage(options: InLocalStorageOptions = {}) {
+export function InLocalStorage(options: InLocalStorageOptions = {}): IStorageSyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
-  return function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS {
+  function InLocalStorageCSFactory(params: IStorageFactoryParams): IStorageSyncCS {
 
     // Fallback to InMemoryStorage if LocalStorage API is not available
     if (!isLocalStorageAvailable()) {
@@ -69,5 +70,8 @@ export function InLocalStorage(options: InLocalStorageOptions = {}) {
         };
       },
     };
-  };
+  }
+
+  InLocalStorageCSFactory.type = STORAGE_LOCALSTORAGE;
+  return InLocalStorageCSFactory;
 }

package/src/storages/inMemory/InMemoryStorage.ts

@@ -4,6 +4,7 @@ import ImpressionsCacheInMemory from './ImpressionsCacheInMemory';
 import EventsCacheInMemory from './EventsCacheInMemory';
 import { IStorageFactoryParams, IStorageSync } from '../types';
 import ImpressionCountsCacheInMemory from './ImpressionCountsCacheInMemory';
+import { STORAGE_MEMORY } from '../../utils/constants';
 
 /**
  * InMemory storage factory for standalone server-side SplitFactory
@@ -32,3 +33,5 @@ export function InMemoryStorageFactory(params: IStorageFactoryParams): IStorageS
     }
   };
 }
+
+InMemoryStorageFactory.type = STORAGE_MEMORY;

package/src/storages/inMemory/InMemoryStorageCS.ts

@@ -4,6 +4,7 @@ import ImpressionsCacheInMemory from './ImpressionsCacheInMemory';
 import EventsCacheInMemory from './EventsCacheInMemory';
 import { IStorageSyncCS, IStorageFactoryParams } from '../types';
 import ImpressionCountsCacheInMemory from './ImpressionCountsCacheInMemory';
+import { STORAGE_MEMORY } from '../../utils/constants';
 
 /**
  * InMemory storage factory for standalone client-side SplitFactory
@@ -46,3 +47,5 @@ export function InMemoryStorageCSFactory(params: IStorageFactoryParams): IStorag
     },
   };
 }
+
+InMemoryStorageCSFactory.type = STORAGE_MEMORY;

package/src/storages/inRedis/SplitsCacheInRedis.ts

@@ -47,7 +47,9 @@ export default class SplitsCacheInRedis extends AbstractSplitsCacheAsync {
   private _decrementCounts(split: ISplit) {
     if (split.trafficTypeName) {
       const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.redis.decr(ttKey);
+      return this.redis.decr(ttKey).then(count => {
+        if (count === 0) return this.redis.del(ttKey);
+      });
     }
   }
 

package/src/storages/inRedis/index.ts

@@ -1,5 +1,5 @@
 import RedisAdapter from './RedisAdapter';
-import { IStorageAsync, IStorageFactoryParams } from '../types';
+import { IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 import { validatePrefix } from '../KeyBuilder';
 import KeyBuilderSS from '../KeyBuilderSS';
 import SplitsCacheInRedis from './SplitsCacheInRedis';
@@ -8,6 +8,7 @@ import ImpressionsCacheInRedis from './ImpressionsCacheInRedis';
 import EventsCacheInRedis from './EventsCacheInRedis';
 import LatenciesCacheInRedis from './LatenciesCacheInRedis';
 import CountsCacheInRedis from './CountsCacheInRedis';
+import { STORAGE_REDIS } from '../../utils/constants';
 
 export interface InRedisStorageOptions {
   prefix?: string
@@ -18,11 +19,11 @@ export interface InRedisStorageOptions {
  * InRedis storage factory for consumer server-side SplitFactory, that uses `Ioredis` Redis client for Node.
  * @see {@link https://www.npmjs.com/package/ioredis}
  */
-export function InRedisStorage(options: InRedisStorageOptions = {}) {
+export function InRedisStorage(options: InRedisStorageOptions = {}): IStorageAsyncFactory {
 
   const prefix = validatePrefix(options.prefix);
 
-  return function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
+  function InRedisStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
 
     const keys = new KeyBuilderSS(prefix, metadata);
     const redisClient = new RedisAdapter(log, options.options || {});
@@ -47,5 +48,8 @@ export function InRedisStorage(options: InRedisStorageOptions = {}) {
         // @TODO check that caches works as expected when redisClient is disconnected
       }
     };
-  };
+  }
+
+  InRedisStorageFactory.type = STORAGE_REDIS;
+  return InRedisStorageFactory;
 }

package/src/storages/pluggable/SplitsCachePluggable.ts

@@ -31,7 +31,9 @@ export class SplitsCachePluggable extends AbstractSplitsCacheAsync {
   private _decrementCounts(split: ISplit) {
     if (split.trafficTypeName) {
       const ttKey = this.keys.buildTrafficTypeKey(split.trafficTypeName);
-      return this.wrapper.decr(ttKey);
+      return this.wrapper.decr(ttKey).then(count => {
+        if (count === 0) return this.wrapper.del(ttKey);
+      });
     }
   }
 

package/src/storages/pluggable/inMemoryWrapper.ts

@@ -36,28 +36,27 @@ export function inMemoryWrapperFactory(): ICustomStorageWrapper & { _cache: Reco
     getKeysByPrefix(prefix: string) {
       return Promise.resolve(Object.keys(_cache).filter(key => startsWith(key, prefix)));
     },
-    getByPrefix(prefix: string) {
-      return Promise.resolve(Object.keys(_cache).filter(key => startsWith(key, prefix)).map(key => _cache[key] as string));
-    },
     incr(key: string) {
       if (key in _cache) {
         const count = toNumber(_cache[key]) + 1;
-        if (isNaN(count)) return Promise.resolve(false);
+        if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
+        return Promise.resolve(count);
       } else {
         _cache[key] = '1';
+        return Promise.resolve(1);
       }
-      return Promise.resolve(true);
     },
     decr(key: string) {
       if (key in _cache) {
         const count = toNumber(_cache[key]) - 1;
-        if (isNaN(count)) return Promise.resolve(false);
+        if (isNaN(count)) return Promise.reject('Given key is not a number');
         _cache[key] = count + '';
+        return Promise.resolve(count);
       } else {
         _cache[key] = '-1';
+        return Promise.resolve(-1);
       }
-      return Promise.resolve(true);
     },
     getMany(keys: string[]) {
       return Promise.resolve(keys.map(key => _cache[key] ? _cache[key] as string : null));

package/src/storages/pluggable/index.ts

@@ -1,4 +1,4 @@
-import { ICustomStorageWrapper, IStorageAsync, IStorageFactoryParams } from '../types';
+import { ICustomStorageWrapper, IStorageAsync, IStorageAsyncFactory, IStorageFactoryParams } from '../types';
 
 import KeyBuilderSS from '../KeyBuilderSS';
 import { SplitsCachePluggable } from './SplitsCachePluggable';
@@ -8,6 +8,7 @@ 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';
 
 const NO_VALID_WRAPPER = 'Expecting custom 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.';
@@ -34,13 +35,13 @@ function validatePluggableStorageOptions(options: any) {
 /**
  * Pluggable storage factory for consumer server-side & client-side SplitFactory.
  */
-export function PluggableStorage(options: PluggableStorageOptions) {
+export function PluggableStorage(options: PluggableStorageOptions): IStorageAsyncFactory {
 
   validatePluggableStorageOptions(options);
 
   const prefix = validatePrefix(options.prefix);
 
-  return function PluggableStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
+  function PluggableStorageFactory({ log, metadata, onReadyCb }: IStorageFactoryParams): IStorageAsync {
     const keys = new KeyBuilderSS(prefix, metadata);
     const wrapper = wrapperAdapter(log, options.wrapper);
 
@@ -63,5 +64,8 @@ export function PluggableStorage(options: PluggableStorageOptions) {
         return wrapper.close();
       }
     };
-  };
+  }
+
+  PluggableStorageFactory.type = STORAGE_CUSTOM;
+  return PluggableStorageFactory;
 }

package/src/storages/pluggable/wrapperAdapter.ts

@@ -8,7 +8,6 @@ export const METHODS_TO_PROMISE_WRAP: string[] = [
   'getAndSet',
   'del',
   'getKeysByPrefix',
-  'getByPrefix',
   'incr',
   'decr',
   'getMany',