Non-standard runtime support (#37)

Adds in support for runtimes that don't properly support the default `fetch-h2` http client by adding a native fetch implementation which is set as the default for non-node environments

It also evolved into a bit of a refactoring of the `api/` stuff

Author: toptobes

.env.example

@@ -8,10 +8,13 @@ APPLICATION_TOKEN=AstraCS:<rest_of_token>
 ASTRA_RUN_VECTORIZE_TESTS=
 
 # Set this to some value to enable running long-running tests
-ASTRA_RUN_LONG_TESTS`=
+ASTRA_RUN_LONG_TESTS=
 
 # Set this to some value to enable running admin tests
 ASTRA_RUN_ADMIN_TESTS=
 
 # Set this to run tests on HTTP1 by default
 ASTRA_USE_HTTP1=
+
+# Set this to use the native fetch instead of fetch-h2
+ASTRA_USE_FETCH=

.eslintrc.cjs

@@ -19,5 +19,6 @@ module.exports = {
         'caughtErrorsIgnorePattern': '^_',
       },
     ],
+    '@typescript-eslint/no-var-requires': 'off',
   },
 };

etc/astra-db-ts.api.md

@@ -4,8 +4,6 @@
 
 ```ts
 
-import { context as context_2 } from 'fetch-h2';
-import { Response as Response_2 } from 'fetch-h2';
 import TypedEmitter from 'typed-emitter';
 
 // @public
@@ -378,19 +376,7 @@ export interface DataAPIErrorDescriptor {
 }
 
 // @public
-export interface DataAPIHttp1Options {
-    keepAlive?: boolean;
-    keepAliveMS?: number;
-    maxFreeSockets?: number;
-    maxSockets?: number;
-}
-
-// @public
-export interface DataAPIHttpOptions {
-    http1?: DataAPIHttp1Options;
-    maxTimeMS?: number;
-    preferHttp2?: boolean;
-}
+export type DataAPIHttpOptions = FetchHttpClientOptions | DefaultHttpClientOptions;
 
 // @public
 export class DataAPIResponseError extends DataAPIError {
@@ -536,6 +522,14 @@ export interface DbSpawnOptions {
     token?: string;
 }
 
+// @public
+export interface DefaultHttpClientOptions {
+    client?: 'default';
+    http1?: Http1Options;
+    maxTimeMS?: number;
+    preferHttp2?: boolean;
+}
+
 // @public
 export interface DefaultIdOptions {
     type: 'uuid' | 'uuidv6' | 'uuidv7' | 'objectId';
@@ -587,10 +581,10 @@ export interface DevOpsAPIErrorDescriptor {
 
 // @public
 export class DevOpsAPIResponseError extends DevOpsAPIError {
-    // Warning: (ae-forgotten-export) The symbol "ResponseWithBody" needs to be exported by the entry point index.d.ts
+    // Warning: (ae-forgotten-export) The symbol "ResponseInfo" needs to be exported by the entry point index.d.ts
     //
     // @internal
-    constructor(resp: ResponseWithBody, data: Record<string, any> | undefined);
+    constructor(resp: ResponseInfo, data: Record<string, any> | undefined);
     readonly errors: DevOpsAPIErrorDescriptor[];
     readonly raw: CuratedAPIResponse;
     readonly status: number;
@@ -616,6 +610,12 @@ export class DevOpsUnexpectedStateError extends DevOpsAPIError {
 export interface DropCollectionOptions extends WithTimeout, WithNamespace {
 }
 
+// @public
+export interface FetchHttpClientOptions {
+    client: 'fetch';
+    maxTimeMS?: number;
+}
+
 // @public
 export type Filter<Schema extends SomeDoc> = {
     [K in keyof NoId<Schema>]?: FilterExpr<NoId<Schema>[K]>;
@@ -767,6 +767,14 @@ export interface GuaranteedUpdateOptions<N extends number> {
     modifiedCount: N;
 }
 
+// @public
+export interface Http1Options {
+    keepAlive?: boolean;
+    keepAliveMS?: number;
+    maxFreeSockets?: number;
+    maxSockets?: number;
+}
+
 // @public
 export type IdOf<TSchema> = TSchema extends {
     _id: infer Id;

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@datastax/astra-db-ts",
-  "version": "1.1.0",
+  "version": "1.1.1-0",
   "description": "Astra DB TS Client",
   "contributors": [
     "Kavin Gupta (https://github.com/toptobes)",

package.json

@@ -39,7 +39,7 @@ export interface DataAPIRequestInfo {
   timeoutManager: TimeoutManager;
 }
 
-type ExecuteCommandOptions = {
+interface ExecuteCommandOptions {
   collection?: string;
   namespace?: string;
 }
@@ -53,10 +53,7 @@ export class DataAPIHttpClient extends HttpClient {
   readonly #props: HTTPClientOptions & WithNamespace;
 
   constructor(props: HTTPClientOptions & WithNamespace) {
-    super({
-      ...props,
-      mkAuthHeader: (token) => ({ [DEFAULT_DATA_API_AUTH_HEADER]: token }),
-    });
+    super(props, mkAuthHeader);
     this.namespace = props.namespace;
     this.#props = props;
   }
@@ -195,3 +192,7 @@ export function reviver(_: string, value: any): any {
   }
   return value;
 }
+
+function mkAuthHeader(token: string): Record<string, any> {
+  return { [DEFAULT_DATA_API_AUTH_HEADER]: token };
+}

src/api/data-api-http-client.ts renamed to src/api/clients/data-api-http-client.ts

@@ -13,8 +13,7 @@
 // limitations under the License.
 // noinspection ExceptionCaughtLocallyJS
 
-import { hrTimeMs, HttpClient } from '@/src/api/http-client';
-import { APIResponse, HTTPClientOptions, HttpMethodStrings } from '@/src/api/types';
+import { hrTimeMs, HttpClient } from '@/src/api/clients/http-client';
 import { DevOpsAPIResponseError, DevOpsAPITimeoutError, DevOpsUnexpectedStateError } from '@/src/devops/errors';
 import { AdminBlockingOptions } from '@/src/devops/types';
 import { TimeoutManager, TimeoutOptions } from '@/src/api/timeout-managers';
@@ -25,6 +24,7 @@ import {
   AdminCommandStartedEvent,
   AdminCommandSucceededEvent,
 } from '@/src/devops';
+import { HTTPClientOptions, HttpMethodStrings } from '@/src/api/clients/types';
 
 /**
  * @internal
@@ -36,33 +36,29 @@ export interface DevOpsAPIRequestInfo {
   params?: Record<string, any>,
 }
 
-/**
- * @internal
- */
-export interface LongRunningRequestInfo {
-  id: string | ((resp: APIResponse) => string),
+interface LongRunningRequestInfo {
+  id: string | ((resp: DevopsAPIResponse) => string),
   target: string,
   legalStates: string[],
   defaultPollInterval: number,
   options: AdminBlockingOptions | undefined,
 }
 
+interface DevopsAPIResponse {
+  data?: Record<string, any>,
+  headers: Record<string, string>,
+  status: number,
+}
+
 /**
  * @internal
  */
 export class DevOpsAPIHttpClient extends HttpClient {
-  constructor(props: HTTPClientOptions) {
-    super({
-      ...props,
-      mkAuthHeader: (token) => ({ [DEFAULT_DEVOPS_API_AUTH_HEADER]: `Bearer ${token}` }),
-      fetchCtx: {
-        ...props.fetchCtx,
-        preferred: props.fetchCtx.http1,
-      },
-    });
+  constructor(opts: HTTPClientOptions) {
+    super(opts, mkAuthHeader);
   }
 
-  public async request(req: DevOpsAPIRequestInfo, options: TimeoutOptions | undefined, started: number = 0): Promise<APIResponse> {
+  public async request(req: DevOpsAPIRequestInfo, options: TimeoutOptions | undefined, started: number = 0): Promise<DevopsAPIResponse> {
     const isLongRunning = started !== 0;
 
     try {
@@ -80,6 +76,7 @@ export class DevOpsAPIHttpClient extends HttpClient {
         method: req.method,
         params: req.params,
         data: JSON.stringify(req.data),
+        forceHttp1: true,
         timeoutManager,
       });
 
@@ -111,7 +108,7 @@ export class DevOpsAPIHttpClient extends HttpClient {
     }
   }
 
-  public async requestLongRunning(req: DevOpsAPIRequestInfo, info: LongRunningRequestInfo): Promise<APIResponse> {
+  public async requestLongRunning(req: DevOpsAPIRequestInfo, info: LongRunningRequestInfo): Promise<DevopsAPIResponse> {
     const timeoutManager = this._mkTimeoutManager(info.options?.maxTimeMS);
     const isLongRunning = info?.options?.blocking !== false;
 
@@ -186,6 +183,10 @@ export class DevOpsAPIHttpClient extends HttpClient {
 
   private _mkTimeoutManager(timeout: number | undefined) {
     timeout ??= this.fetchCtx.maxTimeMS ?? (12 * 60 * 1000);
-    return new TimeoutManager(timeout, (info) => new DevOpsAPITimeoutError(info.url, timeout));
+    return new TimeoutManager(timeout, (url) => new DevOpsAPITimeoutError(url, timeout));
   }
 }
+
+function mkAuthHeader(token: string) {
+  return { [DEFAULT_DEVOPS_API_AUTH_HEADER]: `Bearer ${token}` };
+}

src/api/devops-api-http-client.ts renamed to src/api/clients/devops-api-http-client.ts

@@ -13,10 +13,10 @@
 // limitations under the License.
 
 import { CLIENT_USER_AGENT, RAGSTACK_REQUESTED_WITH } from '@/src/api/constants';
-import { HTTPRequestInfo, InternalFetchCtx, InternalHTTPClientOptions, ResponseWithBody } from '@/src/api/types';
 import { Caller, DataAPIClientEvents } from '@/src/client';
 import TypedEmitter from 'typed-emitter';
-import { TimeoutError } from 'fetch-h2';
+import { FetchCtx, ResponseInfo } from '@/src/api/fetch/types';
+import { AuthHeaderFactory, HTTPClientOptions, HTTPRequestInfo } from '@/src/api/clients/types';
 
 /**
  * @internal
@@ -25,11 +25,11 @@ export abstract class HttpClient {
   readonly baseUrl: string;
   readonly emitter: TypedEmitter<DataAPIClientEvents>;
   readonly monitorCommands: boolean;
-  readonly fetchCtx: InternalFetchCtx;
+  readonly fetchCtx: FetchCtx;
   readonly #applicationToken: string;
   readonly baseHeaders: Record<string, any>;
 
-  protected constructor(options: InternalHTTPClientOptions) {
+  protected constructor(options: HTTPClientOptions, mkAuthHeader: AuthHeaderFactory) {
     this.#applicationToken = options.applicationToken;
     this.baseUrl = options.baseUrl;
     this.emitter = options.emitter;
@@ -40,20 +40,20 @@ export abstract class HttpClient {
       this.baseUrl += '/' + options.baseApiPath;
     }
 
-    this.baseHeaders = options.mkAuthHeader?.(this.#applicationToken) ?? {};
+    this.baseHeaders = mkAuthHeader?.(this.#applicationToken) ?? {};
   }
 
   public get applicationToken(): string {
     return this.#applicationToken;
   }
 
-  protected async _request(info: HTTPRequestInfo): Promise<ResponseWithBody> {
+  protected async _request(info: HTTPRequestInfo): Promise<ResponseInfo> {
     if (this.fetchCtx.closed.ref) {
       throw new Error('Can\'t make requests on a closed client');
     }
 
-    if (info.timeoutManager.msRemaining <= 0) {
-      throw info.timeoutManager.mkTimeoutError(info);
+    if (info.timeoutManager.msRemaining() <= 0) {
+      throw info.timeoutManager.mkTimeoutError(info.url);
     }
 
     const params = info.params ?? {};
@@ -63,23 +63,14 @@ export abstract class HttpClient {
       ? `${info.url}?${new URLSearchParams(params).toString()}`
       : info.url;
 
-    try {
-      const resp = await this.fetchCtx.preferred.fetch(url, {
-        body: info.data as string,
-        method: info.method,
-        timeout: info.timeoutManager.msRemaining,
-        headers: this.baseHeaders,
-      }) as ResponseWithBody;
-
-      resp.body = await resp.text();
-
-      return resp;
-    } catch (e) {
-      if (e instanceof TimeoutError) {
-        throw info.timeoutManager.mkTimeoutError(info);
-      }
-      throw e;
-    }
+    return await this.fetchCtx.ctx.fetch({
+      url: url,
+      body: info.data,
+      method: info.method,
+      timeoutManager: info.timeoutManager,
+      headers: this.baseHeaders,
+      forceHttp1: info.forceHttp1,
+    });
   }
 }
 

src/api/http-client.ts renamed to src/api/clients/http-client.ts

@@ -0,0 +1,38 @@
+import type TypedEmitter from 'typed-emitter';
+import type { DataAPICommandEvents } from '@/src/data-api';
+import type { FetchCtx, HttpMethods } from '@/src/api';
+import type { TimeoutManager } from '@/src/api/timeout-managers';
+
+/**
+ * @internal
+ */
+export interface HTTPClientOptions {
+  baseUrl: string,
+  baseApiPath?: string,
+  applicationToken: string,
+  emitter: TypedEmitter<DataAPICommandEvents>,
+  monitorCommands: boolean,
+  fetchCtx: FetchCtx,
+}
+
+/**
+ * @internal
+ */
+export type AuthHeaderFactory = (token: string) => Record<string, any>;
+
+/**
+ * @internal
+ */
+export type HttpMethodStrings = typeof HttpMethods[keyof typeof HttpMethods];
+
+/**
+ * @internal
+ */
+export interface HTTPRequestInfo {
+  url: string,
+  data?: string,
+  params?: Record<string, string>,
+  method: HttpMethodStrings,
+  timeoutManager: TimeoutManager,
+  forceHttp1?: boolean,
+}