@io-orkes/conductor-javascript
Version:
Typescript Client for Netflix Conductor
2,050 lines (2,037 loc) • 112 kB
JavaScript
// src/common/ConductorLogger.ts
var LOG_LEVELS = {
DEBUG: 10,
INFO: 30,
ERROR: 60
};
var DefaultLogger = class {
tags;
level;
constructor(config = {}) {
const { level, tags = [] } = config;
this.tags = tags;
if (level && level in LOG_LEVELS) {
this.level = LOG_LEVELS[level];
} else {
this.level = LOG_LEVELS.INFO;
}
}
log(level, ...args) {
let resolvedLevel;
let name = level;
if (level in LOG_LEVELS) {
resolvedLevel = LOG_LEVELS[level];
} else {
name = "INFO";
resolvedLevel = LOG_LEVELS.INFO;
}
if (resolvedLevel >= this.level) {
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
debug: (...args) => {
},
//eslint-disable-next-line
info: (...args) => {
},
//eslint-disable-next-line
error: (...args) => {
}
};
// src/common/types.ts
var TaskType = /* @__PURE__ */ ((TaskType2) => {
TaskType2["START"] = "START";
TaskType2["SIMPLE"] = "SIMPLE";
TaskType2["DYNAMIC"] = "DYNAMIC";
TaskType2["FORK_JOIN"] = "FORK_JOIN";
TaskType2["FORK_JOIN_DYNAMIC"] = "FORK_JOIN_DYNAMIC";
TaskType2["DECISION"] = "DECISION";
TaskType2["SWITCH"] = "SWITCH";
TaskType2["JOIN"] = "JOIN";
TaskType2["DO_WHILE"] = "DO_WHILE";
TaskType2["SUB_WORKFLOW"] = "SUB_WORKFLOW";
TaskType2["EVENT"] = "EVENT";
TaskType2["WAIT"] = "WAIT";
TaskType2["USER_DEFINED"] = "USER_DEFINED";
TaskType2["HTTP"] = "HTTP";
TaskType2["LAMBDA"] = "LAMBDA";
TaskType2["INLINE"] = "INLINE";
TaskType2["EXCLUSIVE_JOIN"] = "EXCLUSIVE_JOIN";
TaskType2["TERMINAL"] = "TERMINAL";
TaskType2["TERMINATE"] = "TERMINATE";
TaskType2["KAFKA_PUBLISH"] = "KAFKA_PUBLISH";
TaskType2["JSON_JQ_TRANSFORM"] = "JSON_JQ_TRANSFORM";
TaskType2["SET_VARIABLE"] = "SET_VARIABLE";
return TaskType2;
})(TaskType || {});
// src/common/open-api/services/EventResourceService.ts
var EventResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Get queue config by name
* @param queueType
* @param queueName
* @returns any OK
* @throws ApiError
*/
getQueueConfig(queueType, queueName) {
return this.httpRequest.request({
method: "GET",
url: "/event/queue/config/{queueType}/{queueName}",
path: {
"queueType": queueType,
"queueName": queueName
}
});
}
/**
* Create or update queue config by name
* @param queueType
* @param queueName
* @param requestBody
* @returns any OK
* @throws ApiError
*/
putQueueConfig(queueType, queueName, requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/event/queue/config/{queueType}/{queueName}",
path: {
"queueType": queueType,
"queueName": queueName
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Delete queue config by name
* @param queueType
* @param queueName
* @returns any OK
* @throws ApiError
*/
deleteQueueConfig(queueType, queueName) {
return this.httpRequest.request({
method: "DELETE",
url: "/event/queue/config/{queueType}/{queueName}",
path: {
"queueType": queueType,
"queueName": queueName
}
});
}
/**
* Get all the event handlers
* @returns EventHandler OK
* @throws ApiError
*/
getEventHandlers() {
return this.httpRequest.request({
method: "GET",
url: "/event"
});
}
/**
* Update an existing event handler.
* @param requestBody
* @returns any OK
* @throws ApiError
*/
updateEventHandler(requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/event",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Add a new event handler.
* @param requestBody
* @returns any OK
* @throws ApiError
*/
addEventHandler(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/event",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get all queue configs
* @returns any OK
* @throws ApiError
*/
getQueueNames() {
return this.httpRequest.request({
method: "GET",
url: "/event/queue/config"
});
}
/**
* Remove an event handler
* @param name
* @returns any OK
* @throws ApiError
*/
removeEventHandlerStatus(name) {
return this.httpRequest.request({
method: "DELETE",
url: "/event/{name}",
path: {
"name": name
}
});
}
/**
* Get event handlers for a given event
* @param event
* @param activeOnly
* @returns EventHandler OK
* @throws ApiError
*/
getEventHandlersForEvent(event, activeOnly = true) {
return this.httpRequest.request({
method: "GET",
url: "/event/{event}",
path: {
"event": event
},
query: {
"activeOnly": activeOnly
}
});
}
};
// src/common/open-api/services/HealthCheckResourceService.ts
var HealthCheckResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* @returns any OK
* @throws ApiError
*/
doCheck() {
return this.httpRequest.request({
method: "GET",
url: "/health"
});
}
};
// src/common/open-api/services/MetadataResourceService.ts
var MetadataResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Gets the task definition
* @param tasktype
* @param metadata
* @returns TaskDef OK
* @throws ApiError
*/
getTaskDef(tasktype, metadata = false) {
return this.httpRequest.request({
method: "GET",
url: "/metadata/taskdefs/{tasktype}",
path: {
"tasktype": tasktype
},
query: {
"metadata": metadata
}
});
}
/**
* Remove a task definition
* @param tasktype
* @returns any OK
* @throws ApiError
*/
unregisterTaskDef(tasktype) {
return this.httpRequest.request({
method: "DELETE",
url: "/metadata/taskdefs/{tasktype}",
path: {
"tasktype": tasktype
}
});
}
/**
* Retrieves all workflow definition along with blueprint
* @param access
* @param metadata
* @param tagKey
* @param tagValue
* @returns WorkflowDef OK
* @throws ApiError
*/
getAllWorkflows(access = "READ", metadata = false, tagKey, tagValue) {
return this.httpRequest.request({
method: "GET",
url: "/metadata/workflow",
query: {
"access": access,
"metadata": metadata,
"tagKey": tagKey,
"tagValue": tagValue
}
});
}
/**
* Create or update workflow definition(s)
* @param requestBody
* @param overwrite
* @returns any OK
* @throws ApiError
*/
update(requestBody, overwrite = true) {
return this.httpRequest.request({
method: "PUT",
url: "/metadata/workflow",
query: {
"overwrite": overwrite
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Create a new workflow definition
* @param requestBody
* @param overwrite
* @returns any OK
* @throws ApiError
*/
create(requestBody, overwrite = false) {
return this.httpRequest.request({
method: "POST",
url: "/metadata/workflow",
query: {
"overwrite": overwrite
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Gets all task definition
* @param access
* @param metadata
* @param tagKey
* @param tagValue
* @returns TaskDef OK
* @throws ApiError
*/
getTaskDefs(access = "READ", metadata = false, tagKey, tagValue) {
return this.httpRequest.request({
method: "GET",
url: "/metadata/taskdefs",
query: {
"access": access,
"metadata": metadata,
"tagKey": tagKey,
"tagValue": tagValue
}
});
}
/**
* Update an existing task
* @param requestBody
* @returns any OK
* @throws ApiError
*/
updateTaskDef(requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/metadata/taskdefs",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Create or update task definition(s)
* @param requestBody
* @returns any OK
* @throws ApiError
*/
registerTaskDef(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/metadata/taskdefs",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Removes workflow definition. It does not remove workflows associated with the definition.
* @param name
* @param version
* @returns any OK
* @throws ApiError
*/
unregisterWorkflowDef(name, version) {
return this.httpRequest.request({
method: "DELETE",
url: "/metadata/workflow/{name}/{version}",
path: {
"name": name,
"version": version
}
});
}
/**
* Retrieves workflow definition along with blueprint
* @param name
* @param version
* @param metadata
* @returns WorkflowDef OK
* @throws ApiError
*/
get(name, version, metadata = false) {
return this.httpRequest.request({
method: "GET",
url: "/metadata/workflow/{name}",
path: {
"name": name
},
query: {
"version": version,
"metadata": metadata
}
});
}
};
// src/common/open-api/services/SchedulerResourceService.ts
var SchedulerResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Get an existing workflow schedule by name
* @param name
* @returns any OK
* @throws ApiError
*/
getSchedule(name) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/schedules/{name}",
path: {
"name": name
}
});
}
/**
* Deletes an existing workflow schedule by name
* @param name
* @returns any OK
* @throws ApiError
*/
deleteSchedule(name) {
return this.httpRequest.request({
method: "DELETE",
url: "/scheduler/schedules/{name}",
path: {
"name": name
}
});
}
/**
* Get list of the next x (default 3, max 5) execution times for a scheduler
* @param cronExpression
* @param scheduleStartTime
* @param scheduleEndTime
* @param limit
* @returns number OK
* @throws ApiError
*/
getNextFewSchedules(cronExpression, scheduleStartTime, scheduleEndTime, limit = 3) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/nextFewSchedules",
query: {
"cronExpression": cronExpression,
"scheduleStartTime": scheduleStartTime,
"scheduleEndTime": scheduleEndTime,
"limit": limit
}
});
}
/**
* Pauses an existing schedule by name
* @param name
* @returns any OK
* @throws ApiError
*/
pauseSchedule(name) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/schedules/{name}/pause",
path: {
"name": name
}
});
}
/**
* Pause all scheduling in a single conductor server instance (for debugging only)
* @returns any OK
* @throws ApiError
*/
pauseAllSchedules() {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/admin/pause"
});
}
/**
* Resume a paused schedule by name
* @param name
* @returns any OK
* @throws ApiError
*/
resumeSchedule(name) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/schedules/{name}/resume",
path: {
"name": name
}
});
}
/**
* Requeue all execution records
* @returns any OK
* @throws ApiError
*/
requeueAllExecutionRecords() {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/admin/requeue"
});
}
/**
* Resume all scheduling
* @returns any OK
* @throws ApiError
*/
resumeAllSchedules() {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/admin/resume"
});
}
/**
* Get all existing workflow schedules and optionally filter by workflow name
* @param workflowName
* @returns WorkflowSchedule OK
* @throws ApiError
*/
getAllSchedules(workflowName) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/schedules",
query: {
"workflowName": workflowName
}
});
}
/**
* Create or update a schedule for a specified workflow with a corresponding start workflow request
* @param requestBody
* @returns any OK
* @throws ApiError
*/
saveSchedule(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/scheduler/schedules",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Test timeout - do not use in production
* @returns any OK
* @throws ApiError
*/
testTimeout() {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/test/timeout"
});
}
/**
* Search for workflows based on payload and other parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultWorkflowScheduleExecutionModel OK
* @throws ApiError
*/
searchV21(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/scheduler/search/executions",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
};
// src/common/open-api/services/TaskResourceService.ts
var TaskResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Poll for a task of a certain type
* @param tasktype
* @param workerid
* @param domain
* @returns Task OK
* @throws ApiError
*/
poll(tasktype, workerid, domain) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/poll/{tasktype}",
path: {
"tasktype": tasktype
},
query: {
"workerid": workerid,
"domain": domain
}
});
}
/**
* Get the details about each queue
* @returns number OK
* @throws ApiError
*/
allVerbose() {
return this.httpRequest.request({
method: "GET",
url: "/tasks/queue/all/verbose"
});
}
/**
* Update a task By Ref Name
* @param workflowId
* @param taskRefName
* @param status
* @param requestBody
* @returns string OK
* @throws ApiError
*/
updateTask(workflowId, taskRefName, status, requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/tasks/{workflowId}/{taskRefName}/{status}",
path: {
"workflowId": workflowId,
"taskRefName": taskRefName,
"status": status
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get task by Id
* @param taskId
* @returns Task OK
* @throws ApiError
*/
getTask(taskId) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/{taskId}",
path: {
"taskId": taskId
}
});
}
/**
* Get the details about each queue
* @returns number OK
* @throws ApiError
*/
all() {
return this.httpRequest.request({
method: "GET",
url: "/tasks/queue/all"
});
}
/**
* Requeue pending tasks
* @param taskType
* @returns string OK
* @throws ApiError
*/
requeuePendingTask(taskType) {
return this.httpRequest.request({
method: "POST",
url: "/tasks/queue/requeue/{taskType}",
path: {
"taskType": taskType
}
});
}
/**
* Search for tasks based in payload and other parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultTaskSummary OK
* @throws ApiError
*/
search(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/search",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
/**
* Search for tasks based in payload and other parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultTask OK
* @throws ApiError
*/
searchV22(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/search-v2",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
/**
* Get the last poll data for a given task type
* @param taskType
* @returns PollData OK
* @throws ApiError
*/
getPollData(taskType) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/queue/polldata",
query: {
"taskType": taskType
}
});
}
/**
* Get Task Execution Logs
* @param taskId
* @returns TaskExecLog OK
* @throws ApiError
*/
getTaskLogs(taskId) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/{taskId}/log",
path: {
"taskId": taskId
}
});
}
/**
* Log Task Execution Details
* @param taskId
* @param requestBody
* @returns any OK
* @throws ApiError
*/
log(taskId, requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/tasks/{taskId}/log",
path: {
"taskId": taskId
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get the last poll data for all task types
* @returns PollData OK
* @throws ApiError
*/
getAllPollData() {
return this.httpRequest.request({
method: "GET",
url: "/tasks/queue/polldata/all"
});
}
/**
* Batch poll for a task of a certain type
* @param tasktype
* @param workerid
* @param domain
* @param count
* @param timeout
* @returns Task OK
* @throws ApiError
*/
batchPoll(tasktype, workerid, domain, count = 1, timeout = 100) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/poll/batch/{tasktype}",
path: {
"tasktype": tasktype
},
query: {
"workerid": workerid,
"domain": domain,
"count": count,
"timeout": timeout
}
});
}
/**
* Update a task
* @param requestBody
* @returns string OK
* @throws ApiError
*/
updateTask1(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/tasks",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get Task type queue sizes
* @param taskType
* @returns number OK
* @throws ApiError
*/
size1(taskType) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/queue/sizes",
query: {
"taskType": taskType
}
});
}
/**
* Get the external uri where the task payload is to be stored
* @param path
* @param operation
* @param payloadType
* @returns ExternalStorageLocation OK
* @throws ApiError
*/
getExternalStorageLocation1(path, operation, payloadType) {
return this.httpRequest.request({
method: "GET",
url: "/tasks/externalstoragelocation",
query: {
"path": path,
"operation": operation,
"payloadType": payloadType
}
});
}
};
// src/common/open-api/services/TokenResourceService.ts
var TokenResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Generate JWT with the given access key
* @param requestBody
* @returns Response OK
* @throws ApiError
*/
generateToken(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/token",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get the user info from the token
* @returns any OK
* @throws ApiError
*/
getUserInfo() {
return this.httpRequest.request({
method: "GET",
url: "/token/userInfo"
});
}
};
// src/common/open-api/services/WorkflowBulkResourceService.ts
var WorkflowBulkResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Retry the last failed task for each workflow from the list
* @param requestBody
* @returns BulkResponse OK
* @throws ApiError
*/
retry(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/bulk/retry",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Restart the list of completed workflow
* @param requestBody
* @param useLatestDefinitions
* @returns BulkResponse OK
* @throws ApiError
*/
restart(requestBody, useLatestDefinitions = false) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/bulk/restart",
query: {
"useLatestDefinitions": useLatestDefinitions
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Terminate workflows execution
* @param requestBody
* @param reason
* @returns BulkResponse OK
* @throws ApiError
*/
terminate(requestBody, reason) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/bulk/terminate",
query: {
"reason": reason
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Resume the list of workflows
* @param requestBody
* @returns BulkResponse OK
* @throws ApiError
*/
resumeWorkflow(requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/bulk/resume",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Pause the list of workflows
* @param requestBody
* @returns BulkResponse OK
* @throws ApiError
*/
pauseWorkflow1(requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/bulk/pause",
body: requestBody,
mediaType: "application/json"
});
}
};
// src/common/open-api/services/WorkflowResourceService.ts
var WorkflowResourceService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* Retrieve all the running workflows
* @param name
* @param version
* @param startTime
* @param endTime
* @returns string OK
* @throws ApiError
*/
getRunningWorkflow(name, version = 1, startTime, endTime) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/running/{name}",
path: {
"name": name
},
query: {
"version": version,
"startTime": startTime,
"endTime": endTime
}
});
}
/**
* Execute a workflow synchronously
* @param body
* @param name
* @param version
* @param requestId
* @param waitUntilTaskRef
* @param callback
* @returns workflowRun
* @throws ApiError
*/
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"
});
}
/**
* Start a new workflow with StartWorkflowRequest, which allows task to be executed in a domain
* @param requestBody
* @returns string OK
* @throws ApiError
*/
startWorkflow(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/workflow",
body: requestBody,
mediaType: "application/json"
});
}
/**
* Starts the decision task for a workflow
* @param workflowId
* @returns any OK
* @throws ApiError
*/
decide(workflowId) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/decide/{workflowId}",
path: {
"workflowId": workflowId
}
});
}
/**
* Reruns the workflow from a specific task
* @param workflowId
* @param requestBody
* @returns string OK
* @throws ApiError
*/
rerun(workflowId, requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{workflowId}/rerun",
path: {
"workflowId": workflowId
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Search for workflows based on payload and other parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultWorkflow OK
* @throws ApiError
*/
searchV21(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/search-v2",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
/**
* Pauses the workflow
* @param workflowId
* @returns any OK
* @throws ApiError
*/
pauseWorkflow(workflowId) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/{workflowId}/pause",
path: {
"workflowId": workflowId
}
});
}
/**
* Skips a given task from a current running workflow
* @param workflowId
* @param taskReferenceName
* @param requestBody
* @returns any OK
* @throws ApiError
*/
skipTaskFromWorkflow(workflowId, taskReferenceName, requestBody) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/{workflowId}/skiptask/{taskReferenceName}",
path: {
"workflowId": workflowId,
"taskReferenceName": taskReferenceName
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Lists workflows for the given correlation id list
* @param name
* @param requestBody
* @param includeClosed
* @param includeTasks
* @returns Workflow OK
* @throws ApiError
*/
getWorkflows(name, requestBody, includeClosed = false, includeTasks = false) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{name}/correlated",
path: {
"name": name
},
query: {
"includeClosed": includeClosed,
"includeTasks": includeTasks
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Gets the workflow by workflow id
* @param workflowId
* @param includeOutput
* @param includeVariables
* @returns WorkflowStatus OK
* @throws ApiError
*/
getWorkflowStatusSummary(workflowId, includeOutput = false, includeVariables = false) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/{workflowId}/status",
path: {
"workflowId": workflowId
},
query: {
"includeOutput": includeOutput,
"includeVariables": includeVariables
}
});
}
/**
* Lists workflows for the given correlation id
* @param name
* @param correlationId
* @param includeClosed
* @param includeTasks
* @returns Workflow OK
* @throws ApiError
*/
getWorkflows1(name, correlationId, includeClosed = false, includeTasks = false) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/{name}/correlated/{correlationId}",
path: {
"name": name,
"correlationId": correlationId
},
query: {
"includeClosed": includeClosed,
"includeTasks": includeTasks
}
});
}
/**
* Retries the last failed task
* @param workflowId
* @param resumeSubworkflowTasks
* @returns void
* @throws ApiError
*/
retry1(workflowId, resumeSubworkflowTasks = false) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{workflowId}/retry",
path: {
"workflowId": workflowId
},
query: {
"resumeSubworkflowTasks": resumeSubworkflowTasks
}
});
}
/**
* Gets the workflow by workflow id
* @param workflowId
* @param includeTasks
* @returns Workflow OK
* @throws ApiError
*/
getExecutionStatus(workflowId, includeTasks = true) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/{workflowId}",
path: {
"workflowId": workflowId
},
query: {
"includeTasks": includeTasks
}
});
}
/**
* Terminate workflow execution
* @param workflowId
* @param reason
* @returns any OK
* @throws ApiError
*/
terminate1(workflowId, reason) {
return this.httpRequest.request({
method: "DELETE",
url: "/workflow/{workflowId}",
path: {
"workflowId": workflowId
},
query: {
"reason": reason
}
});
}
/**
* Resumes the workflow
* @param workflowId
* @returns any OK
* @throws ApiError
*/
resumeWorkflow(workflowId) {
return this.httpRequest.request({
method: "PUT",
url: "/workflow/{workflowId}/resume",
path: {
"workflowId": workflowId
}
});
}
/**
* Removes the workflow from the system
* @param workflowId
* @param archiveWorkflow
* @returns any OK
* @throws ApiError
*/
delete(workflowId, archiveWorkflow = true) {
return this.httpRequest.request({
method: "DELETE",
url: "/workflow/{workflowId}/remove",
path: {
"workflowId": workflowId
},
query: {
"archiveWorkflow": archiveWorkflow
}
});
}
/**
* Search for workflows based on task parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultWorkflowSummary OK
* @throws ApiError
*/
searchWorkflowsByTasks(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/search-by-tasks",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
/**
* Get the uri and path of the external storage where the workflow payload is to be stored
* @param path
* @param operation
* @param payloadType
* @returns ExternalStorageLocation OK
* @throws ApiError
*/
getExternalStorageLocation(path, operation, payloadType) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/externalstoragelocation",
query: {
"path": path,
"operation": operation,
"payloadType": payloadType
}
});
}
/**
* Start a new workflow. Returns the ID of the workflow instance that can be later used for tracking
* @param name
* @param requestBody
* @param version
* @param correlationId
* @param priority
* @returns string OK
* @throws ApiError
*/
startWorkflow1(name, requestBody, version, correlationId, priority) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{name}",
path: {
"name": name
},
query: {
"version": version,
"correlationId": correlationId,
"priority": priority
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Restarts a completed workflow
* @param workflowId
* @param useLatestDefinitions
* @returns void
* @throws ApiError
*/
restart1(workflowId, useLatestDefinitions = false) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{workflowId}/restart",
path: {
"workflowId": workflowId
},
query: {
"useLatestDefinitions": useLatestDefinitions
}
});
}
/**
* Search for workflows based on payload and other parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC.
* @param queryId
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @param skipCache
* @returns ScrollableSearchResultWorkflowSummary OK
* @throws ApiError
*/
search1(queryId, start, size = 100, sort, freeText = "*", query, skipCache = false) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/search",
query: {
"queryId": queryId,
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query,
"skipCache": skipCache
}
});
}
/**
* Search for workflows based on task parameters
* use sort options as sort=<field>:ASC|DESC e.g. sort=name&sort=workflowId:DESC. If order is not specified, defaults to ASC
* @param start
* @param size
* @param sort
* @param freeText
* @param query
* @returns SearchResultWorkflow OK
* @throws ApiError
*/
searchWorkflowsByTasksV2(start, size = 100, sort, freeText = "*", query) {
return this.httpRequest.request({
method: "GET",
url: "/workflow/search-by-tasks-v2",
query: {
"start": start,
"size": size,
"sort": sort,
"freeText": freeText,
"query": query
}
});
}
/**
* Resets callback times of all non-terminal SIMPLE tasks to 0
* @param workflowId
* @returns void
* @throws ApiError
*/
resetWorkflow(workflowId) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/{workflowId}/resetcallbacks",
path: {
"workflowId": workflowId
}
});
}
/**
* Test workflow execution using mock data
* @param requestBody
* @returns Workflow OK
* @throws ApiError
*/
testWorkflow(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/workflow/test",
body: requestBody,
mediaType: "application/json"
});
}
};
// 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";
this.url = response.url;
this.status = response.status;
this.statusText = response.statusText;
this.body = response.body;
this.request = request3;
}
};
// src/common/open-api/core/CancelablePromise.ts
var CancelError = class extends Error {
constructor(message) {
super(message);
this.name = "CancelError";
}
get isCancelled() {
return true;
}
};
var CancelablePromise = class {
[Symbol.toStringTag];
_isResolved;
_isRejected;
_isCancelled;
_cancelHandlers;
_promise;
_resolve;
_reject;
constructor(executor) {
this._isResolved = false;
this._isRejected = false;
this._isCancelled = false;
this._cancelHandlers = [];
this._promise = new Promise((resolve3, reject) => {
this._resolve = resolve3;
this._reject = reject;
const onResolve = (value) => {
if (this._isResolved || this._isRejected || this._isCancelled) {
return;
}
this._isResolved = true;
this._resolve?.(value);
};
const onReject = (reason) => {
if (this._isResolved || this._isRejected || this._isCancelled) {
return;
}
this._isRejected = true;
this._reject?.(reason);
};
const onCancel = (cancelHandler) => {
if (this._isResolved || this._isRejected || this._isCancelled) {
return;
}
this._cancelHandlers.push(cancelHandler);
};
Object.defineProperty(onCancel, "isResolved", {
get: () => this._isResolved
});
Object.defineProperty(onCancel, "isRejected", {
get: () => this._isRejected
});
Object.defineProperty(onCancel, "isCancelled", {
get: () => this._isCancelled
});
return executor(onResolve, onReject, onCancel);
});
}
then(onFulfilled, onRejected) {
return this._promise.then(onFulfilled, onRejected);
}
catch(onRejected) {
return this._promise.catch(onRejected);
}
finally(onFinally) {
return this._promise.finally(onFinally);
}
cancel() {
if (this._isResolved || this._isRejected || this._isCancelled) {
return;
}
this._isCancelled = true;
if (this._cancelHandlers.length) {
try {
for (const cancelHandler of this._cancelHandlers) {
cancelHandler();
}
} catch (error) {
console.warn("Cancellation threw an error", error);
return;
}
}
this._cancelHandlers.length = 0;
this._reject?.(new CancelError("Request aborted"));
}
get isCancelled() {
return this._isCancelled;
}
};
// src/common/open-api/core/request.ts
var isDefined = (value) => {
return value !== void 0 && value !== null;
};
var isString = (value) => {
return typeof value === "string";
};
var isStringWithValue = (value) => {
return isString(value) && value !== "";
};
var isBlob = (value) => {
return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
};
var isFormData = (value) => {
return value instanceof FormData;
};
var base64 = (str) => {
try {
return btoa(str);
} catch (err) {
return Buffer.from(str).toString("base64");
}
};
var getQueryString = (params) => {
const qs = [];
const append = (key, value) => {
qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
};
const process2 = (key, value) => {
if (isDefined(value)) {
if (Array.isArray(value)) {
value.forEach((v) => {
process2(key, v);
});
} else if (typeof value === "object") {
Object.entries(value).forEach(([k, v]) => {
process2(`${key}[${k}]`, v);
});
} else {
append(key, value);
}
}
};
Object.entries(params).forEach(([key, value]) => {
process2(key, value);
});
if (qs.length > 0) {
return `?${qs.join("&")}`;
}
return "";
};
var getUrl = (config, options) => {
const encoder = config.ENCODE_PATH || encodeURI;
const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
if (options.path?.hasOwnProperty(group)) {
return encoder(String(options.path[group]));
}
return substring;
});
const url = `${config.BASE}${path}`;
if (options.query) {
return `${url}${getQueryString(options.query)}`;
}
return url;
};
var getFormData = (options) => {
if (options.formData) {
const formData = new FormData();
const process2 = (key, value) => {
if (isString(value) || isBlob(value)) {
formData.append(key, value);
} else {
formData.append(key, JSON.stringify(value));
}
};
Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
if (Array.isArray(value)) {
value.forEach((v) => process2(key, v));
} else {
process2(key, value);
}
});
return formData;
}
return void 0;
};
var resolve = async (options, resolver) => {
if (typeof resolver === "function") {
return resolver(options);
}
return resolver;
};
var getHeaders = async (config, options) => {
const token = await resolve(options, config.TOKEN);
const username = await resolve(options, config.USERNAME);
const password = await resolve(options, config.PASSWORD);
const additionalHeaders = await resolve(options, config.HEADERS);
const headers = Object.entries({
Accept: "application/json",
...additionalHeaders,
...options.headers
}).filter(([_, value]) => isDefined(value)).reduce(
(headers2, [key, value]) => ({
...headers2,
[key]: String(value)
}),
{}
);
if (isStringWithValue(token)) {
headers["X-AUTHORIZATION"] = token;
}
if (isStringWithValue(username) && isStringWithValue(password)) {
const credentials = base64(`${username}:${password}`);
headers["Authorization"] = `Basic ${credentials}`;
}
if (options.body) {
if (options.mediaType) {
headers["Content-Type"] = options.mediaType;
} else if (isBlob(options.body)) {
headers["Content-Type"] = "application/octet-stream";
} else if (isString(options.body)) {
headers["Content-Type"] = "text/plain";
} else if (!isFormData(options.body)) {
headers["Content-Type"] = "application/json";
}
}
return new Headers(headers);
};
var getRequestBody = (options) => {
if (options.body) {
if (options.mediaType?.includes("/json")) {
return JSON.stringify(options.body);
} else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
return options.body;
} else {
return JSON.stringify(options.body);
}
}
return void 0;
};
var sendRequest = async (options, url, body, formData, headers, onCancel) => {
const controller = new AbortController();
const request3 = {
headers,
method: options.method,
body: body ?? formData,
signal: controller.signal
};
onCancel(() => controller.abort());
return await fetch(url, request3);
};
var getResponseHeader = (response, responseHeader) => {
if (responseHeader) {
const content = response.headers.get(responseHeader);
if (isString(content)) {
return content;
}
}
return void 0;
};
var getResponseBody = async (response) => {
if (response.status !== 204) {
try {
const contentType = response.headers.get("Content-Type");
if (contentType) {
const isJSON = contentType.toLowerCase().startsWith("application/json");
if (isJSON) {
return await response.json();
} else {
return await response.text();
}
}
} catch (error) {
console.error(error);
}
}
return void 0;
};
var catchErrorCodes = (options, result) => {
const errors = {
400: "Bad Request",
401: "Unauthorized",
403: "Forbidden",
404: "Not Found",
500: "Internal Server Error",
502: "Bad Gateway",
503: "Service Unavailable",
...options.errors
};
const error = errors[result.status];
if (error) {
throw new ApiError(options, result, error);
}
if (!result.ok) {
throw new ApiError(options, result, "Generic Error");
}
};
var request = (config, options) => {
return new CancelablePromise(async (resolve3, reject, onCancel) => {
try {
const url = getUrl(config, options);
const formData = getFormData(options);
const body = getRequestBody(options);
const headers = await getHeaders(config, options);
if (!onCancel.isCancelled) {
const response = await sendRequest(
options,
url,
body,
formData,
headers,
onCancel
);
const responseBody = await getResponseBody(response);
const responseHeader = getResponseHeader(
response,
options.responseHeader
);
const result = {
url,
ok: response.ok,
status: response.status,
statusText: response.statusText,
body: responseHeader ?? responseBody
};
catchErrorCodes(options, result);
resolve3(result.body);
}
} catch (error) {
reject(error);
}
});
};
// src/common/open-api/services/HumanTaskService.ts
var HumanTaskService = class {
constructor(httpRequest) {
this.httpRequest = httpRequest;
}
/**
* If the workflow is disconnected from tasks, this API can be used to clean up (in bulk)
* @param requestBody
* @returns any OK
* @throws ApiError
*/
deleteTaskFromHumanTaskRecords(requestBody) {
return this.httpRequest.request({
method: "DELETE",
url: "/human/tasks/delete",
body: requestBody,
mediaType: "application/json"
});
}
/**
* If the workflow is disconnected from tasks, this API can be used to clean up
* @param taskId
* @returns any OK
* @throws ApiError
*/
deleteTaskFromHumanTaskRecords1(taskId) {
return this.httpRequest.request({
method: "DELETE",
url: "/human/tasks/delete/{taskId}",
path: {
"taskId": taskId
}
});
}
/**
* Search human tasks
* @param requestBody
* @returns HumanTaskSearchResult OK
* @throws ApiError
*/
search(requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/search",
body: requestBody,
mediaType: "application/json"
});
}
/**
* 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
*/
updateTaskOutputByRef(workflowId, taskRefName, requestBody, complete = false, iteration) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/update/taskRef",
query: {
"workflowId": workflowId,
"taskRefName": taskRefName,
"complete": complete,
"iteration": iteration
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Get a task
* @param taskId
* @returns HumanTaskEntry OK
* @throws ApiError
*/
getTask1(taskId) {
return this.httpRequest.request({
method: "GET",
url: "/human/tasks/{taskId}",
path: {
"taskId": taskId
}
});
}
/**
* Claim a task by authenticated Conductor user
* @param taskId
* @param overrideAssignment
* @returns any OK
* @throws ApiError
*/
claimTask(taskId, overrideAssignment = false, withTemplate = false) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/{taskId}/claim",
path: {
"taskId": taskId
},
query: {
"overrideAssignment": overrideAssignment,
"withTemplate": withTemplate
}
});
}
/**
* Claim a task to an external user
* @param taskId
* @param userId
* @param overrideAssignment
* @returns any OK
* @throws ApiError
*/
assignAndClaim(taskId, userId, overrideAssignment = false, withTemplate = false) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/{taskId}/externalUser/{userId}",
path: {
"taskId": taskId,
"userId": userId
},
query: {
"overrideAssignment": overrideAssignment,
"withTemplate": withTemplate
}
});
}
/**
* Release a task without completing it
* @param taskId
* @param requestBody
* @returns any OK
* @throws ApiError
*/
reassignTask(taskId, requestBody) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/{taskId}/reassign",
path: {
"taskId": taskId
},
body: requestBody,
mediaType: "application/json"
});
}
/**
* Release a task without completing it
* @param taskId
* @returns any OK
* @throws ApiError
*/
releaseTask(taskId) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/{taskId}/release",
path: {
"taskId": taskId
}
});
}
/**
* 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
* @param reason
* @returns any OK
* @throws ApiError
*/
skipTask(taskId, reason) {
return this.httpRequest.request({
method: "POST",
url: "/human/tasks/{taskId}/skip",
path: {
"taskId": taskId
},
query: {
"reason": reason
}
});
}
/**
* Update task output, optionally complete
* @param taskId
* @param requestBody
* @param complete
* @returns any OK
* @throws ApiError
*/
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"
});
}
/**
* List all user form templates