Evaluate targeting rules with semver string format (FF-1433) (#38)

* Evaluate targeting rules with semver string format (FF-1433)

* anon func

* bump to v2.2.0

Author: leoromanovsky

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eppo/js-client-sdk-common",
-  "version": "2.1.1",
+  "version": "2.2.0",
   "description": "Eppo SDK for client-side JavaScript applications (base for both web and react native)",
   "main": "dist/index.js",
   "files": [
@@ -41,6 +41,7 @@
   "devDependencies": {
     "@types/jest": "^29.5.11",
     "@types/md5": "^2.3.2",
+    "@types/semver": "^7.5.6",
     "@typescript-eslint/eslint-plugin": "^5.13.0",
     "@typescript-eslint/parser": "^5.13.0",
     "eslint": "^8.17.0",
@@ -65,6 +66,7 @@
   "dependencies": {
     "axios": "^1.6.0",
     "lru-cache": "^10.0.1",
-    "md5": "^2.3.0"
+    "md5": "^2.3.0",
+    "semver": "^7.5.4"
   }
 }

src/dto/rule-dto.ts

@@ -8,6 +8,13 @@ export enum OperatorType {
   NOT_ONE_OF = 'NOT_ONE_OF',
 }
 
+export enum OperatorValueType {
+  PLAIN_STRING = 'PLAIN_STRING',
+  STRING_ARRAY = 'STRING_ARRAY',
+  SEM_VER = 'SEM_VER',
+  NUMERIC = 'NUMERIC',
+}
+
 export interface Condition {
   operator: OperatorType;
   attribute: string;

src/rule_evaluator.spec.ts

@@ -21,6 +21,21 @@ describe('findMatchingRule', () => {
       },
     ],
   };
+  const semverRule: IRule = {
+    allocationKey: 'test',
+    conditions: [
+      {
+        operator: OperatorType.GTE,
+        attribute: 'version',
+        value: '1.0.0',
+      },
+      {
+        operator: OperatorType.LTE,
+        attribute: 'version',
+        value: '2.0.0',
+      },
+    ],
+  };
   const ruleWithMatchesCondition: IRule = {
     allocationKey: 'test',
     conditions: [
@@ -47,6 +62,13 @@ describe('findMatchingRule', () => {
     expect(findMatchingRule({ totalSales: 100 }, rules, false)).toEqual(numericRule);
   });
 
+  it('returns the rule for semver conditions', () => {
+    const rules = [semverRule];
+    expect(findMatchingRule({ version: '1.1.0' }, rules, false)).toEqual(semverRule);
+    expect(findMatchingRule({ version: '2.0.0' }, rules, false)).toEqual(semverRule);
+    expect(findMatchingRule({ version: '2.1.0' }, rules, false)).toBeNull();
+  });
+
   it('returns null if there is no attribute for the condition', () => {
     const rules = [numericRule];
     expect(findMatchingRule({ unknown: 'test' }, rules, false)).toEqual(null);

src/rule_evaluator.ts

@@ -1,5 +1,13 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { Condition, OperatorType, IRule } from './dto/rule-dto';
+import {
+  valid as validSemver,
+  gt as semverGt,
+  lt as semverLt,
+  gte as semverGte,
+  lte as semverLte,
+} from 'semver';
+
+import { Condition, OperatorType, IRule, OperatorValueType } from './dto/rule-dto';
 import { decodeBase64, getMD5Hash } from './obfuscation';
 
 export function findMatchingRule(
@@ -42,15 +50,30 @@ function evaluateRuleConditions(
 
 function evaluateCondition(subjectAttributes: Record<string, any>, condition: Condition): boolean {
   const value = subjectAttributes[condition.attribute];
+
+  const conditionValueType = targetingRuleConditionValuesTypesFromValues(condition.value);
+
   if (value != null) {
     switch (condition.operator) {
       case OperatorType.GTE:
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, condition.value, semverGte);
+        }
         return compareNumber(value, condition.value, (a, b) => a >= b);
       case OperatorType.GT:
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, condition.value, semverGt);
+        }
         return compareNumber(value, condition.value, (a, b) => a > b);
       case OperatorType.LTE:
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, condition.value, semverLte);
+        }
         return compareNumber(value, condition.value, (a, b) => a <= b);
       case OperatorType.LT:
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, condition.value, semverLt);
+        }
         return compareNumber(value, condition.value, (a, b) => a < b);
       case OperatorType.MATCHES:
         return new RegExp(condition.value as string).test(value as string);
@@ -78,15 +101,29 @@ function evaluateObfuscatedCondition(
     {},
   );
   const value = hashedSubjectAttributes[condition.attribute];
+  const conditionValueType = targetingRuleConditionValuesTypesFromValues(value);
+
   if (value != null) {
     switch (condition.operator) {
       case getMD5Hash(OperatorType.GTE):
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, decodeBase64(condition.value), semverGte);
+        }
         return compareNumber(value, Number(decodeBase64(condition.value)), (a, b) => a >= b);
       case getMD5Hash(OperatorType.GT):
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, decodeBase64(condition.value), semverGt);
+        }
         return compareNumber(value, Number(decodeBase64(condition.value)), (a, b) => a > b);
       case getMD5Hash(OperatorType.LTE):
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, decodeBase64(condition.value), semverLte);
+        }
         return compareNumber(value, Number(decodeBase64(condition.value)), (a, b) => a <= b);
       case getMD5Hash(OperatorType.LT):
