move event URL into api endpoints

Author: typotter

src/api-endpoint.spec.ts

@@ -1,22 +1,24 @@
+import * as td from 'testdouble';
+
 import ApiEndpoints from './api-endpoints';
-import { BASE_URL as DEFAULT_BASE_URL } from './constants';
+import { BASE_URL as DEFAULT_BASE_URL, DEFAULT_EVENT_DOMAIN } from './constants';
 import EnhancedSdkToken from './enhanced-sdk-token';
 
 describe('ApiEndpoints', () => {
   it('should append query parameters to the URL', () => {
     const apiEndpoints = new ApiEndpoints({
-      baseUrl: 'https://api.example.com',
+      baseUrl: 'http://api.example.com',
       queryParams: {
         apiKey: '12345',
         sdkVersion: 'foobar',
         sdkName: 'ExampleSDK',
       },
     });
     expect(apiEndpoints.endpoint('/data').toString()).toEqual(
-      'https://api.example.com/data?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
+      'http://api.example.com/data?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
     );
     expect(apiEndpoints.ufcEndpoint().toString()).toEqual(
-      'https://api.example.com/flag-config/v1/config?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
+      'http://api.example.com/flag-config/v1/config?apiKey=12345&sdkVersion=foobar&sdkName=ExampleSDK',
     );
   });
 
@@ -55,7 +57,7 @@ describe('ApiEndpoints', () => {
       // 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');
+      expect(endpoints.endpoint('/data')).toBe('https://test-subdomain.fscdn.eppo.cloud/api/data');
     });
 
     it('should prefer custom baseUrl over SDK token subdomain', () => {
@@ -66,20 +68,21 @@ describe('ApiEndpoints', () => {
         baseUrl: customBaseUrl,
         sdkToken: new EnhancedSdkToken(sdkToken),
       });
-      expect(endpoints.getEffectiveBaseUrl()).toBe(customBaseUrl);
+
+      expect(endpoints.endpoint('')).toContain(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);
+      expect(endpoints.endpoint('').startsWith(DEFAULT_BASE_URL)).toBeTruthy();
     });
 
     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);
+      expect(endpoints.endpoint('').startsWith(DEFAULT_BASE_URL)).toBeTruthy();
     });
   });
 
@@ -133,6 +136,37 @@ describe('ApiEndpoints', () => {
     });
   });
 
+  describe('Event Url generation', () => {
+    const hostnameToken = new EnhancedSdkToken(
+      'zCsQuoHJxVPp895.ZWg9MTIzNDU2LmUudGVzdGluZy5lcHBvLmNsb3Vk',
+    );
+    const mockedToken = td.object<EnhancedSdkToken>();
+    beforeAll(() => {
+      td.when(mockedToken.isValid()).thenReturn(true);
+    });
+
+    it('should decode the event ingestion hostname from the SDK key', () => {
+      const endpoints = new ApiEndpoints({ sdkToken: hostnameToken });
+      const hostname = endpoints.eventIngestionEndpoint();
+      expect(hostname).toEqual('https://123456.e.testing.eppo.cloud/v0/i');
+    });
+
+    it('should decode strings with non URL-safe characters', () => {
+      // this is not a really valid ingestion URL, but it's useful for testing the decoder
+      td.when(mockedToken.getEventIngestionHostname()).thenReturn('12 3456/.e.testing.eppo.cloud');
+      const endpoints = new ApiEndpoints({ sdkToken: mockedToken });
+      const hostname = endpoints.eventIngestionEndpoint();
+      expect(hostname).toEqual('https://12 3456/.e.testing.eppo.cloud/v0/i');
+    });
+
+    it("should return null if the SDK key doesn't contain the event ingestion hostname", () => {
+      td.when(mockedToken.isValid()).thenReturn(false);
+      const endpoints = new ApiEndpoints({ sdkToken: mockedToken });
+      const hostname = endpoints.eventIngestionEndpoint();
+      expect(hostname).toBeNull();
+    });
+  });
+
   describe('Query parameter handling', () => {
     it('should append query parameters to endpoint URLs', () => {
       const queryParams = { apiKey: 'test-key', sdkName: 'js-sdk', sdkVersion: '1.0.0' };
@@ -161,3 +195,110 @@ describe('ApiEndpoints', () => {
     });
   });
 });
