@io-orkes/conductor-javascript 2.1.4 → 2.1.5

package/dist/index.mjs

@@ -52,6 +52,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";
@@ -890,6 +903,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
@@ -1039,16 +1122,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}",
@@ -1058,7 +1143,10 @@ var WorkflowResourceService = class {
       },
       query: {
         "requestId": requestId,
-        "waitUntilTaskRef": waitUntilTaskRef
+        "waitUntilTaskRef": waitUntilTaskRef,
+        "waitForSeconds": waitForSeconds,
+        "consistency": consistency,
+        "returnStrategy": returnStrategy
       },
       body,
       mediaType: "application/json"
@@ -2172,6 +2260,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) => {
@@ -2194,6 +2521,7 @@ var ConductorClient = class {
   tokenResource;
   workflowBulkResource;
   workflowResource;
+  serviceRegistryResource;
   humanTask;
   humanTaskResource;
   request;
@@ -2229,6 +2557,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);
   }
@@ -2684,19 +3013,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
       )
     );
   }
@@ -2949,6 +3277,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
@@ -3249,6 +3631,7 @@ var generateHTTPTask = (overrides = {}) => ({
       method: "GET"
     }
   },
+  asyncComplete: false,
   ...overrides,
   type: "HTTP" /* HTTP */
 });
@@ -3483,12 +3866,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 */
 });
 
@@ -3920,6 +4304,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
@@ -4241,6 +4637,7 @@ export {
   CancelablePromise,
   ConductorClient,
   ConductorError,
+  Consistency,
   DefaultLogger,
   EventResourceService,
   HealthCheckResourceService,
@@ -4248,6 +4645,7 @@ export {
   MAX_RETRIES,
   MetadataClient,
   MetadataResourceService,
+  ReturnStrategy,
   SchedulerClient,
   SchedulerResourceService,
   TaskClient,