@splitsoftware/splitio-commons 2.5.0-rc.0 → 11.5.0-rc.0

package/src/evaluator/index.ts

@@ -1,199 +0,0 @@
-import { engineParser } from './Engine';
-import { thenable } from '../utils/promise/thenable';
-import { EXCEPTION, SPLIT_NOT_FOUND } from '../utils/labels';
-import { CONTROL } from '../utils/constants';
-import { ISplit, MaybeThenable } from '../dtos/types';
-import { IStorageAsync, IStorageSync } from '../storages/types';
-import { IEvaluationResult } from './types';
-import SplitIO from '../../types/splitio';
-import { ILogger } from '../logger/types';
-import { returnSetsUnion, setToArray } from '../utils/lang/sets';
-import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
-
-const treatmentException = {
-  treatment: CONTROL,
-  label: EXCEPTION,
-  config: null
-};
-
-function treatmentsException(splitNames: string[]) {
-  const evaluations: Record<string, IEvaluationResult> = {};
-  splitNames.forEach(splitName => {
-    evaluations[splitName] = treatmentException;
-  });
-  return evaluations;
-}
-
-export function evaluateFeature(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  splitName: string,
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-): MaybeThenable<IEvaluationResult> {
-  let parsedSplit;
-
-  try {
-    parsedSplit = storage.splits.getSplit(splitName);
-  } catch (e) {
-    // Exception on sync `getSplit` storage. Not possible ATM with InMemory and InLocal storages.
-    return treatmentException;
-  }
-
-  if (thenable(parsedSplit)) {
-    return parsedSplit.then((split) => getEvaluation(
-      log,
-      key,
-      split,
-      attributes,
-      storage,
-    )).catch(
-      // Exception on async `getSplit` storage. For example, when the storage is redis or
-      // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-      () => treatmentException
-    );
-  }
-
-  return getEvaluation(
-    log,
-    key,
-    parsedSplit,
-    attributes,
-    storage,
-  );
-}
-
-export function evaluateFeatures(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  splitNames: string[],
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  let parsedSplits;
-
-  try {
-    parsedSplits = storage.splits.getSplits(splitNames);
-  } catch (e) {
-    // Exception on sync `getSplits` storage. Not possible ATM with InMemory and InLocal storages.
-    return treatmentsException(splitNames);
-  }
-
-  return thenable(parsedSplits) ?
-    parsedSplits.then(splits => getEvaluations(log, key, splitNames, splits, attributes, storage))
-      .catch(() => {
-        // Exception on async `getSplits` storage. For example, when the storage is redis or
-        // pluggable and there is a connection issue and we can't retrieve the split to be evaluated
-        return treatmentsException(splitNames);
-      }) :
-    getEvaluations(log, key, splitNames, parsedSplits, attributes, storage);
-}
-
-export function evaluateFeaturesByFlagSets(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  flagSets: string[],
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-  method: string,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  let storedFlagNames: MaybeThenable<Set<string>[]>;
-
-  function evaluate(featureFlagsByFlagSets: Set<string>[]) {
-    let featureFlags = new Set<string>();
-    for (let i = 0; i < flagSets.length; i++) {
-      const featureFlagByFlagSet = featureFlagsByFlagSets[i];
-      if (featureFlagByFlagSet.size) {
-        featureFlags = returnSetsUnion(featureFlags, featureFlagByFlagSet);
-      } else {
-        log.warn(WARN_FLAGSET_WITHOUT_FLAGS, [method, flagSets[i]]);
-      }
-    }
-
-    return featureFlags.size ?
-      evaluateFeatures(log, key, setToArray(featureFlags), attributes, storage) :
-      {};
-  }
-
-  // get features by flag sets
-  try {
-    storedFlagNames = storage.splits.getNamesByFlagSets(flagSets);
-  } catch (e) {
-    // return empty evaluations
-    return {};
-  }
-
-  // evaluate related features
-  return thenable(storedFlagNames) ?
-    storedFlagNames.then((storedFlagNames) => evaluate(storedFlagNames))
-      .catch(() => {
-        return {};
-      }) :
-    evaluate(storedFlagNames);
-}
-
-function getEvaluation(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  splitJSON: ISplit | null,
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-): MaybeThenable<IEvaluationResult> {
-  let evaluation: MaybeThenable<IEvaluationResult> = {
-    treatment: CONTROL,
-    label: SPLIT_NOT_FOUND,
-    config: null
-  };
-
-  if (splitJSON) {
-    const split = engineParser(log, splitJSON, storage);
-    evaluation = split.getTreatment(key, attributes, evaluateFeature);
-
-    // If the storage is async and the evaluated flag uses segments or dependencies, evaluation is thenable
-    if (thenable(evaluation)) {
-      return evaluation.then(result => {
-        result.changeNumber = splitJSON.changeNumber;
-        result.config = splitJSON.configurations && splitJSON.configurations[result.treatment] || null;
-        result.impressionsDisabled = splitJSON.impressionsDisabled;
-
-        return result;
-      });
-    } else {
-      evaluation.changeNumber = splitJSON.changeNumber;
-      evaluation.config = splitJSON.configurations && splitJSON.configurations[evaluation.treatment] || null;
-      evaluation.impressionsDisabled = splitJSON.impressionsDisabled;
-    }
-  }
-
-  return evaluation;
-}
-
-function getEvaluations(
-  log: ILogger,
-  key: SplitIO.SplitKey,
-  splitNames: string[],
-  splits: Record<string, ISplit | null>,
-  attributes: SplitIO.Attributes | undefined,
-  storage: IStorageSync | IStorageAsync,
-): MaybeThenable<Record<string, IEvaluationResult>> {
-  const result: Record<string, IEvaluationResult> = {};
-  const thenables: Promise<void>[] = [];
-  splitNames.forEach(splitName => {
-    const evaluation = getEvaluation(
-      log,
-      key,
-      splits[splitName],
-      attributes,
-      storage
-    );
-    if (thenable(evaluation)) {
-      thenables.push(evaluation.then(res => {
-        result[splitName] = res;
-      }));
-    } else {
-      result[splitName] = evaluation;
-    }
-  });
-
-  return thenables.length > 0 ? Promise.all(thenables).then(() => result) : result;
-}