+
+describe('ApiEndpoints - Additional Tests', () => {
+  describe('URL normalization', () => {
+    it('should preserve different protocol types', () => {
+      // We can test this indirectly through the endpoint method
+      const httpEndpoints = new ApiEndpoints({ baseUrl: 'http://example.com' });
+      const httpsEndpoints = new ApiEndpoints({ baseUrl: 'https://example.com' });
+      const protocolRelativeEndpoints = new ApiEndpoints({ baseUrl: '//example.com' });
+
+      expect(httpEndpoints.endpoint('test')).toEqual('http://example.com/test');
+      expect(httpsEndpoints.endpoint('test')).toEqual('https://example.com/test');
+      expect(protocolRelativeEndpoints.endpoint('test')).toEqual('//example.com/test');
+    });
+
+    it('should add https:// to URLs without protocols', () => {
+      const endpoints = new ApiEndpoints({ baseUrl: 'example.com' });
+      expect(endpoints.endpoint('test')).toEqual('https://example.com/test');
+    });
+
+    it('should handle multiple slashes', () => {
+      const endpoints = new ApiEndpoints({ baseUrl: 'example.com/' });
+      expect(endpoints.endpoint('/test')).toEqual('https://example.com/test');
+    });
+  });
+
+  describe('Subdomain handling', () => {
+    it('should correctly integrate subdomain with base URLs containing paths', () => {
+      const sdkToken = new EnhancedSdkToken('abc.Y3M9dGVzdC1zdWJkb21haW4='); // cs=test-subdomain
+      const endpoints = new ApiEndpoints({
+        sdkToken,
+        defaultUrl: 'example.com/api/v2',
+      });
+
+      expect(endpoints.endpoint('')).toContain('https://test-subdomain.example.com/api/v2');
+    });
+
+    it('should handle subdomains with special characters', () => {
+      // Encode a token with cs=test-sub.domain-special
+      const sdkToken = new EnhancedSdkToken('abc.Y3M9dGVzdC1zdWIuZG9tYWluLXNwZWNpYWw=');
+      const endpoints = new ApiEndpoints({ sdkToken });
+
+      // The implementation should handle this correctly, but this is what we'd expect
+      expect(endpoints.endpoint('')).toContain('test-sub.domain-special');
+    });
+  });
+
+  describe('Event ingestion endpoint', () => {
+    it('should use subdomain with DEFAULT_EVENT_DOMAIN when hostname is not available', () => {
+      // Create a mock token with only a subdomain
+      const mockToken = {
+        isValid: () => true,
+        getEventIngestionHostname: () => null,
+        getSubdomain: () => 'test-subdomain',
+      } as EnhancedSdkToken;
+
+      const endpoints = new ApiEndpoints({ sdkToken: mockToken });
+      expect(endpoints.eventIngestionEndpoint()).toEqual(
+        `https://test-subdomain.${DEFAULT_EVENT_DOMAIN}/v0/i`,
+      );
+    });
+
+    it('should prioritize hostname over subdomain if both are available', () => {
+      // Create a mock token with both hostname and subdomain
+      const mockToken = {
+        isValid: () => true,
+        getEventIngestionHostname: () => 'event-host.example.com',
+        getSubdomain: () => 'test-subdomain',
+      } as EnhancedSdkToken;
+
+      const endpoints = new ApiEndpoints({ sdkToken: mockToken });
+      expect(endpoints.eventIngestionEndpoint()).toEqual('https://event-host.example.com/v0/i');
+    });
+
+    it('should return null when token is valid but no hostname or subdomain is available', () => {
+      // Create a mock token with neither hostname nor subdomain
+      const mockToken = {
+        isValid: () => true,
+        getEventIngestionHostname: () => null,
+        getSubdomain: () => null,
+      } as EnhancedSdkToken;
+
+      const endpoints = new ApiEndpoints({ sdkToken: mockToken });
+      expect(endpoints.eventIngestionEndpoint()).toBeNull();
+    });
+  });
+
+  describe('Edge cases and error handling', () => {
+    it('should handle extremely long subdomains', () => {
+      const longSubdomain = 'a'.repeat(100);
+      const mockToken = {
+        isValid: () => true,
+        getSubdomain: () => longSubdomain,
+      } as EnhancedSdkToken;
+
+      const endpoints = new ApiEndpoints({ sdkToken: mockToken });
+      expect(endpoints.endpoint('')).toContain(longSubdomain);
+    });
+
+    it('should handle unusual base URL formats', () => {
+      const endpoints = new ApiEndpoints({
+        baseUrl: 'https://@:example.com:8080/path?query=value#fragment',
+      });
+      // The exact handling will depend on implementation details, but it shouldn't throw
+      expect(() => endpoints.endpoint('test')).not.toThrow();
+    });
+  });
+});

src/api-endpoints.ts

