wip

Author: typotter

src/api-endpoint.spec.ts

@@ -1,21 +1,22 @@
 import ApiEndpoints from './api-endpoints';
 import { BASE_URL as DEFAULT_BASE_URL } from './constants';
+import EnhancedSdkToken from './enhanced-sdk-token';
 
 describe('ApiEndpoints', () => {
   it('should append query parameters to the URL', () => {
     const apiEndpoints = new ApiEndpoints({
-      baseUrl: 'http://api.example.com',
+      baseUrl: 'https://api.example.com',
       queryParams: {
         apiKey: '12345',
         sdkVersion: 'foobar',
         sdkName: 'ExampleSDK',
       },
     });
     expect(apiEndpoints.endpoint('/data').toString()).toEqual(
-      'http://api.example.com/data?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
+      'https://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',
+      'https://api.example.com/flag-config/v1/config?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
     );
   });
 
@@ -42,4 +43,121 @@ describe('ApiEndpoints', () => {
       `${DEFAULT_BASE_URL}/flag-config/v1/config`,
     );
   });
+
+  describe('Base URL determination', () => {
+    it('should use custom baseUrl when provided', () => {
+      const customBaseUrl = 'https://custom-domain.com';
+      const endpoints = new ApiEndpoints({ baseUrl: customBaseUrl });
+      expect(endpoints.endpoint('')).toContain(customBaseUrl);
+    });
+
+    it('should use subdomain from SDK token when valid', () => {
+      // This token has cs=test-subdomain
+      const sdkToken = 'abc.Y3M9dGVzdC1zdWJkb21haW4=';
+      const endpoints = new ApiEndpoints({ sdkToken: new EnhancedSdkToken(sdkToken) });
+      expect(endpoints.getEffectiveBaseUrl()).toBe('https://test-subdomain.fscdn.eppo.cloud/api');
+    });
+
+    it('should prefer custom baseUrl over SDK token subdomain', () => {
+      const customBaseUrl = 'https://custom-domain.com';
+      // This token has cs=test-subdomain
+      const sdkToken = 'abc.Y3M9dGVzdC1zdWJkb21haW4=';
+      const endpoints = new ApiEndpoints({
+        baseUrl: customBaseUrl,
+        sdkToken: new EnhancedSdkToken(sdkToken),
+      });
+      expect(endpoints.getEffectiveBaseUrl()).toBe(customBaseUrl);
+    });
+
+    it('should fallback to DEFAULT_BASE_URL when SDK token has no subdomain', () => {
+      // This token has no cs parameter
+      const sdkToken = 'abc.ZWg9ZXZlbnQtaG9zdG5hbWU=';
+      const endpoints = new ApiEndpoints({ sdkToken: new EnhancedSdkToken(sdkToken) });
+      expect(endpoints.getEffectiveBaseUrl()).toBe(DEFAULT_BASE_URL);
+    });
+
+    it('should fallback to DEFAULT_BASE_URL when SDK token is invalid', () => {
+      const invalidToken = new EnhancedSdkToken('invalid-token');
+      const endpoints = new ApiEndpoints({ sdkToken: invalidToken });
+      expect(endpoints.getEffectiveBaseUrl()).toBe(DEFAULT_BASE_URL);
+    });
+  });
+
+  describe('Endpoint URL construction', () => {
+    it('should use effective base URL for UFC endpoint', () => {
+      // This token has cs=test-subdomain
+      const sdkToken = 'abc.Y3M9dGVzdC1zdWJkb21haW4=';
+      const endpoints = new ApiEndpoints({ sdkToken: new EnhancedSdkToken(sdkToken) });
+
+      expect(endpoints.ufcEndpoint()).toContain(
+        'https://test-subdomain.fscdn.eppo.cloud/api/flag-config/v1/config',
+      );
+    });
+
+    it('should use effective base URL for bandit parameters endpoint', () => {
+      // This token has cs=test-subdomain
+      const sdkToken = 'abc.Y3M9dGVzdC1zdWJkb21haW4=';
+      const endpoints = new ApiEndpoints({ sdkToken: new EnhancedSdkToken(sdkToken) });
+
+      expect(endpoints.banditParametersEndpoint()).toContain(
+        'https://test-subdomain.fscdn.eppo.cloud/api/flag-config/v1/bandits',
+      );
+    });
+
+    it('should use the sub-domain and default base URL for precomputed flags endpoint', () => {
+      // This token has cs=test-subdomain
+      const sdkToken = 'abc.Y3M9dGVzdC1zdWJkb21haW4=';
+      const endpoints = new ApiEndpoints({
+        sdkToken: new EnhancedSdkToken(sdkToken),
+        defaultUrl: 'default.eppo.cloud',
+      });
+
+      expect(endpoints.precomputedFlagsEndpoint()).toContain('default.eppo.cloud');
+      expect(endpoints.precomputedFlagsEndpoint()).toContain('test-subdomain');
+    });
+
+    it('should handle slash management between base URL and resource', () => {
+      const baseUrlWithSlash = 'https://domain.com/';
+      const baseUrlWithoutSlash = 'https://domain.com';
+      const resourceWithSlash = '/resource';
+      const resourceWithoutSlash = 'resource';
+
+      const endpoints1 = new ApiEndpoints({ baseUrl: baseUrlWithSlash });
+      const endpoints2 = new ApiEndpoints({ baseUrl: baseUrlWithoutSlash });
+
+      // Test all combinations to ensure we avoid double slashes and always have one slash
+      expect(endpoints1.endpoint(resourceWithSlash)).toBe('https://domain.com/resource');
+      expect(endpoints1.endpoint(resourceWithoutSlash)).toBe('https://domain.com/resource');
+      expect(endpoints2.endpoint(resourceWithSlash)).toBe('https://domain.com/resource');
+      expect(endpoints2.endpoint(resourceWithoutSlash)).toBe('https://domain.com/resource');
+    });
+  });
+
+  describe('Query parameter handling', () => {
+    it('should append query parameters to endpoint URLs', () => {
+      const queryParams = { apiKey: 'test-key', sdkName: 'js-sdk', sdkVersion: '1.0.0' };
+      const endpoints = new ApiEndpoints({ queryParams });
+
+      const url = endpoints.ufcEndpoint();
+
+      expect(url).toContain('?');
+      expect(url).toContain('apiKey=test-key');
+      expect(url).toContain('sdkName=js-sdk');
+      expect(url).toContain('sdkVersion=1.0.0');
+    });
+
+    it('should properly encode query parameters with special characters', () => {
+      const queryParams = {
+        apiKey: 'test-key',
+        sdkName: 'value with spaces',
+        sdkVersion: 'a+b=c&d',
+      };
+      const endpoints = new ApiEndpoints({ queryParams });
+
+      const url = endpoints.ufcEndpoint();
+
+      expect(url).toContain('sdkName=value+with+spaces');
+      expect(url).toContain('sdkVersion=a%2Bb%3Dc%26d');
+    });
+  });
 });

