Refactor (rebuilt) top layer and OpenAPI layer code, enable HTTP/2 (#80)

Refactored (rebuilt) the top layer and the OpenAPI-generated layer to eliminate manually modified logic in generated code. This will make it easier to track backend updates and to add new functionality with minimal risk. Ultimately, OpenAPI-generated code should remain untouched, and all customizations should be implemented in the top layers instead. The next step is to regenerate the code for each OpenAPI service (resource) individually.

As part of the refactor, environment variables are now automatically prioritized over config variables, without requiring the "useEnvVars: true" config flag.

Enabled HTTP/2 support for the Node.js environment (powered by Undici). Undici was chosen because it provides the default built-in fetch in Node.js (since v18) and is expected to make H2 requests by default out of the box starting with Node.js v25. The default fetch remains in use for browser environments (browser fetch APIs already prioritize H2) or if undici fails to initialize. Also added the ability to pass in any custom fetch-like function when creating the client so sdk in theory can work on older versions of node.

Author: DmitryBorisov-sm

README.md

@@ -44,7 +44,7 @@ import { OrkesApiConfig, orkesConductorClient } from "@io-orkes/conductor-javasc
 const config: Partial<OrkesApiConfig> = {
   keyId: "XXX", // optional
   keySecret: "XXXX", // optional
-  refreshTokenInterval: 0, // optional (in milliseconds) defaults to 30 minutes (30 * 60 * 1000). 0 no refresh
+  refreshTokenInterval: 0, // optional (in milliseconds) | defaults to 30 minutes | 0 = no refresh
   serverUrl: "https://play.orkes.io/api",
 };
 

jest.config.js jest.config.mjsjest.config.js renamed to jest.config.mjs

@@ -88,5 +88,8 @@
     "suiteNameTemplate": "{filepath}",
     "classNameTemplate": "{classname}",
     "titleTemplate": "{title}"
+  },
+  "optionalDependencies": {
+    "undici": "^7.16.0"
   }
-}
+}

package.json