@@ -1,15 +1,25 @@
-import { BANDIT_ENDPOINT, BASE_URL, PRECOMPUTED_FLAGS_ENDPOINT, UFC_ENDPOINT } from './constants';
+import {
+  BANDIT_ENDPOINT,
+  BASE_URL,
+  DEFAULT_EVENT_DOMAIN,
+  PRECOMPUTED_FLAGS_ENDPOINT,
+  UFC_ENDPOINT,
+} from './constants';
 import EnhancedSdkToken from './enhanced-sdk-token';
 import { IQueryParams, IQueryParamsWithSubject } from './http-client';
 
+const EVENT_ENDPOINT = 'v0/i';
+
 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 */
+/**
+ * Utility class for constructing Eppo API endpoint URLs
+ */
 export default class ApiEndpoints {
   private readonly sdkToken: EnhancedSdkToken | null;
   private readonly _effectiveBaseUrl: string;
@@ -18,12 +28,20 @@ export default class ApiEndpoints {
   constructor(params: Partial<IApiEndpointsParams>) {
     this.params = Object.assign({}, { defaultUrl: BASE_URL }, params);
     this.sdkToken = params.sdkToken ?? null;
+    this._effectiveBaseUrl = this.determineBaseUrl();
+  }
 
-    // this.params.baseUrl =
-    //   params.baseUrl && params.baseUrl !== DEFAULT_BASE_URL ? params.baseUrl : DEFAULT_URL;
+  /**
+   * Normalizes a URL by ensuring proper protocol and removing trailing slashes
+   */
+  private normalizeUrl(url: string, protocol = 'https://'): string {
+    const protocolMatch = url.match(/^(https?:\/\/|\/\/)/i);
 
-    // Set the effective base URL.
-    this._effectiveBaseUrl = this.determineBaseUrl();
+    if (protocolMatch) {
+      return url;
+    } else {
+      return `${protocol}${url}`;
+    }
   }
 
   /**
@@ -32,78 +50,89 @@ export default class ApiEndpoints {
    * 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 joinUrlParts(...parts: string[]): string {
+    return parts
+      .map((part) => part.trim())
+      .map((part, i) => {
+        // For first part, remove trailing slash
+        if (i === 0) return part.replace(/\/+$/, '');
+        // For other parts, remove leading and trailing slashes
+        return part.replace(/^\/+|\/+$/g, '');
+      })
+      .join('/');
+  }
+
+  /**
+   * Determine the effective base URL based on the constructor parameters
+   */
   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;
+      return this.normalizeUrl(this.params.baseUrl);
     }
 
-    // If there's an enhanced SDK token with a subdomain, it will be prepended in the buildUrl method.
+    // If there's a valid SDK token with a subdomain, use it
     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}`;
-  }
+    if (subdomain && this.sdkToken?.isValid()) {
+      // Extract the domain part without protocol
+      const defaultUrl = this.params.defaultUrl;
+      const domainPart = defaultUrl.replace(/^(https?:\/\/|\/\/)/, '');
+      return this.normalizeUrl(`${subdomain}.${domainPart}`);
+    }
 
-  /**
-   * Returns the base URL being used for the UFC and bandit endpoints
-   */
-  getEffectiveBaseUrl(): string {
-    return this._effectiveBaseUrl;
+    // Fall back to default URL
+    return this.normalizeUrl(this.params.defaultUrl);
   }
 
   /**
    * Creates an endpoint URL with the specified resource path and query parameters
    */
   endpoint(resource: string): string {
-    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 url = this.joinUrlParts(this._effectiveBaseUrl, resource);
 
     const queryParams = this.params.queryParams;
     if (!queryParams) {
-      return endpointUrl;
+      return url;
     }
 
     const urlSearchParams = new URLSearchParams();
     Object.entries(queryParams).forEach(([key, value]) => urlSearchParams.append(key, value));
 
-    return `${endpointUrl}?${urlSearchParams}`;
+    return `${url}?${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);
+  eventIngestionEndpoint(): string | null {
+    if (!this.sdkToken?.isValid()) return null;
+
+    const hostname = this.sdkToken.getEventIngestionHostname();
+    const subdomain = this.sdkToken.getSubdomain();
+
+    if (!hostname && !subdomain) return null;
+
+    // If we have a hostname from the token, use it directly
+    if (hostname) {
+      return this.normalizeUrl(this.joinUrlParts(hostname, EVENT_ENDPOINT));
+    }
+
+    // Otherwise use subdomain with default event domain
+    if (subdomain) {
+      return this.normalizeUrl(
+        this.joinUrlParts(`${subdomain}.${DEFAULT_EVENT_DOMAIN}`, EVENT_ENDPOINT),
+      );
+    }
+
+    return null;
   }
-  public static readonly URL_PROTOCOLS = ['http://', 'https://', '//'];
 }