@io-orkes/conductor-javascript 2.1.4 → 2.1.5

package/dist/index.js

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // index.ts
-var conductor_javascript_exports = {};
-__export(conductor_javascript_exports, {
+var index_exports = {};
+__export(index_exports, {
   ApiError: () => ApiError,
   AuthConductorClient: () => AuthConductorClient,
   BaseHttpRequest: () => BaseHttpRequest,
@@ -37,6 +37,7 @@ __export(conductor_javascript_exports, {
   CancelablePromise: () => CancelablePromise,
   ConductorClient: () => ConductorClient,
   ConductorError: () => ConductorError,
+  Consistency: () => Consistency,
   DefaultLogger: () => DefaultLogger,
   EventResourceService: () => EventResourceService,
   HealthCheckResourceService: () => HealthCheckResourceService,
@@ -44,6 +45,7 @@ __export(conductor_javascript_exports, {
   MAX_RETRIES: () => MAX_RETRIES,
   MetadataClient: () => MetadataClient,
   MetadataResourceService: () => MetadataResourceService,
+  ReturnStrategy: () => ReturnStrategy,
   SchedulerClient: () => SchedulerClient,
   SchedulerResourceService: () => SchedulerResourceService,
   TaskClient: () => TaskClient,
@@ -101,7 +103,7 @@ __export(conductor_javascript_exports, {
   waitTaskUntil: () => waitTaskUntil,
   workflow: () => workflow
 });
-module.exports = __toCommonJS(conductor_javascript_exports);
+module.exports = __toCommonJS(index_exports);
 
 // src/common/ConductorLogger.ts
 var LOG_LEVELS = {
@@ -157,6 +159,19 @@ var noopLogger = {
 };
 
 // src/common/types.ts
+var Consistency = /* @__PURE__ */ ((Consistency3) => {
+  Consistency3["SYNCHRONOUS"] = "SYNCHRONOUS";
+  Consistency3["DURABLE"] = "DURABLE";
+  Consistency3["REGION_DURABLE"] = "REGION_DURABLE";
+  return Consistency3;
+})(Consistency || {});
+var ReturnStrategy = /* @__PURE__ */ ((ReturnStrategy2) => {
+  ReturnStrategy2["TARGET_WORKFLOW"] = "TARGET_WORKFLOW";
+  ReturnStrategy2["BLOCKING_WORKFLOW"] = "BLOCKING_WORKFLOW";
+  ReturnStrategy2["BLOCKING_TASK"] = "BLOCKING_TASK";
+  ReturnStrategy2["BLOCKING_TASK_INPUT"] = "BLOCKING_TASK_INPUT";
+  return ReturnStrategy2;
+})(ReturnStrategy || {});
 var TaskType = /* @__PURE__ */ ((TaskType2) => {
   TaskType2["START"] = "START";
   TaskType2["SIMPLE"] = "SIMPLE";
@@ -995,6 +1010,76 @@ var TaskResourceService = class {
       }
     });
   }
+  /**
+   * Update a task By Ref Name synchronously. The output data is merged if data from a previous API call already exists.
+   * @param workflowId
+   * @param taskRefName
+   * @param status
+   * @param output
+   * @param workerId - Optional
+   * @returns Workflow
+   * @throws ApiError
+   */
+  updateTaskSync(workflowId, taskRefName, status, output, workerId2) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/tasks/{workflowId}/{taskRefName}/{status}/sync",
+      path: {
+        "workflowId": workflowId,
+        "taskRefName": taskRefName,
+        "status": status
+      },
+      query: {
+        "workerid": workerId2
+      },
+      body: output,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Signals a task in a workflow synchronously and returns data based on the specified return strategy
+   * @param workflowId - Workflow ID of the workflow to be signaled
+   * @param status - Signal status to be set for the workflow
+   * @param output - Output for the task
+   * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
+   * @returns SignalResponse with data based on the return strategy
+   * @throws ApiError
+   */
+  signal(workflowId, status, output, returnStrategy = "TARGET_WORKFLOW" /* TARGET_WORKFLOW */) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/tasks/{workflowId}/{status}/signal/sync",
+      path: {
+        "workflowId": workflowId,
+        "status": status
+      },
+      query: {
+        "returnStrategy": returnStrategy
+      },
+      body: output,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Signals a task in a workflow asynchronously (fire-and-forget)
+   * @param workflowId - Workflow ID of the workflow to be signaled
+   * @param status - Signal status to be set for the workflow
+   * @param output - Output for the task
+   * @returns Promise<void>
+   * @throws ApiError
+   */
+  signalAsync(workflowId, status, output) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/tasks/{workflowId}/{status}/signal",
+      path: {
+        "workflowId": workflowId,
+        "status": status
+      },
+      body: output,
+      mediaType: "application/json"
+    });
+  }
 };
 
 // src/common/open-api/services/TokenResourceService.ts
@@ -1144,16 +1229,18 @@ var WorkflowResourceService = class {
   }
   /**
    * Execute a workflow synchronously
-   * @param body 
-   * @param name 
-   * @param version 
-   * @param requestId 
-   * @param waitUntilTaskRef 
-   * @param callback 
-   * @returns workflowRun
+   * @param body
+   * @param name
+   * @param version
+   * @param requestId
+   * @param waitUntilTaskRef
+   * @param waitForSeconds - Optional, defaults to 10
+   * @param consistency - Optional, defaults to "DURABLE"
+   * @param returnStrategy - Optional, defaults to "TARGET_WORKFLOW"
+   * @returns SignalResponse
    * @throws ApiError
    */
-  executeWorkflow(body, name, version, requestId, waitUntilTaskRef) {
+  executeWorkflow(body, name, version, requestId, waitUntilTaskRef, waitForSeconds, consistency, returnStrategy) {
     return this.httpRequest.request({
       method: "POST",
       url: "/workflow/execute/{name}/{version}",
@@ -1163,7 +1250,10 @@ var WorkflowResourceService = class {
       },
       query: {
         "requestId": requestId,
-        "waitUntilTaskRef": waitUntilTaskRef
+        "waitUntilTaskRef": waitUntilTaskRef,
+        "waitForSeconds": waitForSeconds,
+        "consistency": consistency,
+        "returnStrategy": returnStrategy
       },
       body,
       mediaType: "application/json"
@@ -2277,6 +2367,245 @@ var HumanTaskResourceService = class {
   }
 };
 
+// src/common/open-api/services/ServiceRegistryResourceService.ts
+var ServiceRegistryResourceService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  /**
+   * Retrieve all registered services
+   * @returns Array<ServiceRegistryModels> List of all registered services
+   * @throws ApiError
+   */
+  getRegisteredServices() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service"
+    });
+  }
+  /**
+   * Remove a service by name
+   * @param name The name of the service to remove
+   * @returns void
+   * @throws ApiError
+   */
+  removeService(name) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/registry/service/{name}",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Get a service by name
+   * @param name The name of the service to retrieve
+   * @returns ServiceRegistryModels The requested service registry
+   * @throws ApiError
+   */
+  getService(name) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service/{name}",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Open the circuit breaker for a service
+   * @param name The name of the service
+   * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
+   * @throws ApiError
+   */
+  openCircuitBreaker(name) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/registry/service/{name}/circuit-breaker/open",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Close the circuit breaker for a service
+   * @param name The name of the service
+   * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
+   * @throws ApiError
+   */
+  closeCircuitBreaker(name) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/registry/service/{name}/circuit-breaker/close",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Get circuit breaker status for a service
+   * @param name The name of the service
+   * @returns CircuitBreakerTransitionResponse Response with circuit breaker status
+   * @throws ApiError
+   */
+  getCircuitBreakerStatus(name) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service/{name}/circuit-breaker/status",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Add or update a service registry
+   * @param serviceRegistry The service registry to add or update
+   * @returns void
+   * @throws ApiError
+   */
+  addOrUpdateService(serviceRegistry) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/registry/service",
+      body: serviceRegistry,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Add or update a service method
+   * @param registryName The name of the registry
+   * @param method The service method to add or update
+   * @returns void
+   * @throws ApiError
+   */
+  addOrUpdateServiceMethod(registryName, method) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/registry/service/{registryName}/methods",
+      path: {
+        "registryName": registryName
+      },
+      body: method,
+      mediaType: "application/json"
+    });
+  }
+  /**
+   * Remove a service method
+   * @param registryName The name of the registry
+   * @param serviceName The name of the service
+   * @param method The name of the method
+   * @param methodType The type of the method
+   * @returns void
+   * @throws ApiError
+   */
+  removeMethod(registryName, serviceName, method, methodType) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/registry/service/{registryName}/methods",
+      path: {
+        "registryName": registryName
+      },
+      query: {
+        "serviceName": serviceName,
+        "method": method,
+        "methodType": methodType
+      }
+    });
+  }
+  /**
+   * Get proto data
+   * @param registryName The name of the registry
+   * @param filename The name of the proto file
+   * @returns binary The proto file data
+   * @throws ApiError
+   */
+  getProtoData(registryName, filename) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service/protos/{registryName}/{filename}",
+      path: {
+        "registryName": registryName,
+        "filename": filename
+      },
+      headers: {
+        "Accept": "application/octet-stream"
+      }
+    });
+  }
+  /**
+   * Set proto data
+   * @param registryName The name of the registry
+   * @param filename The name of the proto file
+   * @param data The proto file data
+   * @returns void
+   * @throws ApiError
+   */
+  setProtoData(registryName, filename, data) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/registry/service/protos/{registryName}/{filename}",
+      path: {
+        "registryName": registryName,
+        "filename": filename
+      },
+      body: data,
+      mediaType: "application/octet-stream"
+    });
+  }
+  /**
+   * Delete a proto file
+   * @param registryName The name of the registry
+   * @param filename The name of the proto file
+   * @returns void
+   * @throws ApiError
+   */
+  deleteProto(registryName, filename) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/registry/service/protos/{registryName}/{filename}",
+      path: {
+        "registryName": registryName,
+        "filename": filename
+      }
+    });
+  }
+  /**
+   * Get all proto files for a registry
+   * @param registryName The name of the registry
+   * @returns Array<ProtoRegistryEntry> List of proto registry entries
+   * @throws ApiError
+   */
+  getAllProtos(registryName) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service/protos/{registryName}",
+      path: {
+        "registryName": registryName
+      }
+    });
+  }
+  /**
+   * Discover service methods
+   * @param name The name of the service
+   * @param create Whether to create the discovered methods (defaults to false)
+   * @returns Array<ServiceMethod> The discovered service methods
+   * @throws ApiError
+   */
+  discover(name, create = false) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/registry/service/{name}/discover",
+      path: {
+        "name": name
+      },
+      query: {
+        "create": create
+      }
+    });
+  }
+};
+
 // src/common/open-api/ConductorClient.ts
 var defaultRequestHandler = (request3, config, options) => request3(config, options);
 var getServerBaseURL = (config) => {
@@ -2299,6 +2628,7 @@ var ConductorClient = class {
   tokenResource;
   workflowBulkResource;
   workflowResource;
+  serviceRegistryResource;
   humanTask;
   humanTaskResource;
   request;
@@ -2334,6 +2664,7 @@ var ConductorClient = class {
     this.tokenResource = new TokenResourceService(this.request);
     this.workflowBulkResource = new WorkflowBulkResourceService(this.request);
     this.workflowResource = new WorkflowResourceService(this.request);
+    this.serviceRegistryResource = new ServiceRegistryResourceService(this.request);
     this.humanTask = new HumanTaskService(this.request);
     this.humanTaskResource = new HumanTaskResourceService(this.request);
   }
@@ -2789,19 +3120,18 @@ var WorkflowExecutor = class {
       () => this._client.workflowResource.startWorkflow(workflowRequest)
     );
   }
-  /**
-   * Execute a workflow synchronously. returns a Promise<WorkflowRun> with details of the running workflow
-   * @param workflowRequest
-   * @returns
-   */
-  executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "") {
+  // Implementation
+  executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "", waitForSeconds, consistency, returnStrategy) {
     return tryCatchReThrow(
       () => this._client.workflowResource.executeWorkflow(
         workflowRequest,
         name,
         version,
         requestId,
-        waitUntilTaskRef
+        waitUntilTaskRef,
+        waitForSeconds,
+        consistency,
+        returnStrategy
       )
     );
   }
