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

package/src/engine/matchers/index.js

@@ -0,0 +1,71 @@
+/**
+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 allMatcher from './all';
+import segmentMatcher from './segment';
+import whitelistMatcher from './whitelist';
+import eqMatcher from './eq';
+import gteMatcher from './gte';
+import lteMatcher from './lte';
+import betweenMatcher from './between';
+import equalToSetMatcher from './eq_set';
+import containsAllSetMatcher from './cont_all';
+import containsAnySetMatcher from './cont_any';
+import partOfSetMatcher from './part_of';
+import swMatcher from './sw';
+import ewMatcher from './ew';
+import containsStrMatcher from './cont_str';
+import dependencyMatcher from './dependency';
+import booleanMatcher from './boolean';
+import stringMatcher from './string';
+
+const matchers = [
+  undefined, // UNDEFINED: 0,
+  allMatcher, // ALL_KEYS: 1,
+  segmentMatcher, // IN_SEGMENT: 2,
+  whitelistMatcher, // WHITELIST: 3,
+  eqMatcher, // EQUAL_TO: 4,
+  gteMatcher, // GREATER_THAN_OR_EQUAL_TO: 5,
+  lteMatcher, // LESS_THAN_OR_EQUAL_TO: 6,
+  betweenMatcher, // BETWEEN: 7,
+  equalToSetMatcher, // EQUAL_TO_SET: 8,
+  containsAnySetMatcher, // CONTAINS_ANY_OF_SET: 9,
+  containsAllSetMatcher, // CONTAINS_ALL_OF_SET: 10,
+  partOfSetMatcher, // PART_OF_SET: 11,
+  ewMatcher, // ENDS_WITH: 12,
+  swMatcher, // STARTS_WITH: 13,
+  containsStrMatcher, // CONTAINS_STRING: 14,
+  dependencyMatcher, // IN_SPLIT_TREATMENT: 15,
+  booleanMatcher, // EQUAL_TO_BOOLEAN: 16,
+  stringMatcher // MATCHES_STRING: 17
+];
+
+/**
+ * Matcher factory.
+ */
+function MatcherFactory(matcherDto, storage) {
+  let {
+    type,
+    value
+  } = matcherDto;
+
+  let matcherFn;
+
+  if (matchers[type]) matcherFn = matchers[type](value, storage); // There is no index-out-of-bound exception in JavaScript
+
+  return matcherFn;
+}
+
+export default MatcherFactory;

package/src/engine/matchers/lte.js

@@ -0,0 +1,30 @@
+/**
+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';
+const log = logFactory('splitio-engine:matcher');
+
+function lessThanEqualMatcherContext(ruleAttr /*: number */) /*: function */ {
+  return function lessThanEqualMatcher(runtimeAttr /*: number */) /*: boolean */ {
+    let isLessEqualThan = runtimeAttr <= ruleAttr;
+
+    log.debug(`[lessThanEqualMatcher] is ${runtimeAttr} less than ${ruleAttr}? ${isLessEqualThan}`);
+
+    return isLessEqualThan;
+  };
+}
+
+export default lessThanEqualMatcherContext;

package/src/engine/matchers/part_of.js

@@ -0,0 +1,37 @@
+/**
+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';
+import { findIndex } from '../../utils/lang';
+const log = logFactory('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.
+    let isPartOf = runtimeAttr.length <= ruleAttr.length;
+
+    for(let i = 0; i < runtimeAttr.length && isPartOf; i++) {
+      // If the length says is possible, we iterate until we prove otherwise or we check all elements.
+      if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isPartOf = false;
+    }
+
+    log.debug(`[partOfMatcher] ${runtimeAttr} is part of ${ruleAttr}? ${isPartOf}`);
+
+    return isPartOf;
+  };
+}
+
+export default partOfMatcherContext;

package/src/engine/matchers/segment.js

@@ -0,0 +1,41 @@
+/**
+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';
+const log = logFactory('splitio-engine:matcher');
+import thenable from '../../utils/promise/thenable';
+
+function matcherSegmentContext(segmentName, storage) {
+
+  function segmentMatcher(key) {
+    const isInSegment = storage.segments.isInSegment(segmentName, key);
+
+    if (thenable(isInSegment)) {
+      isInSegment.then(result => {
+        log.debug(`[asyncSegmentMatcher] evaluated ${segmentName} / ${key} => ${isInSegment}`);
+
+        return result;
+      });
+    } else {
+      log.debug(`[segmentMatcher] evaluated ${segmentName} / ${key} => ${isInSegment}`);
+    }
+
+    return isInSegment;
+  }
+
+  return segmentMatcher;
+}
+
+export default matcherSegmentContext;

package/src/engine/matchers/string.js

@@ -0,0 +1,39 @@
+/**
+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';
+const log = logFactory('splitio-engine:matcher');
+
+function stringMatcherContext(ruleAttr /*: regex */) /*: Function */ {
+  return function stringMatcher(runtimeAttr /*: string */) /*: bool */ {
+    let re;
+
+    try {
+      re = new RegExp(ruleAttr);
+    } catch(e) {
+      log.debug(`[stringMatcher] ${ruleAttr} is an invalid regex`);
+
+      return false;
+    }
+
+    let regexMatches = re.test(runtimeAttr);
+
+    log.debug(`[stringMatcher] does ${runtimeAttr} matches with ${ruleAttr}? ${regexMatches ? 'yes' : 'no'}`);
+
+    return regexMatches;
+  };
+}
+
+export default stringMatcherContext;

