@io-orkes/conductor-javascript 0.0.7 → 0.0.8

package/dist/index.d.ts

@@ -1813,62 +1813,62 @@ declare enum TaskType {
 }
 declare type TaskDefTypes = SimpleTaskDef | DoWhileTaskDef | EventTaskDef | ForkJoinTaskDef | ForkJoinDynamicDef | HttpTaskDef | InlineTaskDef | JsonJQTransformTaskDef | KafkaPublishTaskDef | SetVariableTaskDef | SubWorkflowTaskDef | SwitchTaskDef | TerminateTaskDef | JoinTaskDef | WaitTaskDef;
 interface DoWhileTaskDef extends CommonTaskDef {
-    inputParameters: Record<string, string>;
+    inputParameters: Record<string, unknown>;
     type: TaskType.DO_WHILE;
-    decisionCases: Record<string, TaskDefTypes[]>;
-    startDelay: number;
-    optional: boolean;
-    asyncComplete: boolean;
+    startDelay?: number;
+    optional?: boolean;
+    asyncComplete?: boolean;
     loopCondition: string;
     loopOver: TaskDefTypes[];
 }
 interface EventTaskDef extends CommonTaskDef {
     type: TaskType.EVENT;
     sink: string;
-    asyncComplete: boolean;
+    asyncComplete?: boolean;
 }
 interface ForkJoinTaskDef extends CommonTaskDef {
     type: TaskType.FORK_JOIN;
-    inputParameters: Record<string, string>;
+    inputParameters?: Record<string, string>;
     forkTasks: Array<Array<TaskDefTypes>>;
 }
 interface JoinTaskDef extends CommonTaskDef {
     type: TaskType.JOIN;
-    inputParameters: Record<string, string>;
+    inputParameters?: Record<string, string>;
     joinOn: string[];
-    optional: boolean;
-    asyncComplete: boolean;
+    optional?: boolean;
+    asyncComplete?: boolean;
 }
 interface ForkJoinDynamicDef extends CommonTaskDef {
     inputParameters: {
-        dynamicTasks: string;
-        dynamicTasksInput: string;
+        dynamicTasks: any;
+        dynamicTasksInput: any;
     };
     type: TaskType.FORK_JOIN_DYNAMIC;
     dynamicForkTasksParam: string;
     dynamicForkTasksInputParamName: string;
-    startDelay: number;
-    optional: boolean;
-    asyncComplete: boolean;
+    startDelay?: number;
+    optional?: boolean;
+    asyncComplete?: boolean;
+}
+interface HttpInputParameters {
+    uri: string;
+    method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
+    accept?: string;
+    contentType?: string;
+    headers?: Record<string, string>;
+    body?: unknown;
+    connectionTimeOut?: number;
+    readTimeOut?: string;
 }
 interface HttpTaskDef extends CommonTaskDef {
     inputParameters: {
         [x: string]: unknown;
-        http_request: {
-            uri: string;
-            method: "GET" | "PUT" | "POST" | "DELETE" | "OPTIONS" | "HEAD";
-            accept?: string;
-            contentType?: string;
-            headers?: Record<string, string>;
-            body?: unknown;
-            connectionTimeOut?: number;
-            readTimeOut?: string;
-        };
+        http_request: HttpInputParameters;
     };
     type: TaskType.HTTP;
 }
 interface InlineTaskInputParameters {
-    evaluatorType: "javascript";
+    evaluatorType: "javascript" | "graaljs";
     expression: string;
     [x: string]: unknown;
 }
@@ -1884,22 +1884,23 @@ interface JsonJQTransformTaskDef extends CommonTaskDef {
     type: TaskType.JSON_JQ_TRANSFORM;
     inputParameters: ContainingQueryExpression;
 }
