@splitsoftware/splitio 10.17.3-rc.2 → 10.17.3

package/lib/engine/engine/murmur3/murmur3_128_x86.js

@@ -0,0 +1,189 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hash128 = hash128;
+
+var _common = require("./common");
+
+/* eslint-disable no-fallthrough */
+
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+// PUBLIC FUNCTIONS
+// ----------------
+function hash128x86(key
+/*: string */
+, seed
+/*: number */
+)
+/*: string */
+{
+  //
+  // Given a string and an optional seed as an int, returns a 128 bit
+  // hash using the x86 flavor of MurmurHash3, as an unsigned hex.
+  //
+  key = key || '';
+  seed = seed || 0;
+  var remainder = key.length % 16;
+  var bytes = key.length - remainder;
+  var h1 = seed;
+  var h2 = seed;
+  var h3 = seed;
+  var h4 = seed;
+  var k1 = 0;
+  var k2 = 0;
+  var k3 = 0;
+  var k4 = 0;
+  var c1 = 0x239b961b;
+  var c2 = 0xab0e9789;
+  var c3 = 0x38b34ae5;
+  var c4 = 0xa1e38b93;
+
+  for (var i = 0; i < bytes; i = i + 16) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(i + 1) & 0xff) << 8 | (key.charCodeAt(i + 2) & 0xff) << 16 | (key.charCodeAt(i + 3) & 0xff) << 24;
+    k2 = key.charCodeAt(i + 4) & 0xff | (key.charCodeAt(i + 5) & 0xff) << 8 | (key.charCodeAt(i + 6) & 0xff) << 16 | (key.charCodeAt(i + 7) & 0xff) << 24;
+    k3 = key.charCodeAt(i + 8) & 0xff | (key.charCodeAt(i + 9) & 0xff) << 8 | (key.charCodeAt(i + 10) & 0xff) << 16 | (key.charCodeAt(i + 11) & 0xff) << 24;
+    k4 = key.charCodeAt(i + 12) & 0xff | (key.charCodeAt(i + 13) & 0xff) << 8 | (key.charCodeAt(i + 14) & 0xff) << 16 | (key.charCodeAt(i + 15) & 0xff) << 24;
+    k1 = (0, _common.x86Multiply)(k1, c1);
+    k1 = (0, _common.x86Rotl)(k1, 15);
+    k1 = (0, _common.x86Multiply)(k1, c2);
+    h1 ^= k1;
+    h1 = (0, _common.x86Rotl)(h1, 19);
+    h1 += h2;
+    h1 = (0, _common.x86Multiply)(h1, 5) + 0x561ccd1b;
+    k2 = (0, _common.x86Multiply)(k2, c2);
+    k2 = (0, _common.x86Rotl)(k2, 16);
+    k2 = (0, _common.x86Multiply)(k2, c3);
+    h2 ^= k2;
+    h2 = (0, _common.x86Rotl)(h2, 17);
+    h2 += h3;
+    h2 = (0, _common.x86Multiply)(h2, 5) + 0x0bcaa747;
+    k3 = (0, _common.x86Multiply)(k3, c3);
+    k3 = (0, _common.x86Rotl)(k3, 17);
+    k3 = (0, _common.x86Multiply)(k3, c4);
+    h3 ^= k3;
+    h3 = (0, _common.x86Rotl)(h3, 15);
+    h3 += h4;
+    h3 = (0, _common.x86Multiply)(h3, 5) + 0x96cd1c35;
+    k4 = (0, _common.x86Multiply)(k4, c4);
+    k4 = (0, _common.x86Rotl)(k4, 18);
+    k4 = (0, _common.x86Multiply)(k4, c1);
+    h4 ^= k4;
+    h4 = (0, _common.x86Rotl)(h4, 13);
+    h4 += h1;
+    h4 = (0, _common.x86Multiply)(h4, 5) + 0x32ac3b17;
+  }
+
+  k1 = 0;
+  k2 = 0;
+  k3 = 0;
+  k4 = 0;
+
+  switch (remainder) {
+    case 15:
+      k4 ^= key.charCodeAt(i + 14) << 16;
+
+    case 14:
+      k4 ^= key.charCodeAt(i + 13) << 8;
+
+    case 13:
+      k4 ^= key.charCodeAt(i + 12);
+      k4 = (0, _common.x86Multiply)(k4, c4);
+      k4 = (0, _common.x86Rotl)(k4, 18);
+      k4 = (0, _common.x86Multiply)(k4, c1);
+      h4 ^= k4;
+
+    case 12:
+      k3 ^= key.charCodeAt(i + 11) << 24;
+
+    case 11:
+      k3 ^= key.charCodeAt(i + 10) << 16;
+
+    case 10:
+      k3 ^= key.charCodeAt(i + 9) << 8;
+
+    case 9:
+      k3 ^= key.charCodeAt(i + 8);
+      k3 = (0, _common.x86Multiply)(k3, c3);
+      k3 = (0, _common.x86Rotl)(k3, 17);
+      k3 = (0, _common.x86Multiply)(k3, c4);
+      h3 ^= k3;
+
+    case 8:
+      k2 ^= key.charCodeAt(i + 7) << 24;
+
+    case 7:
+      k2 ^= key.charCodeAt(i + 6) << 16;
+
+    case 6:
+      k2 ^= key.charCodeAt(i + 5) << 8;
+
+    case 5:
+      k2 ^= key.charCodeAt(i + 4);
+      k2 = (0, _common.x86Multiply)(k2, c2);
+      k2 = (0, _common.x86Rotl)(k2, 16);
+      k2 = (0, _common.x86Multiply)(k2, c3);
+      h2 ^= k2;
+
+    case 4:
+      k1 ^= key.charCodeAt(i + 3) << 24;
+
+    case 3:
+      k1 ^= key.charCodeAt(i + 2) << 16;
+
+    case 2:
+      k1 ^= key.charCodeAt(i + 1) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i);
+      k1 = (0, _common.x86Multiply)(k1, c1);
+      k1 = (0, _common.x86Rotl)(k1, 15);
+      k1 = (0, _common.x86Multiply)(k1, c2);
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h2 ^= key.length;
+  h3 ^= key.length;
+  h4 ^= key.length;
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
+  h1 = (0, _common.x86Fmix)(h1);
+  h2 = (0, _common.x86Fmix)(h2);
+  h3 = (0, _common.x86Fmix)(h3);
+  h4 = (0, _common.x86Fmix)(h4);
+  h1 += h2;
+  h1 += h3;
+  h1 += h4;
+  h2 += h1;
+  h3 += h1;
+  h4 += h1;
+  return ('00000000' + (h1 >>> 0).toString(16)).slice(-8) + ('00000000' + (h2 >>> 0).toString(16)).slice(-8) + ('00000000' + (h3 >>> 0).toString(16)).slice(-8) + ('00000000' + (h4 >>> 0).toString(16)).slice(-8);
+}
+/**
+ * x86 version of Murmur3 for 128bits.
+ * Used by hashImpression128 because in JS it is more efficient than the x64 version, no matter the underlying OS/CPU arch.
+ *
+ * @param {string} str
+ */
+
+
+function hash128(str
+/*: string */
+, seed
+/*: number */
+)
+/*: string */
+{
+  return hash128x86((0, _common.UTF16ToUTF8)(str), seed >>> 0);
+}

