@splitsoftware/splitio-commons 1.13.2-rc.1 → 1.13.2-rc.11

package/cjs/utils/Semver.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Semver = void 0;
+var lang_1 = require("../utils/lang");
+var NUMERIC_IDENTIFIER_REGEX = /^[0-9]+$/;
+var METADATA_DELIMITER = '+';
+var PRERELEASE_DELIMITER = '-';
+var VALUE_DELIMITER = '.';
+/**
+ * Compares two strings. If both strings are numeric identifiers, they are compared numerically. Otherwise, they are compared lexicographically.
+ * This could be implemented using `a.localeCompare(b, undefined, { numeric: true })` but locale options are not broadly supported.
+ */
+function compareStrings(a, b) {
+    if (NUMERIC_IDENTIFIER_REGEX.test(a) && NUMERIC_IDENTIFIER_REGEX.test(b)) {
+        var result = a.length - b.length;
+        if (result !== 0) {
+            return result;
+        }
+    }
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+// Sanitizes a numeric identifier by removing leading zeros
+function sanitizeNumericIdentifier(value) {
+    return value.replace(/^0+(?=\d)/, '');
+}
+function throwError(version) {
+    throw new Error('Unable to convert to Semver, incorrect format: ' + version);
+}
+var Semver = /** @class */ (function () {
+    function Semver(version) {
+        if (!(0, lang_1.isString)(version))
+            throwError(version);
+        // Separate metadata if exists
+        var index = version.indexOf(METADATA_DELIMITER);
+        var _a = index === -1 ? [version] : [version.slice(0, index), version.slice(index + 1)], vWithoutMetadata = _a[0], metadata = _a[1];
+        if (metadata === '')
+            throwError(version);
+        // Set pre-release versions if exists
+        index = vWithoutMetadata.indexOf(PRERELEASE_DELIMITER);
+        if (index === -1) {
+            this._isStable = true;
+            this._preRelease = [];
+        }
+        else {
+            this._isStable = false;
+            this._preRelease = vWithoutMetadata.slice(index + 1).split(VALUE_DELIMITER).map(function (value) {
+                if (!value)
+                    throwError(version);
+                return NUMERIC_IDENTIFIER_REGEX.test(value) ?
+                    sanitizeNumericIdentifier(value) :
+                    value;
+            });
+            vWithoutMetadata = vWithoutMetadata.slice(0, index);
+        }
+        // Set major, minor, and patch versions
+        var vParts = vWithoutMetadata.split(VALUE_DELIMITER).map(function (value) {
+            if (!value || !NUMERIC_IDENTIFIER_REGEX.test(value))
+                throwError(version);
+            return sanitizeNumericIdentifier(value);
+        });
+        if (vParts.length !== 3)
+            throwError(version);
+        this._major = vParts[0];
+        this._minor = vParts[1];
+        this._patch = vParts[2];
+        // Set version string
+        this.version = vParts.join(VALUE_DELIMITER);
+        if (this._preRelease.length)
+            this.version += PRERELEASE_DELIMITER + this._preRelease.join(VALUE_DELIMITER);
+        if (metadata)
+            this.version += METADATA_DELIMITER + metadata;
+    }
+    /**
+     * Precedence comparision between 2 Semver objects.
+     *
+     * @return `0` if `this === toCompare`, `-1` if `this < toCompare`, and `1` if `this > toCompare`
+     */
+    Semver.prototype.compare = function (toCompare) {
+        if (this.version === toCompare.version)
+            return 0;
+        var result = compareStrings(this._major, toCompare._major);
+        if (result !== 0)
+            return result;
+        result = compareStrings(this._minor, toCompare._minor);
+        if (result !== 0)
+            return result;
+        result = compareStrings(this._patch, toCompare._patch);
+        if (result !== 0)
+            return result;
+        if (!this._isStable && toCompare._isStable)
+            return -1;
+        if (this._isStable && !toCompare._isStable)
+            return 1;
+        for (var i = 0, length_1 = Math.min(this._preRelease.length, toCompare._preRelease.length); i < length_1; i++) {
+            var result_1 = compareStrings(this._preRelease[i], toCompare._preRelease[i]);
+            if (result_1 !== 0)
+                return result_1;
+        }
+        return this._preRelease.length - toCompare._preRelease.length;
+    };
+    return Semver;
+}());
+exports.Semver = Semver;

package/cjs/utils/labels/index.js

@@ -8,4 +8,4 @@ exports.SDK_NOT_READY = 'not ready';
 exports.EXCEPTION = 'exception';
 exports.SPLIT_ARCHIVED = 'archived';
 exports.NOT_IN_SPLIT = 'not in split';
-exports.UNSUPPORTED_MATCHER_TYPE = 'unsupported matcher type';
+exports.UNSUPPORTED_MATCHER_TYPE = 'targeting rule type unsupported by sdk';

package/cjs/utils/settingsValidation/logger/pluggableLogger.js

@@ -4,7 +4,7 @@ exports.validateLogger = void 0;
 var logger_1 = require("../../../logger");
 var commons_1 = require("./commons");
 function isLogger(log) {
-    return log && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function';
+    return log !== null && typeof log === 'object' && typeof log.debug === 'function' && typeof log.info === 'function' && typeof log.warn === 'function' && typeof log.error === 'function' && typeof log.setLogLevel === 'function';
 }
 // By default it starts disabled.
 var initialLogLevel = logger_1.LogLevels.NONE;

package/esm/evaluator/Engine.js

@@ -2,12 +2,12 @@ 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';
 function evaluationResult(result, defaultTreatment) {
     return {
         treatment: get(result, 'treatment', defaultTreatment),
-        label: get(result, 'label', LabelsConstants.NO_CONDITION_MATCH)
+        label: get(result, 'label', NO_CONDITION_MATCH)
     };
 }
 var Engine = /** @class */ (function () {
@@ -38,16 +38,16 @@ var Engine = /** @class */ (function () {
         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 {
             var evaluation = this.evaluator(parsedKey, seed, trafficAllocation, trafficAllocationSeed, attributes, splitEvaluator);

package/esm/evaluator/combiners/ifelseif.js

@@ -1,6 +1,6 @@
 import { findIndex } from '../../utils/lang';
 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 { ENGINE_COMBINER_IFELSEIF, ENGINE_COMBINER_IFELSEIF_NO_TREATMENT, ERROR_ENGINE_COMBINER_IFELSEIF } from '../../logger/constants';
 export function ifElseIfCombinerContext(log, predicates) {
@@ -8,7 +8,7 @@ export function ifElseIfCombinerContext(log, predicates) {
         log.error(ERROR_ENGINE_COMBINER_IFELSEIF);
         return {
             treatment: CONTROL,
-            label: LabelsConstants.UNSUPPORTED_MATCHER_TYPE
+            label: UNSUPPORTED_MATCHER_TYPE
         };
     }
     function computeTreatment(predicateResults) {

package/esm/evaluator/condition/index.js

@@ -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';
 // Build Evaluation object if and only if matchingResult is true
 function match(log, matchingResult, bucketingKey, seed, treatments, label) {
     if (matchingResult) {
@@ -20,7 +20,7 @@ export function conditionContext(log, matcherEvaluator, treatments, label, condi
         if (conditionType === 'ROLLOUT' && !shouldApplyRollout(trafficAllocation, key.bucketingKey, trafficAllocationSeed)) {
             return {
                 treatment: undefined,
-                label: LabelsConstants.NOT_IN_SPLIT
+                label: NOT_IN_SPLIT
             };
         }
         // matcherEvaluator could be Async, this relays on matchers return value, so we need

package/esm/evaluator/index.js

@@ -1,12 +1,12 @@
 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 { setToArray, returnSetsUnion, _Set } from '../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../logger/constants';
 var treatmentException = {
     treatment: CONTROL,
-    label: LabelsConstants.EXCEPTION,
+    label: EXCEPTION,
     config: null
 };
 function treatmentsException(splitNames) {
@@ -87,13 +87,13 @@ export function evaluateFeaturesByFlagSets(log, key, flagSets, attributes, stora
 function getEvaluation(log, splitJSON, key, attributes, storage) {
     var evaluation = {
         treatment: CONTROL,
-        label: LabelsConstants.SPLIT_NOT_FOUND,
+        label: SPLIT_NOT_FOUND,
         config: null
     };
     if (splitJSON) {
         var split_1 = Engine.parse(log, splitJSON, storage);
         evaluation = split_1.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 flag uses segments or dependencies, evaluation is thenable
         if (thenable(evaluation)) {
             return evaluation.then(function (result) {
                 result.changeNumber = split_1.getChangeNumber();

package/esm/evaluator/matchers/gte.js

@@ -1,8 +1,8 @@
 import { ENGINE_MATCHER_GREATER } from '../../logger/constants';
 export function greaterThanEqualMatcherContext(log, ruleAttr) {
     return function greaterThanEqualMatcher(runtimeAttr) {
-        var isGreaterEqualThan = runtimeAttr >= ruleAttr;
-        log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterEqualThan]);
-        return isGreaterEqualThan;
+        var isGreaterThanEqual = runtimeAttr >= ruleAttr;
+        log.debug(ENGINE_MATCHER_GREATER, [runtimeAttr, ruleAttr, isGreaterThanEqual]);
+        return isGreaterThanEqual;
     };
 }

package/esm/evaluator/matchers/index.js

@@ -15,6 +15,11 @@ 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';
 var matchers = [
     undefined,
     allMatcherContext,
@@ -33,7 +38,12 @@ var matchers = [
     containsStringMatcherContext,
     dependencyMatcherContext,
     booleanMatcherContext,
-    stringMatcherContext // MATCHES_STRING: 17
+    stringMatcherContext,
+    equalToSemverMatcherContext,
+    greaterThanEqualToSemverMatcherContext,
+    lessThanEqualToSemverMatcherContext,
+    betweenSemverMatcherContext,
+    inListSemverMatcherContext, // IN_LIST_SEMVER: 22
 ];
 /**
  * Matcher factory.

package/esm/evaluator/matchers/lte.js

@@ -1,8 +1,8 @@
 import { ENGINE_MATCHER_LESS } from '../../logger/constants';
 export function lessThanEqualMatcherContext(log, ruleAttr) {
     return function lessThanEqualMatcher(runtimeAttr) {
-        var isLessEqualThan = runtimeAttr <= ruleAttr;
-        log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessEqualThan]);
-        return isLessEqualThan;
+        var isLessThanEqual = runtimeAttr <= ruleAttr;
+        log.debug(ENGINE_MATCHER_LESS, [runtimeAttr, ruleAttr, isLessThanEqual]);
+        return isLessThanEqual;
     };
 }

package/esm/evaluator/matchers/matcherTypes.js

@@ -16,7 +16,12 @@ export var matcherTypes = {
     CONTAINS_STRING: 14,
     IN_SPLIT_TREATMENT: 15,
     EQUAL_TO_BOOLEAN: 16,
-    MATCHES_STRING: 17
+    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,
 };
 export var matcherDataTypes = {
     BOOLEAN: 'BOOLEAN',

package/esm/evaluator/matchers/semver_between.js

@@ -0,0 +1,10 @@
+import { Semver } from '../../utils/Semver';
+export function betweenSemverMatcherContext(log, ruleAttr) {
+    var startSemver = new Semver(ruleAttr.start);
+    var endSemver = new Semver(ruleAttr.end);
+    return function betweenSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr);
+        var isBetween = startSemver.compare(runtimeSemver) <= 0 && endSemver.compare(runtimeSemver) >= 0;
+        return isBetween;
+    };
+}

package/esm/evaluator/matchers/semver_eq.js

@@ -0,0 +1,9 @@
+import { Semver } from '../../utils/Semver';
+export function equalToSemverMatcherContext(log, ruleAttr) {
+    var ruleSemver = new Semver(ruleAttr);
+    return function equalToSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr);
+        var isEqual = ruleSemver.version === runtimeSemver.version;
+        return isEqual;
+    };
+}

package/esm/evaluator/matchers/semver_gte.js

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

package/esm/evaluator/matchers/semver_inlist.js

@@ -0,0 +1,13 @@
+import { _Set } from '../../utils/lang/sets';
+import { Semver } from '../../utils/Semver';
+export function inListSemverMatcherContext(log, ruleAttr) {
+    // @TODO ruleAttr validation should be done at the `parser` or `matchersTransform` level to reuse for all matchers
+    if (!ruleAttr || ruleAttr.length === 0)
+        throw new Error('whitelistMatcherData is required for IN_LIST_SEMVER matcher type');
+    var listOfSemvers = new _Set(ruleAttr.map(function (version) { return new Semver(version).version; }));
+    return function inListSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr).version;
+        var isInList = listOfSemvers.has(runtimeSemver);
+        return isInList;
+    };
+}

package/esm/evaluator/matchers/semver_lte.js

@@ -0,0 +1,9 @@
+import { Semver } from '../../utils/Semver';
+export function lessThanEqualToSemverMatcherContext(log, ruleAttr) {
+    var ruleSemver = new Semver(ruleAttr);
+    return function lessThanEqualToSemverMatcher(runtimeAttr) {
+        var runtimeSemver = new Semver(runtimeAttr);
+        var isLessThanEqual = runtimeSemver.compare(ruleSemver) <= 0;
+        return isLessThanEqual;
+    };
+}

package/esm/evaluator/matchers/string.js

@@ -1,15 +1,8 @@
-import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
+import { ENGINE_MATCHER_STRING } from '../../logger/constants';
 export function stringMatcherContext(log, ruleAttr) {
+    var regex = new RegExp(ruleAttr);
     return function stringMatcher(runtimeAttr) {
-        var re;
-        try {
-            re = new RegExp(ruleAttr);
-        }
-        catch (e) {
-            log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]);
-            return false;
-        }
-        var regexMatches = re.test(runtimeAttr);
+        var regexMatches = regex.test(runtimeAttr);
         log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
         return regexMatches;
     };

package/esm/evaluator/matchers/whitelist.js

@@ -1,9 +1,10 @@
-import { setToArray } from '../../utils/lang/sets';
+import { _Set } from '../../utils/lang/sets';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 export function whitelistMatcherContext(log, ruleAttr) {
+    var whitelistSet = new _Set(ruleAttr);
     return function whitelistMatcher(runtimeAttr) {
-        var isInWhitelist = ruleAttr.has(runtimeAttr);
-        log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, setToArray(ruleAttr).join(','), isInWhitelist]);
+        var isInWhitelist = whitelistSet.has(runtimeAttr);
+        log.debug(ENGINE_MATCHER_WHITELIST, [runtimeAttr, ruleAttr.join(','), isInWhitelist]);
         return isInWhitelist;
     };
 }

package/esm/evaluator/matchersTransform/index.js

@@ -2,7 +2,6 @@ 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';
 /**
@@ -10,37 +9,34 @@ import { zeroSinceHH, zeroSinceSS } from '../convertions';
  */
 export function matchersTransform(matchers) {
     var parsedMatchers = matchers.map(function (matcher) {
-        var matcherType = matcher.matcherType /* string */, negate = matcher.negate /* boolean */, keySelector = matcher.keySelector /* keySelectorObject */, segmentObject = matcher.userDefinedSegmentMatcherData /* segmentObject */, whitelistObject = matcher.whitelistMatcherData /* whiteListObject, provided by 'WHITELIST', set and string matchers */, unaryNumericObject = matcher.unaryNumericMatcherData /* unaryNumericObject */, betweenObject = matcher.betweenMatcherData /* betweenObject */, dependencyObject = matcher.dependencyMatcherData /* dependencyObject */, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData;
+        var matcherType = matcher.matcherType, negate = matcher.negate, keySelector = matcher.keySelector, userDefinedSegmentMatcherData = matcher.userDefinedSegmentMatcherData, whitelistMatcherData = matcher.whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */ unaryNumericMatcherData = matcher.unaryNumericMatcherData, betweenMatcherData = matcher.betweenMatcherData, dependencyMatcherData = matcher.dependencyMatcherData, booleanMatcherData = matcher.booleanMatcherData, stringMatcherData = matcher.stringMatcherData, betweenStringMatcherData = matcher.betweenStringMatcherData;
         var attribute = keySelector && keySelector.attribute;
         var type = matcherTypesMapper(matcherType);
         // As default input data type we use string (even for ALL_KEYS)
         var dataType = matcherDataTypes.STRING;
         var value = undefined;
         if (type === matcherTypes.IN_SEGMENT) {
-            value = segmentTransform(segmentObject);
-        }
-        else if (type === matcherTypes.WHITELIST) {
-            value = whitelistTransform(whitelistObject);
+            value = segmentTransform(userDefinedSegmentMatcherData);
         }
         else if (type === matcherTypes.EQUAL_TO) {
-            value = numericTransform(unaryNumericObject);
+            value = numericTransform(unaryNumericMatcherData);
             dataType = matcherDataTypes.NUMBER;
-            if (unaryNumericObject.dataType === 'DATETIME') {
+            if (unaryNumericMatcherData.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);
+            value = numericTransform(unaryNumericMatcherData);
             dataType = matcherDataTypes.NUMBER;
-            if (unaryNumericObject.dataType === 'DATETIME') {
+            if (unaryNumericMatcherData.dataType === 'DATETIME') {
                 value = zeroSinceSS(value);
                 dataType = matcherDataTypes.DATETIME;
             }
         }
         else if (type === matcherTypes.BETWEEN) {
-            value = betweenObject;
+            value = betweenMatcherData;
             dataType = matcherDataTypes.NUMBER;
             if (value.dataType === 'DATETIME') {
                 value.start = zeroSinceSS(value.start);
@@ -48,33 +44,42 @@ export function matchersTransform(matchers) {
                 dataType = matcherDataTypes.DATETIME;
             }
         }
+        else if (type === matcherTypes.BETWEEN_SEMVER) {
+            value = betweenStringMatcherData;
+        }
         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);
+            value = whitelistTransform(whitelistMatcherData);
             dataType = matcherDataTypes.SET;
         }
-        else if (type === matcherTypes.STARTS_WITH ||
+        else if (type === matcherTypes.WHITELIST ||
+            type === matcherTypes.IN_LIST_SEMVER ||
+            type === matcherTypes.STARTS_WITH ||
             type === matcherTypes.ENDS_WITH ||
             type === matcherTypes.CONTAINS_STRING) {
-            value = setTransform(whitelistObject);
+            value = whitelistTransform(whitelistMatcherData);
         }
         else if (type === matcherTypes.IN_SPLIT_TREATMENT) {
-            value = dependencyObject;
+            value = dependencyMatcherData;
             dataType = matcherDataTypes.NOT_SPECIFIED;
         }
         else if (type === matcherTypes.EQUAL_TO_BOOLEAN) {
             dataType = matcherDataTypes.BOOLEAN;
             value = booleanMatcherData;
         }
-        else if (type === matcherTypes.MATCHES_STRING) {
+        else if (type === matcherTypes.MATCHES_STRING ||
+            type === matcherTypes.EQUAL_TO_SEMVER ||
+            type === matcherTypes.GREATER_THAN_OR_EQUAL_TO_SEMVER ||
+            type === matcherTypes.LESS_THAN_OR_EQUAL_TO_SEMVER) {
             value = stringMatcherData;
         }
         return {
             attribute: attribute,
             negate: negate,
             type: type,
+            name: matcherType,
             value: value,
             dataType: dataType // runtime input data type
         };

package/esm/evaluator/matchersTransform/whitelist.js

@@ -1,7 +1,6 @@
-import { _Set } from '../../utils/lang/sets';
 /**
- * Extract whitelist as a set. Used by 'WHITELIST' matcher.
+ * Extract whitelist array.
  */
 export function whitelistTransform(whitelistObject) {
-    return new _Set(whitelistObject.whitelist);
+    return whitelistObject && whitelistObject.whitelist;
 }

package/esm/evaluator/parser/index.js

@@ -6,6 +6,7 @@ import { conditionContext } from '../condition';
 import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
+import { ENGINE_MATCHER_ERROR } from '../../logger/constants';
 export function parser(log, conditions, storage) {
     var predicates = [];
     for (var i = 0; i < conditions.length; i++) {
@@ -14,16 +15,28 @@ export function parser(log, conditions, storage) {
         var matchers = matchersTransform(matcherGroup.matchers);
         // create a set of pure functions from the matcher's dto
         var expressions = matchers.map(function (matcherDto) {
-            var matcher = matcherFactory(log, matcherDto, storage);
+            var matcher;
+            try {
+                matcher = matcherFactory(log, matcherDto, storage);
+            }
+            catch (error) {
+                log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
+            }
             // Evaluator function.
             return function (key, attributes, splitEvaluator) {
                 var value = sanitizeValue(log, key, matcherDto, attributes);
-                var result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
-                if (thenable(result)) {
-                    // @ts-ignore
-                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });
+                var result = false;
+                if (value !== undefined && matcher) {
+                    try {
+                        result = matcher(value, splitEvaluator);
+                    }
+                    catch (error) {
+                        log.error(ENGINE_MATCHER_ERROR, [matcherDto.name, error]);
+                    }
                 }
-                // @ts-ignore
+                if (thenable(result)) { // @ts-ignore
+                    return result.then(function (res) { return Boolean(res ^ matcherDto.negate); });
+                } // @ts-ignore
                 return Boolean(result ^ matcherDto.negate);
             };
         });

package/esm/logger/constants.js

@@ -25,7 +25,6 @@ export var ENGINE_MATCHER_LESS = 16;
 export var ENGINE_MATCHER_PART_OF = 17;
 export var ENGINE_MATCHER_SEGMENT = 18;
 export var ENGINE_MATCHER_STRING = 19;
-export var ENGINE_MATCHER_STRING_INVALID = 20;
 export var ENGINE_MATCHER_STARTS_WITH = 21;
 export var ENGINE_MATCHER_WHITELIST = 22;
 export var ENGINE_VALUE = 23;
@@ -128,6 +127,7 @@ export var ERROR_NOT_BOOLEAN = 325;
 export var ERROR_MIN_CONFIG_PARAM = 326;
 export var ERROR_TOO_MANY_SETS = 327;
 export var ERROR_SETS_FILTER_EXCLUSIVE = 328;
+export var ENGINE_MATCHER_ERROR = 329;
 // Log prefixes (a.k.a. tags or categories)
 export var LOG_PREFIX_SETTINGS = 'settings';
 export var LOG_PREFIX_INSTANTIATION = 'Factory instantiation';

package/esm/logger/index.js

@@ -1,5 +1,5 @@
 import { objectAssign } from '../utils/lang/objectAssign';
-import { find } from '../utils/lang';
+import { find, isObject } from '../utils/lang';
 import { _Map } from '../utils/lang/maps';
 export var LogLevels = {
     DEBUG: 'DEBUG',
@@ -24,7 +24,14 @@ export function _sprintf(format, args) {
     if (args === void 0) { args = []; }
     var i = 0;
     return format.replace(/%s/g, function () {
-        return args[i++];
+        var arg = args[i++];
+        if (isObject(arg) || Array.isArray(arg)) {
+            try {
+                arg = JSON.stringify(arg);
+            }
+            catch (e) { /* empty */ }
+        }
+        return arg;
     });
 }
 var defaultOptions = {

package/esm/logger/messages/debug.js

@@ -22,7 +22,6 @@ export var codesDebug = codesInfo.concat([
     [c.ENGINE_MATCHER_PART_OF, c.LOG_PREFIX_ENGINE_MATCHER + '[partOfMatcher] %s is part of %s? %s'],
     [c.ENGINE_MATCHER_SEGMENT, c.LOG_PREFIX_ENGINE_MATCHER + '[segmentMatcher] evaluated %s / %s => %s'],
     [c.ENGINE_MATCHER_STRING, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] does %s matches with %s? %s'],
-    [c.ENGINE_MATCHER_STRING_INVALID, c.LOG_PREFIX_ENGINE_MATCHER + '[stringMatcher] %s is an invalid regex'],
     [c.ENGINE_MATCHER_STARTS_WITH, c.LOG_PREFIX_ENGINE_MATCHER + '[startsWithMatcher] %s starts with %s? %s'],
     [c.ENGINE_MATCHER_WHITELIST, c.LOG_PREFIX_ENGINE_MATCHER + '[whitelistMatcher] evaluated %s in [%s] => %s'],
     [c.ENGINE_VALUE, c.LOG_PREFIX_ENGINE_VALUE + 'Extracted attribute [%s], [%s] will be used for matching.'],

package/esm/logger/messages/error.js

@@ -1,7 +1,8 @@
 import * as c from '../constants';
 export var codesError = [
     // evaluator
-    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported matcher type found'],
+    [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported targeting rule type found'],
+    [c.ENGINE_MATCHER_ERROR, c.LOG_PREFIX_ENGINE_MATCHER + '[%s] %s'],
     // SDK
     [c.ERROR_LOGLEVEL_INVALID, 'logger: Invalid Log Level - No changes to the logs will be applied.'],
     [c.ERROR_CLIENT_CANNOT_GET_READY, 'The SDK will not get ready. Reason: %s'],

package/esm/services/splitApi.js

@@ -29,16 +29,16 @@ export function splitApiFactory(settings, platform, telemetryTracker) {
             return splitHttpClient(url).then(function () { return true; }).catch(function () { return false; });
         },
         fetchAuth: function (userMatchingKeys) {
-            var url = urls.auth + "/v2/auth";
-            if (userMatchingKeys) { // accounting the possibility that `userMatchingKeys` is undefined (server-side API)
+            var url = urls.auth + "/v2/auth?s=" + FLAGS_SPEC;
+            if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
                 var queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-                if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
-                    url += '?' + queryParams;
+                if (queryParams)
+                    url += '&' + queryParams;
             }
             return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
         },
         fetchSplitChanges: function (since, noCache, till) {
-            var url = urls.sdk + "/splitChanges?s=" + FLAGS_SPEC + "&since=" + since + (till ? '&till=' + till : '') + (filterQueryString || '');
+            var url = urls.sdk + "/splitChanges?s=" + FLAGS_SPEC + "&since=" + since + (filterQueryString || '') + (till ? '&till=' + till : '');
             return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
                 .catch(function (err) {
                 if (err.statusCode === 414)

package/esm/storages/inLocalStorage/SplitsCacheInLocal.js

@@ -123,7 +123,7 @@ var SplitsCacheInLocal = /** @class */ (function (_super) {
     SplitsCacheInLocal.prototype.setChangeNumber = function (changeNumber) {
         // when using a new split query, we must update it at the store
         if (this.updateNewFilter) {
-            this.log.info(LOG_PREFIX + 'SDK key or feature flag filter criteria was modified. Updating cache');
+            this.log.info(LOG_PREFIX + 'SDK key, flags filter criteria or flags spec version was modified. Updating cache');
             var storageHashKey = this.keys.buildHashKey();
             try {
                 localStorage.setItem(storageHashKey, this.storageHash);