Merge pull request #305 from splitio/baseline_semver

Baseline - Semver matchers

Author: EmilianoSanchez

CHANGES.txt

@@ -1,5 +1,7 @@
-1.14.0 (April XX, 2024)
- - Updated impression label to 'unsupported matcher type' when the matcher type is not supported by the SDK.
+1.14.0 (May 6, 2024)
+ - Added support for targeting rules based on semantic versions (https://semver.org/).
+ - Added special impression label "targeting rule type unsupported by sdk" when the matcher type is not supported by the SDK, which returns 'control' treatment.
+ - Updated Split API client to include the flags spec version query parameter for the `splitChanges` and `auth` endpoints.
 
 1.13.1 (January 10, 2024)
  - Updated client `destroy` method to release SDK key immediately and avoid unexpected warning logs when a factory is created with the same SDK key after the previous one was destroyed.

package-lock.json

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

package.json

@@ -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 {

src/dtos/types.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;
   }
 }
-

src/evaluator/Engine.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { evaluateFeature } from '../index';
-import * as LabelsConstants from '../../utils/labels';
+import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 
 const splitsMock = {
@@ -28,7 +28,7 @@ const mockStorage = {
 test('EVALUATOR / should return label exception, treatment control and config null on error', async function () {
   const expectedOutput = {
     treatment: 'control',
-    label: LabelsConstants.EXCEPTION,
+    label: EXCEPTION,
     config: null
   };
   const evaluationPromise = evaluateFeature(
@@ -52,7 +52,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     config: '{color:\'black\'}', changeNumber: 1487277320548
   };
   const expectedOutputControl = {
-    treatment: 'control', label: LabelsConstants.SPLIT_NOT_FOUND, config: null
+    treatment: 'control', label: SPLIT_NOT_FOUND, config: null
   };
 
   const evaluationWithConfig = evaluateFeature(
@@ -89,7 +89,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationKilled).toEqual({ ...expectedOutput, treatment: 'off', config: null, label: LabelsConstants.SPLIT_KILLED });
+  expect(evaluationKilled).toEqual({ ...expectedOutput, treatment: 'off', config: null, label: SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   const evaluationArchived = evaluateFeature(
@@ -99,7 +99,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationArchived).toEqual({ ...expectedOutput, treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
+  expect(evaluationArchived).toEqual({ ...expectedOutput, treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   const evaluationtrafficAlocation1 = evaluateFeature(
@@ -109,7 +109,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationtrafficAlocation1).toEqual({ ...expectedOutput, label: LabelsConstants.NOT_IN_SPLIT, config: null, treatment: 'off' });
+  expect(evaluationtrafficAlocation1).toEqual({ ...expectedOutput, label: NOT_IN_SPLIT, config: null, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
 
   const evaluationKilledWithConfig = evaluateFeature(
@@ -119,7 +119,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationKilledWithConfig).toEqual({ ...expectedOutput, treatment: 'off', label: LabelsConstants.SPLIT_KILLED });
+  expect(evaluationKilledWithConfig).toEqual({ ...expectedOutput, treatment: 'off', label: SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   const evaluationArchivedWithConfig = evaluateFeature(
@@ -129,7 +129,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationArchivedWithConfig).toEqual({ ...expectedOutput, treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
+  expect(evaluationArchivedWithConfig).toEqual({ ...expectedOutput, treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   const evaluationtrafficAlocation1WithConfig = evaluateFeature(
@@ -139,7 +139,7 @@ test('EVALUATOR / should return right label, treatment and config if storage ret
     null,
     mockStorage,
   );
-  expect(evaluationtrafficAlocation1WithConfig).toEqual({ ...expectedOutput, label: LabelsConstants.NOT_IN_SPLIT, treatment: 'off' });
+  expect(evaluationtrafficAlocation1WithConfig).toEqual({ ...expectedOutput, label: NOT_IN_SPLIT, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
 
 });

src/evaluator/__tests__/evaluate-feature.spec.ts

@@ -1,6 +1,6 @@
 // @ts-nocheck
 import { evaluateFeatures, evaluateFeaturesByFlagSets } from '../index';
-import * as LabelsConstants from '../../utils/labels';
+import { EXCEPTION, NOT_IN_SPLIT, SPLIT_ARCHIVED, SPLIT_KILLED, SPLIT_NOT_FOUND } from '../../utils/labels';
 import { loggerMock } from '../../logger/__tests__/sdkLogger.mock';
 import { _Set } from '../../utils/lang/sets';
 import { WARN_FLAGSET_WITHOUT_FLAGS } from '../../logger/constants';
@@ -47,7 +47,7 @@ test('EVALUATOR - Multiple evaluations at once  / should return label exception,
   const expectedOutput = {
     throw_exception: {
       treatment: 'control',
-      label: LabelsConstants.EXCEPTION,
+      label: EXCEPTION,
       config: null
     }
   };
@@ -73,7 +73,7 @@ test('EVALUATOR - Multiple evaluations at once / should return right labels, tre
       config: '{color:\'black\'}', changeNumber: 1487277320548
     },
     not_existent_split: {
-      treatment: 'control', label: LabelsConstants.SPLIT_NOT_FOUND, config: null
+      treatment: 'control', label: SPLIT_NOT_FOUND, config: null
     },
   };
 
@@ -91,27 +91,27 @@ test('EVALUATOR - Multiple evaluations at once / should return right labels, tre
   // assert regular
   expect(multipleEvaluationAtOnce['regular']).toEqual({ ...expectedOutput['config'], config: null }); // If the split is retrieved successfully we should get the right evaluation result, label and config. If Split has no config it should have config equal null.
   // assert killed
-  expect(multipleEvaluationAtOnce['killed']).toEqual({ ...expectedOutput['config'], treatment: 'off', config: null, label: LabelsConstants.SPLIT_KILLED });
+  expect(multipleEvaluationAtOnce['killed']).toEqual({ ...expectedOutput['config'], treatment: 'off', config: null, label: SPLIT_KILLED });
   // 'If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   // assert archived
-  expect(multipleEvaluationAtOnce['archived']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
+  expect(multipleEvaluationAtOnce['archived']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   // assert trafficAllocation1
-  expect(multipleEvaluationAtOnce['trafficAlocation1']).toEqual({ ...expectedOutput['config'], label: LabelsConstants.NOT_IN_SPLIT, config: null, treatment: 'off' });
+  expect(multipleEvaluationAtOnce['trafficAlocation1']).toEqual({ ...expectedOutput['config'], label: NOT_IN_SPLIT, config: null, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
 
   // assert killedWithConfig
-  expect(multipleEvaluationAtOnce['killedWithConfig']).toEqual({ ...expectedOutput['config'], treatment: 'off', label: LabelsConstants.SPLIT_KILLED });
+  expect(multipleEvaluationAtOnce['killedWithConfig']).toEqual({ ...expectedOutput['config'], treatment: 'off', label: SPLIT_KILLED });
   // If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
   // assert archivedWithConfig
-  expect(multipleEvaluationAtOnce['archivedWithConfig']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
+  expect(multipleEvaluationAtOnce['archivedWithConfig']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: SPLIT_ARCHIVED, config: null });
   // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
   // assert trafficAlocation1WithConfig
-  expect(multipleEvaluationAtOnce['trafficAlocation1WithConfig']).toEqual({ ...expectedOutput['config'], label: LabelsConstants.NOT_IN_SPLIT, treatment: 'off' });
+  expect(multipleEvaluationAtOnce['trafficAlocation1WithConfig']).toEqual({ ...expectedOutput['config'], label: NOT_IN_SPLIT, treatment: 'off' });
   // If the split is retrieved but is not in split (out of Traffic Allocation), we should get the right evaluation result, label and config.
 
 });
@@ -124,7 +124,7 @@ describe('EVALUATOR - Multiple evaluations at once by flag sets', () => {
       config: '{color:\'black\'}', changeNumber: 1487277320548
     },
     not_existent_split: {
-      treatment: 'control', label: LabelsConstants.SPLIT_NOT_FOUND, config: null
+      treatment: 'control', label: SPLIT_NOT_FOUND, config: null
     },
   };
 
@@ -150,11 +150,11 @@ describe('EVALUATOR - Multiple evaluations at once by flag sets', () => {
     // assert regular
     expect(multipleEvaluationAtOnceByFlagSets['regular']).toEqual({ ...expectedOutput['config'], config: null }); // If the split is retrieved successfully we should get the right evaluation result, label and config. If Split has no config it should have config equal null.
     // assert killed
-    expect(multipleEvaluationAtOnceByFlagSets['killed']).toEqual({ ...expectedOutput['config'], treatment: 'off', config: null, label: LabelsConstants.SPLIT_KILLED });
+    expect(multipleEvaluationAtOnceByFlagSets['killed']).toEqual({ ...expectedOutput['config'], treatment: 'off', config: null, label: SPLIT_KILLED });
     // 'If the split is retrieved but is killed, we should get the right evaluation result, label and config.
 
     // assert archived
-    expect(multipleEvaluationAtOnceByFlagSets['archived']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: LabelsConstants.SPLIT_ARCHIVED, config: null });
+    expect(multipleEvaluationAtOnceByFlagSets['archived']).toEqual({ ...expectedOutput['config'], treatment: 'control', label: SPLIT_ARCHIVED, config: null });
     // If the split is retrieved but is archived, we should get the right evaluation result, label and config.
 
     // assert not_existent_split not in evaluation if it is not related to defined flag sets

src/evaluator/__tests__/evaluate-features.spec.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
     };
   }
 

src/evaluator/combiners/ifelseif.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
       };
     }
 

src/evaluator/condition/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,15 +143,15 @@ function getEvaluation(
 ): MaybeThenable<IEvaluationResult> {
   let evaluation: MaybeThenable<IEvaluationResult> = {
     treatment: CONTROL,
-    label: LabelsConstants.SPLIT_NOT_FOUND,
+    label: SPLIT_NOT_FOUND,
     config: null
   };
 
   if (splitJSON) {
     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();