+interface KafkaPublishInputParameters {
+    topic: string;
+    value: string;
+    bootStrapServers: string;
+    headers: Record<string, string>;
+    key: string;
+    keySerializer: string;
+}
 interface KafkaPublishTaskDef extends CommonTaskDef {
     inputParameters: {
-        kafka_request: {
-            topic: string;
-            value: string;
-            bootStrapServers: string;
-            headers: Record<string, string>;
-            key: string;
-            keySerializer: string;
-        };
+        kafka_request: KafkaPublishInputParameters;
     };
     type: TaskType.KAFKA_PUBLISH;
 }
 interface SetVariableTaskDef extends CommonTaskDef {
     type: TaskType.SET_VARIABLE;
-    inputParameters: Record<string, string>;
+    inputParameters: Record<string, unknown>;
 }
 interface SimpleTaskDef extends CommonTaskDef {
     type: TaskType.SIMPLE;
@@ -1925,14 +1926,19 @@ interface SwitchTaskDef extends CommonTaskDef {
 interface TerminateTaskDef extends CommonTaskDef {
     inputParameters: {
         terminationStatus: "COMPLETED" | "FAILED";
-        workflowOutput: Record<string, string>;
+        workflowOutput?: Record<string, string>;
+        terminationReason?: string;
     };
     type: TaskType.TERMINATE;
-    startDelay: number;
-    optional: boolean;
+    startDelay?: number;
+    optional?: boolean;
 }
 interface WaitTaskDef extends CommonTaskDef {
     type: TaskType.WAIT;
+    inputParameters: {
+        duration?: string;
+        until?: string;
+    };
 }
 declare type U2O<U extends string> = {
     [key in U]: U2O<Exclude<U, key>>;
@@ -2104,6 +2110,43 @@ declare const generateDoWhileTask: (overrides?: Partial<DoWhileTaskDefGen>, nest
  */
 declare const generateForkJoinTask: (overrides?: Partial<ForkJoinTaskDefGen>, nestedMapper?: NestedTaskMapper) => ForkJoinTaskDef;
 
+declare const doWhileTask: (taskRefName: string, terminationCondition: string, tasks: TaskDefTypes[]) => DoWhileTaskDef;
+declare const newLoopTask: (taskRefName: string, iterations: number, tasks: TaskDefTypes[]) => DoWhileTaskDef;
+
+declare const dynamicForkTask: (taskReferenceName: string, preForkTasks?: TaskDefTypes[], dynamicTasksInput?: string) => ForkJoinDynamicDef;
+
+declare const eventTask: (taskReferenceName: string, eventPrefix: string, eventSuffix: string) => EventTaskDef;
+declare const sqsEventTask: (taskReferenceName: string, queueName: string) => EventTaskDef;
+declare const conductorEventTask: (taskReferenceName: string, eventName: string) => EventTaskDef;
+
+declare const forkTask: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => ForkJoinTaskDef;
+declare const forkTaskJoin: (taskReferenceName: string, forkTasks: TaskDefTypes[]) => [ForkJoinTaskDef, JoinTaskDef];
+
+declare const httpTask: (taskReferenceName: string, inputParameters: HttpInputParameters) => HttpTaskDef;
+
+declare const inlineTask: (taskReferenceName: string, script: string, evaluatorType?: "javascript" | "graaljs") => InlineTaskDef;
+
+declare const joinTask: (taskReferenceName: string, joinOn: string[]) => JoinTaskDef;
+
+declare const jsonJqTask: (taskReferenceName: string, script: string) => JsonJQTransformTaskDef;
+
+declare const kafkaPublishTask: (taskReferenceName: string, kafka_request: KafkaPublishInputParameters) => KafkaPublishTaskDef;
+
+declare const setVariableTask: (taskReferenceName: string, inputParameters: Record<string, unknown>) => SetVariableTaskDef;
+
+declare const simpleTask: (taskReferenceName: string, name: string, inputParameters: Record<string, unknown>) => SimpleTaskDef;
+
+declare const subWorkflowTask: (taskReferenceName: string, workflowName: string, version?: number | undefined) => SubWorkflowTaskDef;
+
+declare const switchTask: (taskReferenceName: string, expression: string, decisionCases?: Record<string, TaskDefTypes[]>, defaultCase?: TaskDefTypes[]) => SwitchTaskDef;
+
+declare const terminateTask: (taskReferenceName: string, status: "COMPLETED" | "FAILED", terminationReason?: string | undefined) => TerminateTaskDef;
+
+declare const waitTaskDuration: (taskReferenceName: string, duration: string) => WaitTaskDef;
+declare const waitTaskUntil: (taskReferenceName: string, until: string) => WaitTaskDef;
+
+declare const workflow: (name: string, tasks: TaskDefTypes[]) => WorkflowDef;
+
 /**
  * Functional interface for defining a worker implementation that processes tasks from a conductor queue.
  *
@@ -2325,4 +2368,4 @@ declare class WorkflowExecutor {
     updateTaskByRefName(taskReferenceName: string, workflowInstanceId: string, status: TaskResult, taskOutput: Record<string, any>): any;
 }
 
-export { CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventTaskDef, ForkJoinDynamicDef, ForkJoinTaskDef, HttpTaskDef, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishTaskDef, OnCancel, OpenAPIConfig, OrkesApiConfig, RequestType, RerunWorkflowRequest, RunnerArgs, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflowRequest, SubWorkflowTaskDef, SwitchTaskDef, TaskDefTypes, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResult, TaskRunner, TaskType, TerminateTaskDef, WaitTaskDef, WorkflowDef, WorkflowExecutor, WorkflowInputParameters, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, orkesConductorClient, taskGenMapper };
+export { CancelError, CancelablePromise, CommonTaskDef, ConductorClient, ConductorError, ConductorHttpRequest, ConductorLogLevel, ConductorLogger, ConductorWorker, DefaultLogger, DefaultLoggerConfig, DoWhileTaskDef, EventTaskDef, ForkJoinDynamicDef, ForkJoinTaskDef, HttpInputParameters, HttpTaskDef, InlineTaskDef, InlineTaskInputParameters, JoinTaskDef, JsonJQTransformTaskDef, KafkaPublishInputParameters, KafkaPublishTaskDef, OnCancel, OpenAPIConfig, OrkesApiConfig, RequestType, RerunWorkflowRequest, RunnerArgs, SetVariableTaskDef, SimpleTaskDef, SkipTaskRequest, StartWorkflowRequest, SubWorkflowTaskDef, SwitchTaskDef, TaskDefTypes, TaskManager, TaskManagerConfig, TaskManagerOptions, TaskResult, TaskRunner, TaskType, TerminateTaskDef, WaitTaskDef, WorkflowDef, WorkflowExecutor, WorkflowInputParameters, conductorEventTask, doWhileTask, dynamicForkTask, eventTask, forkTask, forkTaskJoin, generate, generateDoWhileTask, generateEventTask, generateForkJoinTask, generateHTTPTask, generateInlineTask, generateJQTransformTask, generateJoinTask, generateKafkaPublishTask, generateSetVariableTask, generateSimpleTask, generateSubWorkflowTask, generateSwitchTask, generateTerminateTask, generateWaitTask, httpTask, inlineTask, joinTask, jsonJqTask, kafkaPublishTask, newLoopTask, orkesConductorClient, setVariableTask, simpleTask, sqsEventTask, subWorkflowTask, switchTask, taskGenMapper, terminateTask, waitTaskDuration, waitTaskUntil, workflow };

package/dist/index.js

@@ -9493,6 +9493,12 @@ __export(conductor_javascript_exports, {
   TaskRunner: () => TaskRunner,
   TaskType: () => TaskType,
   WorkflowExecutor: () => WorkflowExecutor,
+  conductorEventTask: () => conductorEventTask,
+  doWhileTask: () => doWhileTask,
+  dynamicForkTask: () => dynamicForkTask,
+  eventTask: () => eventTask,
+  forkTask: () => forkTask,
+  forkTaskJoin: () => forkTaskJoin,
   generate: () => generate,
   generateDoWhileTask: () => generateDoWhileTask2,
   generateEventTask: () => generateEventTask,
@@ -9508,8 +9514,23 @@ __export(conductor_javascript_exports, {
   generateSwitchTask: () => generateSwitchTask2,
   generateTerminateTask: () => generateTerminateTask,
   generateWaitTask: () => generateWaitTask,
+  httpTask: () => httpTask,
+  inlineTask: () => inlineTask,
+  joinTask: () => joinTask,
+  jsonJqTask: () => jsonJqTask,
+  kafkaPublishTask: () => kafkaPublishTask,
+  newLoopTask: () => newLoopTask,
   orkesConductorClient: () => orkesConductorClient,
-  taskGenMapper: () => taskGenMapper
+  setVariableTask: () => setVariableTask,
+  simpleTask: () => simpleTask,
+  sqsEventTask: () => sqsEventTask,
+  subWorkflowTask: () => subWorkflowTask,
+  switchTask: () => switchTask,
+  taskGenMapper: () => taskGenMapper,
+  terminateTask: () => terminateTask,
+  waitTaskDuration: () => waitTaskDuration,
+  waitTaskUntil: () => waitTaskUntil,
+  workflow: () => workflow
 });
 module.exports = __toCommonJS(conductor_javascript_exports);
 init_cjs_shims();
@@ -11574,7 +11595,6 @@ var generateSimpleTask = (overrides = {}) => __spreadProps(__spreadValues(__spre
 init_cjs_shims();
 var generateDoWhileTask = (overrides = {}, nestedTasksMapper) => __spreadProps(__spreadValues(__spreadProps(__spreadValues({}, nameTaskNameGenerator("doWhile", overrides)), {
   inputParameters: {},
-  decisionCases: {},
   startDelay: 0,
   optional: false,
   asyncComplete: false,
@@ -11722,6 +11742,7 @@ var generateTerminateTask = (overrides = {}) => __spreadProps(__spreadValues(__s
 // src/common/generators/WaitTask.ts
 init_cjs_shims();
 var generateWaitTask = (overrides = {}) => __spreadProps(__spreadValues(__spreadValues({}, nameTaskNameGenerator("wait", overrides)), overrides), {
+  inputParameters: {},
   type: "WAIT" /* WAIT */
 });
 
@@ -11837,6 +11858,209 @@ var generateSwitchTask2 = (overrides = {}, nestedTasksMapper = taskGenMapper) =>
 var generateDoWhileTask2 = (overrides = {}, nestedTasksMapper = taskGenMapper) => generateDoWhileTask(overrides, nestedTasksMapper);
 var generateForkJoinTask2 = (overrides = {}, nestedMapper = taskGenMapper) => generateForkJoinTask(overrides, nestedMapper);
 
+// src/common/sdk/index.ts
+init_cjs_shims();
+
+// src/common/sdk/doWhile.ts
+init_cjs_shims();
+var doWhileTask = (taskRefName, terminationCondition, tasks) => ({
+  name: taskRefName,
+  taskReferenceName: taskRefName,
+  loopCondition: terminationCondition,
+  inputParameters: {},
+  type: "DO_WHILE" /* DO_WHILE */,
+  loopOver: tasks
+});
+var loopForCondition = (taskRefName, valueKey) => `if ( $.${taskRefName}['iteration'] < $.${valueKey} ) { true; } else { false; }`;
+var newLoopTask = (taskRefName, iterations, tasks) => ({
+  name: taskRefName,
+  taskReferenceName: taskRefName,
+  loopCondition: loopForCondition(taskRefName, "value"),
+  inputParameters: {
+    value: iterations
+  },
+  type: "DO_WHILE" /* DO_WHILE */,
+  loopOver: tasks
+});
+
+// src/common/sdk/dynamicFork.ts
+init_cjs_shims();
+var dynamicForkTask = (taskReferenceName, preForkTasks = [], dynamicTasksInput = "") => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    dynamicTasks: preForkTasks,
+    dynamicTasksInput
+  },
+  type: "FORK_JOIN_DYNAMIC" /* FORK_JOIN_DYNAMIC */,
+  dynamicForkTasksParam: "dynamicTasks",
+  dynamicForkTasksInputParamName: "dynamicTasksInput"
+});
+
+// src/common/sdk/event.ts
+init_cjs_shims();
+var eventTask = (taskReferenceName, eventPrefix, eventSuffix) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  sink: `${eventPrefix}:${eventSuffix}`,
+  type: "EVENT" /* EVENT */
+});
+var sqsEventTask = (taskReferenceName, queueName) => eventTask(taskReferenceName, "sqs", queueName);
+var conductorEventTask = (taskReferenceName, eventName) => eventTask(taskReferenceName, "conductor", eventName);
+
+// src/common/sdk/forkJoin.ts
+init_cjs_shims();
+var forkTask = (taskReferenceName, forkTasks) => ({
+  taskReferenceName,
+  name: taskReferenceName,
+  type: "FORK_JOIN" /* FORK_JOIN */,
+  forkTasks: [forkTasks]
+});
+var forkTaskJoin = (taskReferenceName, forkTasks) => [
+  forkTask(taskReferenceName, forkTasks),
+  generateJoinTask({ name: `${taskReferenceName}_join` })
+];
+
+// src/common/sdk/http.ts
+init_cjs_shims();
+var httpTask = (taskReferenceName, inputParameters) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    http_request: inputParameters
+  },
+  type: "HTTP" /* HTTP */
+});
+
+// src/common/sdk/inline.ts
+init_cjs_shims();
+var inlineTask = (taskReferenceName, script, evaluatorType = "javascript") => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    evaluatorType,
+    expression: script
+  },
+  type: "INLINE" /* INLINE */
+});
+
+// src/common/sdk/join.ts
+init_cjs_shims();
+var joinTask = (taskReferenceName, joinOn) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  joinOn,
+  type: "JOIN" /* JOIN */
+});
+
+// src/common/sdk/jsonJq.ts
+init_cjs_shims();
+var jsonJqTask = (taskReferenceName, script) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  type: "JSON_JQ_TRANSFORM" /* JSON_JQ_TRANSFORM */,
+  inputParameters: {
+    queryExpression: script
+  }
+});
+
+// src/common/sdk/kafkaPublish.ts
+init_cjs_shims();
+var kafkaPublishTask = (taskReferenceName, kafka_request) => ({
+  taskReferenceName,
+  name: taskReferenceName,
+  type: "KAFKA_PUBLISH" /* KAFKA_PUBLISH */,
+  inputParameters: {
+    kafka_request
+  }
+});
+
+// src/common/sdk/setVariable.ts
+init_cjs_shims();
+var setVariableTask = (taskReferenceName, inputParameters) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  type: "SET_VARIABLE" /* SET_VARIABLE */,
+  inputParameters
+});
+
+// src/common/sdk/simple.ts
+init_cjs_shims();
+var simpleTask = (taskReferenceName, name, inputParameters) => ({
+  name,
+  taskReferenceName,
+  inputParameters,
+  type: "SIMPLE" /* SIMPLE */
+});
+
+// src/common/sdk/subWorkflow.ts
+init_cjs_shims();
+var subWorkflowTask = (taskReferenceName, workflowName, version) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  subWorkflowParam: {
+    name: workflowName,
+    version
+  },
+  type: "SUB_WORKFLOW" /* SUB_WORKFLOW */
+});
+
+// src/common/sdk/switch.ts
+init_cjs_shims();
+var switchTask = (taskReferenceName, expression, decisionCases = {}, defaultCase = []) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  decisionCases,
+  evaluatorType: "value-param",
+  inputParameters: {
+    switchCaseValue: expression
+  },
+  expression: "switchCaseValue",
+  defaultCase,
+  type: "SWITCH" /* SWITCH */
+});
+
+// src/common/sdk/terminate.ts
+init_cjs_shims();
+var terminateTask = (taskReferenceName, status, terminationReason) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    terminationStatus: status,
+    terminationReason
+  },
+  type: "TERMINATE" /* TERMINATE */
+});
+
+// src/common/sdk/wait.ts
+init_cjs_shims();
+var waitTaskDuration = (taskReferenceName, duration) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    duration
+  },
+  type: "WAIT" /* WAIT */
+});
+var waitTaskUntil = (taskReferenceName, until) => ({
+  name: taskReferenceName,
+  taskReferenceName,
+  inputParameters: {
+    until
+  },
+  type: "WAIT" /* WAIT */
+});
+
+// src/common/sdk/workflow.ts
+init_cjs_shims();
+var workflow = (name, tasks) => ({
+  name,
+  version: 1,
+  tasks,
+  inputParameters: [],
+  timeoutSeconds: 0
+});
+
 // src/common/open-api/index.ts
 init_cjs_shims();
 
