@io-orkes/conductor-javascript 1.2.2 → 2.0.0-rc1

package/dist/index.mjs

@@ -1823,83 +1823,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 +1904,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 +1927,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 +1978,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 +2019,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 +2072,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
       }
     });
   }
@@ -2281,6 +2287,15 @@ var Poller = class {
   }
 };
 
+// src/task/helpers.ts
+var optionEquals = (oldOptions, newOptions) => {
+  const newOptionEntries = Object.entries(newOptions);
+  const oldOptionsEntries = Object.entries(oldOptions);
+  return newOptionEntries.length === oldOptionsEntries.length && newOptionEntries.every(
+    ([key, value]) => oldOptions[key] === value
+  );
+};
+
 // src/task/TaskRunner.ts
 var DEFAULT_ERROR_MESSAGE = "An unknown error occurred";
 var MAX_RETRIES = 3;
@@ -2407,13 +2422,16 @@ var TaskRunner = class {
   }
   updateOptions(options) {
     const newOptions = { ...this.options, ...options };
-    this.poller.updateOptions({
-      concurrency: newOptions.concurrency,
-      pollInterval: newOptions.pollInterval
-    });
-    this.logger.info(
-      `TaskWorker ${this.worker.taskDefName} configuration updated with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
-    );
+    const isOptionsUpdated = !optionEquals(this.options, newOptions);
+    if (isOptionsUpdated) {
+      this.poller.updateOptions({
+        concurrency: newOptions.concurrency,
+        pollInterval: newOptions.pollInterval
+      });
+      this.logger.info(
+        `TaskWorker ${this.worker.taskDefName} configuration updated with concurrency of ${this.poller.options.concurrency} and poll interval of ${this.poller.options.pollInterval}`
+      );
+    }
     this.options = newOptions;
   }
   get getOptions() {
@@ -2556,9 +2574,18 @@ 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 {
   constructor(client) {
     this._client = client;
@@ -2591,12 +2618,38 @@ var WorkflowExecutor = class {
    */
   executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef = "") {
     return tryCatchReThrow(
-      () => this._client.workflowResource.executeWorkflow(workflowRequest, name, version, requestId, waitUntilTaskRef)
+      () => this._client.workflowResource.executeWorkflow(
+        workflowRequest,
+        name,
+        version,
+        requestId,
+        waitUntilTaskRef
+      )
     );
   }
   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,
@@ -2641,6 +2694,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
@@ -2810,11 +2879,24 @@ 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 {
   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
@@ -2825,21 +2907,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
@@ -2855,11 +2984,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
@@ -2867,11 +2994,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
@@ -2887,15 +3010,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
@@ -3847,6 +3979,7 @@ export {
   WorkflowExecutor,
   WorkflowResourceService,
   baseOrkesConductorClient,
+  completedTaskMatchingType,
   conductorEventTask,
   doWhileTask,
   dynamicForkTask,