@io-orkes/conductor-javascript 0.9.1 → 1.0.1

package/dist/index.js

@@ -39,16 +39,26 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // index.ts
 var conductor_javascript_exports = {};
 __export(conductor_javascript_exports, {
+  ApiError: () => ApiError,
+  BaseHttpRequest: () => BaseHttpRequest,
   CancelError: () => CancelError,
   CancelablePromise: () => CancelablePromise,
   ConductorClient: () => ConductorClient,
   ConductorError: () => ConductorError,
   DefaultLogger: () => DefaultLogger,
+  EventResourceService: () => EventResourceService,
+  HealthCheckResourceService: () => HealthCheckResourceService,
+  HumanExecutor: () => HumanExecutor,
+  MetadataResourceService: () => MetadataResourceService,
+  SchedulerResourceService: () => SchedulerResourceService,
   TaskManager: () => TaskManager,
-  TaskResult: () => TaskResult,
+  TaskResourceService: () => TaskResourceService,
   TaskRunner: () => TaskRunner,
   TaskType: () => TaskType,
+  TokenResourceService: () => TokenResourceService,
+  WorkflowBulkResourceService: () => WorkflowBulkResourceService,
   WorkflowExecutor: () => WorkflowExecutor,
+  WorkflowResourceService: () => WorkflowResourceService,
   conductorEventTask: () => conductorEventTask,
   doWhileTask: () => doWhileTask,
   dynamicForkTask: () => dynamicForkTask,
@@ -904,6 +914,22 @@ var WorkflowResourceService = class {
       }
     });
   }
+  executeWorkflow(body, name, version, requestId, waitUntilTaskRef) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/workflow/execute/{name}/{version}",
+      path: {
+        "name": name,
+        "version": version
+      },
+      query: {
+        "requestId": requestId,
+        "waitUntilTaskRef": waitUntilTaskRef
+      },
+      body,
+      mediaType: "application/json"
+    });
+  }
   startWorkflow(requestBody) {
     return this.httpRequest.request({
       method: "POST",
@@ -1386,6 +1412,202 @@ var request = (config, options) => {
   });
 };
 
+// src/common/open-api/services/HumanTaskService.ts
+var HumanTaskService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks",
+      query: {
+        "state": state,
+        "assignee": assignee,
+        "assigneeType": assigneeType,
+        "claimedBy": claimedBy,
+        "taskName": taskName,
+        "freeText": freeText,
+        "includeInputOutput": includeInputOutput
+      }
+    });
+  }
+  getTaskLoad() {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/load"
+    });
+  }
+  search1(queryId, start, size = 100, freeText = "*", query, jsonQuery, includeInputOutput = false) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/search",
+      query: {
+        "queryId": queryId,
+        "start": start,
+        "size": size,
+        "freeText": freeText,
+        "query": query,
+        "jsonQuery": jsonQuery,
+        "includeInputOutput": includeInputOutput
+      }
+    });
+  }
+  updateTaskOutput1(taskId) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/tasks/{taskId}",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getTask1(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getActionLogs(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/actionLogs",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  claimTask(taskId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/claim",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  assignAndClaim(taskId, userId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/externalUser/{userId}",
+      path: {
+        "taskId": taskId,
+        "userId": userId
+      }
+    });
+  }
+  reassignTask(taskId, requestBody) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/reassign",
+      path: {
+        "taskId": taskId
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  releaseTask(taskId) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/release",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  getStateLogs(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/stateLogs",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+  updateTaskOutput(taskId, requestBody, complete = false) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/tasks/{taskId}/update",
+      path: {
+        "taskId": taskId
+      },
+      query: {
+        "complete": complete
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  deleteTemplatesByName(name) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/template",
+      query: {
+        "name": name
+      }
+    });
+  }
+  getAllTemplates(name, version) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/template",
+      query: {
+        "name": name,
+        "version": version
+      }
+    });
+  }
+  saveTemplate(requestBody, newVersion = false) {
+    return this.httpRequest.request({
+      method: "POST",
+      url: "/human/template",
+      query: {
+        "newVersion": newVersion
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+  deleteTemplateById(id) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/template/{id}",
+      path: {
+        "id": id
+      }
+    });
+  }
+  getTemplateById(id) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/template/{id}",
+      path: {
+        "id": id
+      }
+    });
+  }
+};
+
+// src/common/open-api/services/HumanTaskResourceService.ts
+var HumanTaskResourceService = class {
+  constructor(httpRequest) {
+    this.httpRequest = httpRequest;
+  }
+  getConductorTaskById(taskId) {
+    return this.httpRequest.request({
+      method: "GET",
+      url: "/human/tasks/{taskId}/conductorTask",
+      path: {
+        "taskId": taskId
+      }
+    });
+  }
+};
+
 // src/common/open-api/ConductorClient.ts
 var defaultRequestHandler = (request2, config, options) => request2(config, options);
 var ConductorClient = class {
@@ -1416,6 +1638,8 @@ var ConductorClient = class {
     this.tokenResource = new TokenResourceService(this.request);
     this.workflowBulkResource = new WorkflowBulkResourceService(this.request);
     this.workflowResource = new WorkflowResourceService(this.request);
+    this.humanTask = new HumanTaskService(this.request);
+    this.humanTaskResource = new HumanTaskResourceService(this.request);
   }
 };
 
