More cleanup

Author: vincent-derks

packages/vercel-flags-core/src/evaluate.test.ts

@@ -1813,6 +1813,94 @@ describe('evaluate', () => {
       entities: { user: { id: null } },
       result: false,
     },
+
+    // ---- ci flag is ignored for non-string comparators ----
+
+    {
+      name: `${Comparator.EXISTS} ci ignored (still matches)`,
+      condition: [['user', 'id'], Comparator.EXISTS, undefined, { ci: true }],
+      entities: { user: { id: 'uid1' } },
+      result: true,
+    },
+    {
+      name: `${Comparator.NOT_EXISTS} ci ignored (still matches)`,
+      condition: [
+        ['user', 'id'],
+        Comparator.NOT_EXISTS,
+        undefined,
+        { ci: true },
+      ],
+      entities: { user: {} },
+      result: true,
+    },
+    {
+      name: `${Comparator.GT} ci ignored (numeric comparison unchanged)`,
+      condition: [['user', 'age'], Comparator.GT, 20, { ci: true }],
+      entities: { user: { age: 30 } },
+      result: true,
+    },
+    {
+      name: `${Comparator.LT} ci ignored (numeric comparison unchanged)`,
+      condition: [['user', 'age'], Comparator.LT, 40, { ci: true }],
+      entities: { user: { age: 30 } },
+      result: true,
+    },
+    {
+      name: `${Comparator.GTE} ci ignored (numeric comparison unchanged)`,
+      condition: [['user', 'age'], Comparator.GTE, 30, { ci: true }],
+      entities: { user: { age: 30 } },
+      result: true,
+    },
+    {
+      name: `${Comparator.LTE} ci ignored (numeric comparison unchanged)`,
+      condition: [['user', 'age'], Comparator.LTE, 30, { ci: true }],
+      entities: { user: { age: 30 } },
+      result: true,
+    },
+    {
+      name: `${Comparator.REGEX} ci ignored (uses raw values)`,
+      condition: [
+        ['user', 'id'],
+        Comparator.REGEX,
+        { type: 'regex', pattern: '^joe', flags: '' },
+        { ci: true },
+      ],
+      entities: { user: { id: 'joewilkinson' } },
+      result: true,
+    },
+    {
+      name: `${Comparator.NOT_REGEX} ci ignored (uses raw values)`,
+      condition: [
+        ['user', 'id'],
+        Comparator.NOT_REGEX,
+        { type: 'regex', pattern: '^joe', flags: '' },
+        { ci: true },
+      ],
+      entities: { user: { id: 'joewilkinson' } },
+      result: false,
+    },
+    {
+      name: `${Comparator.BEFORE} ci ignored (date comparison unchanged)`,
+      condition: [
+        ['user', 'createdAt'],
+        Comparator.BEFORE,
+        '2025-01-02',
+        { ci: true },
+      ],
+      entities: { user: { createdAt: '2025-01-01' } },
+      result: true,
+    },
+    {
+      name: `${Comparator.AFTER} ci ignored (date comparison unchanged)`,
+      condition: [
+        ['user', 'createdAt'],
+        Comparator.AFTER,
+        '2024-12-31',
+        { ci: true },
+      ],
+      entities: { user: { createdAt: '2025-01-01' } },
+      result: true,
+    },
   ])('should evaluate comparator $name', ({ condition, entities, result }) => {
     expect(
       evaluate({

packages/vercel-flags-core/src/evaluate.ts

@@ -8,10 +8,10 @@ import {
   ResolutionReason,
 } from './types';
 
-const MAX_REGEX_INPUT_LENGTH = 10_000;
-
 type PathArray = (string | number)[];
 
+const MAX_REGEX_INPUT_LENGTH = 10_000;
+
 function exhaustivenessCheck(_: never): never {
   throw new Error('Exhaustiveness check failed');
 }
@@ -154,19 +154,23 @@ function matchConditions<T>(
         case Comparator.ONE_OF:
           return isArray(rhs) && rhs.includes(lhs);
         case Comparator.NOT_ONE_OF:
-          // lhs is undefined when the entity value was not provided, in which
+          // lhs would be undefined when the value was not provided, in which
           // case we should not match the rule
-          if (!isArray(rhs) || typeof lhs === 'undefined') return false;
-          return !rhs.includes(lhs);
+          return (
+            isArray(rhs) && typeof lhs !== 'undefined' && !rhs.includes(lhs)
+          );
         case Comparator.CONTAINS_ALL_OF: {
           if (!Array.isArray(rhs) || !Array.isArray(lhs)) return false;
 
           const lhsSet = new Set(lhs.filter(isString));
 
+          // try to use a set if the lhs is a list of strings - O(1)
+          // otherwise we need to iterate over the values - O(n)
           if (lhsSet.size === lhs.length) {
             return rhs.filter(isString).every((item) => lhsSet.has(item));
           }
 
+          // this shouldn't happen since we only allow string[] on the lhs
           return rhs.every((item) => lhs.includes(item));
         }
         case Comparator.CONTAINS_ANY_OF: {
@@ -175,19 +179,26 @@ function matchConditions<T>(
           const rhsSet = new Set(rhs.filter(isString));
           return lhs.some(
             rhsSet.size === rhs.length
-              ? (item) => rhsSet.has(item)
-              : (item) => rhs.includes(item),
+              ? // try to use a set if the rhs is a list of strings - O(1)
+                (item) => rhsSet.has(item)
+              : // otherwise we need to iterate over the values - O(n)
+                (item) => rhs.includes(item),
           );
         }
         case Comparator.CONTAINS_NONE_OF: {
+          // if the rhs is not an array something went wrong and we should not match
           if (!Array.isArray(rhs)) return false;
+
+          // if it's not an array it doesn't contain any of the values
           if (!Array.isArray(lhs)) return true;
 
           const rhsSet = new Set(rhs.filter(isString));
           return lhs.every(
             rhsSet.size === rhs.length
-              ? (item) => !rhsSet.has(item)
-              : (item) => !rhs.includes(item),
+              ? // try to use a set if the rhs is a list of strings - O(1)
+                (item) => !rhsSet.has(item)
+              : // otherwise we need to iterate over the values - O(n)
+                (item) => !rhs.includes(item),
           );
         }
         case Comparator.STARTS_WITH:

packages/vercel-flags-core/src/types.ts

@@ -512,6 +512,8 @@ export namespace Original {
     lhs: LHS;
     cmp: Comparator;
     rhs: RHS;
+    /** When true, string comparisons are case-insensitive. */
+    ci?: boolean;
   };
 
   export type Rule = {