package/lib/engine/engine/murmur3/murmur3_64.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hash64 = hash64;
+
+var _murmur3_ = require("./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
+ */
+
+
+function hash64(str
+/*: string */
+)
+/*: { hex: string, dec: string } */
+{
+  var hex = (0, _murmur3_.hash128)(str).slice(0, 16);
+  return {
+    hex: hex,
+    // BoundedFetchRequest notification
+    dec: hex2dec(hex) // KeyList notification
+
+  };
+}

package/lib/engine/engine/murmur3/utfx.js

@@ -0,0 +1,121 @@
+"use strict";
+
+exports.__esModule = true;
+exports.encodeUTF16toUTF8 = encodeUTF16toUTF8;
+exports.stringSource = stringSource;
+exports.stringDestination = stringDestination;
+
+/*
+ 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
+ */
+
+
+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
+ */
+
+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
+ */
+
+
+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/lib/engine/evaluator/index.js

@@ -0,0 +1,129 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.evaluateFeature = evaluateFeature;
+exports.evaluateFeatures = evaluateFeatures;
+
+var _ = _interopRequireDefault(require("../"));
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+var LabelsConstants = _interopRequireWildcard(require("../../utils/labels"));
+
+var _constants = require("../../utils/constants");
+
+/**
+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.
+**/
+var treatmentException = {
+  treatment: _constants.CONTROL,
+  label: LabelsConstants.EXCEPTION,
+  config: null
+};
+
+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 ((0, _thenable.default)(stringifiedSplit)) {
+    return stringifiedSplit.then(function (result) {
+      return getEvaluation(result, key, attributes, storage);
+    });
+  }
+
+  return getEvaluation(stringifiedSplit, key, attributes, storage);
+}
+
+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 (0, _thenable.default)(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: _constants.CONTROL,
+    label: LabelsConstants.SPLIT_NOT_FOUND,
+    config: null
+  };
+
+  if (stringifiedSplit) {
+    var splitJSON = JSON.parse(stringifiedSplit);
+
+    var split = _.default.parse(splitJSON, storage);
+
+    evaluation = split.getTreatment(key, attributes, evaluateFeature); // If the storage is async and the evaluated split uses segment, evaluation is thenable
+
+    if ((0, _thenable.default)(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 ((0, _thenable.default)(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/lib/engine/index.js

@@ -0,0 +1,128 @@
+"use strict";
+
+var _interopRequireWildcard = require("@babel/runtime/helpers/interopRequireWildcard");
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _objectAssign = _interopRequireDefault(require("object-assign"));
+
+var _lang = require("../utils/lang");
+
+var _parser = _interopRequireDefault(require("./parser"));
+
+var _parser2 = _interopRequireDefault(require("../utils/key/parser"));
+
+var _thenable = _interopRequireDefault(require("../utils/promise/thenable"));
+
+var LabelsConstants = _interopRequireWildcard(require("../utils/labels"));
+
+var _constants = require("../utils/constants");
+
+/**
+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.
+**/
+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 = _constants.CONTROL;
+  }
+}
+
+function evaluationResult(result, defaultTreatment) {
+  return {
+    treatment: (0, _lang.get)(result, 'treatment', defaultTreatment),
+    label: (0, _lang.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 = (0, _parser.default)(conditions, storage);
+  return new Split((0, _objectAssign.default)({}, 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 = (0, _parser2.default)(key);
+  } catch (err) {
+    return {
+      treatment: _constants.CONTROL,
+      label: LabelsConstants.EXCEPTION
+    };
+  }
+
+  if (this.isGarbage()) {
+    treatment = _constants.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 ((0, _thenable.default)(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;
+};
+
+var _default = Split;
+exports.default = _default;

package/lib/engine/matchers/all.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+/**
+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.
+**/
+var log = (0, _logger.default)('splitio-engine:matcher');
+
+function allMatcher(runtimeAttr
+/*: string */
+)
+/*: boolean */
+{
+  log.debug('[allMatcher] is always true');
+  return runtimeAttr != null;
+}
+
+function allMatcherContext() {
+  return allMatcher;
+}
+
+var _default = allMatcherContext;
+exports.default = _default;