package/src/engine/matchers/sw.js

@@ -0,0 +1,31 @@
+/**
+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';
+const log = logFactory('splitio-engine:matcher');
+import { startsWith } from '../../utils/lang';
+
+function startsWithMatcherContext(ruleAttr /*: array */) /*: Function */ {
+  return function startsWithMatcher(runtimeAttr /*: string */) /*: boolean */ {
+    let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
+
+    log.debug(`[startsWithMatcher] ${runtimeAttr} starts with ${ruleAttr}? ${matches}`);
+
+    return matches;
+  };
+}
+
+export default startsWithMatcherContext;

package/src/engine/matchers/types.js

@@ -0,0 +1,52 @@
+/**
+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
+export const 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
+};
+
+export const matcherDataTypes = {
+  BOOLEAN: 'BOOLEAN',
+  STRING: 'STRING',
+  NUMBER: 'NUMBER',
+  SET: 'SET',
+  DATETIME: 'DATETIME',
+  NOT_SPECIFIED: 'NOT_SPECIFIED'
+};
+
+export function matcherTypesMapper(matcherType) {
+  const type = matcherTypes[matcherType];
+  if (type) return type;
+  else return matcherTypes.UNDEFINED;
+}

package/src/engine/matchers/whitelist.js

@@ -0,0 +1,30 @@
+/**
+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 { setToArray } from '../../utils/lang/Sets';
+import logFactory from '../../utils/logger';
+const log = logFactory('splitio-engine:matcher');
+
+function whitelistMatcherContext(ruleAttr /*: Set */) /*: Function */ {
+  return function whitelistMatcher(runtimeAttr /*: string */) /*: boolean */ {
+    let isInWhitelist = ruleAttr.has(runtimeAttr);
+
+    log.debug(`[whitelistMatcher] evaluated ${runtimeAttr} in [${setToArray(ruleAttr).join(',')}] => ${isInWhitelist}`);
+
+    return isInWhitelist;
+  };
+}
+
+export default whitelistMatcherContext;

package/src/engine/parser/index.js

@@ -0,0 +1,79 @@
+/**
+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 matchersTransform from '../transforms/matchers';
+import treatmentsParser from '../treatments';
+import matcherFactory from '../matchers';
+import sanitizeValue from '../value';
+import conditionFactory from '../condition';
+import ifElseIfCombiner from '../combiners/ifelseif';
+import andCombiner from '../combiners/and';
+import thenable from '../../utils/promise/thenable';
+
+function parse(conditions, storage) {
+  let predicates = [];
+
+  for (let i = 0; i < conditions.length; i++) {
+    let {
+      matcherGroup: {
+        matchers
+      },
+      partitions,
+      label,
+      conditionType
+    } = conditions[i];
+
+    // transform data structure
+    matchers = matchersTransform(matchers);
+
+    // create a set of pure functions from the matcher's dto
+    const expressions = matchers.map(matcherDto => {
+      const matcher = matcherFactory(matcherDto, storage);
+
+      // Evaluator function.
+      return (key, attributes, splitEvaluator) => {
+        const value = sanitizeValue(key, matcherDto, attributes);
+        const result = value !== undefined ? matcher(value, splitEvaluator) : false;
+
+        if (thenable(result)) {
+          return result.then(res => 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(conditionFactory(
+      andCombiner(expressions),
+      treatmentsParser.parse(partitions),
+      label,
+      conditionType
+    ));
+  }
+
+  // Instanciate evaluator given the set of conditions using if else if logic
+  return ifElseIfCombiner(predicates);
+}
+
+export default parse;

package/src/engine/parser/segments.js

@@ -0,0 +1,31 @@
+import { _Set } from '../../utils/lang/Sets';
+
+/**
+ * Collect segments from a raw split definition.
+ */
+const parseSegments = (conditions) => {
+  let segments = new _Set();
+
+  conditions.forEach(condition => {
+    let {
+      matcherGroup: {
+        matchers
+      }
+    } = condition;
+
+    matchers.forEach(matcher => {
+      const {
+        matcherType,
+        userDefinedSegmentMatcherData
+      } = matcher;
+
+      if (matcherType === 'IN_SEGMENT') {
+        segments.add(userDefinedSegmentMatcherData.segmentName);
+      }
+    });
+  });
+
+  return segments;
+};
+
+export default parseSegments;

package/src/engine/transforms/matcherGroup.js