@@ -1543,7 +1767,7 @@ var generateHTTPTask = (overrides = {}) => __spreadProps(__spreadValues(__spread
 // src/common/generators/InlineTask.ts
 var defaultInputParams = {
   value: "${workflow.input.value}",
-  evaluatorType: "javascript",
+  evaluatorType: "graaljs",
   expression: "true"
 };
 var generateEvaluationCode = (inputParametersPartial = {}) => {
@@ -1553,15 +1777,15 @@ var generateEvaluationCode = (inputParametersPartial = {}) => {
     const resultingFunction = inlineExpression();
     const resultingFunctionAsString = resultingFunction.toString();
     const toReturn = __spreadProps(__spreadValues({
-      evaluatorType: "javascript"
+      evaluatorType: "graaljs"
     }, inputParametersPartial || { value: "true" }), {
       expression: `(${resultingFunctionAsString})();`
     });
     return toReturn;
   }
-  return __spreadProps(__spreadValues(__spreadValues({}, defaultInputParams), inputParametersPartial), {
-    evaluatorType: "javascript"
-  });
+  return __spreadValues(__spreadProps(__spreadValues({}, defaultInputParams), {
+    evaluatorType: "graaljs"
+  }), inputParametersPartial);
 };
 var generateInlineTask = (override = {}) => __spreadProps(__spreadValues(__spreadValues({}, nameTaskNameGenerator("inline", override)), override), {
   inputParameters: generateEvaluationCode(override?.inputParameters || {}),
@@ -1926,6 +2150,13 @@ var workflow = (name, tasks) => ({
   timeoutSeconds: 0
 });
 
+// src/common/open-api/core/BaseHttpRequest.ts
+var BaseHttpRequest = class {
+  constructor(config) {
+    this.config = config;
+  }
+};
+
 // src/task/TaskManager.ts
 var defaultManagerOptions = {
   workerID: "",
@@ -1993,16 +2224,8 @@ var ConductorError = class extends Error {
     }
   }
 };
-var TaskResult = /* @__PURE__ */ ((TaskResult3) => {
-  TaskResult3["IN_PROGRESS"] = "IN_PROGRESS";
-  TaskResult3["FAILED"] = "FAILED";
-  TaskResult3["FAILED_WITH_TERMINAL_ERROR"] = "FAILED_WITH_TERMINAL_ERROR";
-  TaskResult3["COMPLETED"] = "COMPLETED";
-  return TaskResult3;
-})(TaskResult || {});
 
-// src/core/executor.ts
-var RETRY_TIME_IN_MILLISECONDS = 1e4;
+// src/core/helpers.ts
 var errorMapper = (error) => new ConductorError(error?.body?.message, error);
 var tryCatchReThrow = (fn) => {
   try {
@@ -2011,6 +2234,9 @@ var tryCatchReThrow = (fn) => {
     throw errorMapper(error);
   }
 };
+
+// src/core/executor.ts
+var RETRY_TIME_IN_MILLISECONDS = 1e4;
 var WorkflowExecutor = class {
   constructor(client) {
     this._client = client;
@@ -2021,6 +2247,9 @@ var WorkflowExecutor = class {
   startWorkflow(workflowRequest) {
     return tryCatchReThrow(() => this._client.workflowResource.startWorkflow(workflowRequest));
   }
+  executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "") {
+    return tryCatchReThrow(() => this._client.workflowResource.executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef));
+  }
   startWorkflows(workflowsRequest) {
     return tryCatchReThrow(() => workflowsRequest.map(this.startWorkflow));
   }
@@ -2064,30 +2293,100 @@ var WorkflowExecutor = class {
   terminate(workflowInstanceId, reason) {
     return tryCatchReThrow(() => this._client.workflowResource.terminate1(workflowInstanceId, reason));
   }
-  updateTask(taskId, workflowInstanceId, taskStatus, taskOutput) {
+  updateTask(taskId, workflowInstanceId, taskStatus, outputData) {
     const taskUpdates = {
       status: taskStatus,
       taskId,
       workflowInstanceId
     };
-    return tryCatchReThrow(() => this._client.taskResource.updateTask1(__spreadValues(__spreadValues({}, taskOutput), taskUpdates)));
+    return tryCatchReThrow(() => this._client.taskResource.updateTask1(__spreadValues({
+      outputData
+    }, taskUpdates)));
   }
   updateTaskByRefName(taskReferenceName, workflowInstanceId, status, taskOutput) {
     return tryCatchReThrow(() => this._client.taskResource.updateTask(workflowInstanceId, taskReferenceName, status, taskOutput));
   }
+  getTask(taskId) {
+    return tryCatchReThrow(() => this._client.taskResource.getTask(taskId));
+  }
+};
+
+// src/core/human.ts
+var HumanExecutor = class {
+  constructor(client) {
+    this._client = client;
+  }
+  async getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
+    const response = await this._client.humanTask.getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput);
+    if (response.results != void 0) {
+      return response.results;
+    }
+    return [];
+  }
+  getTaskById(taskId) {
+    return tryCatchReThrow(() => this._client.humanTask.getTask1(taskId));
+  }
+  async claimTaskAsExternalUser(taskId, assignee) {
+    try {
+      await this._client.humanTask.assignAndClaim(taskId, assignee);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async claimTaskAsConductorUser(taskId) {
+    try {
+      await this._client.humanTask.claimTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async releaseTask(taskId) {
+    try {
+      await this._client.humanTask.releaseTask(taskId);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async getTemplateById(templateId) {
+    return tryCatchReThrow(() => this._client.humanTask.getTemplateById(templateId));
+  }
+  async updateTaskOutput(taskId, requestBody) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, false);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
+  async completeTask(taskId, requestBody = {}) {
+    try {
+      await this._client.humanTask.updateTaskOutput(taskId, requestBody, true);
+    } catch (error) {
+      throw errorMapper(error);
+    }
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ApiError,
+  BaseHttpRequest,
   CancelError,
   CancelablePromise,
   ConductorClient,
   ConductorError,
   DefaultLogger,
+  EventResourceService,
+  HealthCheckResourceService,
+  HumanExecutor,
+  MetadataResourceService,
+  SchedulerResourceService,
   TaskManager,
-  TaskResult,
+  TaskResourceService,
   TaskRunner,
   TaskType,
+  TokenResourceService,
+  WorkflowBulkResourceService,
   WorkflowExecutor,
+  WorkflowResourceService,
   conductorEventTask,
   doWhileTask,
   dynamicForkTask,