@@ -3054,6 +3384,60 @@ var WorkflowExecutor = class {
   getTask(taskId) {
     return tryCatchReThrow(() => this._client.taskResource.getTask(taskId));
   }
+  /**
+   * Updates a task by reference name synchronously and returns the complete workflow
+   * @param taskReferenceName
+   * @param workflowInstanceId
+   * @param status
+   * @param taskOutput
+   * @param workerId - Optional
+   * @returns Promise<Workflow>
+   */
+  updateTaskSync(taskReferenceName, workflowInstanceId, status, taskOutput, workerId2) {
+    return tryCatchReThrow(
+      () => this._client.taskResource.updateTaskSync(
+        workflowInstanceId,
+        taskReferenceName,
+        status,
+        taskOutput,
+        workerId2
+      )
+    );
+  }
+  /**
+   * Signals a workflow task and returns data based on the specified return strategy
+   * @param workflowInstanceId - Workflow instance ID to signal
+   * @param status - Task status to set
+   * @param taskOutput - Output data for the task
+   * @param returnStrategy - Optional strategy for what data to return (defaults to TARGET_WORKFLOW)
+   * @returns Promise<SignalResponse> with data based on the return strategy
+   */
+  signal(workflowInstanceId, status, taskOutput, returnStrategy = "TARGET_WORKFLOW" /* TARGET_WORKFLOW */) {
+    return tryCatchReThrow(
+      () => this._client.taskResource.signal(
+        workflowInstanceId,
+        status,
+        taskOutput,
+        returnStrategy
+      )
+    );
+  }
+  /**
+   * Signals a workflow task asynchronously (fire-and-forget)
+   * @param workflowInstanceId - Workflow instance ID to signal
+   * @param status - Task status to set
+   * @param taskOutput - Output data for the task
+   * @returns Promise<void>
+   */
+  signalAsync(workflowInstanceId, status, taskOutput) {
+    return tryCatchReThrow(
+      () => this._client.taskResource.signalAsync(
+        workflowInstanceId,
+        status,
+        taskOutput
+      )
+    );
+  }
 };
 
 // src/core/human.ts
