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

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,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(key: string): boolean {
+    const runtimeSemver = new Semver(key);
+
+    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,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,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 isLessThenEqual = runtimeSemver.compare(ruleSemver) <= 0;
+
+    return isLessThenEqual;
+  };
+}

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

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/parser/index.ts

@@ -7,10 +7,11 @@ import { ifElseIfCombinerContext } from '../combiners/ifelseif';
 import { andCombinerContext } from '../combiners/and';
 import { thenable } from '../../utils/promise/thenable';
 import { IEvaluator, IMatcherDto, ISplitEvaluator } from '../types';
-import { ISplitCondition } from '../../dtos/types';
+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';
 
 export function parser(log: ILogger, conditions: ISplitCondition[], storage: IStorageSync | IStorageAsync): IEvaluator {
   let predicates = [];
@@ -27,19 +28,30 @@ export function parser(log: ILogger, conditions: ISplitCondition[], storage: ISt
     const matchers = matchersTransform(matcherGroup.matchers);
 
     // create a set of pure functions from the matcher's dto
-    const expressions = matchers.map((matcherDto: IMatcherDto) => {
-      const matcher = matcherFactory(log, matcherDto, storage);
+    const expressions = matchers.map((matcherDto: IMatcherDto, index: number) => {
+      let matcher: ReturnType<typeof matcherFactory>;
+      try {
+        matcher = matcherFactory(log, matcherDto, storage);
+      } catch (error) {
+        log.error(ENGINE_MATCHER_ERROR, [matcherGroup.matchers[index].matcherType, error]);
+      }
 
       // Evaluator function.
       return (key: string, attributes: SplitIO.Attributes | undefined, splitEvaluator: ISplitEvaluator) => {
         const value = sanitizeValue(log, key, matcherDto, attributes);
-        const result = value !== undefined && matcher ? matcher(value, splitEvaluator) : false;
+        let result: MaybeThenable<boolean> = false;
 
-        if (thenable(result)) {
-          // @ts-ignore
-          return result.then(res => Boolean(res ^ matcherDto.negate));
+        if (value !== undefined && matcher) {
+          try {
+            result = matcher(value, splitEvaluator);
+          } catch (error) {
+            log.error(ENGINE_MATCHER_ERROR, [matcherGroup.matchers[index].matcherType, error]);
+          }
         }
-        // @ts-ignore
+
+        if (thenable(result)) { // @ts-ignore
+          return result.then(res => Boolean(res ^ matcherDto.negate));
+        } // @ts-ignore
         return Boolean(result ^ matcherDto.negate);
       };
     });

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/logger/constants.ts

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

package/src/logger/messages/debug.ts

@@ -23,7 +23,6 @@ export const codesDebug: [number, string][] = 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/src/logger/messages/error.ts

@@ -3,6 +3,7 @@ import * as c from '../constants';
 export const codesError: [number, string][] = [
   // evaluator
   [c.ERROR_ENGINE_COMBINER_IFELSEIF, c.LOG_PREFIX_ENGINE_COMBINER + 'Invalid feature flag, no valid rules or unsupported matcher 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/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' } };
@@ -44,16 +44,17 @@ export function splitApiFactory(
     },
 
     fetchAuth(userMatchingKeys?: string[]) {
-      let url = `${urls.auth}/v2/auth?s=${FLAGS_SPEC}`;
-      if (userMatchingKeys) { // `userMatchingKeys` is undefined in server-side
+      let url = `${urls.auth}/v2/auth`;
+      if (userMatchingKeys) { // accounting the possibility that `userMatchingKeys` is undefined (server-side API)
         const queryParams = userMatchingKeys.map(userKeyToQueryParam).join('&');
-        if (queryParams) url += '&' + queryParams;
+        if (queryParams) // accounting the possibility that `userKeys` and thus `queryParams` are empty
+          url += '?' + queryParams;
       }
       return splitHttpClient(url, undefined, telemetryTracker.trackHttp(TOKEN));
     },
 
     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);

package/src/storages/KeyBuilder.ts

@@ -1,5 +1,4 @@
 import { ISettings } from '../types';
-import { FLAGS_SPEC } from '../utils/constants';
 import { startsWith } from '../utils/lang';
 import { hash } from '../utils/murmur3/murmur3';
 
@@ -82,9 +81,9 @@ export class KeyBuilder {
 }
 
 /**
- * Generates a murmur32 hash based on the authorization key, the feature flags filter query, and version of SplitChanges API.
+ * Generates a murmur32 hash based on the authorization key and the feature flags filter query.
  * The hash is in hexadecimal format (8 characters max, 32 bits).
  */
 export function getStorageHash(settings: ISettings) {
-  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}::${FLAGS_SPEC}`).toString(16);
+  return hash(`${settings.core.authorizationKey}::${settings.sync.__splitFiltersValidation.queryString}`).toString(16);
 }

package/src/utils/Semver.ts

@@ -0,0 +1,111 @@
+import { isString } from '../utils/lang';
+
+const NUMERIC_IDENTIFIER_REGEX = /^[0-9]+$/;
+
+const METADATA_DELIMITER = '+';
+const PRERELEASE_DELIMITER = '-';
+const 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: string, b: string): number {
+  if (NUMERIC_IDENTIFIER_REGEX.test(a) && NUMERIC_IDENTIFIER_REGEX.test(b)) {
+    const 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: string): string {
+  return value.replace(/^0+(?=\d)/, '');
+}
+
+function throwError(version: string) {
+  throw new Error('Unable to convert to Semver, incorrect format: ' + version);
+}
+
+export class Semver {
+
+  private readonly _major: string;
+  private readonly _minor: string;
+  private readonly _patch: string;
+  private readonly _preRelease: string[];
+  private readonly _isStable: boolean;
+
+  // Version string for 'equal' and 'in list' comparisons
+  public readonly version: string;
+
+  public constructor(version: string) {
+    if (!isString(version)) throwError(version);
+
+    // Separate metadata if exists
+    let index = version.indexOf(METADATA_DELIMITER);
+    let [vWithoutMetadata, metadata] = index === -1 ? [version] : [version.slice(0, index), version.slice(index + 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((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
+    const vParts = vWithoutMetadata.split(VALUE_DELIMITER).map((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`
+   */
+  public compare(toCompare: Semver): number {
+    if (this.version === toCompare.version) return 0;
+
+    let 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 (let i = 0, length = Math.min(this._preRelease.length, toCompare._preRelease.length); i < length; i++) {
+      const result = compareStrings(this._preRelease[i], toCompare._preRelease[i]);
+      if (result !== 0) return result;
+    }
+
+    return this._preRelease.length - toCompare._preRelease.length;
+  }
+}

package/src/utils/constants/index.ts

@@ -104,5 +104,3 @@ export const NON_REQUESTED = 1;
 export const DISABLED = 0;
 export const ENABLED = 1;
 export const PAUSED = 2;
-
-export const FLAGS_SPEC = '1.1';

package/src/utils/settingsValidation/logger/pluggableLogger.ts

@@ -4,7 +4,7 @@ import { LogLevel } from '../../../types';
 import { getLogLevel } from './commons';
 
 function isLogger(log: any): log is ILogger {
-  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.

package/types/dtos/types.d.ts

@@ -11,6 +11,10 @@ export interface IBetweenMatcherData {
     start: number;
     end: number;
 }
+export interface IBetweenStringMatcherData {
+    start: string;
+    end: string;
+}
 export interface IWhitelistMatcherData {
     whitelist: string[];
 }
@@ -35,6 +39,7 @@ interface ISplitMatcherBase {
     dependencyMatcherData?: null | IDependencyMatcherData;
     booleanMatcherData?: null | boolean;
     stringMatcherData?: null | string;
+    betweenStringMatcherData?: null | IBetweenStringMatcherData;
 }
 interface IAllKeysMatcher extends ISplitMatcherBase {
     matcherType: 'ALL_KEYS';
@@ -103,7 +108,27 @@ interface IMatchesStringMatcher extends ISplitMatcherBase {
     matcherType: 'MATCHES_STRING';
     stringMatcherData: string;
 }
-export declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher;
+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 declare type ISplitMatcher = IAllKeysMatcher | IInSegmentMatcher | IWhitelistMatcher | IEqualToMatcher | IGreaterThanOrEqualToMatcher | ILessThanOrEqualToMatcher | IBetweenMatcher | IEqualToSetMatcher | IContainsAnyOfSetMatcher | IContainsAllOfSetMatcher | IPartOfSetMatcher | IStartsWithMatcher | IEndsWithMatcher | IContainsStringMatcher | IInSplitTreatmentMatcher | IEqualToBooleanMatcher | IMatchesStringMatcher | IEqualToSemverMatcher | IGreaterThanOrEqualToSemverMatcher | ILessThanOrEqualToSemverMatcher | IBetweenSemverMatcher | IInListSemverMatcher;
 /** Split object */
 export interface ISplitPartition {
     treatment: string;

package/types/evaluator/matchers/semver_between.d.ts

@@ -1,3 +1,3 @@
-import { IBetweenMatcherData } from '../../dtos/types';
+import { IBetweenStringMatcherData } from '../../dtos/types';
 import { ILogger } from '../../logger/types';
-export declare function betweenSemverMatcherContext(log: ILogger, ruleVO: IBetweenMatcherData): (key: string) => boolean;
+export declare function betweenSemverMatcherContext(log: ILogger, ruleAttr: IBetweenStringMatcherData): (key: string) => boolean;

package/types/evaluator/matchers/semver_inlist.d.ts

@@ -0,0 +1,3 @@
+import { ISet } from '../../utils/lang/sets';
+import { ILogger } from '../../logger/types';
+export declare function inListSemverMatcherContext(log: ILogger, ruleAttr: ISet<string>): (runtimeAttr: string) => boolean;

package/types/evaluator/matchersTransform/string.d.ts

@@ -0,0 +1,7 @@
+import { ISplitMatcher } from '../../dtos/types';
+/**
+ * Extract value from string matcher data.
+ */
+export declare function stringTransform({ stringMatcherData }: ISplitMatcher): {
+    value: string | null | undefined;
+};

package/types/evaluator/types.d.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';
@@ -9,7 +9,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;
     dataType: string;