@splitsoftware/splitio-commons 1.13.2-rc.4 → 1.13.2-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.13.2-rc.4",
+  "version": "1.13.2-rc.6",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",

package/src/evaluator/Engine.ts

@@ -2,7 +2,7 @@ import { get } from '../utils/lang';
 import { parser } from './parser';
 import { keyParser } from '../utils/key';
 import { thenable } from '../utils/promise/thenable';
-import * as LabelsConstants from '../utils/labels';
+import { EXCEPTION, NO_CONDITION_MATCH, SPLIT_ARCHIVED, SPLIT_KILLED } from '../utils/labels';
 import { CONTROL } from '../utils/constants';
 import { ISplit, MaybeThenable } from '../dtos/types';
 import { SplitIO } from '../types';
@@ -13,7 +13,7 @@ import { ILogger } from '../logger/types';
 function evaluationResult(result: IEvaluation | undefined, defaultTreatment: string): IEvaluationResult {
   return {
     treatment: get(result, 'treatment', defaultTreatment),
-    label: get(result, 'label', LabelsConstants.NO_CONDITION_MATCH)
+    label: get(result, 'label', NO_CONDITION_MATCH)
   };
 }
 
@@ -55,16 +55,16 @@ export class Engine {
     } catch (err) {
       return {
         treatment: CONTROL,
-        label: LabelsConstants.EXCEPTION
+        label: EXCEPTION
       };
     }
 
     if (this.isGarbage()) {
       treatment = CONTROL;
-      label = LabelsConstants.SPLIT_ARCHIVED;
+      label = SPLIT_ARCHIVED;
     } else if (killed) {
       treatment = defaultTreatment;
-      label = LabelsConstants.SPLIT_KILLED;
+      label = SPLIT_KILLED;
     } else {
       const evaluation = this.evaluator(
         parsedKey,
@@ -98,4 +98,3 @@ export class Engine {
     return this.baseInfo.changeNumber;
   }
 }
-

package/src/evaluator/combiners/ifelseif.ts

@@ -1,7 +1,7 @@
 import { findIndex } from '../../utils/lang';
 import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import * as LabelsConstants from '../../utils/labels';
+import { UNSUPPORTED_MATCHER_TYPE } from '../../utils/labels';
 import { CONTROL } from '../../utils/constants';
 import { SplitIO } from '../../types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
@@ -14,7 +14,7 @@ export function ifElseIfCombinerContext(log: ILogger, predicates: IEvaluator[]):
 
     return {
       treatment: CONTROL,
-      label: LabelsConstants.UNSUPPORTED_MATCHER_TYPE
+      label: UNSUPPORTED_MATCHER_TYPE
     };
   }
 

package/src/evaluator/condition/index.ts

@@ -1,6 +1,6 @@
 import { getTreatment, shouldApplyRollout } from './engineUtils';
 import { thenable } from '../../utils/promise/thenable';
-import * as LabelsConstants from '../../utils/labels';
+import { NOT_IN_SPLIT } from '../../utils/labels';
 import { MaybeThenable } from '../../dtos/types';
 import { IEvaluation, IEvaluator, ISplitEvaluator } from '../types';
 import { SplitIO } from '../../types';
@@ -30,7 +30,7 @@ export function conditionContext(log: ILogger, matcherEvaluator: (...args: any)
     if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation as number, (key as SplitIO.SplitKeyObject).bucketingKey as string, trafficAllocationSeed as number)) {
       return {
         treatment: undefined, // treatment value is assigned later
-        label: LabelsConstants.NOT_IN_SPLIT
+        label: NOT_IN_SPLIT
       };
     }
 

package/src/evaluator/index.ts

@@ -1,6 +1,6 @@
 import { Engine } from './Engine';
 import { thenable } from '../utils/promise/thenable';
-import * as LabelsConstants from '../utils/labels';
+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';
@@ -12,7 +12,7 @@ import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 
 const treatmentException = {
   treatment: CONTROL,
-  label: LabelsConstants.EXCEPTION,
+  label: EXCEPTION,
   config: null
 };
 
@@ -143,7 +143,7 @@ function getEvaluation(
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
     treatment: CONTROL,
-    label: LabelsConstants.SPLIT_NOT_FOUND,
+    label: SPLIT_NOT_FOUND,
     config: null
   };
 
