[ufc] add null operator and more fixes

src/client/eppo-client.spec.ts

@@ -16,7 +16,6 @@ import {
 import { IAssignmentLogger } from '../assignment-logger';
 import { IConfigurationStore } from '../configuration-store';
 import { MAX_EVENT_QUEUE_SIZE, POLL_INTERVAL_MS, POLL_JITTER_PCT } from '../constants';
-import { Evaluator } from '../evaluator';
 import FlagConfigurationRequestor from '../flag-configuration-requestor';
 import HttpClient from '../http-client';
 import { Flag, VariationType } from '../interfaces';
@@ -301,7 +300,6 @@ describe('EppoClient E2E test', () => {
       mock.setup();
       mock.get(flagEndpoint, (_req, res) => {
         const ufc = readMockUFCResponse(OBFUSCATED_MOCK_UFC_RESPONSE_FILE);
-        console.log(ufc);
         return res.status(200).body(JSON.stringify(ufc));
       });
       await init(storage);

src/client/eppo-client.ts

@@ -23,7 +23,7 @@ import HttpClient from '../http-client';
 import { Flag, VariationType } from '../interfaces';
 import { getMD5Hash } from '../obfuscation';
 import initPoller, { IPoller } from '../poller';
-import { AttributeType } from '../types';
+import { AttributeType, ValueType } from '../types';
 import { validateNotBlank } from '../validation';
 import { LIB_VERSION } from '../version';
 
@@ -364,6 +364,13 @@ export default class EppoClient implements IEppoClient {
       result.flagKey = flagKey;
     }
 
+    if (
+      result?.variation &&
+      !this.checkValueTypeMatch(expectedVariationType, result.variation.value)
+    ) {
+      return noneResult(flagKey, subjectKey, subjectAttributes);
+    }
+
     try {
       if (result?.doLog) {
         this.logAssignment(result);
@@ -386,6 +393,28 @@ export default class EppoClient implements IEppoClient {
     return expectedType === undefined || actualType === expectedType;
   }
 
+  private checkValueTypeMatch(expectedType: VariationType | undefined, value: ValueType): boolean {
+    if (expectedType == undefined) {
+      return true;
+    }
+
+    switch (expectedType) {
+      case VariationType.STRING:
+        return typeof value === 'string';
+      case VariationType.BOOLEAN:
+        return typeof value === 'boolean';
+      case VariationType.INTEGER:
+        return typeof value === 'number' && Number.isInteger(value);
+      case VariationType.NUMERIC:
+        return typeof value === 'number';
+      case VariationType.JSON:
+        // note: converting to object downstream
+        return typeof value === 'string';
+      default:
+        return false;
+    }
+  }
+
   public getFlagKeys() {
     /**
      * Returns a list of all flag keys that have been initialized.

src/evaluator.spec.ts

@@ -1,7 +1,7 @@
-import { Evaluator, hashKey, isInShardRange } from './evaluator';
+import { Evaluator, hashKey, isInShardRange, matchesRules } from './evaluator';
 import { Flag, Variation, Shard, VariationType } from './interfaces';
 import { getMD5Hash } from './obfuscation';
-import { ObfuscatedOperatorType, OperatorType } from './rules';
+import { ObfuscatedOperatorType, OperatorType, Rule } from './rules';
 import { DeterministicSharder } from './sharders';
 
 describe('Evaluator', () => {
@@ -380,7 +380,6 @@ describe('Evaluator', () => {
       allocations: [
         {
           key: 'first',
-          rules: [],
           splits: [
             {
               variationKey: 'a',
@@ -403,7 +402,6 @@ describe('Evaluator', () => {
         },
         {
           key: 'default',
-          rules: [],
           splits: [
             {
               variationKey: 'c',
@@ -454,8 +452,8 @@ describe('Evaluator', () => {
       allocations: [
         {
           key: 'default',
-          startAt: new Date(now.getFullYear() + 1, 0, 1),
-          endAt: new Date(now.getFullYear() + 1, 1, 1),
+          startAt: new Date(now.getFullYear() + 1, 0, 1).toISOString(),
+          endAt: new Date(now.getFullYear() + 1, 1, 1).toISOString(),
           rules: [],
           splits: [
             {
@@ -486,8 +484,8 @@ describe('Evaluator', () => {
       allocations: [
         {
           key: 'default',
-          startAt: new Date(now.getFullYear() - 1, 0, 1),
-          endAt: new Date(now.getFullYear() + 1, 0, 1),
+          startAt: new Date(now.getFullYear() - 1, 0, 1).toISOString(),
+          endAt: new Date(now.getFullYear() + 1, 0, 1).toISOString(),
           rules: [],
           splits: [
             {
@@ -518,8 +516,8 @@ describe('Evaluator', () => {
       allocations: [
         {
           key: 'default',
-          startAt: new Date(now.getFullYear() - 2, 0, 1),
-          endAt: new Date(now.getFullYear() - 1, 0, 1),
+          startAt: new Date(now.getFullYear() - 2, 0, 1).toISOString(),
+          endAt: new Date(now.getFullYear() - 1, 0, 1).toISOString(),
           rules: [],
           splits: [
             {
@@ -554,3 +552,101 @@ describe('Evaluator', () => {
     expect(isInShardRange(1, { start: 1, end: 1 })).toBeFalsy();
   });
 });
+
+describe('matchesRules', () => {
+  describe('matchesRules function', () => {
+    it('should return true when there are no rules', () => {
+      const rules: Rule[] = [];
+      const subjectAttributes = { id: 'test-subject' };
+      const obfuscated = false;
+      expect(matchesRules(rules, subjectAttributes, obfuscated)).toBeTruthy();
+    });
+
+    it('should return true when a rule matches', () => {
+      const rules: Rule[] = [
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.GTE,
+              value: 18,
+            },
+          ],
+        },
+      ];
+      const subjectAttributes = { id: 'test-subject', age: 20 };
+      const obfuscated = false;
+      expect(matchesRules(rules, subjectAttributes, obfuscated)).toBeTruthy();
+    });
+
+    it('should return true when one of two rules matches', () => {
+      const rules: Rule[] = [
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.GTE,
+              value: 18,
+            },
+          ],
+        },
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.LTE,
+              value: 10,
+            },
+          ],
+        },
+      ];
+      const subjectAttributes = { id: 'test-subject', age: 10 };
+      const obfuscated = false;
+      expect(matchesRules(rules, subjectAttributes, obfuscated)).toBeTruthy();
+    });
+
+    it('should return true when null or rule is passed', () => {
+      const rules: Rule[] = [
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.IS_NULL,
+              value: true,
+            },
+          ],
+        },
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.GTE,
+              value: 20,
+            },
+          ],
+        },
+      ];
+      const obfuscated = false;
+      expect(matchesRules(rules, { id: 'test-subject', age: 20 }, obfuscated)).toBeTruthy();
+      expect(matchesRules(rules, { id: 'test-subject', age: 10 }, obfuscated)).toBeFalsy();
+      expect(matchesRules(rules, { id: 'test-subject', country: 'UK' }, obfuscated)).toBeTruthy();
+    });
+
+    it('should return false when no rules match', () => {
+      const rules: Rule[] = [
+        {
+          conditions: [
+            {
+              attribute: 'age',
+              operator: OperatorType.GTE,
+              value: 18,
+            },
+          ],
+        },
+      ];
+      const subjectAttributes = { id: 'test-subject', age: 16 };
+      const obfuscated = false;
+      expect(matchesRules(rules, subjectAttributes, obfuscated)).toBeFalsy();
+    });
+  });
+});

src/evaluator.ts

@@ -1,11 +1,12 @@
 import { Flag, Shard, Range, Variation } from './interfaces';
-import { matchesRule } from './rules';
+import { Rule, matchesRule } from './rules';
 import { MD5Sharder, Sharder } from './sharders';
+import { SubjectAttributes } from './types';
 
 export interface FlagEvaluation {
   flagKey: string;
   subjectKey: string;
-  subjectAttributes: Record<string, string | number | boolean>;
+  subjectAttributes: SubjectAttributes;
   allocationKey: string | null;
   variation: Variation | null;
   extraLogging: Record<string, string>;
@@ -22,7 +23,7 @@ export class Evaluator {
   evaluateFlag(
     flag: Flag,
     subjectKey: string,
-    subjectAttributes: Record<string, string | number | boolean>,
+    subjectAttributes: SubjectAttributes,
     obfuscated: boolean,
   ): FlagEvaluation {
     if (!flag.enabled) {
@@ -31,14 +32,11 @@ export class Evaluator {
 
     const now = new Date();
     for (const allocation of flag.allocations) {
-      if (allocation.startAt && now < allocation.startAt) continue;
-      if (allocation.endAt && now > allocation.endAt) continue;
+      if (allocation.startAt && now < new Date(allocation.startAt)) continue;
+      if (allocation.endAt && now > new Date(allocation.endAt)) continue;
 
       if (
-        !allocation.rules.length ||
-        allocation.rules.some((rule) =>
-          matchesRule(rule, { id: subjectKey, ...subjectAttributes }, obfuscated),
-        )
+        matchesRules(allocation?.rules ?? [], { id: subjectKey, ...subjectAttributes }, obfuscated)
       ) {
         for (const split of allocation.splits) {
           if (
@@ -78,7 +76,7 @@ export function hashKey(salt: string, subjectKey: string): string {
 export function noneResult(
   flagKey: string,
   subjectKey: string,
-  subjectAttributes: Record<string, string | number | boolean>,
+  subjectAttributes: SubjectAttributes,
 ): FlagEvaluation {
   return {
     flagKey,
@@ -90,3 +88,11 @@ export function noneResult(
     doLog: false,
   };
 }
+
+export function matchesRules(
+  rules: Rule[],
+  subjectAttributes: SubjectAttributes,
+  obfuscated: boolean,
+): boolean {
+  return !rules.length || rules.some((rule) => matchesRule(rule, subjectAttributes, obfuscated));
+}

src/interfaces.ts

@@ -31,9 +31,9 @@ export interface Split {
 
 export interface Allocation {
   key: string;
-  rules: Rule[];
-  startAt?: Date;
-  endAt?: Date;
+  rules?: Rule[];
+  startAt?: string; // ISO 8601
+  endAt?: string; // ISO 8601
   splits: Split[];
   doLog: boolean;
 }