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

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",
 };
 

package.json

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

src/__test__/readme.test.ts

@@ -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/common/index.ts

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

src/common/open-api/ConductorClient.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/__test__/EventResourceService.test.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__/WorkflowResourceService.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/core/CancelablePromise.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/OpenAPI.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,

src/common/open-api/index.ts

@@ -1,7 +1,9 @@
+
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-export { ConductorClient, ConductorClientAPIConfig } from "./ConductorClient";
+export { ConductorClient } from "./ConductorClient";
 
 export { ApiError } from "./core/ApiError";
 export { BaseHttpRequest } from "./core/BaseHttpRequest";

src/common/open-api/models/GenerateTokenRequest.ts

@@ -1,10 +1,10 @@
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-
 export type GenerateTokenRequest = {
+  expiration?: number;
   keyId: string;
   keySecret: string;
-  refreshTokenInterval?:number; // 0 no refresh
 };
 

src/common/open-api/models/Response.ts

@@ -1,7 +1,5 @@
+/* generated using openapi-typescript-codegen -- do not edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-
-export type Response = {
-};
-
+export type Response = Record<string, any>;