package/src/evaluator/matchers/all.ts

@@ -1,6 +0,0 @@
-export function allMatcherContext() {
-
-  return function allMatcher(runtimeAttr: string): boolean {
-    return runtimeAttr != null;
-  };
-}

package/src/evaluator/matchers/between.ts

@@ -1,10 +0,0 @@
-import { IBetweenMatcherData } from '../../dtos/types';
-
-export function betweenMatcherContext(ruleVO: IBetweenMatcherData) {
-
-  return function betweenMatcher(runtimeAttr: number): boolean {
-    const isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
-
-    return isBetween;
-  };
-}

package/src/evaluator/matchers/boolean.ts

@@ -1,8 +0,0 @@
-export function booleanMatcherContext(ruleAttr: boolean) {
-
-  return function booleanMatcher(runtimeAttr: boolean): boolean {
-    const booleanMatches = ruleAttr === runtimeAttr;
-
-    return booleanMatches;
-  };
-}

package/src/evaluator/matchers/cont_all.ts

@@ -1,18 +0,0 @@
-import { findIndex } from '../../utils/lang';
-
-export function containsAllSetMatcherContext(ruleAttr: string[]) {
-  return function containsAllMatcher(runtimeAttr: string[]): boolean {
-    let containsAll = true;
-
-    if (runtimeAttr.length < ruleAttr.length) {
-      containsAll = false;
-    } else {
-      for (let i = 0; i < ruleAttr.length && containsAll; i++) {
-        if (findIndex(runtimeAttr, e => e === ruleAttr[i]) < 0)
-          containsAll = false;
-      }
-    }
-
-    return containsAll;
-  };
-}

package/src/evaluator/matchers/cont_any.ts

@@ -1,13 +0,0 @@
-import { findIndex } from '../../utils/lang';
-
-export function containsAnySetMatcherContext(ruleAttr: string[]) {
-  return function containsAnyMatcher(runtimeAttr: string[]): boolean {
-    let containsAny = false;
-
-    for (let i = 0; i < ruleAttr.length && !containsAny; i++) {
-      if (findIndex(runtimeAttr, e => e === ruleAttr[i]) >= 0) containsAny = true;
-    }
-
-    return containsAny;
-  };
-}

