@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/es/engine/engine/murmur3/murmur3_64.js

@@ -0,0 +1,52 @@
+import { hash128 } from './murmur3_128';
+/**
+ * Use instead of parseInt, to not lose precision when converting big integers (greater than 2^53 - 1)
+ */
+
+function hex2dec(s
+/*: string */
+)
+/*: string */
+{
+  var i,
+      j,
+      digits = [0],
+      carry;
+
+  for (i = 0; i < s.length; i += 1) {
+    carry = parseInt(s.charAt(i), 16);
+
+    for (j = digits.length - 1; j >= 0; j -= 1) {
+      digits[j] = digits[j] * 16 + carry;
+      carry = digits[j] / 10 | 0;
+      digits[j] %= 10;
+    }
+
+    while (carry > 0) {
+      digits.unshift(carry % 10);
+      carry = carry / 10 | 0;
+    }
+  }
+
+  return digits.join('');
+}
+/**
+ * Gets the higher 64 bits of the x64 version of Murmur3 for 128bits, as decimal and hexadecimal number strings.
+ * Used for MySegments channel V2 notifications.
+ * @param {string} str
+ */
+
+
+export function hash64(str
+/*: string */
+)
+/*: { hex: string, dec: string } */
+{
+  var hex = hash128(str).slice(0, 16);
+  return {
+    hex: hex,
+    // BoundedFetchRequest notification
+    dec: hex2dec(hex) // KeyList notification
+
+  };
+}

package/es/engine/engine/murmur3/utfx.js

@@ -0,0 +1,112 @@
+/*
+ Trimmed version of "utfx" library (https://www.npmjs.com/package/utfx/v/1.0.1) used to encode,
+ decode and convert UTF8 / UTF16 in JavaScript, with the minimal methods used by the SDK.
+
+ utfx (c) 2014 Daniel Wirtz <dcode@dcode.io>
+ Released under the Apache License, Version 2.0
+ see: https://github.com/dcodeIO/utfx for details
+*/
+
+/**
+ * Encodes UTF8 code points to UTF8 bytes.
+ * @param {(!function():number|null) | number} src Code points source, either as a function returning the next code point
+ *  respectively `null` if there are no more code points left or a single numeric code point.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte
+ * @expose
+ */
+function encodeUTF8(src, dst) {
+  var cp = null;
+  if (typeof src === 'number') cp = src, src = function src() {
+    return null;
+  };
+
+  while (cp !== null || (cp = src()) !== null) {
+    if (cp < 0x80) dst(cp & 0x7F);else if (cp < 0x800) dst(cp >> 6 & 0x1F | 0xC0), dst(cp & 0x3F | 0x80);else if (cp < 0x10000) dst(cp >> 12 & 0x0F | 0xE0), dst(cp >> 6 & 0x3F | 0x80), dst(cp & 0x3F | 0x80);else dst(cp >> 18 & 0x07 | 0xF0), dst(cp >> 12 & 0x3F | 0x80), dst(cp >> 6 & 0x3F | 0x80), dst(cp & 0x3F | 0x80);
+    cp = null;
+  }
+}
+/**
+ * Converts UTF16 characters to UTF8 code points.
+ * @param {!function():number|null} src Characters source as a function returning the next char code respectively
+ *  `null` if there are no more characters left.
+ * @param {!function(number)} dst Code points destination as a function successively called with each converted code
+ *  point.
+ * @expose
+ */
+
+
+function UTF16toUTF8(src, dst) {
+  var c1,
+      c2 = null; // eslint-disable-next-line no-constant-condition
+
+  while (true) {
+    if ((c1 = c2 !== null ? c2 : src()) === null) break;
+
+    if (c1 >= 0xD800 && c1 <= 0xDFFF) {
+      if ((c2 = src()) !== null) {
+        if (c2 >= 0xDC00 && c2 <= 0xDFFF) {
+          dst((c1 - 0xD800) * 0x400 + c2 - 0xDC00 + 0x10000);
+          c2 = null;
+          continue;
+        }
+      }
+    }
+
+    dst(c1);
+  }
+
+  if (c2 !== null) dst(c2);
+}
+/**
+ * Converts and encodes UTF16 characters to UTF8 bytes.
+ * @param {!function():number|null} src Characters source as a function returning the next char code respectively `null`
+ *  if there are no more characters left.
+ * @param {!function(number)} dst Bytes destination as a function successively called with the next byte.
+ * @expose
+ */
+
+
+export function encodeUTF16toUTF8(src, dst) {
+  UTF16toUTF8(src, function (cp) {
+    encodeUTF8(cp, dst);
+  });
+}
+/**
+ * String.fromCharCode reference for compile time renaming.
+ * @type {!function(...[number]):string}
+ * @inner
+ */
+
+var stringFromCharCode = String.fromCharCode;
+/**
+ * Creates a source function for a string.
+ * @param {string} s String to read from
+ * @returns {!function():number|null} Source function returning the next char code respectively `null` if there are
+ *  no more characters left.
+ * @throws {TypeError} If the argument is invalid
+ * @expose
+ */
+
+export function stringSource(s) {
+  if (typeof s !== 'string') throw TypeError('Illegal argument: ' + typeof s);
+  var i = 0;
+  return function () {
+    return i >= s.length ? null : s.charCodeAt(i++);
+  };
+}
+/**
+ * Creates a destination function for a string.
+ * @returns {function(number=):undefined|string} Destination function successively called with the next char code.
+ *  Returns the final string when called without arguments.
+ * @expose
+ */
+
+export function stringDestination() {
+  var cs = [],
+      ps = [];
+  return function () {
+    if (arguments.length === 0) return ps.join('') + stringFromCharCode.apply(String, cs);
+    if (cs.length + arguments.length > 1024) ps.push(stringFromCharCode.apply(String, cs)), cs.length = 0;
+    Array.prototype.push.apply(cs, arguments);
+  };
+}