@@ -11946,8 +12170,8 @@ var WorkflowExecutor = class {
   constructor(client) {
     this._client = client;
   }
-  registerWorkflow(override, workflow) {
-    return tryCatchReThrow(() => this._client.metadataResource.create(workflow, override));
+  registerWorkflow(override, workflow2) {
+    return tryCatchReThrow(() => this._client.metadataResource.create(workflow2, override));
   }
   startWorkflow(workflowRequest) {
     return tryCatchReThrow(() => this._client.workflowResource.startWorkflow(workflowRequest));
@@ -12019,6 +12243,12 @@ var WorkflowExecutor = class {
   TaskRunner,
   TaskType,
   WorkflowExecutor,
+  conductorEventTask,
+  doWhileTask,
+  dynamicForkTask,
+  eventTask,
+  forkTask,
+  forkTaskJoin,
   generate,
   generateDoWhileTask,
   generateEventTask,
@@ -12034,8 +12264,23 @@ var WorkflowExecutor = class {
   generateSwitchTask,
   generateTerminateTask,
   generateWaitTask,
+  httpTask,
+  inlineTask,
+  joinTask,
+  jsonJqTask,
+  kafkaPublishTask,
+  newLoopTask,
   orkesConductorClient,
-  taskGenMapper
+  setVariableTask,
+  simpleTask,
+  sqsEventTask,
+  subWorkflowTask,
+  switchTask,
+  taskGenMapper,
+  terminateTask,
+  waitTaskDuration,
+  waitTaskUntil,
+  workflow
 });
 /*!
  * mime-db