package/src/evaluator/matchers/cont_str.ts

@@ -1,9 +0,0 @@
-import { isString } from '../../utils/lang';
-
-export function containsStringMatcherContext(ruleAttr: string[]) {
-  return function containsStringMatcher(runtimeAttr: string): boolean {
-    const contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
-
-    return contains;
-  };
-}

package/src/evaluator/matchers/dependency.ts

@@ -1,32 +0,0 @@
-import { IDependencyMatcherData, MaybeThenable } from '../../dtos/types';
-import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
-import { thenable } from '../../utils/promise/thenable';
-import { IDependencyMatcherValue, IEvaluation, ISplitEvaluator } from '../types';
-import { ENGINE_MATCHER_DEPENDENCY, ENGINE_MATCHER_DEPENDENCY_PRE } from '../../logger/constants';
-
-export function dependencyMatcherContext({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger) {
-
-  function checkTreatment(evaluation: IEvaluation, acceptableTreatments: string[], parentName: string) {
-    let matches = false;
-
-    if (Array.isArray(acceptableTreatments)) {
-      matches = acceptableTreatments.indexOf(evaluation.treatment as string) !== -1;
-    }
-
-    log.debug(ENGINE_MATCHER_DEPENDENCY, [parentName, evaluation.treatment, evaluation.label, parentName, acceptableTreatments, matches]);
-
-    return matches;
-  }
-
-  return function dependencyMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
-    log.debug(ENGINE_MATCHER_DEPENDENCY_PRE, [split, JSON.stringify(key), attributes ? '\n attributes: ' + JSON.stringify(attributes) : '']);
-    const evaluation = splitEvaluator(log, key, split, attributes, storage);
-
-    if (thenable(evaluation)) {
-      return evaluation.then(ev => checkTreatment(ev, treatments, split));
-    } else {
-      return checkTreatment(evaluation, treatments, split);
-    }
-  };
-}

package/src/evaluator/matchers/eq.ts

@@ -1,8 +0,0 @@
-export function equalToMatcherContext(ruleAttr: number) {
-
-  return function equalToMatcher(runtimeAttr: number): boolean {
-    const isEqual = runtimeAttr === ruleAttr;
-
-    return isEqual;
-  };
-}

package/src/evaluator/matchers/eq_set.ts

@@ -1,15 +0,0 @@
-import { findIndex } from '../../utils/lang';
-
-export function equalToSetMatcherContext(ruleAttr: string[]) {
-  return function equalToSetMatcher(runtimeAttr: string[]): boolean {
-    // Length being the same is the first condition.
-    let isEqual = runtimeAttr.length === ruleAttr.length;
-
-    for (let i = 0; i < runtimeAttr.length && isEqual; i++) {
-      // if length is the same we check that all elements are present in the other collection.
-      if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isEqual = false;
-    }
-
-    return isEqual;
-  };
-}

package/src/evaluator/matchers/ew.ts

@@ -1,9 +0,0 @@
-import { endsWith } from '../../utils/lang';
-
-export function endsWithMatcherContext(ruleAttr: string[]) {
-  return function endsWithMatcher(runtimeAttr: string): boolean {
-    const strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
-
-    return strEndsWith;
-  };
-}

package/src/evaluator/matchers/gte.ts

@@ -1,8 +0,0 @@
-export function greaterThanEqualMatcherContext(ruleAttr: number) {
-
-  return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    const isGreaterThanEqual = runtimeAttr >= ruleAttr;
-
-    return isGreaterThanEqual;
-  };
-}

package/src/evaluator/matchers/index.ts

