@splitsoftware/splitio 10.17.3-rc.1 → 10.17.3-rc.4

package/lib/engine/matchers/part_of.js

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _lang = require("../../utils/lang");
+
+/**
+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 partOfMatcherContext(ruleAttr
+/*: array */
+)
+/*: Function */
+{
+  return function partOfMatcher(runtimeAttr
+  /*: array */
+  )
+  /*: boolean */
+  {
+    // To be part of the length should be minor or equal.
+    var isPartOf = runtimeAttr.length <= ruleAttr.length;
+
+    var _loop = function _loop(i) {
+      // If the length says is possible, we iterate until we prove otherwise or we check all elements.
+      if ((0, _lang.findIndex)(ruleAttr, function (e) {
+        return e === runtimeAttr[i];
+      }) < 0) isPartOf = false;
+    };
+
+    for (var i = 0; i < runtimeAttr.length && isPartOf; i++) {
+      _loop(i);
+    }
+
+    log.debug("[partOfMatcher] " + runtimeAttr + " is part of " + ruleAttr + "? " + isPartOf);
+    return isPartOf;
+  };
+}
+
+var _default = partOfMatcherContext;
+exports.default = _default;

package/lib/engine/matchers/segment.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+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 matcherSegmentContext(segmentName, storage) {
+  function segmentMatcher(key) {
+    var isInSegment = storage.segments.isInSegment(segmentName, key);
+
+    if ((0, _thenable.default)(isInSegment)) {
+      isInSegment.then(function (result) {
+        log.debug("[asyncSegmentMatcher] evaluated " + segmentName + " / " + key + " => " + isInSegment);
+        return result;
+      });
+    } else {
+      log.debug("[segmentMatcher] evaluated " + segmentName + " / " + key + " => " + isInSegment);
+    }
+
+    return isInSegment;
+  }
+
+  return segmentMatcher;
+}
+
+var _default = matcherSegmentContext;
+exports.default = _default;

package/lib/engine/matchers/string.js

@@ -0,0 +1,53 @@
+"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 stringMatcherContext(ruleAttr
+/*: regex */
+)
+/*: Function */
+{
+  return function stringMatcher(runtimeAttr
+  /*: string */
+  )
+  /*: bool */
+  {
+    var re;
+
+    try {
+      re = new RegExp(ruleAttr);
+    } catch (e) {
+      log.debug("[stringMatcher] " + ruleAttr + " is an invalid regex");
+      return false;
+    }
+
+    var regexMatches = re.test(runtimeAttr);
+    log.debug("[stringMatcher] does " + runtimeAttr + " matches with " + ruleAttr + "? " + (regexMatches ? 'yes' : 'no'));
+    return regexMatches;
+  };
+}
+
+var _default = stringMatcherContext;
+exports.default = _default;

package/lib/engine/matchers/sw.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _lang = require("../../utils/lang");
+
+/**
+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 startsWithMatcherContext(ruleAttr
+/*: array */
+)
+/*: Function */
+{
+  return function startsWithMatcher(runtimeAttr
+  /*: string */
+  )
+  /*: boolean */
+  {
+    var matches = ruleAttr.some(function (e) {
+      return (0, _lang.startsWith)(runtimeAttr, e);
+    });
+    log.debug("[startsWithMatcher] " + runtimeAttr + " starts with " + ruleAttr + "? " + matches);
+    return matches;
+  };
+}
+
+var _default = startsWithMatcherContext;
+exports.default = _default;

package/lib/engine/matchers/types.js