@@ -0,0 +1,45 @@
+/**
+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 { matcherTypes, matcherTypesMapper } from '../matchers/types';
+import segmentTransform from './segment';
+import whitelistTransform from './whitelist';
+
+/**
+ * Flat the complex matcherGroup structure into something handy.
+ */
+function transform(matcherGroup) {
+  let {
+    matcherType,
+    userDefinedSegmentMatcherData: segmentObject,
+    whitelistMatcherData: whitelistObject
+  } = matcherGroup.matchers[0];
+
+  let type = matcherTypesMapper(matcherType);
+  let value = undefined;
+
+  if (type === matcherTypes.IN_SEGMENT) {
+    value = segmentTransform(segmentObject);
+  } else if (type === matcherTypes.WHITELIST) {
+    value = whitelistTransform(whitelistObject);
+  }
+
+  return {
+    type,
+    value
+  };
+}
+
+export default transform;

package/src/engine/transforms/matchers.js

@@ -0,0 +1,118 @@
+/**
+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 { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/types';
+import segmentTransform from './segment';
+import whitelistTransform from './whitelist';
+import setTransform from './set';
+import numericTransform from './unaryNumeric';
+import { zeroSinceHH, zeroSinceSS } from '../convertions';
+
+// Flat the complex matcherGroup structure into something handy.
+function transform(matchers) {
+
+  let parsedMatchers = matchers.map(matcher => {
+    let {
+      matcherType                                   /* string */,
+      negate                                        /* boolean */,
+      keySelector                                   /* keySelectorObject */,
+      userDefinedSegmentMatcherData: segmentObject  /* segmentObject */,
+      whitelistMatcherData: whitelistObject         /* whiteListObject */,
+      unaryNumericMatcherData: unaryNumericObject   /* unaryNumericObject */,
+      betweenMatcherData: betweenObject             /* betweenObject */,
+      dependencyMatcherData: dependencyObject       /* dependencyObject */,
+      booleanMatcherData,
+      stringMatcherData
+    } = matcher;
+
+    let attribute = keySelector && keySelector.attribute;
+    let type = matcherTypesMapper(matcherType);
+    // As default input data type we use string (even for ALL_KEYS)
+    let dataType = matcherDataTypes.STRING;
+    let value = undefined;
+
+    if (type === matcherTypes.IN_SEGMENT) {
+      value = segmentTransform(segmentObject);
+    } else if (type === matcherTypes.WHITELIST) {
+      value = whitelistTransform(whitelistObject);
+    } else if (type === matcherTypes.EQUAL_TO) {
+      value = numericTransform(unaryNumericObject);
+      dataType = matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = zeroSinceHH(value);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (type === matcherTypes.GREATER_THAN_OR_EQUAL_TO ||
+               type === matcherTypes.LESS_THAN_OR_EQUAL_TO) {
+      value = numericTransform(unaryNumericObject);
+      dataType = matcherDataTypes.NUMBER;
+
+      if (unaryNumericObject.dataType === 'DATETIME') {
+        value = zeroSinceSS(value);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (type === matcherTypes.BETWEEN) {
+      value = betweenObject;
+      dataType = matcherDataTypes.NUMBER;
+
+      if (betweenObject.dataType === 'DATETIME') {
+        value.start = zeroSinceSS(value.start);
+        value.end = zeroSinceSS(value.end);
+        dataType = matcherDataTypes.DATETIME;
+      }
+    } else if (
+      type === matcherTypes.EQUAL_TO_SET ||
+      type === matcherTypes.CONTAINS_ANY_OF_SET ||
+      type === matcherTypes.CONTAINS_ALL_OF_SET ||
+      type === matcherTypes.PART_OF_SET
+    ) {
+      value = setTransform(whitelistObject);
+      dataType = matcherDataTypes.SET;
+    } else if (
+      type === matcherTypes.STARTS_WITH ||
+      type === matcherTypes.ENDS_WITH ||
+      type === matcherTypes.CONTAINS_STRING
+    ) {
+      value = setTransform(whitelistObject);
+    } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
+      value = dependencyObject;
+      dataType = matcherDataTypes.NOT_SPECIFIED;
+    } else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
+      dataType = matcherDataTypes.BOOLEAN;
+      value = booleanMatcherData;
+    } else if (type === matcherTypes.MATCHES_STRING) {
+      value = stringMatcherData;
+    }
+
+    return {
+      attribute,        // attribute over we should do the matching, undefined means 'use the key'
+      negate,           // should we negate the result?
+      type,             // which kind of matcher we should evaluate
+      value,            // metadata used for the matching
+      dataType          // runtime input data type
+    };
+  });
+
+  if (findIndex(parsedMatchers, m => m.type === matcherTypes.UNDEFINED) === -1) {
+    return parsedMatchers;
+  } else {
+    return [];
+  }
+}
+
+export default transform;

package/src/engine/transforms/segment.js

@@ -0,0 +1,23 @@
+/**
+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 = {}) {
+  return segment.segmentName;
+}
+
+export default transform;

package/src/engine/transforms/set.js

@@ -0,0 +1,20 @@
+/**
+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;
+}
+
+export default transform;

package/src/engine/transforms/unaryNumeric.js

@@ -0,0 +1,20 @@
+/**
+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(unaryNumericObject) {
+  return unaryNumericObject.value;
+}
+
+export default transform;