@@ -151,7 +151,7 @@ function getEvaluation(
     const split = Engine.parse(log, splitJSON, storage);
     evaluation = split.getTreatment(key, attributes, evaluateFeature);
 
-    // If the storage is async and the evaluated split uses segment, evaluation is thenable
+    // If the storage is async and the evaluated feature flag is type IN_SPLIT_TREATMENT or IN_SEGMENT, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();

package/src/evaluator/matchers/all.ts

@@ -1,10 +1,6 @@
-import { ENGINE_MATCHER_ALL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function allMatcherContext() {
 
-export function allMatcherContext(log: ILogger) {
   return function allMatcher(runtimeAttr: string): boolean {
-    log.debug(ENGINE_MATCHER_ALL);
-
     return runtimeAttr != null;
   };
 }

package/src/evaluator/matchers/between.ts

@@ -1,13 +1,9 @@
 import { IBetweenMatcherData } from '../../dtos/types';
-import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 
-export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) {
-  return function betweenMatcher(runtimeAttr: number): boolean {
-
-    let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
+export function betweenMatcherContext(ruleVO: IBetweenMatcherData) {
 
-    log.debug(ENGINE_MATCHER_BETWEEN, [runtimeAttr, ruleVO.start, ruleVO.end, isBetween]);
+  return function betweenMatcher(runtimeAttr: number): boolean {
+    const isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;
 
     return isBetween;
   };

package/src/evaluator/matchers/boolean.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_BOOLEAN } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function booleanMatcherContext(ruleAttr: boolean) {
 
-export function booleanMatcherContext(log: ILogger, ruleAttr: boolean) {
   return function booleanMatcher(runtimeAttr: boolean): boolean {
-    let booleanMatches = ruleAttr === runtimeAttr;
-
-    log.debug(ENGINE_MATCHER_BOOLEAN, [ruleAttr, runtimeAttr]);
+    const booleanMatches = ruleAttr === runtimeAttr;
 
     return booleanMatches;
   };

package/src/evaluator/matchers/cont_all.ts

@@ -1,8 +1,6 @@
-import { ENGINE_MATCHER_CONTAINS_ALL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function containsAllSetMatcherContext(ruleAttr: string[]) {
   return function containsAllMatcher(runtimeAttr: string[]): boolean {
     let containsAll = true;
 
@@ -15,8 +13,6 @@ export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) {
       }
     }
 
-    log.debug(ENGINE_MATCHER_CONTAINS_ALL, [runtimeAttr, ruleAttr, containsAll]);
-
     return containsAll;
   };
 }

package/src/evaluator/matchers/cont_any.ts

@@ -1,8 +1,6 @@
-import { ENGINE_MATCHER_CONTAINS_ANY } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function containsAnySetMatcherContext(ruleAttr: string[]) {
   return function containsAnyMatcher(runtimeAttr: string[]): boolean {
     let containsAny = false;
 
@@ -10,8 +8,6 @@ export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) {
       if (findIndex(runtimeAttr, e => e === ruleAttr[i]) >= 0) containsAny = true;
     }
 
-    log.debug(ENGINE_MATCHER_CONTAINS_ANY, [runtimeAttr, ruleAttr, containsAny]);
-
     return containsAny;
   };
 }

package/src/evaluator/matchers/cont_str.ts

@@ -1,12 +1,8 @@
 import { isString } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_CONTAINS_STRING } from '../../logger/constants';
 
-export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function containsStringMatcherContext(ruleAttr: string[]) {
   return function containsStringMatcher(runtimeAttr: string): boolean {
-    let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
-
-    log.debug(ENGINE_MATCHER_CONTAINS_STRING, [runtimeAttr, ruleAttr, contains]);
+    const contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
 
     return contains;
   };

package/src/evaluator/matchers/dependency.ts

@@ -5,7 +5,7 @@ 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(log: ILogger, { split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync) {
+export function dependencyMatcherContext({ split, treatments }: IDependencyMatcherData, storage: IStorageSync | IStorageAsync, log: ILogger) {
 
   function checkTreatment(evaluation: IEvaluation, acceptableTreatments: string[], parentName: string) {
     let matches = false;

package/src/evaluator/matchers/eq.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_EQUAL } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function equalToMatcherContext(ruleAttr: number) {
 
-export function equalToMatcherContext(log: ILogger, ruleAttr: number) {
   return function equalToMatcher(runtimeAttr: number): boolean {
-    let isEqual = runtimeAttr === ruleAttr;
-
-    log.debug(ENGINE_MATCHER_EQUAL, [runtimeAttr, ruleAttr, isEqual]);
+    const isEqual = runtimeAttr === ruleAttr;
 
     return isEqual;
   };

package/src/evaluator/matchers/eq_set.ts

@@ -1,8 +1,6 @@
-import { ENGINE_MATCHER_EQUAL_TO_SET } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { findIndex } from '../../utils/lang';
 
-export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
+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;
@@ -12,8 +10,6 @@ export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
       if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isEqual = false;
     }
 
-    log.debug(ENGINE_MATCHER_EQUAL_TO_SET, [runtimeAttr, ruleAttr, isEqual]);
-
     return isEqual;
   };
 }

package/src/evaluator/matchers/ew.ts

@@ -1,12 +1,8 @@
-import { ENGINE_MATCHER_ENDS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { endsWith } from '../../utils/lang';
 
-export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function endsWithMatcherContext(ruleAttr: string[]) {
   return function endsWithMatcher(runtimeAttr: string): boolean {
-    let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
-
-    log.debug(ENGINE_MATCHER_ENDS_WITH, [runtimeAttr, ruleAttr, strEndsWith]);
+    const strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
 
     return strEndsWith;
   };

package/src/evaluator/matchers/gte.ts

@@ -1,11 +1,7 @@
-import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function greaterThanEqualMatcherContext(ruleAttr: number) {
 
-export function greaterThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function greaterThanEqualMatcher(runtimeAttr: number): boolean {
-    let isGreaterThanEqual = runtimeAttr >= ruleAttr;
-
-    log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
+    const isGreaterThanEqual = runtimeAttr >= ruleAttr;
 
     return isGreaterThanEqual;
   };

package/src/evaluator/matchers/index.ts

@@ -61,6 +61,6 @@ export function matcherFactory(log: ILogger, matcherDto: IMatcherDto, storage?:
 
   let matcherFn;
   // @ts-ignore
-  if (matchers[type]) matcherFn = matchers[type](log, value, storage); // There is no index-out-of-bound exception in JavaScript
+  if (matchers[type]) matcherFn = matchers[type](value, storage, log); // There is no index-out-of-bound exception in JavaScript
   return matcherFn;
 }

package/src/evaluator/matchers/lte.ts

@@ -1,12 +1,8 @@
-import { ENGINE_MATCHER_LESS } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
+export function lessThanEqualMatcherContext(ruleAttr: number) {
 
-export function lessThanEqualMatcherContext(log: ILogger, ruleAttr: number) {
   return function lessThanEqualMatcher(runtimeAttr: number): boolean {
-    let isLessEqualThan = runtimeAttr <= ruleAttr;
+    const isLessThanEqual = runtimeAttr <= ruleAttr;
 
-    log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]);
-
-    return isLessEqualThan;
+    return isLessThanEqual;
   };
 }

package/src/evaluator/matchers/part_of.ts

@@ -1,8 +1,6 @@
 import { findIndex } from '../../utils/lang';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_PART_OF } from '../../logger/constants';
 
-export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) {
+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;
@@ -12,8 +10,6 @@ export function partOfSetMatcherContext(log: ILogger, ruleAttr: string[]) {
       if (findIndex(ruleAttr, e => e === runtimeAttr[i]) < 0) isPartOf = false;
     }
 
-    log.debug(ENGINE_MATCHER_PART_OF, [runtimeAttr, ruleAttr, isPartOf]);
-
     return isPartOf;
   };
 }

package/src/evaluator/matchers/segment.ts

@@ -1,25 +1,18 @@
 import { MaybeThenable } from '../../dtos/types';
 import { ISegmentsCacheBase } from '../../storages/types';
-import { ILogger } from '../../logger/types';
 import { thenable } from '../../utils/promise/thenable';
-import { ENGINE_MATCHER_SEGMENT } from '../../logger/constants';
 
-export function segmentMatcherContext(log: ILogger, segmentName: string, storage: { segments: ISegmentsCacheBase }) {
+export function segmentMatcherContext(segmentName: string, storage: { segments: ISegmentsCacheBase }) {
 
   return function segmentMatcher(key: string): MaybeThenable<boolean> {
     const isInSegment = storage.segments.isInSegment(segmentName, key);
 
     if (thenable(isInSegment)) {
       isInSegment.then(result => {
-        log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
-
         return result;
       });
-    } else {
-      log.debug(ENGINE_MATCHER_SEGMENT, [segmentName, key, isInSegment]);
     }
 
     return isInSegment;
   };
-
 }

package/src/evaluator/matchers/semver_between.ts

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

package/src/evaluator/matchers/semver_eq.ts

@@ -1,7 +1,6 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function equalToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function equalToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function equalToSemverMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/semver_gte.ts

@@ -1,7 +1,6 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function greaterThanEqualToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function greaterThanEqualToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function greaterThanEqualToSemverMatcher(runtimeAttr: string): boolean {

package/src/evaluator/matchers/semver_inlist.ts

@@ -1,13 +1,15 @@
-import { setToArray, ISet, _Set } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
+import { _Set } from '../../utils/lang/sets';
 import { Semver } from '../../utils/Semver';
 
-export function inListSemverMatcherContext(log: ILogger, ruleAttr: ISet<string>) {
+export function inListSemverMatcherContext(ruleAttr: string[]) {
+  // @TODO move eventually to `matchersTransform` and validate for all matchers
+  if (!ruleAttr || ruleAttr.length === 0) throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
 
-  const listOfSemvers = new _Set(setToArray(ruleAttr).map((version) => new Semver(version).version));
+  const listOfSemvers = new _Set(ruleAttr.map((version) => new Semver(version).version));
 
   return function inListSemverMatcher(runtimeAttr: string): boolean {
     const runtimeSemver = new Semver(runtimeAttr).version;
+
     const isInList = listOfSemvers.has(runtimeSemver);
 
     return isInList;

package/src/evaluator/matchers/semver_lte.ts

@@ -1,14 +1,13 @@
-import { ILogger } from '../../logger/types';
 import { Semver } from '../../utils/Semver';
 
-export function lessThanEqualToSemverMatcherContext(log: ILogger, ruleAttr: string) {
+export function lessThanEqualToSemverMatcherContext(ruleAttr: string) {
   const ruleSemver = new Semver(ruleAttr);
 
   return function lessThanEqualToSemverMatcher(runtimeAttr: string): boolean {
     const runtimeSemver = new Semver(runtimeAttr);
 
-    const isLessThenEqual = runtimeSemver.compare(ruleSemver) <= 0;
+    const isLessThanEqual = runtimeSemver.compare(ruleSemver) <= 0;
 
-    return isLessThenEqual;
+    return isLessThanEqual;
   };
 }

package/src/evaluator/matchers/string.ts

@@ -1,14 +1,9 @@
-import { ENGINE_MATCHER_STRING } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
-
-export function stringMatcherContext(log: ILogger, ruleAttr: string) {
+export function stringMatcherContext(ruleAttr: string) {
   const regex = new RegExp(ruleAttr);
 
   return function stringMatcher(runtimeAttr: string): boolean {
     const regexMatches = regex.test(runtimeAttr);
 
-    log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
-
     return regexMatches;
   };
 }

package/src/evaluator/matchers/sw.ts

@@ -1,12 +1,8 @@
-import { ENGINE_MATCHER_STARTS_WITH } from '../../logger/constants';
-import { ILogger } from '../../logger/types';
 import { startsWith } from '../../utils/lang';
 
-export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
+export function startsWithMatcherContext(ruleAttr: string[]) {
   return function startsWithMatcher(runtimeAttr: string): boolean {
-    let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
-
-    log.debug(ENGINE_MATCHER_STARTS_WITH, [runtimeAttr, ruleAttr, matches]);
+    const matches = ruleAttr.some(e => startsWith(runtimeAttr, e));
 
     return matches;
   };

package/src/evaluator/matchers/whitelist.ts

@@ -1,12 +1,10 @@
-import { setToArray, ISet } from '../../utils/lang/sets';
-import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
+import { _Set } from '../../utils/lang/sets';
 
-export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) {
-  return function whitelistMatcher(runtimeAttr: string): boolean {
-    let isInWhitelist = ruleAttr.has(runtimeAttr);
+export function whitelistMatcherContext(ruleAttr: string[]) {
+  const whitelistSet = new _Set(ruleAttr);
 
-    log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]);
+  return function whitelistMatcher(runtimeAttr: string): boolean {
+    const isInWhitelist = whitelistSet.has(runtimeAttr);
 
     return isInWhitelist;
   };

package/src/evaluator/matchersTransform/index.ts

@@ -2,10 +2,9 @@ import { findIndex } from '../../utils/lang';
 import { matcherTypes, matcherTypesMapper, matcherDataTypes } from '../matchers/matcherTypes';
 import { segmentTransform } from './segment';
 import { whitelistTransform } from './whitelist';
-import { setTransform } from './set';
 import { numericTransform } from './unaryNumeric';
 import { zeroSinceHH, zeroSinceSS } from '../convertions';
-import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData, IWhitelistMatcherData } from '../../dtos/types';
+import { IBetweenMatcherData, IInSegmentMatcherData, ISplitMatcher, IUnaryNumericMatcherData } from '../../dtos/types';
 import { IMatcherDto } from '../types';
 
 /**
@@ -32,15 +31,10 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let type = matcherTypesMapper(matcherType);
     // As default input data type we use string (even for ALL_KEYS)
     let dataType = matcherDataTypes.STRING;
-    let value = undefined;
+    let value: IMatcherDto['value'] = undefined;
 
     if (type === matcherTypes.IN_SEGMENT) {
       value = segmentTransform(userDefinedSegmentMatcherData as IInSegmentMatcherData);
-    } else if (
-      type === matcherTypes.WHITELIST ||
-      type === matcherTypes.IN_LIST_SEMVER
-    ) {
-      value = whitelistTransform(whitelistMatcherData as IWhitelistMatcherData);
     } else if (type === matcherTypes.EQUAL_TO) {
       value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;
@@ -75,14 +69,16 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
       type === matcherTypes.CONTAINS_ALL_OF_SET ||
       type === matcherTypes.PART_OF_SET
     ) {
-      value = setTransform(whitelistMatcherData as IWhitelistMatcherData);
+      value = whitelistTransform(whitelistMatcherData);
       dataType = matcherDataTypes.SET;
     } else if (
+      type === matcherTypes.WHITELIST ||
+      type === matcherTypes.IN_LIST_SEMVER ||
       type === matcherTypes.STARTS_WITH ||
       type === matcherTypes.ENDS_WITH ||
       type === matcherTypes.CONTAINS_STRING
     ) {
-      value = setTransform(whitelistMatcherData as IWhitelistMatcherData);
+      value = whitelistTransform(whitelistMatcherData);
     } else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
       value = dependencyMatcherData;
       dataType = matcherDataTypes.NOT_SPECIFIED;

package/src/evaluator/matchersTransform/whitelist.ts

@@ -1,9 +1,8 @@
-import { IWhitelistMatcherData } from '../../dtos/types';
-import { _Set } from '../../utils/lang/sets';
+import { ISplitMatcher } from '../../dtos/types';
 
 /**
  * Extract whitelist as a set. Used by 'WHITELIST' matcher.
  */
-export function whitelistTransform(whitelistObject: IWhitelistMatcherData) {
-  return new _Set(whitelistObject.whitelist);
+export function whitelistTransform(whitelistObject: ISplitMatcher['whitelistMatcherData']) {
+  return whitelistObject && whitelistObject.whitelist;
 }

package/src/evaluator/parser/index.ts

@@ -11,7 +11,7 @@ import { ISplitCondition, MaybeThenable } from '../../dtos/types';
 import { IStorageAsync, IStorageSync } from '../../storages/types';
 import { SplitIO } from '../../types';
 import { ILogger } from '../../logger/types';
-import { ENGINE_MATCHER_ERROR } from '../../logger/constants';
+import { ENGINE_MATCHER_ERROR, ENGINE_MATCHER_RESULT } from '../../logger/constants';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -45,14 +45,19 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
           try {
             result = matcher(value, splitEvaluator);
           } catch (error) {
+            // @TODO should we propagate the error, to create impressions with label EXCEPTION?
             log.error(ENGINE_MATCHER_ERROR, [matcherGroup.matchers[index].matcherType, error]);
           }
         }
 
-        if (thenable(result)) { // @ts-ignore
-          return result.then(res => Boolean(res ^ matcherDto.negate));
-        } // @ts-ignore
-        return Boolean(result ^ matcherDto.negate);
+        function handleResult(result: boolean) {
+          log.debug(ENGINE_MATCHER_RESULT, [matcherGroup.matchers[index].matcherType, result, matcherDto.value, value]); // @ts-ignore
+          return Boolean(result ^ matcherDto.negate);
+        }
+
+        return thenable(result) ?
+          result.then(handleResult) :
+          handleResult(result);
       };
     });
 

package/src/evaluator/types.ts

@@ -1,6 +1,5 @@
 import { IBetweenMatcherData, IBetweenStringMatcherData, IDependencyMatcherData, MaybeThenable } from '../dtos/types';
 import { IStorageAsync, IStorageSync } from '../storages/types';
-import { ISet } from '../utils/lang/sets';
 import { SplitIO } from '../types';
 import { ILogger } from '../logger/types';
 
@@ -11,7 +10,7 @@ export interface IDependencyMatcherValue {
 
 export interface IMatcherDto {
   type: number
-  value?: string | number | boolean | string[] | IDependencyMatcherData | ISet<string> | IBetweenMatcherData | IBetweenStringMatcherData | null
+  value?: string | number | boolean | string[] | IDependencyMatcherData | IBetweenMatcherData | IBetweenStringMatcherData | null
 
   attribute: string | null
   negate: boolean