@@ -0,0 +1,57 @@
+"use strict";
+
+exports.__esModule = true;
+exports.matcherTypesMapper = matcherTypesMapper;
+exports.matcherDataTypes = exports.matcherTypes = void 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.
+**/
+// @WARNING Symbol is not correctly working in PhantomJS
+var matcherTypes = {
+  UNDEFINED: 0,
+  ALL_KEYS: 1,
+  IN_SEGMENT: 2,
+  WHITELIST: 3,
+  EQUAL_TO: 4,
+  GREATER_THAN_OR_EQUAL_TO: 5,
+  LESS_THAN_OR_EQUAL_TO: 6,
+  BETWEEN: 7,
+  EQUAL_TO_SET: 8,
+  CONTAINS_ANY_OF_SET: 9,
+  CONTAINS_ALL_OF_SET: 10,
+  PART_OF_SET: 11,
+  ENDS_WITH: 12,
+  STARTS_WITH: 13,
+  CONTAINS_STRING: 14,
+  IN_SPLIT_TREATMENT: 15,
+  EQUAL_TO_BOOLEAN: 16,
+  MATCHES_STRING: 17
+};
+exports.matcherTypes = matcherTypes;
+var matcherDataTypes = {
+  BOOLEAN: 'BOOLEAN',
+  STRING: 'STRING',
+  NUMBER: 'NUMBER',
+  SET: 'SET',
+  DATETIME: 'DATETIME',
+  NOT_SPECIFIED: 'NOT_SPECIFIED'
+};
+exports.matcherDataTypes = matcherDataTypes;
+
+function matcherTypesMapper(matcherType) {
+  var type = matcherTypes[matcherType];
+  if (type) return type;else return matcherTypes.UNDEFINED;
+}

package/lib/engine/matchers/whitelist.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _Sets = require("../../utils/lang/Sets");
+
+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 whitelistMatcherContext(ruleAttr
+/*: Set */
+)
+/*: Function */
+{
+  return function whitelistMatcher(runtimeAttr
+  /*: string */
+  )
+  /*: boolean */
+  {
+    var isInWhitelist = ruleAttr.has(runtimeAttr);
+    log.debug("[whitelistMatcher] evaluated " + runtimeAttr + " in [" + (0, _Sets.setToArray)(ruleAttr).join(',') + "] => " + isInWhitelist);
+    return isInWhitelist;
+  };
+}
+
+var _default = whitelistMatcherContext;
+exports.default = _default;

package/lib/engine/parser/index.js

@@ -0,0 +1,84 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _matchers = _interopRequireDefault(require("../transforms/matchers"));
+
+var _treatments = _interopRequireDefault(require("../treatments"));
+
+var _matchers2 = _interopRequireDefault(require("../matchers"));
+
+var _value = _interopRequireDefault(require("../value"));
+
+var _condition = _interopRequireDefault(require("../condition"));
+
+var _ifelseif = _interopRequireDefault(require("../combiners/ifelseif"));
+
+var _and = _interopRequireDefault(require("../combiners/and"));
+
+var _thenable = _interopRequireDefault(require("../../utils/promise/thenable"));
+
+/**
+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 parse(conditions, storage) {
+  var predicates = [];
+
+  for (var i = 0; i < conditions.length; i++) {
+    var _conditions$i = conditions[i],
+        matchers = _conditions$i.matcherGroup.matchers,
+        partitions = _conditions$i.partitions,
+        label = _conditions$i.label,
+        conditionType = _conditions$i.conditionType; // transform data structure
+
+    matchers = (0, _matchers.default)(matchers); // create a set of pure functions from the matcher's dto
+
+    var expressions = matchers.map(function (matcherDto) {
+      var matcher = (0, _matchers2.default)(matcherDto, storage); // Evaluator function.
+
+      return function (key, attributes, splitEvaluator) {
+        var value = (0, _value.default)(key, matcherDto, attributes);
+        var result = value !== undefined ? matcher(value, splitEvaluator) : false;
+
+        if ((0, _thenable.default)(result)) {
+          return result.then(function (res) {
+            return Boolean(res ^ matcherDto.negate);
+          });
+        }
+
+        return Boolean(result ^ matcherDto.negate);
+      };
+    }); // if matcher's factory can't instanciate the matchers, the expressions array
+    // will be empty
+
+    if (expressions.length === 0) {
+      // reset any data collected during parsing
+      predicates = []; // and break the loop
+
+      break;
+    }
+
+    predicates.push((0, _condition.default)((0, _and.default)(expressions), _treatments.default.parse(partitions), label, conditionType));
+  } // Instanciate evaluator given the set of conditions using if else if logic
+
+
+  return (0, _ifelseif.default)(predicates);
+}
+
+var _default = parse;
+exports.default = _default;

package/lib/engine/parser/segments.js

@@ -0,0 +1,28 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _Sets = require("../../utils/lang/Sets");
+
+/**
+ * Collect segments from a raw split definition.
+ */
+var parseSegments = function parseSegments(conditions) {
+  var segments = new _Sets._Set();
+  conditions.forEach(function (condition) {
+    var matchers = condition.matcherGroup.matchers;
+    matchers.forEach(function (matcher) {
+      var matcherType = matcher.matcherType,
+          userDefinedSegmentMatcherData = matcher.userDefinedSegmentMatcherData;
+
+      if (matcherType === 'IN_SEGMENT') {
+        segments.add(userDefinedSegmentMatcherData.segmentName);
+      }
+    });
+  });
+  return segments;
+};
+
+var _default = parseSegments;
+exports.default = _default;

