@splitsoftware/splitio 10.17.2 → 10.17.3-rc.3

package/src/engine/matchers/index.js

@@ -1,71 +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 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

@@ -1,30 +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 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

@@ -1,37 +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 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

@@ -1,41 +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 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

@@ -1,39 +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 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

@@ -1,31 +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 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

@@ -1,52 +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.
-**/
-
-// @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

@@ -1,30 +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 { 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

@@ -1,79 +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 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

@@ -1,31 +0,0 @@
-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

@@ -1,45 +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 { 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

@@ -1,118 +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 { 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

@@ -1,23 +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.
-**/
-/**
- * Extract segment name as a plain string.
- */
-function transform(segment = {}) {
-  return segment.segmentName;
-}
-
-export default transform;

package/src/engine/transforms/set.js

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

package/src/engine/transforms/unaryNumeric.js

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