@@ -1,70 +0,0 @@
-import { allMatcherContext } from './all';
-import { segmentMatcherContext } from './segment';
-import { largeSegmentMatcherContext } from './large_segment';
-import { whitelistMatcherContext } from './whitelist';
-import { equalToMatcherContext } from './eq';
-import { greaterThanEqualMatcherContext } from './gte';
-import { lessThanEqualMatcherContext } from './lte';
-import { betweenMatcherContext } from './between';
-import { equalToSetMatcherContext } from './eq_set';
-import { containsAnySetMatcherContext } from './cont_any';
-import { containsAllSetMatcherContext } from './cont_all';
-import { partOfSetMatcherContext } from './part_of';
-import { endsWithMatcherContext } from './ew';
-import { startsWithMatcherContext } from './sw';
-import { containsStringMatcherContext } from './cont_str';
-import { dependencyMatcherContext } from './dependency';
-import { booleanMatcherContext } from './boolean';
-import { stringMatcherContext } from './string';
-import { equalToSemverMatcherContext } from './semver_eq';
-import { greaterThanEqualToSemverMatcherContext } from './semver_gte';
-import { lessThanEqualToSemverMatcherContext } from './semver_lte';
-import { betweenSemverMatcherContext } from './semver_between';
-import { inListSemverMatcherContext } from './semver_inlist';
-import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { IMatcher, IMatcherDto } from '../types';
-import { ILogger } from '../../logger/types';
-import { ruleBasedSegmentMatcherContext } from './rbsegment';
-
-const matchers = [
-  undefined, // UNDEFINED: 0
-  allMatcherContext, // ALL_KEYS: 1
-  segmentMatcherContext, // IN_SEGMENT: 2
-  whitelistMatcherContext, // WHITELIST: 3
-  equalToMatcherContext, // EQUAL_TO: 4
-  greaterThanEqualMatcherContext, // GREATER_THAN_OR_EQUAL_TO: 5
-  lessThanEqualMatcherContext, // LESS_THAN_OR_EQUAL_TO: 6
-  betweenMatcherContext, // BETWEEN: 7
-  equalToSetMatcherContext, // EQUAL_TO_SET: 8
-  containsAnySetMatcherContext, // CONTAINS_ANY_OF_SET: 9
-  containsAllSetMatcherContext, // CONTAINS_ALL_OF_SET: 10
-  partOfSetMatcherContext, // PART_OF_SET: 11
-  endsWithMatcherContext, // ENDS_WITH: 12
-  startsWithMatcherContext, // STARTS_WITH: 13
-  containsStringMatcherContext, // CONTAINS_STRING: 14
-  dependencyMatcherContext, // IN_SPLIT_TREATMENT: 15
-  booleanMatcherContext, // EQUAL_TO_BOOLEAN: 16
-  stringMatcherContext, // MATCHES_STRING: 17
-  equalToSemverMatcherContext, // EQUAL_TO_SEMVER: 18
-  greaterThanEqualToSemverMatcherContext, // GREATER_THAN_OR_EQUAL_TO_SEMVER: 19
-  lessThanEqualToSemverMatcherContext, // LESS_THAN_OR_EQUAL_TO_SEMVER: 20
-  betweenSemverMatcherContext, // BETWEEN_SEMVER: 21
-  inListSemverMatcherContext, // IN_LIST_SEMVER: 22
-  largeSegmentMatcherContext, // IN_LARGE_SEGMENT: 23
-  ruleBasedSegmentMatcherContext // IN_RULE_BASED_SEGMENT: 24
-];
-
-/**
- * Matcher factory.
- */
-export function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?: IStorageSync | IStorageAsync): IMatcher | undefined {
-  let {
-    type,
-    value
-  } = matcherDto;
-
-  let matcherFn;
-  // @ts-ignore
-  if (matchers[type]) matcherFn = matchers[type](value, storage, log); // There is no index-out-of-bound exception in JavaScript
-  return matcherFn as IMatcher;
-}

package/src/evaluator/matchers/large_segment.ts

@@ -1,11 +0,0 @@
-import { MaybeThenable } from '../../dtos/types';
-import { ISegmentsCacheBase } from '../../storages/types';
-
-export function largeSegmentMatcherContext(largeSegmentName: string, storage: { largeSegments?: ISegmentsCacheBase }) {
-
-  return function largeSegmentMatcher(key: string): MaybeThenable<boolean> {
-    const isInLargeSegment = storage.largeSegments ? storage.largeSegments.isInSegment(largeSegmentName, key) : false;
-
-    return isInLargeSegment;
-  };
-}

package/src/evaluator/matchers/lte.ts

@@ -1,8 +0,0 @@
-export function lessThanEqualMatcherContext(ruleAttr: number) {
-
-  return function lessThanEqualMatcher(runtimeAttr: number): boolean {
-    const isLessThanEqual = runtimeAttr <= ruleAttr;
-
-    return isLessThanEqual;
-  };
-}