package/es/engine/evaluator/index.js

@@ -0,0 +1,111 @@
+/**
+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 Engine from '../';
+import thenable from '../../utils/promise/thenable';
+import * as LabelsConstants from '../../utils/labels';
+import { CONTROL } from '../../utils/constants';
+var treatmentException = {
+  treatment: CONTROL,
+  label: LabelsConstants.EXCEPTION,
+  config: null
+};
+export function evaluateFeature(key, splitName, attributes, storage) {
+  var stringifiedSplit;
+
+  try {
+    stringifiedSplit = storage.splits.getSplit(splitName);
+  } catch (e) {
+    // the only scenario where getSplit can throw an error is when the storage
+    // is redis and there is a connection issue and we can't retrieve the split
+    // to be evaluated
+    return Promise.resolve(treatmentException);
+  }
+
+  if (thenable(stringifiedSplit)) {
+    return stringifiedSplit.then(function (result) {
+      return getEvaluation(result, key, attributes, storage);
+    });
+  }
+
+  return getEvaluation(stringifiedSplit, key, attributes, storage);
+}
+export function evaluateFeatures(key, splitNames, attributes, storage) {
+  var stringifiedSplits;
+  var evaluations = {};
+
+  try {
+    stringifiedSplits = storage.splits.fetchMany(splitNames);
+  } catch (e) {
+    // the only scenario where fetchMany can throw an error is when the storage
+    // is redis and there is a connection issue and we can't retrieve the split
+    // to be evaluated
+    splitNames.forEach(function (splitName) {
+      evaluations[splitName] = treatmentException;
+    });
+    return Promise.resolve(evaluations);
+  }
+
+  return thenable(stringifiedSplits) ? stringifiedSplits.then(function (splits) {
+    return getEvaluations(splitNames, splits, key, attributes, storage);
+  }) : getEvaluations(splitNames, stringifiedSplits, key, attributes, storage);
+}
+
+function getEvaluation(stringifiedSplit, key, attributes, storage) {
+  var evaluation = {
+    treatment: CONTROL,
+    label: LabelsConstants.SPLIT_NOT_FOUND,
+    config: null
+  };
+
+  if (stringifiedSplit) {
+    var splitJSON = JSON.parse(stringifiedSplit);
+    var split = Engine.parse(splitJSON, storage);
+    evaluation = split.getTreatment(key, attributes, evaluateFeature); // If the storage is async and the evaluated split uses segment, evaluation is thenable
+
+    if (thenable(evaluation)) {
+      return evaluation.then(function (result) {
+        result.changeNumber = split.getChangeNumber();
+        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
+        return result;
+      });
+    } else {
+      evaluation.changeNumber = split.getChangeNumber(); // Always sync and optional
+
+      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
+    }
+  }
+
+  return evaluation;
+}
+
+function getEvaluations(splitNames, splits, key, attributes, storage) {
+  var result = {};
+  var thenables = [];
+  splitNames.forEach(function (splitName) {
+    var evaluation = getEvaluation(splits[splitName], key, attributes, storage);
+
+    if (thenable(evaluation)) {
+      thenables.push(evaluation.then(function (res) {
+        result[splitName] = res;
+      }));
+    } else {
+      result[splitName] = evaluation;
+    }
+  });
+  return thenables.length > 0 ? Promise.all(thenables).then(function () {
+    return result;
+  }) : result;
+}

package/es/engine/index.js

@@ -0,0 +1,112 @@
+/**
+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 objectAssign from 'object-assign';
+import { get } from '../utils/lang';
+import parser from './parser';
+import keyParser from '../utils/key/parser';
+import thenable from '../utils/promise/thenable';
+import * as LabelsConstants from '../utils/labels';
+import { CONTROL } from '../utils/constants';
+
+function defaults(inst) {
+  // in case we don't have a default treatment in the instanciation, use 'control'
+  if (typeof inst.baseInfo.defaultTreatment !== 'string') {
+    inst.baseInfo.defaultTreatment = CONTROL;
+  }
+}
+
+function evaluationResult(result, defaultTreatment) {
+  return {
+    treatment: get(result, 'treatment', defaultTreatment),
+    label: get(result, 'label', LabelsConstants.NO_CONDITION_MATCH)
+  };
+}
+
+function Split(baseInfo, evaluator) {
+  if (!(this instanceof Split)) {
+    return new Split(baseInfo, evaluator);
+  }
+
+  this.baseInfo = baseInfo;
+  this.evaluator = evaluator;
+  defaults(this);
+}
+
+Split.parse = function parse(splitFlatStructure, storage) {
+  var conditions = splitFlatStructure.conditions;
+  var evaluator = parser(conditions, storage);
+  return new Split(objectAssign({}, splitFlatStructure), evaluator);
+};
+
+Split.prototype.getKey = function getKey() {
+  return this.baseInfo.name;
+};
+
+Split.prototype.getTreatment = function getTreatment(key, attributes, splitEvaluator) {
+  var _this$baseInfo = this.baseInfo,
+      killed = _this$baseInfo.killed,
+      seed = _this$baseInfo.seed,
+      defaultTreatment = _this$baseInfo.defaultTreatment,
+      trafficAllocation = _this$baseInfo.trafficAllocation,
+      trafficAllocationSeed = _this$baseInfo.trafficAllocationSeed,
+      algo = _this$baseInfo.algo;
+  var parsedKey;
+  var treatment;
+  var label;
+
+  try {
+    parsedKey = keyParser(key);
+  } catch (err) {
+    return {
+      treatment: CONTROL,
+      label: LabelsConstants.EXCEPTION
+    };
+  }
+
+  if (this.isGarbage()) {
+    treatment = CONTROL;
+    label = LabelsConstants.SPLIT_ARCHIVED;
+  } else if (killed) {
+    treatment = defaultTreatment;
+    label = LabelsConstants.SPLIT_KILLED;
+  } else {
+    var evaluation = this.evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, algo, splitEvaluator); // Evaluation could be async, so we should handle that case checking for a
+    // thenable object
+
+    if (thenable(evaluation)) {
+      return evaluation.then(function (result) {
+        return evaluationResult(result, defaultTreatment);
+      });
+    } else {
+      return evaluationResult(evaluation, defaultTreatment);
+    }
+  }
+
+  return {
+    treatment: treatment,
+    label: label
+  };
+};
+
+Split.prototype.isGarbage = function isGarbage() {
+  return this.baseInfo.status === 'ARCHIVED';
+};
+
+Split.prototype.getChangeNumber = function getChangeNumber() {
+  return this.baseInfo.changeNumber;
+};
+
+export default Split;

package/es/engine/matchers/all.js

@@ -0,0 +1,32 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+
+function allMatcher(runtimeAttr
+/*: string */
+)
+/*: boolean */
+{
+  log.debug('[allMatcher] is always true');
+  return runtimeAttr != null;
+}
+
+function allMatcherContext() {
+  return allMatcher;
+}
+
+export default allMatcherContext;

