Merge branch 'main' into feat--eppo-assignment-logger

Author: felipecsl

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eppo/js-client-sdk-common",
-  "version": "4.9.0",
+  "version": "4.12.1-alpha.0",
   "description": "Common library for Eppo JavaScript SDKs (web, react native, and node)",
   "main": "dist/index.js",
   "files": [
@@ -53,7 +53,7 @@
     "eslint-config-prettier": "^10.0.1",
     "eslint-import-resolver-typescript": "^3.7.0",
     "eslint-plugin-import": "^2.25.4",
-    "eslint-plugin-prettier": "5.0.0",
+    "eslint-plugin-prettier": "5.2.3",
     "eslint-plugin-promise": "^7.2.1",
     "eslint-plugin-unused-imports": "^4.1.4",
     "jest": "^29.7.0",

src/api-endpoints.ts

@@ -3,6 +3,7 @@ import {
   UFC_ENDPOINT,
   BANDIT_ENDPOINT,
   PRECOMPUTED_FLAGS_ENDPOINT,
+  FLAG_OVERRIDES_KEY_VALIDATION_URL,
 } from './constants';
 import { IQueryParams, IQueryParamsWithSubject } from './http-client';
 
@@ -36,4 +37,8 @@ export default class ApiEndpoints {
   precomputedFlagsEndpoint(): URL {
     return this.endpoint(PRECOMPUTED_FLAGS_ENDPOINT);
   }
+
+  flagOverridesKeyValidationEndpoint(): URL {
+    return this.endpoint(FLAG_OVERRIDES_KEY_VALIDATION_URL);
+  }
 }

src/client/eppo-client-with-bandits.spec.ts

@@ -12,13 +12,13 @@ import ApiEndpoints from '../api-endpoints';
 import { IAssignmentEvent, IAssignmentLogger } from '../assignment-logger';
 import { BanditEvaluation, BanditEvaluator } from '../bandit-evaluator';
 import { IBanditEvent, IBanditLogger } from '../bandit-logger';
+import ConfigurationRequestor from '../configuration-requestor';
+import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
 import {
   IConfigurationWire,
   IPrecomputedConfiguration,
   IObfuscatedPrecomputedConfigurationResponse,
-} from '../configuration';
-import ConfigurationRequestor from '../configuration-requestor';
-import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
+} from '../configuration-wire-types';
 import { Evaluator, FlagEvaluation } from '../evaluator';
 import {
   AllocationEvaluationCode,

src/client/eppo-client-with-overrides.spec.ts

@@ -0,0 +1,141 @@
+import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
+import { Flag, FormatEnum, ObfuscatedFlag, VariationType } from '../interfaces';
+import * as overrideValidatorModule from '../override-validator';
+
+import EppoClient from './eppo-client';
+
+describe('EppoClient', () => {
+  const storage = new MemoryOnlyConfigurationStore<Flag | ObfuscatedFlag>();
+
+  function setUnobfuscatedFlagEntries(
+    entries: Record<string, Flag | ObfuscatedFlag>,
+  ): Promise<boolean> {
+    storage.setFormat(FormatEnum.SERVER);
+    return storage.setEntries(entries);
+  }
+
+  const flagKey = 'mock-flag';
+
+  const variationA = {
+    key: 'a',
+    value: 'variation-a',
+  };
+
+  const variationB = {
+    key: 'b',
+    value: 'variation-b',
+  };
+
+  const mockFlag: Flag = {
+    key: flagKey,
+    enabled: true,
+    variationType: VariationType.STRING,
+    variations: { a: variationA, b: variationB },
+    allocations: [
+      {
+        key: 'allocation-a',
+        rules: [],
+        splits: [
+          {
+            shards: [],
+            variationKey: 'a',
+          },
+        ],
+        doLog: true,
+      },
+    ],
+    totalShards: 10000,
+  };
+
+  let client: EppoClient;
+  let subjectKey: string;
+
+  beforeEach(async () => {
+    await setUnobfuscatedFlagEntries({ [flagKey]: mockFlag });
+    subjectKey = 'subject-10';
+    client = new EppoClient({ flagConfigurationStore: storage });
+  });
+
+  describe('parseOverrides', () => {
+    it('should parse a valid payload', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockResolvedValue(undefined);
+      const result = await client.parseOverrides(
+        JSON.stringify({
+          browserExtensionKey: 'my-key',
+          overrides: { [flagKey]: variationB },
+        }),
+      );
+      expect(result).toEqual({ [flagKey]: variationB });
+    });
+
+    it('should throw an error if the key is missing', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockResolvedValue(undefined);
+      expect(() =>
+        client.parseOverrides(
+          JSON.stringify({
+            overrides: { [flagKey]: variationB },
+          }),
+        ),
+      ).rejects.toThrow();
+    });
+
+    it('should throw an error if the key is not a string', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockResolvedValue(undefined);
+      expect(() =>
+        client.parseOverrides(
+          JSON.stringify({
+            browserExtensionKey: 123,
+            overrides: { [flagKey]: variationB },
+          }),
+        ),
+      ).rejects.toThrow();
+    });
+
+    it('should throw an error if the overrides are not parseable', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockResolvedValue(undefined);
+      expect(() =>
+        client.parseOverrides(`{
+          browserExtensionKey: 'my-key',
+          overrides: { [flagKey]: ,
+        }`),
+      ).rejects.toThrow();
+    });
+
+    it('should throw an error if overrides is not an object', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockResolvedValue(undefined);
+      expect(() =>
+        client.parseOverrides(
+          JSON.stringify({
+            browserExtensionKey: 'my-key',
+            overrides: false,
+          }),
+        ),
+      ).rejects.toThrow();
+    });
+
+    it('should throw an error if an invalid key is supplied', async () => {
+      jest.spyOn(overrideValidatorModule, 'sendValidationRequest').mockImplementation(async () => {
+        throw new Error(`Unable to authorize key`);
+      });
+      expect(() =>
+        client.parseOverrides(
+          JSON.stringify({
+            browserExtensionKey: 'my-key',
+            overrides: { [flagKey]: variationB },
+          }),
+        ),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('withOverrides', () => {
+    it('should create a new instance of EppoClient with specified overrides without affecting the original instance', () => {
+      const clientWithOverrides = client.withOverrides({ [flagKey]: variationB });
+
+      expect(client.getStringAssignment(flagKey, subjectKey, {}, 'default')).toBe('variation-a');
+      expect(clientWithOverrides.getStringAssignment(flagKey, subjectKey, {}, 'default')).toBe(
+        'variation-b',
+      );
+    });
+  });
+});