feat: Expose new ApiEndpoints class to return API endpoint URL (#73)

* feat: Expose API to return API endpoint URL

* export ApiEndpoints

* jsdoc

* bump version

* do not export ApiEndpoints

Author: felipecsl

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@eppo/js-client-sdk-common",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Eppo SDK for client-side JavaScript applications (base for both web and react native)",
   "main": "dist/index.js",
   "files": [

src/api-endpoint.spec.ts

@@ -0,0 +1,17 @@
+import ApiEndpoints from './api-endpoints';
+
+describe('ApiEndpoints', () => {
+  it('should append query parameters to the URL', () => {
+    const apiEndpoints = new ApiEndpoints('http://api.example.com', {
+      apiKey: '12345',
+      sdkVersion: 'foobar',
+      sdkName: 'ExampleSDK',
+    });
+    expect(apiEndpoints.endpoint('/data').toString()).toEqual(
+      'http://api.example.com/data?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
+    );
+    expect(apiEndpoints.ufcEndpoint().toString()).toEqual(
+      'http://api.example.com/flag-config/v1/config?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
+    );
+  });
+});

src/api-endpoints.ts

@@ -0,0 +1,18 @@
+import { ISdkParams } from './http-client';
+
+const UFC_ENDPOINT = '/flag-config/v1/config';
+
+/** Utility class for constructing an Eppo API endpoint URL given a provided baseUrl and query parameters */
+export default class ApiEndpoints {
+  constructor(private readonly baseUrl: string, private readonly queryParams: ISdkParams) {}
+
+  endpoint(resource: string): URL {
+    const url = new URL(this.baseUrl + resource);
+    Object.entries(this.queryParams).forEach(([key, value]) => url.searchParams.append(key, value));
+    return url;
+  }
+
+  ufcEndpoint(): URL {
+    return this.endpoint(UFC_ENDPOINT);
+  }
+}

src/client/eppo-client.spec.ts

@@ -10,6 +10,7 @@ import {
   readMockUFCResponse,
   validateTestAssignments,
 } from '../../test/testHelpers';
+import ApiEndpoints from '../api-endpoints';
 import { IAssignmentLogger } from '../assignment-logger';
 import { IConfigurationStore } from '../configuration-store/configuration-store';
 import { MemoryOnlyConfigurationStore } from '../configuration-store/memory.store';
@@ -21,15 +22,12 @@ import { Flag, ObfuscatedFlag, VariationType } from '../interfaces';
 import EppoClient, { FlagConfigurationRequestParameters, checkTypeMatch } from './eppo-client';
 
 export async function init(configurationStore: IConfigurationStore<Flag | ObfuscatedFlag>) {
-  const httpClient = new FetchHttpClient(
-    'http://127.0.0.1:4000',
-    {
-      apiKey: 'dummy',
-      sdkName: 'js-client-sdk-common',
-      sdkVersion: '1.0.0',
-    },
-    1000,
-  );
+  const apiEndpoints = new ApiEndpoints('http://127.0.0.1:4000', {
+    apiKey: 'dummy',
+    sdkName: 'js-client-sdk-common',
+    sdkVersion: '1.0.0',
+  });
+  const httpClient = new FetchHttpClient(apiEndpoints, 1000);
   const configurationRequestor = new FlagConfigurationRequestor(configurationStore, httpClient);
   await configurationRequestor.fetchAndStoreConfigurations();
 }

src/client/eppo-client.ts

@@ -1,3 +1,4 @@
+import ApiEndpoints from '../api-endpoints';
 import { logger } from '../application-logger';
 import {
   AssignmentCache,
@@ -165,7 +166,6 @@ export default class EppoClient implements IEppoClient {
   private queuedEvents: IAssignmentEvent[] = [];
   private assignmentLogger: IAssignmentLogger | undefined;
   private isGracefulFailureMode = true;
-  private isObfuscated = false;
   private assignmentCache: AssignmentCache<Cacheable> | undefined;
   private configurationStore: IConfigurationStore<Flag | ObfuscatedFlag>;
   private configurationRequestParameters: FlagConfigurationRequestParameters | undefined;
@@ -175,12 +175,11 @@ export default class EppoClient implements IEppoClient {
   constructor(
     configurationStore: IConfigurationStore<Flag | ObfuscatedFlag>,
     configurationRequestParameters?: FlagConfigurationRequestParameters,
-    obfuscated = false,
+    private readonly isObfuscated = false,
   ) {
     this.evaluator = new Evaluator();
     this.configurationStore = configurationStore;
     this.configurationRequestParameters = configurationRequestParameters;
-    this.isObfuscated = obfuscated;
   }
 
   public setConfigurationRequestParameters(
@@ -212,17 +211,22 @@ export default class EppoClient implements IEppoClient {
       );
       return;
     }
-
-    // todo: consider injecting the IHttpClient interface
-    const httpClient = new FetchHttpClient(
-      this.configurationRequestParameters.baseUrl || DEFAULT_BASE_URL,
-      {
-        apiKey: this.configurationRequestParameters.apiKey,
-        sdkName: this.configurationRequestParameters.sdkName,
-        sdkVersion: this.configurationRequestParameters.sdkVersion,
-      },
-      this.configurationRequestParameters.requestTimeoutMs || DEFAULT_REQUEST_TIMEOUT_MS,
-    );
+    const {
+      apiKey,
+      sdkName,
+      sdkVersion,
+      baseUrl = DEFAULT_BASE_URL,
+      requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS,
+      numInitialRequestRetries = DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES,
+      numPollRequestRetries = DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
+      pollAfterSuccessfulInitialization = false,
+      pollAfterFailedInitialization = false,
+      throwOnFailedInitialization = false,
+      skipInitialPoll = false,
+    } = this.configurationRequestParameters;
+    // todo: Inject the chain of dependencies below
+    const apiEndpoints = new ApiEndpoints(baseUrl, { apiKey, sdkName, sdkVersion });
+    const httpClient = new FetchHttpClient(apiEndpoints, requestTimeoutMs);
     const configurationRequestor = new FlagConfigurationRequestor(
       this.configurationStore,
       httpClient,
@@ -232,19 +236,12 @@ export default class EppoClient implements IEppoClient {
       POLL_INTERVAL_MS,
       configurationRequestor.fetchAndStoreConfigurations.bind(configurationRequestor),
       {
-        maxStartRetries:
-          this.configurationRequestParameters.numInitialRequestRetries ??
-          DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES,
-        maxPollRetries:
-          this.configurationRequestParameters.numPollRequestRetries ??
-          DEFAULT_POLL_CONFIG_REQUEST_RETRIES,
-        pollAfterSuccessfulStart:
-          this.configurationRequestParameters.pollAfterSuccessfulInitialization ?? false,
-        pollAfterFailedStart:
-          this.configurationRequestParameters.pollAfterFailedInitialization ?? false,
-        errorOnFailedStart:
-          this.configurationRequestParameters.throwOnFailedInitialization ?? false,
-        skipInitialPoll: this.configurationRequestParameters.skipInitialPoll ?? false,
+        maxStartRetries: numInitialRequestRetries,
+        maxPollRetries: numPollRequestRetries,
+        pollAfterSuccessfulStart: pollAfterSuccessfulInitialization,
+        pollAfterFailedStart: pollAfterFailedInitialization,
+        errorOnFailedStart: throwOnFailedInitialization,
+        skipInitialPoll: skipInitialPoll,
       },
     );
 
@@ -390,11 +387,10 @@ export default class EppoClient implements IEppoClient {
    * Note: This method is experimental and may change in future versions.
    * Please only use for debugging purposes, and not in production.
    *
-   * @param subjectKey The subject key
    * @param flagKey The flag key
+   * @param subjectKey The subject key
    * @param subjectAttributes The subject attributes
    * @param expectedVariationType The expected variation type
-   * @param obfuscated Whether the flag key is obfuscated
    * @returns A detailed return of assignment for a particular subject and flag
    */
   public getAssignmentDetail(

src/flag-configuration-requestor.ts

@@ -2,20 +2,15 @@ import { IConfigurationStore } from './configuration-store/configuration-store';
 import { IHttpClient } from './http-client';
 import { Flag } from './interfaces';
 
-const UFC_ENDPOINT = '/flag-config/v1/config';
-
-interface IUniversalFlagConfig {
-  flags: Record<string, Flag>;
-}
-
+// Requests AND stores flag configurations
 export default class FlagConfigurationRequestor {
   constructor(
-    private configurationStore: IConfigurationStore<Flag>,
-    private httpClient: IHttpClient,
+    private readonly configurationStore: IConfigurationStore<Flag>,
+    private readonly httpClient: IHttpClient,
   ) {}
 
   async fetchAndStoreConfigurations(): Promise<Record<string, Flag>> {
-    const responseData = await this.httpClient.get<IUniversalFlagConfig>(UFC_ENDPOINT);
+    const responseData = await this.httpClient.getUniversalFlagConfiguration();
     if (!responseData) {
       return {};
     }

src/http-client.spec.ts

@@ -1,3 +1,4 @@
+import ApiEndpoints from './api-endpoints';
 import FetchHttpClient, { HttpRequestError, ISdkParams } from './http-client';
 
 describe('FetchHttpClient', () => {
@@ -8,11 +9,10 @@ describe('FetchHttpClient', () => {
     sdkName: 'ExampleSDK',
   };
   const timeout = 5000; // 5 seconds
-
-  let httpClient: FetchHttpClient;
+  const apiEndpoints = new ApiEndpoints(baseUrl, sdkParams);
+  const httpClient = new FetchHttpClient(apiEndpoints, timeout);
 
   beforeEach(() => {
-    httpClient = new FetchHttpClient(baseUrl, sdkParams, timeout);
     global.fetch = jest.fn();
   });
 
@@ -30,7 +30,7 @@ describe('FetchHttpClient', () => {
     (global.fetch as jest.Mock).mockImplementation(() => mockFetchPromise);
 
     const resource = '/data';
-    const result = await httpClient.get(resource);
+    const result = await httpClient.rawGet(apiEndpoints.endpoint(resource));
 
     expect(global.fetch).toHaveBeenCalledTimes(1);
     expect(global.fetch).toHaveBeenCalledWith(
@@ -49,8 +49,9 @@ describe('FetchHttpClient', () => {
     (global.fetch as jest.Mock).mockImplementation(() => mockFetchPromise);
 
     const resource = '/data';
-    await expect(httpClient.get(resource)).rejects.toThrow(HttpRequestError);
-    await expect(httpClient.get(resource)).rejects.toEqual(
+    const url = apiEndpoints.endpoint(resource);
+    await expect(httpClient.rawGet(url)).rejects.toThrow(HttpRequestError);
+    await expect(httpClient.rawGet(url)).rejects.toEqual(
       new HttpRequestError('Failed to fetch data', 404),
     );
   });
@@ -71,7 +72,8 @@ describe('FetchHttpClient', () => {
     );
 
     const resource = '/data';
-    const getPromise = httpClient.get(resource);
+    const url = apiEndpoints.endpoint(resource);
+    const getPromise = httpClient.rawGet(url);
 
     // Immediately advance the timers by 10 seconds to simulate the timeout
     jest.advanceTimersByTime(10000);

src/http-client.ts

@@ -1,3 +1,6 @@
+import ApiEndpoints from './api-endpoints';
+import { Flag } from './interfaces';
+
 export interface ISdkParams {
   apiKey: string;
   sdkVersion: string;
@@ -13,31 +16,38 @@ export class HttpRequestError extends Error {
   }
 }
 
+export interface IUniversalFlagConfig {
+  flags: Record<string, Flag>;
+}
+
 export interface IHttpClient {
-  get<T>(resource: string): Promise<T | undefined>;
+  getUniversalFlagConfiguration(): Promise<IUniversalFlagConfig | undefined>;
+  rawGet<T>(url: URL): Promise<T | undefined>;
 }
 
 export default class FetchHttpClient implements IHttpClient {
-  constructor(private baseUrl: string, private sdkParams: ISdkParams, private timeout: number) {}
+  constructor(private readonly apiEndpoints: ApiEndpoints, private readonly timeout: number) {}
 
-  async get<T>(resource: string): Promise<T | undefined> {
-    const url = new URL(this.baseUrl + resource);
-    Object.entries(this.sdkParams).forEach(([key, value]) => url.searchParams.append(key, value));
+  async getUniversalFlagConfiguration(): Promise<IUniversalFlagConfig | undefined> {
+    const url = this.apiEndpoints.ufcEndpoint();
+    return await this.rawGet<IUniversalFlagConfig>(url);
+  }
 
+  async rawGet<T>(url: URL): Promise<T | undefined> {
     try {
       // Canonical implementation of abortable fetch for interrupting when request takes longer than desired.
       // https://developer.chrome.com/blog/abortable-fetch/#reacting_to_an_aborted_fetch
       const controller = new AbortController();
       const signal = controller.signal;
       const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-      const response = await fetch(url.toString(), { signal: signal });
+      const response = await fetch(url.toString(), { signal });
       // Clear timeout when response is received within the budget.
       clearTimeout(timeoutId);
 
       if (!response.ok) {
         throw new HttpRequestError('Failed to fetch data', response.status);
       }
-      return response.json() as Promise<T>;
+      return await response.json();
     } catch (error) {
       if (error.name === 'AbortError') {
         throw new HttpRequestError('Request timed out', 408, error);