@splitsoftware/splitio 10.17.2 → 10.17.3-rc.3

package/src/{utils/settings → settings}/storage/node.js

@@ -1,28 +1,14 @@
-/**
-Copyright 2016 Split Software
+import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS, CONSUMER_MODE, STANDALONE_MODE } from '@splitsoftware/splitio-commons/src/utils/constants';
 
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-**/
-import { LOCALHOST_MODE, STORAGE_MEMORY, STORAGE_REDIS } from '../../constants';
-
-const ParseStorageSettings = (settings) => {
+export function validateStorage(settings) {
   let {
+    log,
     mode,
     storage: {
       type,
       options = {},
       prefix
-    }
+    } = { type: STORAGE_MEMORY }
   } = settings;
 
   if (prefix) {
@@ -31,15 +17,17 @@ const ParseStorageSettings = (settings) => {
     prefix = 'SPLITIO';
   }
 
-  // In localhost mode we should force the user to use the MEMORY storage
-  if (mode === LOCALHOST_MODE) return {
-    type: STORAGE_MEMORY,
-    prefix
-  };
-
-  // In other cases we can have MEMORY or REDIS
+  // We can have MEMORY, REDIS or an invalid storage type
   switch (type) {
     case STORAGE_REDIS: {
+      // If passing REDIS storage in localhost or standalone mode, we log an error and fallback to MEMORY storage
+      if (mode === STANDALONE_MODE || mode === LOCALHOST_MODE) {
+        log.error('The provided REDIS storage is invalid for this mode. It requires consumer mode. Fallbacking into default MEMORY storage.');
+        return {
+          type: STORAGE_MEMORY,
+          prefix
+        };
+      }
       let {
         host,
         port,
@@ -84,12 +72,14 @@ const ParseStorageSettings = (settings) => {
     // For now, we don't have modifiers or settings for MEMORY in NodeJS
     case STORAGE_MEMORY:
     default: {
+      // If passing MEMORY storage in consumer mode, throw an error (no way to fallback to REDIS storage)
+      if (mode === CONSUMER_MODE) throw new Error('A REDIS storage is required on consumer mode');
+      // If passing an invalid storage type, log an error
+      if (type !== STORAGE_MEMORY) log.error(`The provided '${type}' storage type is invalid. Fallbacking into default MEMORY storage.`);
       return {
         type: STORAGE_MEMORY,
         prefix
       };
     }
   }
-};
-
-export default ParseStorageSettings;
+}

package/src/umd.js

@@ -1,3 +1,4 @@
 import { SplitFactory } from './index';
 
+// eslint-disable-next-line import/no-default-export
 export default SplitFactory;

package/types/client/index.d.ts

@@ -0,0 +1,14 @@
+// Declaration file for Javascript Split Software SDK
+// Project: http://www.split.io/
+
+/// <reference path="../splitio.d.ts" />
+export = JsSdk;
+
+declare module JsSdk {
+  /**
+   * Split.io sdk factory function.
+   * The settings parameter should be an object that complies with the SplitIO.IBrowserSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020448791-JavaScript-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.IBrowserSettings): SplitIO.IBrowserSDK;
+}

package/types/server/index.d.ts

@@ -0,0 +1,20 @@
+// Declaration file for Javascript Split Software SDK
+// Project: http://www.split.io/
+
+/// <reference path="../splitio.d.ts" />
+export = JsSdk;
+
+declare module JsSdk {
+  /**
+   * Split.io sdk factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeAsyncSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeAsyncSettings): SplitIO.IAsyncSDK;
+  /**
+   * Split.io sdk factory function.
+   * The settings parameter should be an object that complies with the SplitIO.INodeSettings.
+   * For more information read the corresponding article: @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#configuration}
+   */
+  export function SplitFactory(settings: SplitIO.INodeSettings): SplitIO.ISDK;
+}

package/types/splitio.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Javascript and Node Split Software SDK v8.1.0
+// Type definitions for Javascript and Node Split Software SDK
 // Project: http://www.split.io/
 // Definitions by: Nico Zelaya <https://github.com/NicoZelaya/>
 
@@ -336,7 +336,8 @@ interface INodeBasicSettings extends ISharedSettings {
     prefix?: string
   },
   /**
-   * The SDK mode. Possible values are "standalone" (which is the default) and "consumer". For "localhost" mode, use "localhost" as authorizationKey.
+   * The SDK mode. Possible values are "standalone", which is the default when using a synchronous storage, like 'MEMORY' and 'LOCALSTORAGE',
+   * and "consumer", which must be set when using an asynchronous storage, like 'REDIS'. For "localhost" mode, use "localhost" as authorizationKey.
    * @property {SDKMode} mode
    * @default standalone
    */
@@ -1020,7 +1021,15 @@ declare namespace SplitIO {
        * @default SPLITIO
        */
       prefix?: string
-    }
+    },
+    /**
+     * The SDK mode. When using the default 'MEMORY' storage, the only possible value is "standalone", which is the default.
+     * For "localhost" mode, use "localhost" as authorizationKey.
+     *
+     * @property {'standalone'} mode
+     * @default standalone
+     */
+    mode?: 'standalone'
   }
   /**
    * Settings interface with async storage for SDK instances created on NodeJS.
@@ -1032,7 +1041,7 @@ declare namespace SplitIO {
   interface INodeAsyncSettings extends INodeBasicSettings {
     storage: {
       /**
-       * Redis storage type to be instantiated by the SDK.
+       * 'REDIS' storage type to be instantiated by the SDK.
        * @property {NodeAsyncStorage} type
        */
       type: NodeAsyncStorage,
@@ -1047,7 +1056,15 @@ declare namespace SplitIO {
        * @default SPLITIO
        */
       prefix?: string
-    }
+    },
+    /**
+     * The SDK mode. When using 'REDIS' storage type, the only possible value is "consumer", which is required.
+     *
+     * @see {@link https://help.split.io/hc/en-us/articles/360020564931-Node-js-SDK#state-sharing-redis-integration}
+     *
+     * @property {'consumer'} mode
+     */
+    mode: 'consumer'
   }
   /**
    * This represents the interface for the SDK instance with synchronous storage.

package/es/client/attributesDecoration.js

@@ -1,116 +0,0 @@
-import ClientInputValidationLayer from './inputValidation';
-import AttributesCacheInMemory from '../storage/AttributesCache/InMemory';
-import { validateAttributesDeep } from '../utils/inputValidation/attributes';
-import logFactory from '../utils/logger';
-import objectAssign from 'object-assign';
-var log = logFactory('splitio-client');
-/**
- * Add in memory attributes storage methods and combine them with any attribute received from the getTreatment/s call 
- */
-
-export default function ClientAttributesDecorationLayer(context, isKeyBinded, isTTBinded) {
-  var client = ClientInputValidationLayer(context, isKeyBinded, isTTBinded);
-  var attributeStorage = new AttributesCacheInMemory(); // Keep a reference to the original methods
-
-  var clientGetTreatment = client.getTreatment;
-  var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  var clientGetTreatments = client.getTreatments;
-  var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  /**
-   * Add an attribute to client's in memory attributes storage
-   * 
-   * @param {string} attributeName Attrinute name
-   * @param {string, number, boolean, list} attributeValue Attribute value
-   * @returns {boolean} true if the attribute was stored and false otherways
-   */
-
-  client.setAttribute = function (attributeName, attributeValue) {
-    var attribute = {};
-    attribute[attributeName] = attributeValue;
-    if (!validateAttributesDeep(attribute)) return false;
-    log.debug("stored " + attributeValue + " for attribute " + attributeName);
-    return attributeStorage.setAttribute(attributeName, attributeValue);
-  };
-  /**
-   * Returns the attribute with the given key
-   * 
-   * @param {string} attributeName Attribute name
-   * @returns {Object} Attribute with the given key
-   */
-
-
-  client.getAttribute = function (attributeName) {
-    log.debug("retrieved attribute " + attributeName);
-    return attributeStorage.getAttribute(attributeName + '');
-  };
-  /**
-   * Add to client's in memory attributes storage the attributes in 'attributes'
-   * 
-   * @param {Object} attributes Object with attributes to store
-   * @returns true if attributes were stored an false otherways
-   */
-
-
-  client.setAttributes = function (attributes) {
-    if (!validateAttributesDeep(attributes)) return false;
-    return attributeStorage.setAttributes(attributes);
-  };
-  /**
-   * Return all the attributes stored in client's in memory attributes storage
-   * 
-   * @returns {Object} returns all the stored attributes
-   */
-
-
-  client.getAttributes = function () {
-    return attributeStorage.getAll();
-  };
-  /**
-   * Removes from client's in memory attributes storage the attribute with the given key
-   * 
-   * @param {string} attributeName 
-   * @returns {boolean} true if attribute was removed and false otherways
-   */
-
-
-  client.removeAttribute = function (attributeName) {
-    log.debug("removed attribute " + attributeName);
-    return attributeStorage.removeAttribute(attributeName + '');
-  };
-  /**
-   * Remove all the stored attributes in the client's in memory attribute storage
-   */
-
-
-  client.clearAttributes = function () {
-    return attributeStorage.clear();
-  };
-
-  client.getTreatment = function (maybeKey, maybeSplit, maybeAttributes) {
-    return clientGetTreatment(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentWithConfig = function (maybeKey, maybeSplit, maybeAttributes) {
-    return clientGetTreatmentWithConfig(maybeKey, maybeSplit, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatments = function (maybeKey, maybeSplits, maybeAttributes) {
-    return clientGetTreatments(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  client.getTreatmentsWithConfig = function (maybeKey, maybeSplits, maybeAttributes) {
-    return clientGetTreatmentsWithConfig(maybeKey, maybeSplits, combineAttributes(maybeAttributes));
-  };
-
-  function combineAttributes(maybeAttributes) {
-    var storedAttributes = attributeStorage.getAll();
-
-    if (Object.keys(storedAttributes).length > 0) {
-      return objectAssign({}, storedAttributes, maybeAttributes);
-    }
-
-    return maybeAttributes;
-  }
-
-  return client;
-}

package/es/client/browser.js

@@ -1,39 +0,0 @@
-import { get } from '../utils/lang';
-import ClientAttributesDecorationLayer from './attributesDecoration';
-import { LOCALHOST_MODE } from '../utils/constants';
-import { validateKey, validateTrafficType } from '../utils/inputValidation';
-
-function BrowserClientFactory(context) {
-  var _client$track;
-
-  var settings = context.get(context.constants.SETTINGS);
-  var maybeKey = get(settings, 'core.key', undefined);
-  var maybeTT = get(settings, 'core.trafficType', undefined);
-
-  if (settings.mode === LOCALHOST_MODE && maybeKey === undefined) {
-    settings.core.key = 'localhost_key';
-  } else {
-    settings.core.key = validateKey(maybeKey, 'Client instantiation');
-  } // Key is also binded to the .track method. Same thing happens with trafficType but only if present on configs. (not required)
-
-
-  var trackBindings = [settings.core.key];
-
-  if (maybeTT !== undefined) {
-    var tt = validateTrafficType(maybeTT, 'Client instantiation');
-    settings.core.trafficType = tt;
-    trackBindings.push(tt);
-  }
-
-  var client = ClientAttributesDecorationLayer(context, true, trackBindings.length > 1);
-  client.isBrowserClient = true; // In the browser land, we can bind the key and the traffic type (if provided)
-
-  client.getTreatment = client.getTreatment.bind(client, settings.core.key);
-  client.getTreatmentWithConfig = client.getTreatmentWithConfig.bind(client, settings.core.key);
-  client.getTreatments = client.getTreatments.bind(client, settings.core.key);
-  client.getTreatmentsWithConfig = client.getTreatmentsWithConfig.bind(client, settings.core.key);
-  client.track = (_client$track = client.track).bind.apply(_client$track, [client].concat(trackBindings));
-  return client;
-}
-
-export default BrowserClientFactory;

package/es/client/client.js

@@ -1,155 +0,0 @@
-import logFactory from '../utils/logger';
-var log = logFactory('splitio-client');
-import { evaluateFeature, evaluateFeatures } from '../engine/evaluator';
-import ImpressionsTracker from '../trackers/impressions';
-import EventTracker from '../trackers/event';
-import tracker from '../utils/timeTracker';
-import thenable from '../utils/promise/thenable';
-import { matching, bucketing } from '../utils/key/factory';
-/* asynchronous validations that live on the client. */
-
-import { validateSplitExistance, validateTrafficTypeExistance } from '../utils/inputValidation';
-import { SDK_NOT_READY } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
-
-function ClientFactory(context) {
-  var storage = context.get(context.constants.STORAGE);
-  var metricCollectors = context.get(context.constants.COLLECTORS);
-  var impressionsTracker = ImpressionsTracker(context);
-  var eventTracker = EventTracker(context);
-
-  function getTreatment(key, splitName, attributes, withConfig) {
-    if (withConfig === void 0) {
-      withConfig = false;
-    }
-
-    var taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENT_WITH_CONFIG' : 'SDK_GET_TREATMENT'];
-    var stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-    var evaluation = evaluateFeature(key, splitName, attributes, storage);
-
-    var wrapUp = function wrapUp(evaluationResult) {
-      var treatment = processEvaluation(evaluationResult, splitName, key, attributes, withConfig, "getTreatment" + (withConfig ? 'withConfig' : ''));
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return treatment;
-    };
-
-    return thenable(evaluation) ? evaluation.then(function (res) {
-      return wrapUp(res);
-    }) : wrapUp(evaluation);
-  }
-
-  function getTreatmentWithConfig(key, splitName, attributes) {
-    return getTreatment(key, splitName, attributes, true);
-  }
-
-  function getTreatments(key, splitNames, attributes, withConfig) {
-    if (withConfig === void 0) {
-      withConfig = false;
-    }
-
-    var taskToBeTracked = tracker.TaskNames[withConfig ? 'SDK_GET_TREATMENTS_WITH_CONFIG' : 'SDK_GET_TREATMENTS'];
-    var stopLatencyTracker = tracker.start(taskToBeTracked, metricCollectors);
-
-    var wrapUp = function wrapUp(evaluationResults) {
-      var results = {};
-      Object.keys(evaluationResults).forEach(function (splitName) {
-        results[splitName] = processEvaluation(evaluationResults[splitName], splitName, key, attributes, withConfig, "getTreatments" + (withConfig ? 'withConfig' : ''));
-      });
-      impressionsTracker.track();
-      stopLatencyTracker();
-      return results;
-    };
-
-    var evaluations = evaluateFeatures(key, splitNames, attributes, storage);
-    return thenable(evaluations) ? evaluations.then(function (res) {
-      return wrapUp(res);
-    }) : wrapUp(evaluations);
-  }
-
-  function getTreatmentsWithConfig(key, splitNames, attributes) {
-    return getTreatments(key, splitNames, attributes, true);
-  } // Internal function
-
-
-  function processEvaluation(evaluation, splitName, key, attributes, withConfig, invokingMethodName) {
-    var isSdkReady = context.get(context.constants.READY, true) || context.get(context.constants.READY_FROM_CACHE, true);
-    var matchingKey = matching(key);
-    var bucketingKey = bucketing(key); // If the SDK was not ready, treatment may be incorrect due to having Splits but not segments data.
-
-    if (!isSdkReady) {
-      evaluation = {
-        treatment: CONTROL,
-        label: SDK_NOT_READY
-      };
-    }
-
-    var _evaluation = evaluation,
-        treatment = _evaluation.treatment,
-        label = _evaluation.label,
-        changeNumber = _evaluation.changeNumber,
-        _evaluation$config = _evaluation.config,
-        config = _evaluation$config === void 0 ? null : _evaluation$config;
-    log.info("Split: " + splitName + ". Key: " + matchingKey + ". Evaluation: " + treatment + ". Label: " + label);
-
-    if (validateSplitExistance(context, splitName, label, invokingMethodName)) {
-      log.info('Queueing corresponding impression.');
-      impressionsTracker.queue({
-        feature: splitName,
-        keyName: matchingKey,
-        treatment: treatment,
-        time: Date.now(),
-        bucketingKey: bucketingKey,
-        label: label,
-        changeNumber: changeNumber
-      }, attributes);
-    }
-
-    if (withConfig) {
-      return {
-        treatment: treatment,
-        config: config
-      };
-    }
-
-    return treatment;
-  }
-
-  function track(key, trafficTypeName, eventTypeId, value, properties, size) {
-    if (value === void 0) {
-      value = null;
-    }
-
-    if (properties === void 0) {
-      properties = null;
-    }
-
-    if (size === void 0) {
-      size = 1024;
-    }
-
-    var matchingKey = matching(key);
-    var timestamp = Date.now();
-    var eventData = {
-      eventTypeId: eventTypeId,
-      trafficTypeName: trafficTypeName,
-      value: value,
-      timestamp: timestamp,
-      key: matchingKey,
-      properties: properties
-    }; // This may be async but we only warn, we don't actually care if it is valid or not in terms of queueing the event.
-
-    validateTrafficTypeExistance(trafficTypeName, context, 'track');
-    return eventTracker.track(eventData, size);
-  }
-
-  return {
-    getTreatment: getTreatment,
-    getTreatmentWithConfig: getTreatmentWithConfig,
-    getTreatments: getTreatments,
-    getTreatmentsWithConfig: getTreatmentsWithConfig,
-    track: track
-  };
-}
-
-export default ClientFactory;

package/es/client/inputValidation.js

@@ -1,117 +0,0 @@
-import objectAssign from 'object-assign';
-import ClientFactory from './client';
-import { validateAttributes, validateEvent, validateEventValue, validateEventProperties, validateKey, validateSplit, validateSplits, validateTrafficType, validateIfDestroyed, validateIfReady } from '../utils/inputValidation';
-import { startsWith } from '../utils/lang';
-import { STORAGE_REDIS, CONTROL, CONTROL_WITH_CONFIG } from '../utils/constants';
-/**
- * We will validate the input before actually executing the client methods. We should "guard" the client here,
- * while not polluting the "real" implementation of those methods.
- */
-
-function ClientInputValidationLayer(context, isKeyBinded, isTTBinded) {
-  var settings = context.get(context.constants.SETTINGS);
-  var isStorageSync = settings.storage.type !== STORAGE_REDIS; // instantiate the client
-
-  var client = ClientFactory(context); // Keep a reference to the original methods
-
-  var clientGetTreatment = client.getTreatment;
-  var clientGetTreatmentWithConfig = client.getTreatmentWithConfig;
-  var clientGetTreatments = client.getTreatments;
-  var clientGetTreatmentsWithConfig = client.getTreatmentsWithConfig;
-  var clientTrack = client.track;
-  /**
-   * Avoid repeating this validations code
-   */
-
-  function validateEvaluationParams(maybeKey, maybeSplitOrSplits, maybeAttributes, methodName) {
-    var multi = startsWith(methodName, 'getTreatments');
-    var key = isKeyBinded ? maybeKey : validateKey(maybeKey, methodName);
-    var splitOrSplits = multi ? validateSplits(maybeSplitOrSplits, methodName) : validateSplit(maybeSplitOrSplits, methodName);
-    var attributes = validateAttributes(maybeAttributes, methodName);
-    var isOperational = validateIfDestroyed(context);
-    validateIfReady(context, methodName);
-    var valid = isOperational && key && splitOrSplits && attributes !== false;
-    return {
-      valid: valid,
-      key: key,
-      splitOrSplits: splitOrSplits,
-      attributes: attributes
-    };
-  }
-
-  client.getTreatment = function getTreatment(maybeKey, maybeSplit, maybeAttributes) {
-    var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatment');
-
-    if (params.valid) {
-      return clientGetTreatment(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      if (isStorageSync) return CONTROL;
-      return Promise.resolve(CONTROL);
-    }
-  };
-
-  client.getTreatmentWithConfig = function getTreatmentWithConfig(maybeKey, maybeSplit, maybeAttributes) {
-    var params = validateEvaluationParams(maybeKey, maybeSplit, maybeAttributes, 'getTreatmentWithConfig');
-
-    if (params.valid) {
-      return clientGetTreatmentWithConfig(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      if (isStorageSync) return objectAssign({}, CONTROL_WITH_CONFIG);
-      return Promise.resolve(objectAssign({}, CONTROL_WITH_CONFIG));
-    }
-  };
-
-  client.getTreatments = function getTreatments(maybeKey, maybeSplits, maybeAttributes) {
-    var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatments');
-
-    if (params.valid) {
-      return clientGetTreatments(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      var res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(function (split) {
-        return res[split] = CONTROL;
-      });
-      if (isStorageSync) return res;
-      return Promise.resolve(res);
-    }
-  };
-
-  client.getTreatmentsWithConfig = function getTreatmentsWithConfig(maybeKey, maybeSplits, maybeAttributes) {
-    var params = validateEvaluationParams(maybeKey, maybeSplits, maybeAttributes, 'getTreatmentsWithConfig');
-
-    if (params.valid) {
-      return clientGetTreatmentsWithConfig(params.key, params.splitOrSplits, params.attributes);
-    } else {
-      var res = {};
-      if (params.splitOrSplits) params.splitOrSplits.forEach(function (split) {
-        return res[split] = objectAssign({}, CONTROL_WITH_CONFIG);
-      });
-      if (isStorageSync) return res;
-      return Promise.resolve(res);
-    }
-  };
-
-  client.track = function track(maybeKey, maybeTT, maybeEvent, maybeEventValue, maybeProperties) {
-    var key = isKeyBinded ? maybeKey : validateKey(maybeKey, 'track');
-    var tt = isTTBinded ? maybeTT : validateTrafficType(maybeTT, 'track');
-    var event = validateEvent(maybeEvent, 'track');
-    var eventValue = validateEventValue(maybeEventValue, 'track');
-
-    var _validateEventPropert = validateEventProperties(maybeProperties, 'track'),
-        properties = _validateEventPropert.properties,
-        size = _validateEventPropert.size;
-
-    var isOperational = validateIfDestroyed(context);
-
-    if (isOperational && key && tt && event && eventValue !== false && properties !== false) {
-      return clientTrack(key, tt, event, eventValue, properties, size);
-    } else {
-      if (isStorageSync) return false;
-      return Promise.resolve(false);
-    }
-  };
-
-  return client;
-}
-
-export default ClientInputValidationLayer;

package/es/client/node.js

@@ -1,6 +0,0 @@
-import ClientWithInputValidationLayer from './inputValidation';
-export default function NodeClientFactory(context) {
-  var client = ClientWithInputValidationLayer(context);
-  client.isBrowserClient = false;
-  return client;
-}

package/es/engine/combiners/and.js

@@ -1,54 +0,0 @@
-/**
-Copyright 2016 Split Software
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.
-**/
-import { findIndex } from '../../utils/lang';
-import logFactory from '../../utils/logger';
-var log = logFactory('splitio-engine:combiner');
-import thenable from '../../utils/promise/thenable';
-
-function andResults(results) {
-  var i = 0;
-  var len = results.length;
-  var hasMatchedAll; // loop through all the matchers an stop at the first one returning false.
-
-  for (; i < len && results[i]; i++) {// logic is run inside the condition of evaluates next step.
-  }
-
-  hasMatchedAll = i === len;
-  log.debug("[andCombiner] evaluates to " + hasMatchedAll);
-  return hasMatchedAll;
-}
-
-function andCombinerContext(matchers) {
-  function andCombiner() {
-    for (var _len = arguments.length, params = new Array(_len), _key = 0; _key < _len; _key++) {
-      params[_key] = arguments[_key];
-    }
-
-    var matcherResults = matchers.map(function (matcher) {
-      return matcher.apply(void 0, params);
-    }); // If any matching result is a thenable we should use Promise.all
-
-    if (findIndex(matcherResults, thenable) !== -1) {
-      return Promise.all(matcherResults).then(andResults);
-    } else {
-      return andResults(matcherResults);
-    }
-  }
-
-  return andCombiner;
-}
-
-export default andCombinerContext;