package/lib/engine/transforms/matcherGroup.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _types = require("../matchers/types");
+
+var _segment = _interopRequireDefault(require("./segment"));
+
+var _whitelist = _interopRequireDefault(require("./whitelist"));
+
+/**
+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.
+**/
+
+/**
+ * Flat the complex matcherGroup structure into something handy.
+ */
+function transform(matcherGroup) {
+  var _matcherGroup$matcher = matcherGroup.matchers[0],
+      matcherType = _matcherGroup$matcher.matcherType,
+      segmentObject = _matcherGroup$matcher.userDefinedSegmentMatcherData,
+      whitelistObject = _matcherGroup$matcher.whitelistMatcherData;
+  var type = (0, _types.matcherTypesMapper)(matcherType);
+  var value = undefined;
+
+  if (type === _types.matcherTypes.IN_SEGMENT) {
+    value = (0, _segment.default)(segmentObject);
+  } else if (type === _types.matcherTypes.WHITELIST) {
+    value = (0, _whitelist.default)(whitelistObject);
+  }
+
+  return {
+    type: type,
+    value: value
+  };
+}
+
+var _default = transform;
+exports.default = _default;

package/lib/engine/transforms/matchers.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _lang = require("../../utils/lang");
+
+var _types = require("../matchers/types");
+
+var _segment = _interopRequireDefault(require("./segment"));
+
+var _whitelist = _interopRequireDefault(require("./whitelist"));
+
+var _set = _interopRequireDefault(require("./set"));
+
+var _unaryNumeric = _interopRequireDefault(require("./unaryNumeric"));
+
+var _convertions = require("../convertions");
+
+/**
+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.
+**/
+// Flat the complex matcherGroup structure into something handy.
+function transform(matchers) {
+  var parsedMatchers = matchers.map(function (matcher) {
+    var matcherType = matcher.matcherType,
+        negate = matcher.negate,
+        keySelector = matcher.keySelector,
+        segmentObject = matcher.userDefinedSegmentMatcherData,
+        whitelistObject = matcher.whitelistMatcherData,
+        unaryNumericObject = matcher.unaryNumericMatcherData,
+        betweenObject = matcher.betweenMatcherData,
+        dependencyObject = matcher.dependencyMatcherData,
+        booleanMatcherData = matcher.booleanMatcherData,
+        stringMatcherData = matcher.stringMatcherData;
+    var attribute = keySelector && keySelector.attribute;
+    var type = (0, _types.matcherTypesMapper)(matcherType); // As default input data type we use string (even for ALL_KEYS)
+
+    var dataType = _types.matcherDataTypes.STRING;
+    var value = undefined;
+
+    if (type === _types.matcherTypes.IN_SEGMENT) {
+      value = (0, _segment.default)(segmentObject);
+    } else if (type === _types.matcherTypes.WHITELIST) {
+      value = (0, _whitelist.default)(whitelistObject);
+    } else if (type === _types.matcherTypes.EQUAL_TO) {
+      value = (0, _unaryNumeric.default)(unaryNumericObject);
+      dataType = _types.matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = (0, _convertions.zeroSinceHH)(value);
+        dataType = _types.matcherDataTypes.DATETIME;
+      }
+    } else if (type === _types.matcherTypes.GREATER_THAN_OR_EQUAL_TO || type === _types.matcherTypes.LESS_THAN_OR_EQUAL_TO) {
+      value = (0, _unaryNumeric.default)(unaryNumericObject);
+      dataType = _types.matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = (0, _convertions.zeroSinceSS)(value);
+        dataType = _types.matcherDataTypes.DATETIME;
+      }
+    } else if (type === _types.matcherTypes.BETWEEN) {
+      value = betweenObject;
+      dataType = _types.matcherDataTypes.NUMBER;
+
+      if (betweenObject.dataType === 'DATETIME') {
+        value.start = (0, _convertions.zeroSinceSS)(value.start);
+        value.end = (0, _convertions.zeroSinceSS)(value.end);
+        dataType = _types.matcherDataTypes.DATETIME;
+      }
+    } else if (type === _types.matcherTypes.EQUAL_TO_SET || type === _types.matcherTypes.CONTAINS_ANY_OF_SET || type === _types.matcherTypes.CONTAINS_ALL_OF_SET || type === _types.matcherTypes.PART_OF_SET) {
+      value = (0, _set.default)(whitelistObject);
+      dataType = _types.matcherDataTypes.SET;
+    } else if (type === _types.matcherTypes.STARTS_WITH || type === _types.matcherTypes.ENDS_WITH || type === _types.matcherTypes.CONTAINS_STRING) {
+      value = (0, _set.default)(whitelistObject);
+    } else if (type === _types.matcherTypes.IN_SPLIT_TREATMENT) {
+      value = dependencyObject;
+      dataType = _types.matcherDataTypes.NOT_SPECIFIED;
+    } else if (type === _types.matcherTypes.EQUAL_TO_BOOLEAN) {
+      dataType = _types.matcherDataTypes.BOOLEAN;
+      value = booleanMatcherData;
+    } else if (type === _types.matcherTypes.MATCHES_STRING) {
+      value = stringMatcherData;
+    }
+
+    return {
+      attribute: attribute,
+      // attribute over we should do the matching, undefined means 'use the key'
+      negate: negate,
+      // should we negate the result?
+      type: type,
+      // which kind of matcher we should evaluate
+      value: value,
+      // metadata used for the matching
+      dataType: dataType // runtime input data type
+
+    };
+  });
+
+  if ((0, _lang.findIndex)(parsedMatchers, function (m) {
+    return m.type === _types.matcherTypes.UNDEFINED;
+  }) === -1) {
+    return parsedMatchers;
+  } else {
+    return [];
+  }
+}
+
+var _default = transform;
+exports.default = _default;

package/lib/engine/transforms/segment.js

@@ -0,0 +1,34 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 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.
+**/
+
+/**
+ * Extract segment name as a plain string.
+ */
+function transform(segment) {
+  if (segment === void 0) {
+    segment = {};
+  }
+
+  return segment.segmentName;
+}
+
+var _default = transform;
+exports.default = _default;

package/lib/engine/transforms/set.js

@@ -0,0 +1,26 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 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.
+**/
+function transform(whitelistObject) {
+  return whitelistObject.whitelist;
+}
+
+var _default = transform;
+exports.default = _default;