wip

Author: silesky

packages/browser/src/browser/__tests__/standalone-analytics.test.ts

@@ -1,6 +1,6 @@
 import jsdom, { JSDOM } from 'jsdom'
 import { InitOptions, getGlobalAnalytics } from '../../'
-import { AnalyticsBrowser, loadCDNSettings } from '../../browser'
+import { AnalyticsBrowser } from '../../browser'
 import { snippet } from '../../tester/__fixtures__/segment-snippet'
 import { install } from '../standalone-analytics'
 import unfetch from 'unfetch'

packages/browser/src/browser/index.ts

@@ -31,6 +31,8 @@ import { ClassicIntegrationSource } from '../plugins/ajs-destination/types'
 import { attachInspector } from '../core/inspector'
 import { Stats } from '../core/stats'
 import { setGlobalAnalyticsKey } from '../lib/global-analytics-helper'
+import { loadCDNSettings } from '../core/http-client/api-clients'
+import { FetchHTTPClient } from '../core/http-client'
 
 export interface RemoteIntegrationSettings {
   /* @deprecated - This does not indicate browser types anymore */
@@ -153,25 +155,6 @@ export interface AnalyticsBrowserSettings {
   classicIntegrations?: ClassicIntegrationSource[]
 }
 
-export function loadCDNSettings(
-  writeKey: string,
-  baseUrl: string
-): Promise<CDNSettings> {
-  return fetch(`${baseUrl}/v1/projects/${writeKey}/settings`)
-    .then((res) => {
-      if (!res.ok) {
-        return res.text().then((errorResponseMessage) => {
-          throw new Error(errorResponseMessage)
-        })
-      }
-      return res.json()
-    })
-    .catch((err) => {
-      console.error(err.message)
-      throw err
-    })
-}
-
 function hasLegacyDestinations(settings: CDNSettings): boolean {
   return (
     getProcessEnv().NODE_ENV !== 'test' &&
@@ -350,6 +333,8 @@ async function loadAnalytics(
     return [new NullAnalytics(), Context.system()]
   }
 
+  const httpClient = new FetchHTTPClient(options.httpClient)
+
   if (options.globalAnalyticsKey)
     setGlobalAnalyticsKey(options.globalAnalyticsKey)
   // this is an ugly side-effect, but it's for the benefits of the plugins that get their cdn via getCDN()
@@ -362,7 +347,11 @@ async function loadAnalytics(
 
   const cdnURL = settings.cdnURL ?? getCDN()
   let cdnSettings =
-    settings.cdnSettings ?? (await loadCDNSettings(settings.writeKey, cdnURL))
+    settings.cdnSettings ??
+    (await loadCDNSettings(httpClient, {
+      writeKey: settings.writeKey,
+      baseUrl: cdnURL,
+    }))
 
   if (options.updateCDNSettings) {
     cdnSettings = options.updateCDNSettings(cdnSettings)

packages/browser/src/core/analytics/index.ts

@@ -55,6 +55,7 @@ import {
   isSegmentPlugin,
   SegmentIOPluginMetadata,
 } from '../../plugins/segmentio'
+import { HTTPClient, HTTPFetchFn } from '../http-client'
 
 const deprecationWarning =
   'This is being deprecated and will be not be available in future releases of Analytics JS'
@@ -178,6 +179,11 @@ export interface InitOptions {
    * ```
    */
   disable?: boolean | ((cdnSettings: CDNSettings) => boolean | Promise<boolean>)
+
+  /**
+   * Override the fetch function used by the analytics instance.
+   */
+  httpClient?: HTTPFetchFn
 }
 
 /* analytics-classic stubs */

packages/browser/src/core/http-client/api-clients.ts

@@ -0,0 +1,25 @@
+import { HTTPClient } from '.'
+import { CDNSettings } from '../../browser'
+
+export async function loadCDNSettings(
+  client: HTTPClient,
+  { writeKey, baseUrl }: { writeKey: string; baseUrl: string }
+): Promise<CDNSettings> {
+  return client
+    .makeRequest({
+      url: `${baseUrl}/v1/projects/${writeKey}/settings`,
+      method: 'GET',
+    })
+    .then((res) => {
+      if (!res.ok) {
+        return res.text().then((errorResponseMessage) => {
+          throw new Error(errorResponseMessage)
+        })
+      }
+      return res.json()
+    })
+    .catch((err) => {
+      console.error(err.message)
+      throw err
+    })
+}

packages/browser/src/core/http-client/index.ts

@@ -0,0 +1,91 @@
+import { fetch as defaultFetch } from '../../lib/fetch'
+/**
+ * This interface is meant to be compatible with different fetch implementations (node and browser).
+ * Using the ambient fetch type is not possible because the AbortSignal type is not compatible with node-fetch.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API
+ */
+export interface HTTPFetchFn {
+  (url: string, requestInit: HTTPFetchRequest): Promise<HTTPResponse>
+}
+
+/**
+ * This interface is meant to be compatible with the Request interface.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Request
+ */
+export interface HTTPFetchRequest {
+  headers?: Record<string, string>
+  body?: string
+  method: HTTPClientRequest['method']
+}
+
+/**
+ * This interface is meant to be compatible with the Headers interface.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Headers
+ */
+export interface HTTPHeaders {
+  get: (key: string) => string | null
+  has: (key: string) => boolean
+  entries: () => IterableIterator<[string, any]>
+}
+
+/**
+ * This interface is meant to very minimally conform to the Response interface.
+ * @link https://developer.mozilla.org/en-US/docs/Web/API/Response
+ */
+export interface HTTPResponse {
+  headers?: Record<string, any> | HTTPHeaders
+  text: () => Promise<string>
+  json: () => Promise<any>
+  ok: boolean
+  status: number
+  statusText: string
+}
+
+/**
+ * This interface is meant to be a generic interface for making HTTP requests.
+ * While it may overlap with fetch's Request interface, it is not coupled to it.
+ */
+export interface HTTPClientRequest {
+  /**
+   * URL to be used for the request
+   * @example 'https://api.segment.io/v1/t'
+   */
+  url: string
+  /**
+   * HTTP method to be used for the request.
+   **/
+  method: string
+  /**
+   * Headers to be sent with the request
+   */
+  headers?: Record<string, string>
+  /**
+   * Data to be sent with the request
+   */
+  body?: string
+
+  /**
+   * Other options defined by the fetch API
+   */
+  [key: string]: unknown
+}
+
+/**
+ * HTTP client interface for making requests
+ */
+export interface HTTPClient {
+  makeRequest(_options: HTTPClientRequest): Promise<HTTPResponse>
+}
+
+/**
+ * Default HTTP client implementation using fetch
+ */
+export class FetchHTTPClient implements HTTPClient {
+  private _fetch: HTTPFetchFn
+  constructor(fetchFn?: HTTPFetchFn) {
+    this._fetch = fetchFn ?? defaultFetch
+  }
+  makeRequest(options: HTTPClientRequest): Promise<HTTPResponse> {
+    return this._fetch(options.url, options)
+  }
+}