+        if (conditionValueType === OperatorValueType.SEM_VER) {
+          return compareSemVer(value, decodeBase64(condition.value), semverLt);
+        }
         return compareNumber(value, Number(decodeBase64(condition.value)), (a, b) => a < b);
       case getMD5Hash(OperatorType.MATCHES):
         return new RegExp(decodeBase64(condition.value)).test(value as string);
@@ -115,10 +152,48 @@ function compareNumber(
   attributeValue: any,
   conditionValue: any,
   compareFn: (a: number, b: number) => boolean,
-) {
+): boolean {
   return (
     typeof attributeValue === 'number' &&
     typeof conditionValue === 'number' &&
     compareFn(attributeValue, conditionValue)
   );
 }
+
+function compareSemVer(
+  attributeValue: any,
+  conditionValue: any,
+  compareFn: (a: string, b: string) => boolean,
+): boolean {
+  return (
+    !!validSemver(attributeValue) &&
+    !!validSemver(conditionValue) &&
+    compareFn(attributeValue, conditionValue)
+  );
+}
+
+function targetingRuleConditionValuesTypesFromValues(
+  value: number | string | string[],
+): OperatorValueType {
+  // Check if input is a number
+  if (typeof value === 'number') {
+    return OperatorValueType.NUMERIC;
+  }
+
+  if (Array.isArray(value)) {
+    return OperatorValueType.STRING_ARRAY;
+  }
+
+  // Check if input is a string that represents a SemVer
+  if (validSemver(value)) {
+    return OperatorValueType.SEM_VER;
+  }
+
+  // Check if input is a string that represents a number
+  if (!isNaN(Number(value))) {
+    return OperatorValueType.NUMERIC;
+  }
+
+  // If none of the above, it's a general string
+  return OperatorValueType.PLAIN_STRING;
+}

yarn.lock

@@ -786,6 +786,11 @@
   dependencies:
     undici-types "~5.26.4"
 
+"@types/semver@^7.5.6":
+  version "7.5.6"
+  resolved "https://registry.yarnpkg.com/@types/semver/-/semver-7.5.6.tgz#c65b2bfce1bec346582c07724e3f8c1017a20339"
+  integrity sha512-dn1l8LaMea/IjDoHNd9J52uBbInB796CDffS6VdIxvqYCPSG0V0DzHp76GpaWnlhg88uYyPbXCDIowa86ybd5A==
+
 "@types/stack-utils@^2.0.0":
   version "2.0.3"
   resolved "https://registry.yarnpkg.com/@types/stack-utils/-/stack-utils-2.0.3.tgz#6209321eb2c1712a7e7466422b8cb1fc0d9dd5d8"