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

package/esm/utils/Semver.js

@@ -0,0 +1,97 @@
+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) {
+        // 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/constants/index.js

@@ -86,4 +86,3 @@ export var NON_REQUESTED = 1;
 export var DISABLED = 0;
 export var ENABLED = 1;
 export var PAUSED = 2;
-export var FLAGS_SPEC = '1.1';

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.3",
   "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/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,7 +1,7 @@
 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;
 

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,18 @@
+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(key: string): boolean {
+
+    const runtimeSemver = new Semver(key);
+
+    let isBetween = startSemver.compare(runtimeSemver) <= 0 && endSemver.compare(runtimeSemver) >= 0;
+
+    return isBetween;
+  };
+}

package/src/evaluator/matchers/semver_eq.ts

@@ -0,0 +1,13 @@
+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 isEqual = ruleSemver.version === new Semver(runtimeAttr).version;
+
+    return isEqual;
+  };
+}

package/src/evaluator/matchers/semver_gte.ts

@@ -0,0 +1,13 @@
+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 {
+    let isGreaterThanEqual = new Semver(runtimeAttr).compare(ruleSemver) >= 0;
+
+    return isGreaterThanEqual;
+  };
+}

package/src/evaluator/matchers/semver_inlist.ts

@@ -0,0 +1,15 @@
+import { setToArray, ISet, _Set } from '../../utils/lang/sets';
+import { ILogger } from '../../logger/types';
+import { Semver } from '../../utils/Semver';
+
+export function inListSemverMatcherContext(log: ILogger, ruleAttr: ISet<string>) {
+
+  const listOfSemvers = new _Set(setToArray(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,13 @@
+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 {
+    let isLessThenEqual = new Semver(runtimeAttr).compare(ruleSemver) <= 0;
+
+    return isLessThenEqual;
+  };
+}

package/src/evaluator/matchers/string.ts

@@ -1,7 +1,7 @@
 import { ENGINE_MATCHER_STRING_INVALID, ENGINE_MATCHER_STRING } from '../../logger/constants';
 import { ILogger } from '../../logger/types';
 
-export function stringMatcherContext(log: ILogger, ruleAttr: string) /*: Function */ {
+export function stringMatcherContext(log: ILogger, ruleAttr: string) {
   return function stringMatcher(runtimeAttr: string): boolean {
     let re;
 

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));
 

package/src/evaluator/matchers/whitelist.ts

@@ -2,7 +2,7 @@ import { setToArray, ISet } from '../../utils/lang/sets';
 import { ILogger } from '../../logger/types';
 import { ENGINE_MATCHER_WHITELIST } from '../../logger/constants';
 
-export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) /*: Function */ {
+export function whitelistMatcherContext(log: ILogger, ruleAttr: ISet<string>) {
   return function whitelistMatcher(runtimeAttr: string): boolean {
     let isInWhitelist = ruleAttr.has(runtimeAttr);
 

package/src/evaluator/matchersTransform/index.ts

@@ -15,16 +15,17 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
 
   let parsedMatchers = matchers.map(matcher => {
     let {
-      matcherType                                   /* string */,
-      negate                                        /* boolean */,
-      keySelector                                   /* keySelectorObject */,
-      userDefinedSegmentMatcherData: segmentObject  /* segmentObject */,
-      whitelistMatcherData: whitelistObject         /* whiteListObject, provided by 'WHITELIST', set and string matchers */,
-      unaryNumericMatcherData: unaryNumericObject   /* unaryNumericObject */,
-      betweenMatcherData: betweenObject             /* betweenObject */,
-      dependencyMatcherData: dependencyObject       /* dependencyObject */,
+      matcherType,
+      negate,
+      keySelector,
+      userDefinedSegmentMatcherData,
+      whitelistMatcherData, /* whitelistObject, provided by 'WHITELIST', 'IN_LIST_SEMVER', set and string matchers */
+      unaryNumericMatcherData,
+      betweenMatcherData,
+      dependencyMatcherData,
       booleanMatcherData,
-      stringMatcherData
+      stringMatcherData,
+      betweenStringMatcherData
     } = matcher;
 
     let attribute = keySelector && keySelector.attribute;
@@ -34,28 +35,31 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
     let value = undefined;
 
     if (type === matcherTypes.IN_SEGMENT) {
-      value = segmentTransform(segmentObject as IInSegmentMatcherData);
-    } else if (type === matcherTypes.WHITELIST) {
-      value = whitelistTransform(whitelistObject as IWhitelistMatcherData);
+      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(unaryNumericObject as IUnaryNumericMatcherData);
+      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;
 
-      if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
+      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).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 as IUnaryNumericMatcherData);
+      value = numericTransform(unaryNumericMatcherData as IUnaryNumericMatcherData);
       dataType = matcherDataTypes.NUMBER;
 
-      if ((unaryNumericObject as IUnaryNumericMatcherData).dataType === 'DATETIME') {
+      if ((unaryNumericMatcherData as IUnaryNumericMatcherData).dataType === 'DATETIME') {
         value = zeroSinceSS(value);
         dataType = matcherDataTypes.DATETIME;
       }
     } else if (type === matcherTypes.BETWEEN) {
-      value = betweenObject as IBetweenMatcherData;
+      value = betweenMatcherData as IBetweenMatcherData;
       dataType = matcherDataTypes.NUMBER;
 
       if (value.dataType === 'DATETIME') {
@@ -63,27 +67,34 @@ export function matchersTransform(matchers: ISplitMatcher[]): IMatcherDto[] {
         value.end = zeroSinceSS(value.end);
         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 as IWhitelistMatcherData);
+      value = setTransform(whitelistMatcherData as IWhitelistMatcherData);
       dataType = matcherDataTypes.SET;
     } else if (
       type === matcherTypes.STARTS_WITH ||
       type === matcherTypes.ENDS_WITH ||
       type === matcherTypes.CONTAINS_STRING
     ) {
-      value = setTransform(whitelistObject as IWhitelistMatcherData);
+      value = setTransform(whitelistMatcherData as IWhitelistMatcherData);
     } 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;
     }
 

package/src/evaluator/types.ts

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

package/src/services/splitApi.ts

@@ -4,7 +4,7 @@ import { splitHttpClientFactory } from './splitHttpClient';
 import { ISplitApi } from './types';
 import { objectAssign } from '../utils/lang/objectAssign';
 import { ITelemetryTracker } from '../trackers/types';
-import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT, FLAGS_SPEC } from '../utils/constants';
+import { SPLITS, IMPRESSIONS, IMPRESSIONS_COUNT, EVENTS, TELEMETRY, TOKEN, SEGMENT, MY_SEGMENT } from '../utils/constants';
 import { ERROR_TOO_MANY_SETS } from '../logger/constants';
 
 const noCacheHeaderOptions = { headers: { 'Cache-Control': 'no-cache' } };
@@ -54,7 +54,7 @@ export function splitApiFactory(
     },
 
     fetchSplitChanges(since: number, noCache?: boolean, till?: number) {
-      const url = `${urls.sdk}/splitChanges?s=${FLAGS_SPEC}&since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
+      const url = `${urls.sdk}/splitChanges?since=${since}${till ? '&till=' + till : ''}${filterQueryString || ''}`;
       return splitHttpClient(url, noCache ? noCacheHeaderOptions : undefined, telemetryTracker.trackHttp(SPLITS))
         .catch((err) => {
           if (err.statusCode === 414) settings.log.error(ERROR_TOO_MANY_SETS);