@io-orkes/conductor-javascript 1.0.0 → 1.1.0

package/dist/index.js

@@ -48,6 +48,7 @@ __export(conductor_javascript_exports, {
   DefaultLogger: () => DefaultLogger,
   EventResourceService: () => EventResourceService,
   HealthCheckResourceService: () => HealthCheckResourceService,
+  HumanExecutor: () => HumanExecutor,
   MetadataResourceService: () => MetadataResourceService,
   SchedulerResourceService: () => SchedulerResourceService,
   TaskManager: () => TaskManager,
@@ -100,11 +101,7 @@ __export(conductor_javascript_exports, {
 });
 module.exports = __toCommonJS(conductor_javascript_exports);
 
-// src/task/TaskRunner.ts
-var DEFAULT_ERROR_MESSAGE = "An unknown error occurred";
-var MAX_RETRIES = 3;
-var noopErrorHandler = (__error) => {
-};
+// src/task/helpers.ts
 var noopLogger = {
   debug: (...args) => {
   },
@@ -113,6 +110,88 @@ var noopLogger = {
   error: (...args) => {
   }
 };
+
+// src/task/Poller.ts
+var Poller = class {
+  constructor(pollFunction, pollerOptions, logger) {
+    this.concurrentCalls = [];
+    this.pollFunction = async () => {
+    };
+    this.isPolling = false;
+    this.options = {
+      pollInterval: 1e3,
+      concurrency: 1
+    };
+    this.logger = noopLogger;
+    this.startPolling = () => {
+      if (this.isPolling) {
+        throw new Error("Runner is already started");
+      }
+      return this.poll();
+    };
+    this.stopPolling = () => {
+      this.isPolling = false;
+      this.concurrentCalls.forEach((call) => call.stop());
+    };
+    this.poll = async () => {
+      if (!this.isPolling) {
+        this.isPolling = true;
+        for (let i = 0; i < this.options.concurrency; i++) {
+          this.concurrentCalls.push(this.singlePoll());
+        }
+      }
+    };
+    this.singlePoll = () => {
+      let poll = this.isPolling;
+      let timeout;
+      const pollingCall = async () => {
+        while (poll) {
+          await this.pollFunction();
+          await new Promise((r) => timeout = setTimeout(() => r(true), this.options.pollInterval));
+        }
+      };
+      return {
+        promise: pollingCall(),
+        stop: () => {
+          clearTimeout(timeout);
+          poll = false;
+          this.logger.debug("stopping single poll call");
+        }
+      };
+    };
+    this.pollFunction = pollFunction;
+    this.options = __spreadValues(__spreadValues({}, this.options), pollerOptions);
+    this.logger = logger || noopLogger;
+  }
+  updateConcurrency(concurrency) {
+    if (concurrency > 0 && concurrency !== this.options.concurrency) {
+      if (concurrency < this.options.concurrency) {
+        const result = this.concurrentCalls.splice(0, this.options.concurrency - concurrency);
+        result.forEach((call) => {
+          call.stop();
+          this.logger.debug("stopping some spawned calls");
+        });
+      } else {
+        for (let i = 0; i < concurrency - this.options.concurrency; i++) {
+          this.concurrentCalls.push(this.singlePoll());
+          this.logger.debug("spawning additional poll calls");
+        }
+      }
+      this.options.concurrency = concurrency;
+    }
+  }
+  updateOptions(options) {
+    const newOptions = __spreadValues(__spreadValues({}, this.options), options);
+    this.updateConcurrency(newOptions.concurrency);
+    this.options = newOptions;
+  }
+};
+
+// src/task/TaskRunner.ts
+var DEFAULT_ERROR_MESSAGE = "An unknown error occurred";
+var MAX_RETRIES = 3;
+var noopErrorHandler = (__error) => {
+};
 var TaskRunner = class {
   constructor({
     worker,
@@ -121,32 +200,24 @@ var TaskRunner = class {
     logger = noopLogger,
     onError: errorHandler = noopErrorHandler
   }) {
-    this.isPolling = false;
     this.startPolling = () => {
-      if (this.isPolling) {
-        throw new Error("Runner is already started");
-      }
-      this.isPolling = true;
-      return this.poll();
+      this.poller.startPolling();
     };
     this.stopPolling = () => {
-      this.isPolling = false;
+      this.poller.stopPolling();
     };
-    this.poll = async () => {
-      while (this.isPolling) {
-        try {
-          const { workerID } = this.options;
-          const task = await this.taskResource.poll(this.worker.taskDefName, workerID, this.options.domain);
-          if (task && task.taskId) {
-            await this.executeTask(task);
-          } else {
-            this.logger.debug(`No tasks for ${this.worker.taskDefName}`);
-          }
-        } catch (unknownError) {
-          this.handleUnknownError(unknownError);
-          this.errorHandler(unknownError);
+    this.pollAndExecute = async () => {
+      try {
+        const { workerID } = this.options;
+        const task = await this.taskResource.poll(this.worker.taskDefName, workerID, this.worker.domain ?? this.options.domain);
+        if (task && task.taskId) {
+          await this.executeTask(task);
+        } else {
+          this.logger.debug(`No tasks for ${this.worker.taskDefName}`);
         }
-        await new Promise((r) => setTimeout(() => r(true), this.options.pollInterval));
+      } catch (unknownError) {
+        this.handleUnknownError(unknownError);
+        this.errorHandler(unknownError);
       }
     };
     this.updateTaskWithRetry = async (task, taskResult) => {
@@ -200,6 +271,18 @@ var TaskRunner = class {
     this.worker = worker;
     this.options = options;
     this.errorHandler = errorHandler;
+    this.poller = new Poller(this.pollAndExecute, { concurrency: options.concurrency, pollInterval: options.pollInterval }, this.logger);
+  }
+  updateOptions(options) {
+    const newOptions = __spreadValues(__spreadValues({}, this.options), options);
+    this.poller.updateOptions({
+      concurrency: newOptions.concurrency,
+      pollInterval: newOptions.pollInterval
+    });
+    this.options = newOptions;
+  }
+  get getOptions() {
+    return this.options;
   }
 };
 
@@ -1411,6 +1494,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 {
@@ -1441,6 +1720,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);
   }
 };
 
@@ -1971,25 +2252,35 @@ function workerId(options) {
 var TaskManager = class {
   constructor(client, workers, config = {}) {
     this.tasks = {};
+    this.workerManagerWorkerOptions = (worker) => {
+      return __spreadProps(__spreadValues({}, this.taskManageOptions), {
+        concurrency: worker.concurrency ?? this.taskManageOptions.concurrency,
+        domain: worker.domain ?? this.taskManageOptions.domain
+      });
+    };
+    this.updatePollingOptions = (options) => {
+      this.workers.forEach((worker) => {
+        const newOptions = __spreadValues(__spreadValues({}, this.workerManagerWorkerOptions(worker)), options);
+        const runners = this.tasks[worker.taskDefName];
+        runners.forEach((runner) => {
+          runner.updateOptions(newOptions);
+        });
+      });
+    };
     this.startPolling = () => {
       this.workers.forEach((worker) => {
         this.tasks[worker.taskDefName] = [];
-        const options = __spreadProps(__spreadValues({}, this.taskManageOptions), {
-          concurrency: worker.concurrency ?? this.taskManageOptions.concurrency,
-          domain: worker.domain ?? this.taskManageOptions.domain
-        });
+        const options = this.workerManagerWorkerOptions(worker);
         this.logger.debug(`Starting taskDefName=${worker.taskDefName} concurrency=${options.concurrency} domain=${options.domain}`);
-        for (let i = 0; i < options.concurrency; i++) {
-          const runner = new TaskRunner({
-            worker,
-            options,
-            taskResource: this.client.taskResource,
-            logger: this.logger,
-            onError: this.errorHandler
-          });
-          runner.startPolling();
-          this.tasks[worker.taskDefName].push(runner);
-        }
+        const runner = new TaskRunner({
+          worker,
+          options,
+          taskResource: this.client.taskResource,
+          logger: this.logger,
+          onError: this.errorHandler
+        });
+        runner.startPolling();
+        this.tasks[worker.taskDefName].push(runner);
       });
     };
     this.stopPolling = () => {
@@ -2026,8 +2317,7 @@ var ConductorError = class extends Error {
   }
 };
 
-// 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 {
@@ -2036,6 +2326,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;
@@ -2109,6 +2402,61 @@ var WorkflowExecutor = class {
     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,
@@ -2120,6 +2468,7 @@ var WorkflowExecutor = class {
   DefaultLogger,
   EventResourceService,
   HealthCheckResourceService,
+  HumanExecutor,
   MetadataResourceService,
   SchedulerResourceService,
   TaskManager,