add ability to pass custom fetchFn, refactor code

Author: DmitryBorisov-sm

src/orkes/ConductorClientWithAuth.ts

@@ -1,18 +1,17 @@
-import type { OpenAPIConfig } from "../common";
+import type { BaseHttpRequest, OpenAPIConfig } from "../common";
 import { ConductorClient } from "../common";
-import { HttpRequestConstructor } from "./types";
 
 export class ConductorClientWithAuth extends ConductorClient {
   private intervalId?: NodeJS.Timeout;
 
   constructor(
     config: Partial<OpenAPIConfig>,
-    HttpRequest?: HttpRequestConstructor
+    HttpRequest?: new (config: OpenAPIConfig) => BaseHttpRequest
   ) {
     super(config, HttpRequest);
   }
 
-  private setToken(token: string) {
+  private setToken(token: string | undefined) {
     this.request.config.TOKEN = token;
   }
 
@@ -40,13 +39,9 @@ export class ConductorClientWithAuth extends ConductorClient {
   }
 
   public deAuthorize(): void {
-    this.clearTokenInterval();
-    this.request.config.TOKEN = undefined;
-  }
-
-  public clearTokenInterval(): void {
-    if (this.intervalId != null) {
+    if (this.intervalId) {
       clearInterval(this.intervalId);
     }
+    this.setToken(undefined);
   }
 }

src/orkes/constants.ts

@@ -0,0 +1 @@
+export const REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1000;

src/orkes/OrkesConductorClient.ts src/orkes/createOrkesConductorClient.tssrc/orkes/OrkesConductorClient.ts renamed to src/orkes/createOrkesConductorClient.ts

@@ -1,30 +1,27 @@
 import { ConductorClientWithAuth } from "./ConductorClientWithAuth";
-import { OrkesHttpRequest } from "./request/OrkesHttpRequest";
-import { HttpRequestConstructor, OrkesApiConfig } from "./types";
-
-const REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1000;
+import { resolveFetchFn, resolveOrkesConfig } from "./helpers";
+import { createOrkesHttpRequest } from "./request/createOrkesHttpRequest";
+import type { FetchFn, OrkesApiConfig } from "./types";
+import { REFRESH_TOKEN_IN_MILLISECONDS } from "./constants";
 
 /**
  * Takes a config with keyId and keySecret returns a promise with an instance of ConductorClient
  *
  * @param config (optional) OrkesApiConfig with keyId and keySecret
- * @param HttpRequest (optional) Custom request class, could be used to pass in a custom fetch function
+ * @param customFetch (optional) custom fetch function
  * @returns
  */
 export const orkesConductorClient = async (
   config?: Partial<OrkesApiConfig>,
-  HttpRequest: HttpRequestConstructor = OrkesHttpRequest
+  customFetch?: FetchFn
 ) => {
-  const serverUrl = process.env.CONDUCTOR_SERVER_URL || config?.serverUrl;
+  const { serverUrl, keyId, keySecret } = resolveOrkesConfig(config);
 
   if (!serverUrl) throw new Error("Conductor server URL is not set");
 
-  const keyId = process.env.CONDUCTOR_AUTH_KEY || config?.keyId;
-  const keySecret = process.env.CONDUCTOR_AUTH_SECRET || config?.keySecret;
-
   const conductorClientWithAuth = new ConductorClientWithAuth(
     { ...config, BASE: serverUrl },
-    HttpRequest
+    createOrkesHttpRequest(resolveFetchFn(customFetch))
   );
 
   if (keyId && keySecret) {

src/orkes/helpers/createUndiciHttp2Fetch.ts

@@ -0,0 +1,17 @@
+import {
+  fetch as undiciFetch,
+  Agent as UndiciAgent,
+  RequestInfo as UndiciRequestInfo,
+  RequestInit as UndiciRequestInit,
+} from "undici";
+
+export const createUndiciHttp2Fetch = () => {
+  const undiciHttp2Agent = new UndiciAgent({ allowH2: true });
+
+  return async (input: UndiciRequestInfo, init?: UndiciRequestInit) => {
+    return undiciFetch(input, {
+      ...init,
+      dispatcher: undiciHttp2Agent,
+    });
+  };
+};

src/orkes/helpers/index.ts

@@ -0,0 +1,3 @@
+export * from "./resolveFetchFn";
+export * from "./resolveOrkesConfig";
+export * from "./createUndiciHttp2Fetch";

src/orkes/helpers/resolveFetchFn.ts

@@ -0,0 +1,8 @@
+import { FetchFn } from "../types";
+import { createUndiciHttp2Fetch } from "./createUndiciHttp2Fetch";
+
+export const resolveFetchFn = (customFetch?: FetchFn) =>
+  customFetch ||
+  (process?.release?.name === "node"
+    ? (createUndiciHttp2Fetch() as FetchFn)
+    : fetch);

src/orkes/helpers/resolveOrkesConfig.ts

@@ -0,0 +1,9 @@
+import { OrkesApiConfig } from "../types";
+
+export const resolveOrkesConfig = (config?: Partial<OrkesApiConfig>) => {
+  return {
+    serverUrl: process.env.CONDUCTOR_SERVER_URL || config?.serverUrl,
+    keyId: process.env.CONDUCTOR_AUTH_KEY || config?.keyId,
+    keySecret: process.env.CONDUCTOR_AUTH_SECRET || config?.keySecret,
+  };
+};

src/orkes/index.ts

@@ -1,4 +1,4 @@
-export * from "./OrkesConductorClient";
+export * from "./createOrkesConductorClient";
 export * from "./ConductorClientWithAuth";
 export * from "./request/request";
 

src/orkes/request/OrkesHttpRequest.ts

@@ -0,0 +1,20 @@
+import {
+  ApiRequestOptions,
+  BaseHttpRequest,
+  CancelablePromise,
+  OpenAPIConfig,
+} from "../../common";
+import { FetchFn } from "../types";
+import { request as orkesRequest } from "./request";
+
+export function createOrkesHttpRequest(fetchFn?: FetchFn) {
+  return class OrkesHttpRequest extends BaseHttpRequest {
+    constructor(config: OpenAPIConfig) {
+      super(config);
+    }
+
+    public request<T>(options: ApiRequestOptions): CancelablePromise<T> {
+      return orkesRequest(this.config, options, fetchFn);
+    }
+  };
+}