package/src/evaluator/matchers/matcherTypes.ts

@@ -1,42 +0,0 @@
-export const matcherTypes: Record<string, number> = {
-  UNDEFINED: 0, // Value for unsupported or invalid matchers
-  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,
-  EQUAL_TO_SEMVER: 18,
-  GREATER_THAN_OR_EQUAL_TO_SEMVER: 19,
-  LESS_THAN_OR_EQUAL_TO_SEMVER: 20,
-  BETWEEN_SEMVER: 21,
-  IN_LIST_SEMVER: 22,
-  IN_LARGE_SEGMENT: 23,
-  IN_RULE_BASED_SEGMENT: 24,
-};
-
-export const matcherDataTypes = {
-  BOOLEAN: 'BOOLEAN',
-  STRING: 'STRING',
-  NUMBER: 'NUMBER',
-  SET: 'SET',
-  DATETIME: 'DATETIME',
-  NOT_SPECIFIED: 'NOT_SPECIFIED'
-};
-
-export function matcherTypesMapper(matcherType: string) {
-  const type = matcherTypes[matcherType];
-  if (type) return type;
-  else return matcherTypes.UNDEFINED;
-}

package/src/evaluator/matchers/part_of.ts

@@ -1,15 +0,0 @@
-import { findIndex } from '../../utils/lang';
-
-export function partOfSetMatcherContext(ruleAttr: string[]) {
-  return function partOfMatcher(runtimeAttr: string[]): 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;
-    }
-
-    return isPartOf;
-  };
-}

package/src/evaluator/matchers/prerequisites.ts

@@ -1,24 +0,0 @@
-import { ISplit, MaybeThenable } from '../../dtos/types';
-import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
-import { thenable } from '../../utils/promise/thenable';
-import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
-
-export function prerequisitesMatcherContext(prerequisites: ISplit['prerequisites'] = [], storage: IStorageSync | IStorageAsync, log: ILogger) {
-
-  return function prerequisitesMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
-
-    function evaluatePrerequisite(prerequisite: { n: string; ts: string[] }): MaybeThenable<boolean> {
-      const evaluation = splitEvaluator(log, key, prerequisite.n, attributes, storage);
-      return thenable(evaluation) ?
-        evaluation.then(evaluation => prerequisite.ts.indexOf(evaluation.treatment!) !== -1) :
-        prerequisite.ts.indexOf(evaluation.treatment!) !== -1;
-    }
-
-    return prerequisites.reduce<MaybeThenable<boolean>>((prerequisitesMet, prerequisite) => {
-      return thenable(prerequisitesMet) ?
-        prerequisitesMet.then(prerequisitesMet => prerequisitesMet ? evaluatePrerequisite(prerequisite) : false) :
-        prerequisitesMet ? evaluatePrerequisite(prerequisite) : false;
-    }, true);
-  };
-}

package/src/evaluator/matchers/rbsegment.ts