package/es/engine/matchers/between.js

@@ -0,0 +1,35 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+
+function betweenMatcherContext(ruleVO
+/*: betweenObject */
+)
+/*: Function */
+{
+  return function betweenMatcher(runtimeAttr
+  /*: number */
+  )
+  /*: boolean */
+  {
+    var isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
+    log.debug("[betweenMatcher] is " + runtimeAttr + " between " + ruleVO.start + " and " + ruleVO.end + "? " + isBetween);
+    return isBetween;
+  };
+}
+
+export default betweenMatcherContext;

package/es/engine/matchers/boolean.js

@@ -0,0 +1,35 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+
+function booleanMatcherContext(ruleAttr
+/*: bool */
+)
+/*: Function */
+{
+  return function booleanMatcher(runtimeAttr
+  /*: bool */
+  )
+  /*: bool */
+  {
+    var booleanMatches = ruleAttr === runtimeAttr;
+    log.debug("[booleanMatcher] " + ruleAttr + " === " + runtimeAttr);
+    return booleanMatches;
+  };
+}
+
+export default booleanMatcherContext;

package/es/engine/matchers/cont_all.js

@@ -0,0 +1,51 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+import { findIndex } from '../../utils/lang';
+
+function containsAllMatcherContext(ruleAttr
+/*: array */
+)
+/*: Function */
+{
+  return function containsAllMatcher(runtimeAttr
+  /*: array */
+  )
+  /*: boolean */
+  {
+    var containsAll = true;
+
+    if (runtimeAttr.length < ruleAttr.length) {
+      containsAll = false;
+    } else {
+      var _loop = function _loop(i) {
+        if (findIndex(runtimeAttr, function (e) {
+          return e === ruleAttr[i];
+        }) < 0) containsAll = false;
+      };
+
+      for (var i = 0; i < ruleAttr.length && containsAll; i++) {
+        _loop(i);
+      }
+    }
+
+    log.debug("[containsAllMatcher] " + runtimeAttr + " contains all elements of " + ruleAttr + "? " + containsAll);
+    return containsAll;
+  };
+}
+
+export default containsAllMatcherContext;