@@ -3354,6 +3738,7 @@ var generateHTTPTask = (overrides = {}) => ({
       method: "GET"
     }
   },
+  asyncComplete: false,
   ...overrides,
   type: "HTTP" /* HTTP */
 });
@@ -3588,12 +3973,13 @@ var forkTaskJoin = (taskReferenceName, forkTasks) => [
 ];
 
 // src/core/sdk/http.ts
-var httpTask = (taskReferenceName, inputParameters) => ({
+var httpTask = (taskReferenceName, inputParameters, asyncComplete = false) => ({
   name: taskReferenceName,
   taskReferenceName,
   inputParameters: {
     http_request: inputParameters
   },
+  asyncComplete,
   type: "HTTP" /* HTTP */
 });
 
@@ -4025,6 +4411,18 @@ var MetadataClient = class {
       () => this._client.metadataResource.create(workflowDef, overwrite)
     );
   }
+  /**
+   * Unregister (overwrite: true) a workflow definition
+   *
+   * @param workflowDef
+   * @param overwrite
+   * @returns
+   */
+  unregisterWorkflow(workflowName, version = 1) {
+    return tryCatchReThrow(
+      () => this._client.metadataResource.unregisterWorkflowDef(workflowName, version)
+    );
+  }
 };
 
 // src/orkes/BaseOrkesConductorClient.ts
@@ -4347,6 +4745,7 @@ var request2 = (config, options, fetchFn = fetch) => {
   CancelablePromise,
   ConductorClient,
   ConductorError,
+  Consistency,
   DefaultLogger,
   EventResourceService,
   HealthCheckResourceService,
@@ -4354,6 +4753,7 @@ var request2 = (config, options, fetchFn = fetch) => {
   MAX_RETRIES,
   MetadataClient,
   MetadataResourceService,
+  ReturnStrategy,
   SchedulerClient,
   SchedulerResourceService,
   TaskClient,