@@ -1,74 +0,0 @@
-import { IExcludedSegment, IRBSegment, MaybeThenable } from '../../dtos/types';
-import { IStorageAsync, IStorageSync } from '../../storages/types';
-import { ILogger } from '../../logger/types';
-import { IDependencyMatcherValue, ISplitEvaluator } from '../types';
-import { thenable } from '../../utils/promise/thenable';
-import { getMatching, keyParser } from '../../utils/key';
-import { parser } from '../parser';
-import { STANDARD_SEGMENT, RULE_BASED_SEGMENT, LARGE_SEGMENT } from '../../utils/constants';
-
-
-export function ruleBasedSegmentMatcherContext(segmentName: string, storage: IStorageSync | IStorageAsync, log: ILogger) {
-
-  return function ruleBasedSegmentMatcher({ key, attributes }: IDependencyMatcherValue, splitEvaluator: ISplitEvaluator): MaybeThenable<boolean> {
-    const matchingKey = getMatching(key);
-
-    function matchConditions(rbsegment: IRBSegment) {
-      const conditions = rbsegment.conditions || [];
-
-      if (!conditions.length) return false;
-
-      const evaluator = parser(log, conditions, storage);
-
-      const evaluation = evaluator(
-        keyParser(key),
-        undefined,
-        undefined,
-        undefined,
-        attributes,
-        splitEvaluator
-      );
-
-      return thenable(evaluation) ?
-        evaluation.then(evaluation => evaluation ? true : false) :
-        evaluation ? true : false;
-    }
-
-    function isInExcludedSegment({ type, name }: IExcludedSegment) {
-      return type === STANDARD_SEGMENT ?
-        storage.segments.isInSegment(name, matchingKey) :
-        type === RULE_BASED_SEGMENT ?
-          ruleBasedSegmentMatcherContext(name, storage, log)({ key, attributes }, splitEvaluator) :
-          type === LARGE_SEGMENT && storage.largeSegments ?
-            storage.largeSegments.isInSegment(name, matchingKey) :
-            false;
-    }
-
-    function isExcluded(rbSegment: IRBSegment) {
-      const excluded = rbSegment.excluded || {};
-
-      if (excluded.keys && excluded.keys.indexOf(matchingKey) !== -1) return true;
-
-      return (excluded.segments || []).reduce<MaybeThenable<boolean>>((result, excludedSegment) => {
-        return thenable(result) ?
-          result.then(result => result || isInExcludedSegment(excludedSegment)) :
-          result || isInExcludedSegment(excludedSegment);
-      }, false);
-    }
-
-    function isInRBSegment(rbSegment: IRBSegment | null) {
-      if (!rbSegment) return false;
-      const excluded = isExcluded(rbSegment);
-
-      return thenable(excluded) ?
-        excluded.then(excluded => excluded ? false : matchConditions(rbSegment)) :
-        excluded ? false : matchConditions(rbSegment);
-    }
-
-    const rbSegment = storage.rbSegments.get(segmentName);
-
-    return thenable(rbSegment) ?
-      rbSegment.then(isInRBSegment) :
-      isInRBSegment(rbSegment);
-  };
-}

package/src/evaluator/matchers/segment.ts

@@ -1,11 +0,0 @@
-import { MaybeThenable } from '../../dtos/types';
-import { ISegmentsCacheBase } from '../../storages/types';
-
-export function segmentMatcherContext(segmentName: string, storage: { segments: ISegmentsCacheBase }) {
-
-  return function segmentMatcher(key: string): MaybeThenable<boolean> {
-    const isInSegment = storage.segments.isInSegment(segmentName, key);
-
-    return isInSegment;
-  };
-}

package/src/evaluator/matchers/semver_between.ts

@@ -1,15 +0,0 @@
-import { IBetweenStringMatcherData } from '../../dtos/types';
-import { Semver } from '../../utils/Semver';
-
-export function betweenSemverMatcherContext(ruleAttr: IBetweenStringMatcherData) {
-  const startSemver = new Semver(ruleAttr.start);
-  const endSemver = new Semver(ruleAttr.end);
-
-  return function betweenSemverMatcher(runtimeAttr: string): boolean {
-    const runtimeSemver = new Semver(runtimeAttr);
-
-    const isBetween = startSemver.compare(runtimeSemver) <= 0 && endSemver.compare(runtimeSemver) >= 0;
-
-    return isBetween;
-  };
-}

package/src/evaluator/matchers/semver_eq.ts

@@ -1,13 +0,0 @@
-import { Semver } from '../../utils/Semver';
-
-export function equalToSemverMatcherContext(ruleAttr: string) {
-  const ruleSemver = new Semver(ruleAttr);
-
-  return function equalToSemverMatcher(runtimeAttr: string): boolean {
-    const runtimeSemver = new Semver(runtimeAttr);
-
-    const isEqual = ruleSemver.version === runtimeSemver.version;
-
-    return isEqual;
-  };
-}

package/src/evaluator/matchers/semver_gte.ts

@@ -1,13 +0,0 @@
-import { Semver } from '../../utils/Semver';
-
-export function greaterThanEqualToSemverMatcherContext(ruleAttr: string) {
-  const ruleSemver = new Semver(ruleAttr);
-
-  return function greaterThanEqualToSemverMatcher(runtimeAttr: string): boolean {
-    const runtimeSemver = new Semver(runtimeAttr);
-
-    const isGreaterThanEqual = runtimeSemver.compare(ruleSemver) >= 0;
-
-    return isGreaterThanEqual;
-  };
-}