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

package/esm/storages/pluggable/index.js

@@ -79,7 +79,7 @@ export function PluggableStorage(options) {
                 return wrapper.get(keys.buildHashKey()).then(function (hash) {
                     var currentHash = getStorageHash(settings);
                     if (hash !== currentHash) {
-                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key or feature flag filter criteria was modified). Clearing cache');
+                        log.info(LOG_PREFIX + 'Storage HASH has changed (SDK key, flags filter criteria or flags spec version was modified). Clearing cache');
                         return wrapper.getKeysByPrefix(keys.prefix + ".").then(function (storageKeys) {
                             return Promise.all(storageKeys.map(function (storageKey) { return wrapper.del(storageKey); }));
                         }).then(function () { return wrapper.set(keys.buildHashKey(), currentHash); });

package/esm/utils/Semver.js

@@ -0,0 +1,100 @@
+import { isString } from '../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 (!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;
+}());
+export { Semver };

package/esm/utils/labels/index.js

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

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

@@ -1,7 +1,7 @@
 import { Logger, LogLevels } from '../../../logger';
 import { getLogLevel } from './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 = LogLevels.NONE;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@splitsoftware/splitio-commons",
-  "version": "1.13.2-rc.1",
+  "version": "1.13.2-rc.11",
   "description": "Split JavaScript SDK common components",
   "main": "cjs/index.js",
   "module": "esm/index.js",
@@ -63,7 +63,6 @@
     "@typescript-eslint/eslint-plugin": "^6.6.0",
     "@typescript-eslint/parser": "^6.6.0",
     "cross-env": "^7.0.2",
-    "csv-streamify": "^4.0.0",
     "eslint": "^8.48.0",
     "eslint-plugin-compat": "^4.2.0",
     "eslint-plugin-import": "^2.25.3",

package/src/dtos/types.ts

@@ -17,6 +17,11 @@ export interface IBetweenMatcherData {
   end: number
 }
 
+export interface IBetweenStringMatcherData {
+  start: string
+  end: string
+}
+
 export interface IWhitelistMatcherData {
   whitelist: string[]
 }
@@ -44,6 +49,7 @@ interface ISplitMatcherBase {
   dependencyMatcherData?: null | IDependencyMatcherData
   booleanMatcherData?: null | boolean
   stringMatcherData?: null | string
+  betweenStringMatcherData?: null | IBetweenStringMatcherData
 }
 
 interface IAllKeysMatcher extends ISplitMatcherBase {
@@ -130,9 +136,36 @@ interface IMatchesStringMatcher extends ISplitMatcherBase {
   stringMatcherData: string
 }
 
+interface IEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+interface IGreaterThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'GREATER_THAN_OR_EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+
+interface ILessThanOrEqualToSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'LESS_THAN_OR_EQUAL_TO_SEMVER',
+  stringMatcherData: string
+}
+
+interface IBetweenSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'BETWEEN_SEMVER'
+  betweenStringMatcherData: IBetweenStringMatcherData
+}
+
+interface IInListSemverMatcher extends ISplitMatcherBase {
+  matcherType: 'IN_LIST_SEMVER',
+  whitelistMatcherData: IWhitelistMatcherData
+}
+
 export type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher |
   ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher |
