@io-orkes/conductor-javascript 1.2.3 → 2.0.0-rc2

package/dist/index.mjs

@@ -5,16 +5,9 @@ var LOG_LEVELS = {
   ERROR: 60
 };
 var DefaultLogger = class {
+  tags;
+  level;
   constructor(config = {}) {
-    this.info = (...args) => {
-      this.log("INFO", ...args);
-    };
-    this.debug = (...args) => {
-      this.log("DEBUG", ...args);
-    };
-    this.error = (...args) => {
-      this.log("ERROR", ...args);
-    };
     const { level, tags = [] } = config;
     this.tags = tags;
     if (level && level in LOG_LEVELS) {
@@ -36,6 +29,15 @@ var DefaultLogger = class {
       console.log(name, ...this.tags, ...args);
     }
   }
+  info = (...args) => {
+    this.log("INFO", ...args);
+  };
+  debug = (...args) => {
+    this.log("DEBUG", ...args);
+  };
+  error = (...args) => {
+    this.log("ERROR", ...args);
+  };
 };
 var noopLogger = {
   //eslint-disable-next-line
@@ -1486,6 +1488,11 @@ var WorkflowResourceService = class {
 
 // src/common/open-api/core/ApiError.ts
 var ApiError = class extends Error {
+  url;
+  status;
+  statusText;
+  body;
+  request;
   constructor(request3, response, message) {
     super(message);
     this.name = "ApiError";
@@ -1508,9 +1515,14 @@ var CancelError = class extends Error {
   }
 };
 var CancelablePromise = class {
-  static {
-    Symbol.toStringTag;
-  }
+  [Symbol.toStringTag];
+  _isResolved;
+  _isRejected;
+  _isCancelled;
+  _cancelHandlers;
+  _promise;
+  _resolve;
+  _reject;
   constructor(executor) {
     this._isResolved = false;
     this._isRejected = false;
@@ -1823,83 +1835,70 @@ var HumanTaskService = class {
     this.httpRequest = httpRequest;
   }
   /**
-   * List tasks by filters - task name, state, assignee, assignee type, claimed
-   * @param state
-   * @param assignee
-   * @param assigneeType
-   * @param claimedBy
-   * @param taskName
-   * @param freeText
-   * @param includeInputOutput
-   * @returns SearchResultHumanTaskEntry OK
+   * If the workflow is disconnected from tasks, this API can be used to clean up (in bulk)
+   * @param requestBody
+   * @returns any OK
    * @throws ApiError
    */
-  getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
+  deleteTaskFromHumanTaskRecords(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/human/tasks",
-      query: {
-        "state": state,
-        "assignee": assignee,
-        "assigneeType": assigneeType,
-        "claimedBy": claimedBy,
-        "taskName": taskName,
-        "freeText": freeText,
-        "includeInputOutput": includeInputOutput
-      }
+      method: "DELETE",
+      url: "/human/tasks/delete",
+      body: requestBody,
+      mediaType: "application/json"
     });
   }
   /**
-   * Get task load grouped by workflow name and task ref name per user
-   * @returns HumanTaskLoad OK
+   * If the workflow is disconnected from tasks, this API can be used to clean up
+   * @param taskId
+   * @returns any OK
    * @throws ApiError
    */
-  getTaskLoad() {
+  deleteTaskFromHumanTaskRecords1(taskId) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/human/tasks/load"
+      method: "DELETE",
+      url: "/human/tasks/delete/{taskId}",
+      path: {
+        "taskId": taskId
+      }
     });
   }
   /**
    * Search human tasks
-   * @param queryId
-   * @param start
-   * @param size
-   * @param freeText
-   * @param query
-   * @param jsonQuery
-   * @param includeInputOutput
-   * @returns HTScrollableSearchResultHumanTaskEntry OK
+   * @param requestBody
+   * @returns HumanTaskSearchResult OK
    * @throws ApiError
    */
-  search1(queryId, start, size = 100, freeText = "*", query, jsonQuery, includeInputOutput = false) {
+  search(requestBody) {
     return this.httpRequest.request({
-      method: "GET",
+      method: "POST",
       url: "/human/tasks/search",
-      query: {
-        "queryId": queryId,
-        "start": start,
-        "size": size,
-        "freeText": freeText,
-        "query": query,
-        "jsonQuery": jsonQuery,
-        "includeInputOutput": includeInputOutput
-      }
+      body: requestBody,
+      mediaType: "application/json"
     });
   }
   /**
-   * If the workflow is disconnected from tasks, this API can be used to clean up
-   * @param taskId
+   * Update task output, optionally complete
+   * @param workflowId
+   * @param taskRefName
+   * @param requestBody
+   * @param complete
+   * @param iteration Populate this value if your task is in a loop and you want to update a specific iteration. If its not in a loop OR if you want to just update the latest iteration, leave this as empty
    * @returns any OK
    * @throws ApiError
    */
-  updateTaskOutput1(taskId) {
+  updateTaskOutputByRef(workflowId, taskRefName, requestBody, complete = false, iteration) {
     return this.httpRequest.request({
-      method: "DELETE",
-      url: "/human/tasks/{taskId}",
-      path: {
-        "taskId": taskId
-      }
+      method: "POST",
+      url: "/human/tasks/update/taskRef",
+      query: {
+        "workflowId": workflowId,
+        "taskRefName": taskRefName,
+        "complete": complete,
+        "iteration": iteration
+      },
+      body: requestBody,
+      mediaType: "application/json"
     });
   }
   /**
@@ -1917,33 +1916,22 @@ var HumanTaskService = class {
       }
     });
   }
-  /**
-   * Get human task action log entries by task id
-   * @param taskId
-   * @returns HumanTaskActionLogEntry OK
-   * @throws ApiError
-   */
-  getActionLogs(taskId) {
-    return this.httpRequest.request({
-      method: "GET",
-      url: "/human/tasks/{taskId}/actionLogs",
-      path: {
-        "taskId": taskId
-      }
-    });
-  }
   /**
    * Claim a task by authenticated Conductor user
    * @param taskId
+   * @param overrideAssignment
    * @returns any OK
    * @throws ApiError
    */
-  claimTask(taskId) {
+  claimTask(taskId, overrideAssignment = false) {
     return this.httpRequest.request({
       method: "POST",
       url: "/human/tasks/{taskId}/claim",
       path: {
         "taskId": taskId
+      },
+      query: {
+        "overrideAssignment": overrideAssignment
       }
     });
   }
@@ -1951,16 +1939,20 @@ var HumanTaskService = class {
    * Claim a task to an external user
    * @param taskId
    * @param userId
+   * @param overrideAssignment
    * @returns any OK
    * @throws ApiError
    */
-  assignAndClaim(taskId, userId) {
+  assignAndClaim(taskId, userId, overrideAssignment = false) {
     return this.httpRequest.request({
       method: "POST",
       url: "/human/tasks/{taskId}/externalUser/{userId}",
       path: {
         "taskId": taskId,
         "userId": userId
+      },
+      query: {
+        "overrideAssignment": overrideAssignment
       }
     });
   }
@@ -1998,17 +1990,21 @@ var HumanTaskService = class {
     });
   }
   /**
-   * Get human task state log entries by task id
+   * If a task is assigned to a user, this API can be used to skip that assignment and move to the next assignee
    * @param taskId
-   * @returns HumanTaskStateLogEntry OK
+   * @param reason
+   * @returns any OK
    * @throws ApiError
    */
-  getStateLogs(taskId) {
+  skipTask(taskId, reason) {
     return this.httpRequest.request({
-      method: "GET",
-      url: "/human/tasks/{taskId}/stateLogs",
+      method: "POST",
+      url: "/human/tasks/{taskId}/skip",
       path: {
         "taskId": taskId
+      },
+      query: {
+        "reason": reason
       }
     });
   }
@@ -2035,48 +2031,51 @@ var HumanTaskService = class {
     });
   }
   /**
-   * Delete human task templates by name
+   * List all user form templates or get templates by name, or a template by name and version
    * @param name
-   * @returns any OK
+   * @param version
+   * @returns HumanTaskTemplate OK
    * @throws ApiError
    */
-  deleteTemplatesByName(name) {
+  getAllTemplates(name, version) {
     return this.httpRequest.request({
-      method: "DELETE",
+      method: "GET",
       url: "/human/template",
       query: {
-        "name": name
+        "name": name,
+        "version": version
       }
     });
   }
   /**
-   * List all human task templates or get templates by name, or a template by name and version
-   * @param name
-   * @param version
-   * @returns HumanTaskTemplateEntry OK
+   * Save user form template
+   * @param requestBody
+   * @param newVersion
+   * @returns HumanTaskTemplate OK
    * @throws ApiError
    */
-  getAllTemplates(name, version) {
+  saveTemplate(requestBody, newVersion = false) {
     return this.httpRequest.request({
-      method: "GET",
+      method: "POST",
       url: "/human/template",
       query: {
-        "name": name,
-        "version": version
-      }
+        "newVersion": newVersion
+      },
+      body: requestBody,
+      mediaType: "application/json"
     });
   }
   /**
-   * Save human task template
+   * Save user form template
    * @param requestBody
    * @param newVersion
-   * @returns string OK
+   * @returns HumanTaskTemplate OK
    * @throws ApiError
    */
-  saveTemplate(requestBody, newVersion = false) {
+  saveTemplates(requestBody, newVersion = false) {
     return this.httpRequest.request({
       method: "POST",
-      url: "/human/template",
+      url: "/human/template/bulk",
       query: {
         "newVersion": newVersion
       },
@@ -2085,32 +2084,51 @@ var HumanTaskService = class {
     });
   }
   /**
-   * Delete human task template
-   * @param id
+   * Delete all versions of user form template by name
+   * @param name
+   * @returns any OK
+   * @throws ApiError
+   */
+  deleteTemplateByName(name) {
+    return this.httpRequest.request({
+      method: "DELETE",
+      url: "/human/template/{name}",
+      path: {
+        "name": name
+      }
+    });
+  }
+  /**
+   * Delete a version of form template by name
+   * @param name
+   * @param version
    * @returns any OK
    * @throws ApiError
    */
-  deleteTemplateById(id) {
+  deleteTemplatesByNameAndVersion(name, version) {
     return this.httpRequest.request({
       method: "DELETE",
-      url: "/human/template/{id}",
+      url: "/human/template/{name}/{version}",
       path: {
-        "id": id
+        "name": name,
+        "version": version
       }
     });
   }
   /**
-   * Get human task template by id
-   * @param id
-   * @returns HumanTaskTemplateEntry OK
+   * Get user form template by name and version
+   * @param name
+   * @param version
+   * @returns HumanTaskTemplate OK
    * @throws ApiError
    */
-  getTemplateById(id) {
+  getTemplateByNameAndVersion(name, version) {
     return this.httpRequest.request({
       method: "GET",
-      url: "/human/template/{id}",
+      url: "/human/template/{name}/{version}",
       path: {
-        "id": id
+        "name": name,
+        "version": version
       }
     });
   }
@@ -2141,6 +2159,18 @@ var HumanTaskResourceService = class {
 // src/common/open-api/ConductorClient.ts
 var defaultRequestHandler = (request3, config, options) => request3(config, options);
 var ConductorClient = class {
+  eventResource;
+  healthCheckResource;
+  metadataResource;
+  schedulerResource;
+  taskResource;
+  tokenResource;
+  workflowBulkResource;
+  workflowResource;
+  humanTask;
+  humanTaskResource;
+  request;
+  token;
   constructor(config, requestHandler = defaultRequestHandler) {
     const resolvedConfig = {
       BASE: config?.serverUrl ?? "http://localhost:8080",
@@ -2194,75 +2224,21 @@ var DEFAULT_BATCH_POLLING_TIMEOUT = 100;
 
 // src/task/Poller.ts
 var Poller = class {
+  timeoutHandler;
+  pollFunction;
+  performWorkFunction = async () => {
+  };
+  polling = false;
+  _tasksInProcess = 0;
+  _counterAtO = 0;
+  _pollerId = "";
+  options = {
+    pollInterval: DEFAULT_POLL_INTERVAL,
+    concurrency: DEFAULT_CONCURRENCY,
+    warnAtO: DEFAULT_WARN_AT_O
+  };
+  logger = noopLogger;
   constructor(pollerId, pollFunction, performWorkFunction, pollerOptions, logger) {
-    this.performWorkFunction = async () => {
-    };
-    this.polling = false;
-    this._tasksInProcess = 0;
-    this._counterAtO = 0;
-    this._pollerId = "";
-    this.options = {
-      pollInterval: DEFAULT_POLL_INTERVAL,
-      concurrency: DEFAULT_CONCURRENCY,
-      warnAtO: DEFAULT_WARN_AT_O
-    };
-    this.logger = noopLogger;
-    /**
-     * Starts polling for work
-     */
-    this.startPolling = () => {
-      if (this.polling) {
-        throw new Error("Runner is already started");
-      }
-      this._tasksInProcess = 0;
-      this.polling = true;
-      this.poll();
-    };
-    /**
-     * Stops Polling for work
-     */
-    this.stopPolling = async () => {
-      this.polling = false;
-      clearTimeout(this.timeoutHandler);
-    };
-    this.performWork = async (work) => {
-      await this.performWorkFunction(work);
-      this._tasksInProcess--;
-    };
-    this.poll = async () => {
-      while (this.isPolling) {
-        try {
-          const count = Math.max(
-            0,
-            this.options.concurrency - this._tasksInProcess
-          );
-          if (count === 0) {
-            this.logger.debug(
-              "Max in process reached, Will skip polling for " + this._pollerId
-            );
-            this._counterAtO++;
-            if (this._counterAtO > (this.options.warnAtO ?? 100)) {
-              this.logger.info(
-                `Not polling anything because in process tasks is maxed as concurrency level. ${this._pollerId}`
-              );
-            }
-          } else {
-            this._counterAtO = 0;
-            const tasksResult = await this.pollFunction(count);
-            this._tasksInProcess = this._tasksInProcess + (tasksResult ?? []).length;
-            tasksResult.forEach(this.performWork);
-          }
-        } catch (e) {
-          this.logger.error(`Error polling for tasks: ${e.message}`, e);
-        }
-        await new Promise(
-          (r) => this.isPolling ? this.timeoutHandler = setTimeout(
-            () => r(true),
-            this.options.pollInterval
-          ) : r(true)
-        );
-      }
-    };
     this._pollerId = pollerId;
     this.pollFunction = pollFunction;
     this.performWorkFunction = performWorkFunction;
@@ -2275,10 +2251,66 @@ var Poller = class {
   get tasksInProcess() {
     return this._tasksInProcess;
   }
+  /**
+   * Starts polling for work
+   */
+  startPolling = () => {
+    if (this.polling) {
+      throw new Error("Runner is already started");
+    }
+    this._tasksInProcess = 0;
+    this.polling = true;
+    this.poll();
+  };
+  /**
+   * Stops Polling for work
+   */
+  stopPolling = async () => {
+    this.polling = false;
+    clearTimeout(this.timeoutHandler);
+  };
+  performWork = async (work) => {
+    await this.performWorkFunction(work);
+    this._tasksInProcess--;
+  };
   updateOptions(options) {
     const newOptions = { ...this.options, ...options };
     this.options = newOptions;
   }
+  poll = async () => {
+    while (this.isPolling) {
+      try {
+        const count = Math.max(
+          0,
+          this.options.concurrency - this._tasksInProcess
+        );
+        if (count === 0) {
+          this.logger.debug(
+            "Max in process reached, Will skip polling for " + this._pollerId
+          );
+          this._counterAtO++;
+          if (this._counterAtO > (this.options.warnAtO ?? 100)) {
+            this.logger.info(
+              `Not polling anything because in process tasks is maxed as concurrency level. ${this._pollerId}`
+            );
+          }
+        } else {
+          this._counterAtO = 0;
+          const tasksResult = await this.pollFunction(count);
+          this._tasksInProcess = this._tasksInProcess + (tasksResult ?? []).length;
+          tasksResult.forEach(this.performWork);
+        }
+      } catch (e) {
+        this.logger.error(`Error polling for tasks: ${e.message}`, e);
+      }
+      await new Promise(
+        (r) => this.isPolling ? this.timeoutHandler = setTimeout(
+          () => r(true),
+          this.options.pollInterval
+        ) : r(true)
+      );
+    }
+  };
 };
 
 // src/task/helpers.ts
@@ -2303,6 +2335,12 @@ var defaultRunnerOptions = {
   batchPollingTimeout: DEFAULT_BATCH_POLLING_TIMEOUT
 };
 var TaskRunner = class {
+  taskResource;
+  worker;
+  logger;
+  options;
+  errorHandler;
+  poller;
   constructor({
     worker,
     taskResource,
@@ -2310,91 +2348,6 @@ var TaskRunner = class {
     logger = noopLogger,
     onError: errorHandler = noopErrorHandler
   }) {
-    /**
-     * Starts polling for work
-     */
-    this.startPolling = () => {
-      this.poller.startPolling();
-      this.logger.info(
-        `TaskWorker ${this.worker.taskDefName} initialized with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
-      );
-    };
-    /**
-     * Stops Polling for work
-     */
-    this.stopPolling = async () => {
-      await this.poller.stopPolling();
-    };
-    this.batchPoll = async (count) => {
-      const { workerID } = this.options;
-      const tasks = await this.taskResource.batchPoll(
-        this.worker.taskDefName,
-        workerID,
-        this.worker.domain ?? this.options.domain,
-        count,
-        this.options.batchPollingTimeout ?? 100
-        // default batch poll defined in the method
-      );
-      return tasks;
-    };
-    this.updateTaskWithRetry = async (task, taskResult) => {
-      const { workerID } = this.options;
-      let retryCount = 0;
-      while (retryCount < MAX_RETRIES) {
-        try {
-          await this.taskResource.updateTask1({
-            ...taskResult,
-            workerId: workerID
-          });
-          return;
-        } catch (error) {
-          this.errorHandler(error, task);
-          this.logger.error(
-            `Error updating task ${taskResult.taskId} on retry ${retryCount}`,
-            error
-          );
-          retryCount++;
-          await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
-        }
-      }
-      this.logger.error(
-        `Unable to update task ${taskResult.taskId} after ${retryCount} retries`
-      );
-    };
-    this.executeTask = async (task) => {
-      try {
-        const result = await this.worker.execute(task);
-        await this.updateTaskWithRetry(task, {
-          ...result,
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId
-        });
-        this.logger.debug(`Task has executed successfully ${task.taskId}`);
-      } catch (error) {
-        await this.updateTaskWithRetry(task, {
-          workflowInstanceId: task.workflowInstanceId,
-          taskId: task.taskId,
-          reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
-          status: "FAILED",
-          outputData: {}
-        });
-        this.errorHandler(error, task);
-        this.logger.error(`Error executing ${task.taskId}`, error);
-      }
-    };
-    this.handleUnknownError = (unknownError) => {
-      let message = "";
-      let stack = "";
-      if (unknownError.stack) {
-        stack = unknownError.stack;
-      }
-      if (unknownError.message) {
-        message = unknownError.message;
-      }
-      this.logger.error(
-        `Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`
-      );
-    };
     this.taskResource = taskResource;
     this.logger = logger;
     this.worker = worker;
@@ -2414,6 +2367,21 @@ var TaskRunner = class {
   get isPolling() {
     return this.poller.isPolling;
   }
+  /**
+   * Starts polling for work
+   */
+  startPolling = () => {
+    this.poller.startPolling();
+    this.logger.info(
+      `TaskWorker ${this.worker.taskDefName} initialized with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
+    );
+  };
+  /**
+   * Stops Polling for work
+   */
+  stopPolling = async () => {
+    await this.poller.stopPolling();
+  };
   updateOptions(options) {
     const newOptions = { ...this.options, ...options };
     const isOptionsUpdated = !optionEquals(this.options, newOptions);
@@ -2431,6 +2399,76 @@ var TaskRunner = class {
   get getOptions() {
     return this.options;
   }
+  batchPoll = async (count) => {
+    const { workerID } = this.options;
+    const tasks = await this.taskResource.batchPoll(
+      this.worker.taskDefName,
+      workerID,
+      this.worker.domain ?? this.options.domain,
+      count,
+      this.options.batchPollingTimeout ?? 100
+      // default batch poll defined in the method
+    );
+    return tasks;
+  };
+  updateTaskWithRetry = async (task, taskResult) => {
+    const { workerID } = this.options;
+    let retryCount = 0;
+    while (retryCount < MAX_RETRIES) {
+      try {
+        await this.taskResource.updateTask1({
+          ...taskResult,
+          workerId: workerID
+        });
+        return;
+      } catch (error) {
+        this.errorHandler(error, task);
+        this.logger.error(
+          `Error updating task ${taskResult.taskId} on retry ${retryCount}`,
+          error
+        );
+        retryCount++;
+        await new Promise((r) => setTimeout(() => r(true), retryCount * 10));
+      }
+    }
+    this.logger.error(
+      `Unable to update task ${taskResult.taskId} after ${retryCount} retries`
+    );
+  };
+  executeTask = async (task) => {
+    try {
+      const result = await this.worker.execute(task);
+      await this.updateTaskWithRetry(task, {
+        ...result,
+        workflowInstanceId: task.workflowInstanceId,
+        taskId: task.taskId
+      });
+      this.logger.debug(`Task has executed successfully ${task.taskId}`);
+    } catch (error) {
+      await this.updateTaskWithRetry(task, {
+        workflowInstanceId: task.workflowInstanceId,
+        taskId: task.taskId,
+        reasonForIncompletion: error?.message ?? DEFAULT_ERROR_MESSAGE,
+        status: "FAILED",
+        outputData: {}
+      });
+      this.errorHandler(error, task);
+      this.logger.error(`Error executing ${task.taskId}`, error);
+    }
+  };
+  handleUnknownError = (unknownError) => {
+    let message = "";
+    let stack = "";
+    if (unknownError.stack) {
+      stack = unknownError.stack;
+    }
+    if (unknownError.message) {
+      message = unknownError.message;
+    }
+    this.logger.error(
+      `Error for ${this.worker.taskDefName}: error: ${message}, stack: ${stack}`
+    );
+  };
 };
 
 // src/task/TaskManager.ts
@@ -2446,84 +2484,14 @@ function workerId(options) {
   return options.workerID ?? os.hostname();
 }
 var TaskManager = class {
+  workerRunners = /* @__PURE__ */ new Map();
+  client;
+  logger;
+  errorHandler;
+  workers;
+  options;
+  polling = false;
   constructor(client, workers, config = {}) {
-    this.workerRunners = /* @__PURE__ */ new Map();
-    this.polling = false;
-    this.workerManagerWorkerOptions = (worker) => {
-      return {
-        ...this.options,
-        concurrency: worker.concurrency ?? this.options.concurrency,
-        pollInterval: worker.pollInterval ?? this.options.pollInterval,
-        domain: worker.domain ?? this.options.domain
-      };
-    };
-    this.updatePollingOptionForWorker = (workerTaskDefName, options) => {
-      const maybeRunner = this.workerRunners.get(workerTaskDefName);
-      if (maybeRunner != null) {
-        maybeRunner.updateOptions(options);
-      } else {
-        this.logger.info(
-          `No runner found for worker with taskDefName: ${workerTaskDefName}`
-        );
-      }
-    };
-    /**
-     * new options will get merged to existing options
-     * @param options new options to update polling options
-     */
-    this.updatePollingOptions = (options) => {
-      this.workers.forEach((worker) => {
-        const newOptions = {
-          ...this.workerManagerWorkerOptions(worker),
-          ...options
-        };
-        this.updatePollingOptionForWorker(worker.taskDefName, newOptions);
-      });
-      this.options.concurrency = options.concurrency ?? this.options.concurrency;
-      this.options.pollInterval = options.pollInterval ?? this.options.pollInterval;
-    };
-    this.sanityCheck = () => {
-      if (this.workers.length === 0) {
-        throw new Error("No workers supplied to TaskManager");
-      }
-      const workerIDs = /* @__PURE__ */ new Set();
-      for (const item of this.workers) {
-        if (workerIDs.has(item.taskDefName)) {
-          throw new Error(`Duplicate worker taskDefName: ${item.taskDefName}`);
-        }
-        workerIDs.add(item.taskDefName);
-      }
-    };
-    /**
-     * Start polling for tasks
-     */
-    this.startPolling = () => {
-      this.sanityCheck();
-      this.workers.forEach((worker) => {
-        const options = this.workerManagerWorkerOptions(worker);
-        const runner = new TaskRunner({
-          worker,
-          options,
-          taskResource: this.client.taskResource,
-          logger: this.logger,
-          onError: this.errorHandler
-        });
-        runner.startPolling();
-        this.workerRunners.set(worker.taskDefName, runner);
-      });
-      this.polling = true;
-    };
-    /**
-     * Stops polling for tasks
-     */
-    this.stopPolling = async () => {
-      for (const [workerTaskDefName, runner] of this.workerRunners) {
-        this.logger.debug(`Stopping taskDefName=${workerTaskDefName}`);
-        await runner.stopPolling();
-        this.workerRunners.delete(workerTaskDefName);
-      }
-      this.polling = false;
-    };
     if (!workers) {
       throw new Error(
         "No workers supplied to TaskManager. Please pass an array of workers."
@@ -2540,21 +2508,98 @@ var TaskManager = class {
       workerID: workerId(providedOptions)
     };
   }
+  workerManagerWorkerOptions = (worker) => {
+    return {
+      ...this.options,
+      concurrency: worker.concurrency ?? this.options.concurrency,
+      pollInterval: worker.pollInterval ?? this.options.pollInterval,
+      domain: worker.domain ?? this.options.domain
+    };
+  };
   get isPolling() {
     return this.polling;
   }
-};
-
-// src/core/types.ts
-var ConductorError = class extends Error {
-  constructor(message, innerError) {
-    super(message);
-    this._trace = innerError;
-    const actualProto = new.target.prototype;
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(this, actualProto);
+  updatePollingOptionForWorker = (workerTaskDefName, options) => {
+    const maybeRunner = this.workerRunners.get(workerTaskDefName);
+    if (maybeRunner != null) {
+      maybeRunner.updateOptions(options);
     } else {
-      this.__proto__ = actualProto;
+      this.logger.info(
+        `No runner found for worker with taskDefName: ${workerTaskDefName}`
+      );
+    }
+  };
+  /**
+   * new options will get merged to existing options
+   * @param options new options to update polling options
+   */
+  updatePollingOptions = (options) => {
+    this.workers.forEach((worker) => {
+      const newOptions = {
+        ...this.workerManagerWorkerOptions(worker),
+        ...options
+      };
+      this.updatePollingOptionForWorker(worker.taskDefName, newOptions);
+    });
+    this.options.concurrency = options.concurrency ?? this.options.concurrency;
+    this.options.pollInterval = options.pollInterval ?? this.options.pollInterval;
+  };
+  sanityCheck = () => {
+    if (this.workers.length === 0) {
+      throw new Error("No workers supplied to TaskManager");
+    }
+    const workerIDs = /* @__PURE__ */ new Set();
+    for (const item of this.workers) {
+      if (workerIDs.has(item.taskDefName)) {
+        throw new Error(`Duplicate worker taskDefName: ${item.taskDefName}`);
+      }
+      workerIDs.add(item.taskDefName);
+    }
+  };
+  /**
+   * Start polling for tasks
+   */
+  startPolling = () => {
+    this.sanityCheck();
+    this.workers.forEach((worker) => {
+      const options = this.workerManagerWorkerOptions(worker);
+      const runner = new TaskRunner({
+        worker,
+        options,
+        taskResource: this.client.taskResource,
+        logger: this.logger,
+        onError: this.errorHandler
+      });
+      runner.startPolling();
+      this.workerRunners.set(worker.taskDefName, runner);
+    });
+    this.polling = true;
+  };
+  /**
+   * Stops polling for tasks
+   */
+  stopPolling = async () => {
+    for (const [workerTaskDefName, runner] of this.workerRunners) {
+      this.logger.debug(`Stopping taskDefName=${workerTaskDefName}`);
+      await runner.stopPolling();
+      this.workerRunners.delete(workerTaskDefName);
+    }
+    this.polling = false;
+  };
+};
+
+// src/core/types.ts
+var ConductorError = class extends Error {
+  _trace;
+  __proto__;
+  constructor(message, innerError) {
+    super(message);
+    this._trace = innerError;
+    const actualProto = new.target.prototype;
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(this, actualProto);
+    } else {
+      this.__proto__ = actualProto;
     }
   }
 };
@@ -2568,10 +2613,20 @@ var tryCatchReThrow = (fn) => {
     throw errorMapper(error);
   }
 };
+function reverseFind(array, predicate) {
+  for (let i = array.length - 1; i >= 0; i--) {
+    if (predicate(array[i], i, array)) {
+      return array[i];
+    }
+  }
+  return void 0;
+}
 
 // src/core/executor.ts
 var RETRY_TIME_IN_MILLISECONDS = 1e4;
+var completedTaskMatchingType = (taskType) => (task) => task.status === "COMPLETED" && task.taskType === taskType;
 var WorkflowExecutor = class {
+  _client;
   constructor(client) {
     this._client = client;
   }
@@ -2615,6 +2670,26 @@ var WorkflowExecutor = class {
   startWorkflows(workflowsRequest) {
     return tryCatchReThrow(() => workflowsRequest.map(this.startWorkflow));
   }
+  async goBackToTask(workflowInstanceId, taskFinderPredicate, rerunWorkflowRequestOverrides = {}) {
+    const { tasks: executedTasks = [] } = await this.getExecution(
+      workflowInstanceId
+    );
+    const maybePreviousTask = reverseFind(
+      executedTasks,
+      taskFinderPredicate
+    );
+    if (!maybePreviousTask) {
+      throw new Error("Task not found");
+    }
+    await this.reRun(workflowInstanceId, {
+      //taskInput: previousTask.inputData,
+      ...rerunWorkflowRequestOverrides,
+      reRunFromTaskId: maybePreviousTask.taskId
+    });
+  }
+  async goBackToFirstTaskMatchingType(workflowInstanceId, taskType) {
+    return this.goBackToTask(workflowInstanceId, completedTaskMatchingType(taskType));
+  }
   /**
    * Takes an workflowInstanceId and an includeTasks and an optional retry parameter returns the whole execution status.
    * If includeTasks flag is provided. Details of tasks execution will be returned as well,
@@ -2659,6 +2734,22 @@ var WorkflowExecutor = class {
       )
     );
   }
+  /**
+   *  Returns a summary of the current workflow status.
+   *
+   * @param workflowInstanceId current running workflow
+   * @param includeOutput flag to include output
+   * @param includeVariables flag to include variable
+   * @returns Promise<WorkflowStatus>
+   */
+  getExecution(workflowInstanceId, includeTasks = true) {
+    return tryCatchReThrow(
+      () => this._client.workflowResource.getExecutionStatus(
+        workflowInstanceId,
+        includeTasks
+      )
+    );
+  }
   /**
    * Pauses a running workflow
    * @param workflowInstanceId current workflow execution
@@ -2828,11 +2919,25 @@ var WorkflowExecutor = class {
 };
 
 // src/core/human.ts
+var EMPTY_SEARCH = {
+  size: 15,
+  states: [],
+  taskInputQuery: "",
+  taskOutputQuery: "",
+  definitionNames: [],
+  taskRefNames: [],
+  claimants: [],
+  assignees: [],
+  start: 0
+};
+var DEFAULT_POLL_INTERVAL2 = { pollInterval: 100, maxPollTimes: 20 };
 var HumanExecutor = class {
+  _client;
   constructor(client) {
     this._client = client;
   }
   /**
+   * @deprecated use search instead
    * Takes a set of filter parameters. return matches of human tasks for that set of parameters
    * @param state
    * @param assignee
@@ -2843,21 +2948,68 @@ var HumanExecutor = class {
    * @param includeInputOutput
    * @returns
    */
-  async getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, freeText, includeInputOutput = false) {
-    const response = await this._client.humanTask.getTasksByFilter(
-      state,
-      assignee,
-      assigneeType,
-      claimedBy,
-      taskName,
-      freeText,
-      includeInputOutput
+  async getTasksByFilter(state, assignee, assigneeType, claimedBy, taskName, taskInputQuery, taskOutputQuery) {
+    const [claimedUserType, claimedUser] = claimedBy?.split(":") ?? [];
+    if (claimedUserType && !claimedUser) {
+      throw new Error("claimedBy should be in the format of <userType>:<user>");
+    }
+    const response = await this.search({
+      states: [state],
+      assignees: assignee ? [{ userType: assigneeType, user: assignee }] : [],
+      claimants: claimedBy ? [{ userType: claimedUserType, user: claimedUser }] : [],
+      taskRefNames: taskName ? [taskName] : [],
+      taskInputQuery,
+      taskOutputQuery
+    });
+    return response;
+  }
+  /**
+   * Takes a set of filter parameters. return matches of human tasks for that set of parameters
+   * @param state
+   * @param assignee
+   * @param assigneeType
+   * @param claimedBy
+   * @param taskName
+   * @param freeText
+   * @param includeInputOutput
+   * @returns Promise<HumanTaskEntry[]>
+   */
+  async search(searchParams) {
+    const search = { ...EMPTY_SEARCH, ...searchParams };
+    const response = await tryCatchReThrow(
+      () => this._client.humanTask.search(search)
     );
     if (response.results != void 0) {
       return response.results;
     }
     return [];
   }
+  /**
+   * Takes a set of filter parameters. An polling interval options. will poll until the task returns a result
+   * @param state
+   * @param assignee
+   * @param assigneeType
+   * @param claimedBy
+   * @param taskName
+   * @param freeText
+   * @param includeInputOutput
+   * @returns Promise<HumanTaskEntry[]>
+   */
+  async pollSearch(searchParams, {
+    pollInterval = 100,
+    maxPollTimes = 20
+  } = DEFAULT_POLL_INTERVAL2) {
+    let pollCount = 0;
+    while (pollCount < maxPollTimes) {
+      const response = await this.search(searchParams);
+      if (response.length > 0) {
+        return response;
+      }
+      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
+      pollCount++;
+    }
+    return [];
+  }
   /**
    * Returns task for a given task id
    * @param taskId
@@ -2873,11 +3025,9 @@ var HumanExecutor = class {
    * @returns
    */
   async claimTaskAsExternalUser(taskId, assignee) {
-    try {
-      await this._client.humanTask.assignAndClaim(taskId, assignee);
-    } catch (error) {
-      throw errorMapper(error);
-    }
+    return tryCatchReThrow(
+      () => this._client.humanTask.assignAndClaim(taskId, assignee)
+    );
   }
   /**
    * Claim task as conductor user
@@ -2885,11 +3035,7 @@ var HumanExecutor = class {
    * @returns
    */
   async claimTaskAsConductorUser(taskId) {
-    try {
-      await this._client.humanTask.claimTask(taskId);
-    } catch (error) {
-      throw errorMapper(error);
-    }
+    return tryCatchReThrow(() => this._client.humanTask.claimTask(taskId));
   }
   /**
    * Claim task as conductor user
@@ -2905,15 +3051,24 @@ var HumanExecutor = class {
     }
   }
   /**
-   * Returns a HumanTaskTemplateEntry for a given templateId
+   * Returns a HumanTaskTemplateEntry for a given name and version
    * @param templateId
    * @returns
    */
-  async getTemplateById(templateId) {
+  async getTemplateByNameVersion(name, version) {
     return tryCatchReThrow(
-      () => this._client.humanTask.getTemplateById(templateId)
+      () => this._client.humanTask.getTemplateByNameAndVersion(name, version)
     );
   }
+  /**
+   * @deprecated use getTemplate instead. name will be used as id here with version 1
+   * Returns a HumanTaskTemplateEntry for a given templateId
+   * @param templateId
+   * @returns
+   */
+  async getTemplateById(templateNameVersionOne) {
+    return this.getTemplateByNameVersion(templateNameVersionOne, 1);
+  }
   /**
    * Takes a taskId and a partial body. will update with given body
    * @param taskId
@@ -3422,105 +3577,73 @@ var workflow = (name, tasks) => ({
   timeoutSeconds: 0
 });
 
-// src/orkes/request/fetchCatchDns/DnsResolver.ts
-import { promises } from "dns";
-var DEFAULT_OPTIONS = {
-  logger: noopLogger,
-  resolver: promises.resolve4
-};
-var dnsResolver = async (host, { resolver = promises.resolve4, logger = console } = DEFAULT_OPTIONS) => {
-  try {
-    const addresses = await resolver(host);
-    if (addresses.length > 0)
-      return addresses[0];
-  } catch (e) {
-    logger.error("Could not resolve host: " + host + " error: " + e);
-  }
-  return void 0;
-};
-
-// src/orkes/request/fetchCatchDns/DnsCache.ts
-var DnsCacheResolver = class {
-  constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
-    this._cache = /* @__PURE__ */ new Map();
-    this._cache = initialCache;
+// src/orkes/BaseOrkesConductorClient.ts
+var defaultRequestHandler2 = (request3, config, options) => request3(config, options);
+var REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1e3;
+var AuthConductorClient = class extends ConductorClient {
+  intervalId;
+  constructor(config, requestHandler = defaultRequestHandler2) {
+    super(config, requestHandler);
   }
-  async resolve(host) {
-    const cachedIp = this._cache.get(host);
-    if (cachedIp) {
-      return cachedIp;
-    }
-    const ip = await dnsResolver(host);
-    if (ip != void 0) {
-      this._cache.set(host, ip);
+  /**
+   * Stops the interval that refreshes the token
+   */
+  stop() {
+    if (this.intervalId != null) {
+      clearInterval(this.intervalId);
     }
-    return ip;
-  }
-  clearCache() {
-    this._cache.clear();
-  }
-  removeCache(host) {
-    this._cache.delete(host);
-  }
-  get cache() {
-    return this._cache;
   }
 };
-
-// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
-import { isIP } from "net";
-var isEmpty = (value) => {
-  return value === void 0 || value.trim().length === 0;
-};
-var toMaybeUrl = (originalUrl, modifiedParams) => {
-  const urlToHit = new URL(originalUrl.toString());
-  urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
-  return urlToHit;
-};
-var DEFAULT_OPTIONS2 = {
-  dnsCache: new DnsCacheResolver(),
-  headerFactory: (headers) => new Headers(headers || {})
-};
-var fetchCatchDns = (fetch3, {
-  dnsCache = new DnsCacheResolver(),
-  headerFactory = (headers) => new Headers(headers || {})
-} = DEFAULT_OPTIONS2) => {
-  const fetchWithDns = async (input, options) => {
-    const parsedUrl = new URL(input.toString());
-    const { hostname, host, port } = parsedUrl;
-    if (isIP(hostname)) {
-      return await fetch3(input, options);
-    }
-    const maybeTargetIp = await dnsCache.resolve(hostname);
-    if (isEmpty(maybeTargetIp)) {
-      return await fetch3(input, options);
-    }
-    const target = toMaybeUrl(input, {
-      ...parsedUrl,
-      host: maybeTargetIp,
-      port
-    });
-    const headersOverride = headerFactory(options?.headers ?? {});
-    if (!headersOverride.has("Host")) {
-      headersOverride.set("Host", host);
-    }
-    const optionsOverride = {
-      ...options,
-      headers: headersOverride
-    };
-    try {
-      const res = await fetch3(target.toString(), optionsOverride);
-      return res;
-    } catch (e) {
-      if (e && e?.code === "ETIMEDOUT") {
-        dnsCache.removeCache(hostname);
+var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHandler2) => {
+  const requestTokenForKeySecret = (keyId, keySecret, tokenUrl) => fetchFn(tokenUrl, {
+    headers: {
+      "Content-Type": "application/json",
+      Accept: "application/json"
+    },
+    body: JSON.stringify({ keyId, keySecret }),
+    method: "POST"
+  });
+  return async (config, requestHandler = baseRequestHandler) => {
+    if (config?.keySecret != null && config?.keyId != null) {
+      const {
+        serverUrl,
+        keyId,
+        keySecret,
+        refreshTokenInterval = REFRESH_TOKEN_IN_MILLISECONDS
+      } = config;
+      const tokenUrl = `${serverUrl}/token`;
+      const res = await requestTokenForKeySecret(keyId, keySecret, tokenUrl);
+      const { token } = await res.json();
+      const conductorClientInstance = new AuthConductorClient(
+        { ...config, TOKEN: token },
+        requestHandler
+      );
+      if (token != null && refreshTokenInterval > 0) {
+        const intervalId = setInterval(async () => {
+          const res2 = await requestTokenForKeySecret(
+            keyId,
+            keySecret,
+            tokenUrl
+          );
+          const { token: token2 } = await res2.json();
+          conductorClientInstance.token = token2;
+        }, refreshTokenInterval);
+        conductorClientInstance.intervalId = intervalId;
       }
-      throw e;
+      return conductorClientInstance;
+    } else {
+      return new ConductorClient(config, requestHandler);
     }
   };
-  return fetchWithDns;
 };
 
+// src/orkes/OrkesConductorClient.ts
+var defaultRequestHandler3 = (request3, config, options) => request3(config, options);
+var orkesConductorClient = baseOrkesConductorClient(
+  fetch,
+  defaultRequestHandler3
+);
+
 // src/orkes/request/request.ts
 var isDefined2 = (value) => {
   return value !== void 0 && value !== null;
@@ -3756,91 +3879,104 @@ var request2 = (config, options, fetchFn = fetch) => {
   });
 };
 
-// src/orkes/BaseOrkesConductorClient.ts
-var defaultRequestHandler2 = (request3, config, options) => request3(config, options);
-var REFRESH_TOKEN_IN_MILLISECONDS = 30 * 60 * 1e3;
-var AuthConductorClient = class extends ConductorClient {
-  constructor(config, requestHandler = defaultRequestHandler2) {
-    super(config, requestHandler);
+// src/orkes/request/fetchCatchDns/DnsResolver.ts
+import { promises } from "dns";
+var DEFAULT_OPTIONS = {
+  logger: noopLogger,
+  resolver: promises.resolve4
+};
+var dnsResolver = async (host, { resolver = promises.resolve4, logger = console } = DEFAULT_OPTIONS) => {
+  try {
+    const addresses = await resolver(host);
+    if (addresses.length > 0)
+      return addresses[0];
+  } catch (e) {
+    logger.error("Could not resolve host: " + host + " error: " + e);
   }
-  /**
-   * Stops the interval that refreshes the token
-   */
-  stop() {
-    if (this.intervalId != null) {
-      clearInterval(this.intervalId);
+  return void 0;
+};
+
+// src/orkes/request/fetchCatchDns/DnsCache.ts
+var DnsCacheResolver = class {
+  _cache = /* @__PURE__ */ new Map();
+  constructor({ initialCache = /* @__PURE__ */ new Map() } = {}) {
+    this._cache = initialCache;
+  }
+  async resolve(host) {
+    const cachedIp = this._cache.get(host);
+    if (cachedIp) {
+      return cachedIp;
+    }
+    const ip = await dnsResolver(host);
+    if (ip != void 0) {
+      this._cache.set(host, ip);
     }
+    return ip;
+  }
+  clearCache() {
+    this._cache.clear();
+  }
+  removeCache(host) {
+    this._cache.delete(host);
+  }
+  get cache() {
+    return this._cache;
   }
 };
-var baseOrkesConductorClient = (fetchFn, baseRequestHandler = defaultRequestHandler2) => {
-  const requestTokenForKeySecret = (keyId, keySecret, tokenUrl) => fetchFn(tokenUrl, {
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/json"
-    },
-    body: JSON.stringify({ keyId, keySecret }),
-    method: "POST"
-  });
-  return async (config, requestHandler = baseRequestHandler) => {
-    if (config?.keySecret != null && config?.keyId != null) {
-      const {
-        serverUrl,
-        keyId,
-        keySecret,
-        refreshTokenInterval = REFRESH_TOKEN_IN_MILLISECONDS
-      } = config;
-      const tokenUrl = `${serverUrl}/token`;
-      const res = await requestTokenForKeySecret(keyId, keySecret, tokenUrl);
-      const { token } = await res.json();
-      const conductorClientInstance = new AuthConductorClient(
-        { ...config, TOKEN: token },
-        requestHandler
-      );
-      if (token != null && refreshTokenInterval > 0) {
-        const intervalId = setInterval(async () => {
-          const res2 = await requestTokenForKeySecret(
-            keyId,
-            keySecret,
-            tokenUrl
-          );
-          const { token: token2 } = await res2.json();
-          conductorClientInstance.token = token2;
-        }, refreshTokenInterval);
-        conductorClientInstance.intervalId = intervalId;
+
+// src/orkes/request/fetchCatchDns/fetchCatchDns.ts
+import { isIP } from "net";
+var isEmpty = (value) => {
+  return value === void 0 || value.trim().length === 0;
+};
+var toMaybeUrl = (originalUrl, modifiedParams) => {
+  const urlToHit = new URL(originalUrl.toString());
+  urlToHit.host = isEmpty(modifiedParams.port) ? `${modifiedParams.host}:${modifiedParams.port}` : modifiedParams.host;
+  return urlToHit;
+};
+var DEFAULT_OPTIONS2 = {
+  dnsCache: new DnsCacheResolver(),
+  headerFactory: (headers) => new Headers(headers || {})
+};
+var fetchCatchDns = (fetch2, {
+  dnsCache = new DnsCacheResolver(),
+  headerFactory = (headers) => new Headers(headers || {})
+} = DEFAULT_OPTIONS2) => {
+  const fetchWithDns = async (input, options) => {
+    const parsedUrl = new URL(input.toString());
+    const { hostname, host, port } = parsedUrl;
+    if (isIP(hostname)) {
+      return await fetch2(input, options);
+    }
+    const maybeTargetIp = await dnsCache.resolve(hostname);
+    if (isEmpty(maybeTargetIp)) {
+      return await fetch2(input, options);
+    }
+    const target = toMaybeUrl(input, {
+      ...parsedUrl,
+      host: maybeTargetIp,
+      port
+    });
+    const headersOverride = headerFactory(options?.headers ?? {});
+    if (!headersOverride.has("Host")) {
+      headersOverride.set("Host", host);
+    }
+    const optionsOverride = {
+      ...options,
+      headers: headersOverride
+    };
+    try {
+      const res = await fetch2(target.toString(), optionsOverride);
+      return res;
+    } catch (e) {
+      if (e && e?.code === "ETIMEDOUT") {
+        dnsCache.removeCache(hostname);
       }
-      return conductorClientInstance;
-    } else {
-      return new ConductorClient(config, requestHandler);
+      throw e;
     }
   };
+  return fetchWithDns;
 };
-
-// src/orkes/OrkesConductorClient.ts
-import fetch2, { Headers as Headers2 } from "node-fetch";
-import http from "http";
-import https from "https";
-var httpAgent = new http.Agent({ keepAlive: true });
-var httpsAgent = new https.Agent({ keepAlive: true });
-var agent = (_parsedURL) => _parsedURL.protocol == "http:" ? httpAgent : httpsAgent;
-var nodeFetchWrapper = async (input, options = {}) => {
-  const res = await fetch2(input.toString(), {
-    ...options,
-    agent
-  });
-  return res;
-};
-var fetchCache = fetchCatchDns(
-  nodeFetchWrapper,
-  {
-    //@ts-ignore
-    headerFactory: (headers) => new Headers2(headers || {})
-  }
-);
-var defaultRequestHandler3 = (__request, config, options) => request2(config, options, fetchCache);
-var orkesConductorClient = baseOrkesConductorClient(
-  fetchCache,
-  defaultRequestHandler3
-);
 export {
   ApiError,
   AuthConductorClient,
@@ -3865,6 +4001,7 @@ export {
   WorkflowExecutor,
   WorkflowResourceService,
   baseOrkesConductorClient,
+  completedTaskMatchingType,
   conductorEventTask,
   doWhileTask,
   dynamicForkTask,