package/es/engine/matchers/cont_any.js

@@ -0,0 +1,47 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+import { findIndex } from '../../utils/lang';
+
+function containsAnyMatcherContext(ruleAttr
+/*: array */
+)
+/*: Function */
+{
+  return function containsAnyMatcher(runtimeAttr
+  /*: array */
+  )
+  /*: boolean */
+  {
+    var containsAny = false;
+
+    var _loop = function _loop(i) {
+      if (findIndex(runtimeAttr, function (e) {
+        return e === ruleAttr[i];
+      }) >= 0) containsAny = true;
+    };
+
+    for (var i = 0; i < ruleAttr.length && !containsAny; i++) {
+      _loop(i);
+    }
+
+    log.debug("[containsAnyMatcher] " + runtimeAttr + " contains at least an element of " + ruleAttr + "? " + containsAny);
+    return containsAny;
+  };
+}
+
+export default containsAnyMatcherContext;

package/es/engine/matchers/cont_str.js

@@ -0,0 +1,38 @@
+/**
+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 { isString } from '../../utils/lang';
+import logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+
+function containsStringMatcherContext(ruleAttr
+/*: array */
+)
+/*: Function */
+{
+  return function containsStringMatcher(runtimeAttr
+  /*: string */
+  )
+  /*: boolean */
+  {
+    var contains = ruleAttr.some(function (e) {
+      return isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1;
+    });
+    log.debug("[containsStringMatcher] " + runtimeAttr + " contains " + ruleAttr + "? " + contains);
+    return contains;
+  };
+}
+
+export default containsStringMatcherContext;

package/es/engine/matchers/dependency.js

@@ -0,0 +1,50 @@
+/**
+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 logFactory from '../../utils/logger';
+var log = logFactory('splitio-engine:matcher');
+import thenable from '../../utils/promise/thenable';
+
+function checkTreatment(evaluation, acceptableTreatments, parentName) {
+  var matches = false;
+
+  if (Array.isArray(acceptableTreatments)) {
+    matches = acceptableTreatments.indexOf(evaluation.treatment) !== -1;
+  }
+
+  log.debug("[dependencyMatcher] Parent split \"" + parentName + "\" evaluated to \"" + evaluation.treatment + "\" with label \"" + evaluation.label + "\". " + parentName + " evaluated treatment is part of [" + acceptableTreatments + "] ? " + matches + ".");
+  return matches;
+}
+
+function dependencyMatcherContext(_ref, storage) {
+  var split = _ref.split,
+      treatments = _ref.treatments;
+  return function dependencyMatcher(_ref2, splitEvaluator) {
+    var key = _ref2.key,
+        attributes = _ref2.attributes;
+    log.debug("[dependencyMatcher] will evaluate parent split: \"" + split + "\" with key: " + JSON.stringify(key) + " " + (attributes ? "\n attributes: " + JSON.stringify(attributes) : ''));
+    var evaluation = splitEvaluator(key, split, attributes, storage);
+
+    if (thenable(evaluation)) {
+      return evaluation.then(function (ev) {
+        return checkTreatment(ev, treatments, split);
+      });
+    } else {
+      return checkTreatment(evaluation, treatments, split);
+    }
+  };
+}
+
+export default dependencyMatcherContext;