@@ -5,7 +5,7 @@ import { TaskType } from "../common";
 import { TaskRunner } from "../task";
 
 describe("TaskManager", () => {
-  const clientPromise = orkesConductorClient({ useEnvVars: true });
+  const clientPromise = orkesConductorClient();
 
   jest.setTimeout(20000);
   test("worker example ", async () => {

src/__test__/readme.test.ts

@@ -6,7 +6,6 @@ export {
   ConductorClient,
   ApiRequestOptions,
   ApiResult,
-  ConductorClientAPIConfig,
   OpenAPIConfig,
   OnCancel,
   ApiError,

src/common/index.ts

@@ -1,9 +1,9 @@
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
 import type { BaseHttpRequest } from "./core/BaseHttpRequest";
-import type { OpenAPIConfig, Resolver } from "./core/OpenAPI";
-
+import type { OpenAPIConfig } from "./core/OpenAPI";
 import { EventResourceService } from "./services/EventResourceService";
 import { HealthCheckResourceService } from "./services/HealthCheckResourceService";
 import { MetadataResourceService } from "./services/MetadataResourceService";
@@ -12,36 +12,12 @@ import { TaskResourceService } from "./services/TaskResourceService";
 import { TokenResourceService } from "./services/TokenResourceService";
 import { WorkflowBulkResourceService } from "./services/WorkflowBulkResourceService";
 import { WorkflowResourceService } from "./services/WorkflowResourceService";
-import { request as baseRequest } from "./core/request";
-import { ConductorHttpRequest } from "../RequestCustomizer";
 import { HumanTaskService } from "./services/HumanTaskService";
 import { HumanTaskResourceService } from "./services/HumanTaskResourceService";
-import {ServiceRegistryResourceService} from "./services/ServiceRegistryResourceService";
-
-export const defaultRequestHandler: ConductorHttpRequest = (
-  request,
-  config,
-  options
-) => request(config, options);
-
-export interface ConductorClientAPIConfig extends Omit<OpenAPIConfig, "BASE"> {
-  serverUrl: string;
-  useEnvVars: boolean;
-}
-
-const getServerBaseURL = (config?: Partial<ConductorClientAPIConfig>) => {
-  if (config?.useEnvVars) {
-    if(!process.env.CONDUCTOR_SERVER_URL) {
-      throw new Error(
-        "Environment variable CONDUCTOR_SERVER_URL is not defined."
-      );
-    }
+import { ServiceRegistryResourceService } from "./services/ServiceRegistryResourceService";
+import { NodeHttpRequest } from "./core/NodeHttpRequest";
 
-    return process.env.CONDUCTOR_SERVER_URL;
-  }
-
-  return config?.serverUrl ?? "http://localhost:8080";
-};
+type HttpRequestConstructor = new (config: OpenAPIConfig) => BaseHttpRequest;
 
 export class ConductorClient {
   public readonly eventResource: EventResourceService;
@@ -53,47 +29,25 @@ export class ConductorClient {
   public readonly workflowBulkResource: WorkflowBulkResourceService;
   public readonly workflowResource: WorkflowResourceService;
   public readonly serviceRegistryResource: ServiceRegistryResourceService;
-
   public readonly humanTask: HumanTaskService;
   public readonly humanTaskResource: HumanTaskResourceService;
   public readonly request: BaseHttpRequest;
 
-  public token?: string | Resolver<string>;
-
   constructor(
-    config?: Partial<ConductorClientAPIConfig>,
-    requestHandler: ConductorHttpRequest = defaultRequestHandler
+    config?: Partial<OpenAPIConfig>,
+    HttpRequest: HttpRequestConstructor = NodeHttpRequest
   ) {
-    const resolvedConfig = {
-      BASE: getServerBaseURL(config),
-      VERSION: config?.VERSION ?? "0",
+    this.request = new HttpRequest({
+      BASE: config?.BASE ?? "http://localhost:8080",
+      VERSION: config?.VERSION ?? "2",
       WITH_CREDENTIALS: config?.WITH_CREDENTIALS ?? false,
       CREDENTIALS: config?.CREDENTIALS ?? "include",
       TOKEN: config?.TOKEN,
       USERNAME: config?.USERNAME,
       PASSWORD: config?.PASSWORD,
       HEADERS: config?.HEADERS,
       ENCODE_PATH: config?.ENCODE_PATH,
-    };
-
-    // START conductor-client-modification
-    /* The generated models are all based on the concept of an instantiated base http
-    class. To avoid making edits there, we just create an object that satisfies the same
-    interface. Yay typescript!
-     */
-    this.request = {
-      config: resolvedConfig,
-      request: (apiConfig) => {
-        return requestHandler(
-          baseRequest,
-          { ...resolvedConfig, TOKEN: this.token },
-          apiConfig
-        );
-      },
-    };
-    this.token = config?.TOKEN;
-    // END conductor-client-modification
-
+    });
     this.eventResource = new EventResourceService(this.request);
     this.healthCheckResource = new HealthCheckResourceService(this.request);
     this.metadataResource = new MetadataResourceService(this.request);
@@ -106,5 +60,4 @@ export class ConductorClient {
     this.humanTask = new HumanTaskService(this.request);
     this.humanTaskResource = new HumanTaskResourceService(this.request);
   }
-  stop() {}
 }

src/common/open-api/ConductorClient.ts

@@ -3,7 +3,7 @@ import { orkesConductorClient } from "../../../orkes";
 
 describe("EventResourceService", () => {
   test("Should create an event handler with description and tags and then delete it", async () => {
-    const orkesClient = await orkesConductorClient({ useEnvVars: true });
+    const orkesClient = await orkesConductorClient();
     const eventApi = orkesClient.eventResource;
 
     const [eventName, event, eventDescription, eventTagKey, eventTagValue] = [

src/common/open-api/__test__/EventResourceService.test.ts

@@ -8,7 +8,7 @@ describe("WorkflowResourceService", () => {
   jest.setTimeout(120000);
 
   test("Should test a workflow", async () => {
-    const client = await orkesConductorClient({ useEnvVars: true });
+    const client = await orkesConductorClient();
     const metadataClient = new MetadataClient(client);
     const tasks: TaskDefTypes[] = [
       simpleTask("simple_ref", "le_simple_task", {}),

src/common/open-api/__test__/WorkflowResourceService.test.ts

@@ -1,3 +1,4 @@
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
@@ -22,15 +23,13 @@ export interface OnCancel {
 }
 
 export class CancelablePromise<T> implements Promise<T> {
-  readonly [Symbol.toStringTag]!: string;
-
-  private _isResolved: boolean;
-  private _isRejected: boolean;
-  private _isCancelled: boolean;
-  private readonly _cancelHandlers: (() => void)[];
-  private readonly _promise: Promise<T>;
-  private _resolve?: (value: T | PromiseLike<T>) => void;
-  private _reject?: (reason?: any) => void;
+  #isResolved: boolean;
+  #isRejected: boolean;
+  #isCancelled: boolean;
+  readonly #cancelHandlers: (() => void)[];
+  readonly #promise: Promise<T>;
+  #resolve?: (value: T | PromiseLike<T>) => void;
+  #reject?: (reason?: any) => void;
 
   constructor(
     executor: (
@@ -39,90 +38,94 @@ export class CancelablePromise<T> implements Promise<T> {
       onCancel: OnCancel
     ) => void
   ) {
-    this._isResolved = false;
-    this._isRejected = false;
-    this._isCancelled = false;
-    this._cancelHandlers = [];
-    this._promise = new Promise<T>((resolve, reject) => {
-      this._resolve = resolve;
-      this._reject = reject;
+    this.#isResolved = false;
+    this.#isRejected = false;
+    this.#isCancelled = false;
+    this.#cancelHandlers = [];
+    this.#promise = new Promise<T>((resolve, reject) => {
+      this.#resolve = resolve;
+      this.#reject = reject;
 
       const onResolve = (value: T | PromiseLike<T>): void => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
           return;
         }
-        this._isResolved = true;
-        this._resolve?.(value);
+        this.#isResolved = true;
+        if (this.#resolve) this.#resolve(value);
       };
 
       const onReject = (reason?: any): void => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
           return;
         }
-        this._isRejected = true;
-        this._reject?.(reason);
+        this.#isRejected = true;
+        if (this.#reject) this.#reject(reason);
       };
 
       const onCancel = (cancelHandler: () => void): void => {
-        if (this._isResolved || this._isRejected || this._isCancelled) {
+        if (this.#isResolved || this.#isRejected || this.#isCancelled) {
           return;
         }
-        this._cancelHandlers.push(cancelHandler);
+        this.#cancelHandlers.push(cancelHandler);
       };
 
       Object.defineProperty(onCancel, 'isResolved', {
-        get: (): boolean => this._isResolved,
+        get: (): boolean => this.#isResolved,
       });
 
       Object.defineProperty(onCancel, 'isRejected', {
-        get: (): boolean => this._isRejected,
+        get: (): boolean => this.#isRejected,
       });
 
       Object.defineProperty(onCancel, 'isCancelled', {
-        get: (): boolean => this._isCancelled,
+        get: (): boolean => this.#isCancelled,
       });
 
       return executor(onResolve, onReject, onCancel as OnCancel);
     });
   }
 
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+
   public then<TResult1 = T, TResult2 = never>(
     onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
     onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
   ): Promise<TResult1 | TResult2> {
-    return this._promise.then(onFulfilled, onRejected);
+    return this.#promise.then(onFulfilled, onRejected);
   }
 
   public catch<TResult = never>(
     onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
   ): Promise<T | TResult> {
-    return this._promise.catch(onRejected);
+    return this.#promise.catch(onRejected);
   }
 
   public finally(onFinally?: (() => void) | null): Promise<T> {
-    return this._promise.finally(onFinally);
+    return this.#promise.finally(onFinally);
   }
 
   public cancel(): void {
-    if (this._isResolved || this._isRejected || this._isCancelled) {
+    if (this.#isResolved || this.#isRejected || this.#isCancelled) {
       return;
     }
-    this._isCancelled = true;
-    if (this._cancelHandlers.length) {
+    this.#isCancelled = true;
+    if (this.#cancelHandlers.length) {
       try {
-        for (const cancelHandler of this._cancelHandlers) {
+        for (const cancelHandler of this.#cancelHandlers) {
           cancelHandler();
         }
       } catch (error) {
         console.warn('Cancellation threw an error', error);
         return;
       }
     }
-    this._cancelHandlers.length = 0;
-    this._reject?.(new CancelError('Request aborted'));
+    this.#cancelHandlers.length = 0;
+    if (this.#reject) this.#reject(new CancelError('Request aborted'));
   }
 
   public get isCancelled(): boolean {
-    return this._isCancelled;
+    return this.#isCancelled;
   }
 }

src/common/open-api/core/CancelablePromise.ts

@@ -1,26 +1,27 @@
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
 import type { ApiRequestOptions } from './ApiRequestOptions';
 
-export type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
 type Headers = Record<string, string>;
 
 export type OpenAPIConfig = {
   BASE: string;
   VERSION: string;
   WITH_CREDENTIALS: boolean;
   CREDENTIALS: 'include' | 'omit' | 'same-origin';
-  TOKEN?: string | Resolver<string>;
-  USERNAME?: string | Resolver<string>;
-  PASSWORD?: string | Resolver<string>;
-  HEADERS?: Headers | Resolver<Headers>;
-  ENCODE_PATH?: (path: string) => string;
+  TOKEN?: string | Resolver<string> | undefined;
+  USERNAME?: string | Resolver<string> | undefined;
+  PASSWORD?: string | Resolver<string> | undefined;
+  HEADERS?: Headers | Resolver<Headers> | undefined;
+  ENCODE_PATH?: ((path: string) => string) | undefined;
 };
 
 export const OpenAPI: OpenAPIConfig = {
   BASE: 'http://localhost:8080',
-  VERSION: '0',
+  VERSION: '2',
   WITH_CREDENTIALS: false,
   CREDENTIALS: 'include',
   TOKEN: undefined,