src/api-endpoints.ts

@@ -1,42 +1,109 @@
-import {
-  BASE_URL as DEFAULT_BASE_URL,
-  UFC_ENDPOINT,
-  BANDIT_ENDPOINT,
-  PRECOMPUTED_FLAGS_ENDPOINT,
-} from './constants';
+import { BANDIT_ENDPOINT, BASE_URL, PRECOMPUTED_FLAGS_ENDPOINT, UFC_ENDPOINT } from './constants';
+import EnhancedSdkToken from './enhanced-sdk-token';
 import { IQueryParams, IQueryParamsWithSubject } from './http-client';
 
 interface IApiEndpointsParams {
   queryParams?: IQueryParams | IQueryParamsWithSubject;
   baseUrl?: string;
+  defaultUrl: string;
+  sdkToken?: EnhancedSdkToken;
 }
 
 /** Utility class for constructing an Eppo API endpoint URL given a provided baseUrl and query parameters */
 export default class ApiEndpoints {
-  constructor(private readonly params: IApiEndpointsParams) {
-    this.params.baseUrl = params.baseUrl ?? DEFAULT_BASE_URL;
+  private readonly sdkToken: EnhancedSdkToken | null;
+  private readonly _effectiveBaseUrl: string;
+  private readonly params: IApiEndpointsParams;
+
+  constructor(params: Partial<IApiEndpointsParams>) {
+    this.params = Object.assign({}, { defaultUrl: BASE_URL }, params);
+    this.sdkToken = params.sdkToken ?? null;
+
+    // this.params.baseUrl =
+    //   params.baseUrl && params.baseUrl !== DEFAULT_BASE_URL ? params.baseUrl : DEFAULT_URL;
+
+    // Set the effective base URL.
+    this._effectiveBaseUrl = this.determineBaseUrl();
+  }
+
+  /**
+   * Determine the effective base URL based on the constructor parameters:
+   * 1. If baseUrl is provided, and it is not equal to the DEFAULT_BASE_URL, use it
+   * 2. If the api key contains an encoded customer-specific subdomain, use it with DEFAULT_DOMAIN
+   * 3. Otherwise, fall back to DEFAULT_BASE_URL
+   */
+  private determineBaseUrl(): string {
+    // If baseUrl is explicitly provided and different from default, use it
+    if (this.params.baseUrl && this.params.baseUrl !== this.params.defaultUrl) {
+      return this.params.baseUrl;
+    }
+
+    // If there's an enhanced SDK token with a subdomain, it will be prepended in the buildUrl method.
+    const subdomain = this.sdkToken?.getSubdomain();
+    return this.buildUrl(this.params.defaultUrl, subdomain);
+  }
+
+  private buildUrl(domain: string, subdomain?: string | null) {
+    const protocol = ApiEndpoints.URL_PROTOCOLS.find((v) => domain.startsWith(v)) ?? 'https://';
+
+    const base = this.stripProtocol(domain);
+    return subdomain ? `${protocol}${subdomain}.${base}` : `${protocol}${base}`;
+  }
+
+  /**
+   * Returns the base URL being used for the UFC and bandit endpoints
+   */
+  getEffectiveBaseUrl(): string {
+    return this._effectiveBaseUrl;
   }
 
+  /**
+   * Creates an endpoint URL with the specified resource path and query parameters
+   */
   endpoint(resource: string): string {
-    const endpointUrl = `${this.params.baseUrl}${resource}`;
+    const baseUrl = this._effectiveBaseUrl;
+
+    // Ensure baseUrl and resource join correctly with only one slash
+    const base = baseUrl.endsWith('/') ? baseUrl.substring(0, baseUrl.length - 1) : baseUrl;
+    const path = resource.startsWith('/') ? resource.substring(1) : resource;
+    const endpointUrl = `${base}/${path}`;
+
     const queryParams = this.params.queryParams;
     if (!queryParams) {
       return endpointUrl;
     }
+
     const urlSearchParams = new URLSearchParams();
     Object.entries(queryParams).forEach(([key, value]) => urlSearchParams.append(key, value));
+
     return `${endpointUrl}?${urlSearchParams}`;
   }
 
+  /**
+   * Returns the URL for the UFC endpoint
+   */
   ufcEndpoint(): string {
     return this.endpoint(UFC_ENDPOINT);
   }
 
+  /**
+   * Returns the URL for the bandit parameters endpoint
+   */
   banditParametersEndpoint(): string {
     return this.endpoint(BANDIT_ENDPOINT);
   }
 
+  /**
+   * Returns the URL for the precomputed flags endpoint
+   */
   precomputedFlagsEndpoint(): string {
     return this.endpoint(PRECOMPUTED_FLAGS_ENDPOINT);
   }
+
+  private stripProtocol(url: string) {
+    return ApiEndpoints.URL_PROTOCOLS.reduce((prev, cur) => {
+      return prev.replace(cur, '');
+    }, url);
+  }
+  public static readonly URL_PROTOCOLS = ['http://', 'https://', '//'];
 }

src/client/eppo-client.ts

@@ -30,6 +30,7 @@ import {
   DEFAULT_REQUEST_TIMEOUT_MS,
 } from '../constants';
 import { decodeFlag } from '../decoding';
+import EnhancedSdkToken from '../enhanced-sdk-token';
 import { EppoValue } from '../eppo_value';
 import { Evaluator, FlagEvaluation, noneResult, overrideResult } from '../evaluator';
 import { BoundedEventQueue } from '../events/bounded-event-queue';
@@ -326,11 +327,12 @@ export default class EppoClient {
       pollingIntervalMs = DEFAULT_POLL_INTERVAL_MS;
     }
 
-    // todo: Inject the chain of dependencies below
     const apiEndpoints = new ApiEndpoints({
       baseUrl,
       queryParams: { apiKey, sdkName, sdkVersion },
+      sdkToken: new EnhancedSdkToken(apiKey),
     });
+
     const httpClient = new FetchHttpClient(apiEndpoints, requestTimeoutMs);
     const configurationRequestor = new ConfigurationRequestor(
       httpClient,

src/client/eppo-precomputed-client.ts

@@ -161,7 +161,8 @@ export default class EppoPrecomputedClient {
 
     // todo: Inject the chain of dependencies below
     const apiEndpoints = new ApiEndpoints({
-      baseUrl: baseUrl ?? PRECOMPUTED_BASE_URL,
+      defaultUrl: PRECOMPUTED_BASE_URL,
+      baseUrl,
       queryParams: { apiKey, sdkName, sdkVersion },
     });
     const httpClient = new FetchHttpClient(apiEndpoints, requestTimeoutMs);

src/configuration-wire/configuration-wire-helper.ts

@@ -1,4 +1,5 @@
 import ApiEndpoints from '../api-endpoints';
+import EnhancedSdkToken from '../enhanced-sdk-token';
 import FetchHttpClient, {
   IBanditParametersResponse,
   IHttpClient,
@@ -45,6 +46,7 @@ export class ConfigurationWireHelper {
     const apiEndpoints = new ApiEndpoints({
       baseUrl,
       queryParams,
+      sdkToken: new EnhancedSdkToken(sdkKey),
     });
 
     this.httpClient = new FetchHttpClient(apiEndpoints, 5000);

src/constants.ts

@@ -6,11 +6,14 @@ export const DEFAULT_POLL_INTERVAL_MS = 30000;
 export const POLL_JITTER_PCT = 0.1;
 export const DEFAULT_INITIAL_CONFIG_REQUEST_RETRIES = 1;
 export const DEFAULT_POLL_CONFIG_REQUEST_RETRIES = 7;
-export const BASE_URL = 'https://fscdn.eppo.cloud/api';
+export const DEFAULT_URL = 'fscdn.eppo.cloud/api';
+export const BASE_URL = 'https://' + DEFAULT_URL;
 export const UFC_ENDPOINT = '/flag-config/v1/config';
 export const BANDIT_ENDPOINT = '/flag-config/v1/bandits';
 export const PRECOMPUTED_BASE_URL = 'https://fs-edge-assignment.eppo.cloud';
 export const PRECOMPUTED_FLAGS_ENDPOINT = '/assignments';
+export const DEFAULT_EVENT_DOMAIN = 'e.eppo.cloud';
+
 export const SESSION_ASSIGNMENT_CONFIG_LOADED = 'eppo-session-assignment-config-loaded';
 export const NULL_SENTINEL = 'EPPO_NULL';
 // number of logging events that may be queued while waiting for initialization

src/enhanced-sdk-token.spec.ts

@@ -0,0 +1,54 @@
+import EnhancedSdkToken from './enhanced-sdk-token';
+
+describe('EnhancedSdkToken', () => {
+  it('should extract the event ingestion hostname from the SDK token', () => {
+    const token = new EnhancedSdkToken('zCsQuoHJxVPp895.ZWg9MTIzNDU2LmUudGVzdGluZy5lcHBvLmNsb3Vk');
+    expect(token.getEventIngestionHostname()).toEqual('123456.e.testing.eppo.cloud');
+  });
+
+  it('should extract the subdomain from the SDK token', () => {
+    const token = new EnhancedSdkToken(
+      'zCsQuoHJxVPp895.Y3M9ZXhwZXJpbWVudCZlaD1hYmMxMjMuZXBwby5jbG91ZA==',
+    );
+    expect(token.getSubdomain()).toEqual('experiment');
+    expect(token.getEventIngestionHostname()).toEqual('abc123.eppo.cloud');
+  });
+
+  it('should handle tokens with non URL-safe characters', () => {
+    // Include both eh and cs parameters with special characters
+    const params = 'eh=12+3456/.e.testing.eppo.cloud&cs=test+subdomain/special';
+    const encoded = Buffer.from(params).toString('base64url');
+    const token = new EnhancedSdkToken(`zCsQuoHJxVPp895.${encoded}`);
+
+    expect(token.getEventIngestionHostname()).toEqual('12 3456/.e.testing.eppo.cloud');
+    expect(token.getSubdomain()).toEqual('test subdomain/special');
+  });
+
+  it('should return null for tokens without the required parameter', () => {
+    const tokenWithoutEh = new EnhancedSdkToken('zCsQuoHJxVPp895.Y3M9ZXhwZXJpbWVudA=='); // only cs=experiment
+    expect(tokenWithoutEh.getEventIngestionHostname()).toBeNull();
+    expect(tokenWithoutEh.getSubdomain()).toEqual('experiment');
+
+    const tokenWithoutCs = new EnhancedSdkToken('zCsQuoHJxVPp895.ZWg9YWJjMTIzLmVwcG8uY2xvdWQ='); // only eh=abc123.eppo.cloud
+    expect(tokenWithoutCs.getEventIngestionHostname()).toEqual('abc123.eppo.cloud');
+    expect(tokenWithoutCs.getSubdomain()).toBeNull();
+  });
+
+  it('should handle invalid tokens', () => {
+    const invalidToken = new EnhancedSdkToken('zCsQuoHJxVPp895');
+    expect(invalidToken.getEventIngestionHostname()).toBeNull();
+    expect(invalidToken.getSubdomain()).toBeNull();
+    expect(invalidToken.isValid()).toBeFalsy();
+
+    const invalidEncodingToken = new EnhancedSdkToken('zCsQuoHJxVPp895.%%%');
+    expect(invalidEncodingToken.getEventIngestionHostname()).toBeNull();
+    expect(invalidEncodingToken.getSubdomain()).toBeNull();
+    expect(invalidEncodingToken.isValid()).toBeFalsy();
+  });
+
+  it('should provide access to the original token string', () => {
+    const tokenString = 'zCsQuoHJxVPp895.ZWg9MTIzNDU2LmUudGVzdGluZy5lcHBvLmNsb3Vk';
+    const token = new EnhancedSdkToken(tokenString);
+    expect(token.getToken()).toEqual(tokenString);
+  });
+});