-  IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher
+  IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher |
+  IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher
 
 /** Split object */
 export interface ISplitPartition {

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 flag uses segments or dependencies, evaluation is thenable
     if (thenable(evaluation)) {
       return evaluation.then(result => {
         result.changeNumber = split.getChangeNumber();

package/src/evaluator/matchers/between.ts

@@ -2,7 +2,7 @@ import { IBetweenMatcherData } from '../../dtos/types';
 import { ENGINE_MATCHER_BETWEEN } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) /*: Function */ {
+export function betweenMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData) {
   return function betweenMatcher(runtimeAttr: number): boolean {
 
     let isBetween = runtimeAttr >= ruleVO.start && runtimeAttr <= ruleVO.end;

package/src/evaluator/matchers/boolean.ts

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

package/src/evaluator/matchers/cont_all.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function containsAllSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAllMatcher(runtimeAttr: string[]): boolean {
     let containsAll = true;
 

package/src/evaluator/matchers/cont_any.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function containsAnySetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsAnyMatcher(runtimeAttr: string[]): boolean {
     let containsAny = false;
 

package/src/evaluator/matchers/cont_str.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function containsStringMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function containsStringMatcher(runtimeAttr: string): boolean {
     let contains = ruleAttr.some(e => isString(runtimeAttr) && runtimeAttr.indexOf(e) > -1);
 

package/src/evaluator/matchers/eq.ts

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

package/src/evaluator/matchers/eq_set.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function equalToSetMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function equalToSetMatcher(runtimeAttr: string[]): boolean {
     // Length being the same is the first condition.
     let isEqual = runtimeAttr.length === ruleAttr.length;

package/src/evaluator/matchers/ew.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function endsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function endsWithMatcher(runtimeAttr: string): boolean {
     let strEndsWith = ruleAttr.some(e => endsWith(runtimeAttr, e));
 

package/src/evaluator/matchers/gte.ts

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

package/src/evaluator/matchers/index.ts

@@ -15,29 +15,39 @@ 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';
 
 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
+  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
 ];
 
 /**

package/src/evaluator/matchers/lte.ts

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

package/src/evaluator/matchers/matcherTypes.ts

@@ -16,7 +16,12 @@ export const matcherTypes: Record<string, number> = {
   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 const matcherDataTypes = {

package/src/evaluator/matchers/part_of.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function partOfSetMatcherContext(log: ILogger, 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;

package/src/evaluator/matchers/semver_between.ts

@@ -0,0 +1,16 @@
+import { IBetweenStringMatcherData } from '../../dtos/types';
+import { ILogger } from '../../logger/types';
+import { Semver } from '../../utils/Semver';
+
+export function betweenSemverMatcherContext(log: ILogger, 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

@@ -0,0 +1,14 @@
+import { ILogger } from '../../logger/types';
+import { Semver } from '../../utils/Semver';
+
+export function equalToSemverMatcherContext(log: ILogger, 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

@@ -0,0 +1,14 @@
+import { ILogger } from '../../logger/types';
+import { Semver } from '../../utils/Semver';
+
+export function greaterThanEqualToSemverMatcherContext(log: ILogger, 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;
+  };
+}

package/src/evaluator/matchers/semver_inlist.ts

@@ -0,0 +1,17 @@
+import { _Set } from '../../utils/lang/sets';
+import { ILogger } from '../../logger/types';
+import { Semver } from '../../utils/Semver';
+
+export function inListSemverMatcherContext(log: ILogger, ruleAttr: string[]) {
+  // @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');
+
+  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

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

package/src/evaluator/matchers/string.ts

@@ -1,19 +1,11 @@
-import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
+import { ENGINE_MATCHER_STRING } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
-  return function stringMatcher(runtimeAttr: string): boolean {
-    let re;
-
-    try {
-      re = new RegExp(ruleAttr);
-    } catch (e) {
-      log.debug(ENGINE_MATCHER_STRING_INVALID, [ruleAttr]);
+export function stringMatcherContext(log: ILogger, ruleAttr: string) {
+  const regex = new RegExp(ruleAttr);
 
-      return false;
-    }
-
-    let regexMatches = re.test(runtimeAttr);
+  return function stringMatcher(runtimeAttr: string): boolean {
+    const regexMatches = regex.test(runtimeAttr);
 
     log.debug(ENGINE_MATCHER_STRING, [runtimeAttr, ruleAttr, regexMatches ? 'yes' : 'no']);
 

package/src/evaluator/matchers/sw.ts

@@ -2,7 +2,7 @@ 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[]) /*: Function */ {
+export function startsWithMatcherContext(log: ILogger, ruleAttr: string[]) {
   return function startsWithMatcher(runtimeAttr: string): boolean {
     let matches = ruleAttr.some(e => startsWith(runtimeAttr, e));