@aikirun/task 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Serializable } from '@aikirun/types/serializable';
-import { TaskName, TaskOptions } from '@aikirun/types/task';
+import { TaskName, TaskStartOptions, TaskDefinitionOptions } from '@aikirun/types/task';
 import { WorkflowRunContext } from '@aikirun/workflow';
 import { StandardSchemaV1 } from '@standard-schema/spec';
 import { RequireAtLeastOneProp } from '@aikirun/types/utils';
@@ -76,7 +76,7 @@ declare function task<Input extends Serializable, Output extends Serializable>(p
 interface TaskParams<Input, Output> {
     name: string;
     handler: (input: Input) => Promise<Output>;
-    opts?: TaskOptions;
+    opts?: TaskDefinitionOptions;
     schema?: RequireAtLeastOneProp<{
         input?: StandardSchemaV1<Input>;
         output?: StandardSchemaV1<Output>;
@@ -88,7 +88,7 @@ interface Task<Input, Output> {
     start: (run: WorkflowRunContext<unknown, unknown, EventsDefinition>, ...args: Input extends void ? [] : [Input]) => Promise<Output>;
 }
 interface TaskBuilder<Input, Output> {
-    opt<Path extends PathFromObject<TaskOptions>>(path: Path, value: TypeOfValueAtPath<TaskOptions, Path>): TaskBuilder<Input, Output>;
+    opt<Path extends PathFromObject<TaskStartOptions>>(path: Path, value: TypeOfValueAtPath<TaskStartOptions, Path>): TaskBuilder<Input, Output>;
     start: Task<Input, Output>["start"];
 }
 

package/dist/index.js

@@ -1,6 +1,6 @@
-// ../../lib/array/utils.ts
-function isNonEmptyArray(value) {
-  return value.length > 0;
+// ../../lib/address/index.ts
+function getTaskAddress(name, referenceId) {
+  return `${name}/${referenceId}`;
 }
 
 // ../../lib/async/delay.ts
@@ -101,11 +101,6 @@ var objectOverrider = (defaultObj) => (obj) => {
   return createBuilder([]);
 };
 
-// ../../lib/path/index.ts
-function getTaskPath(name, referenceId) {
-  return `${name}/${referenceId}`;
-}
-
 // ../../lib/retry/strategy.ts
 function getRetryParams(attempts, strategy) {
   const strategyType = strategy.type;
@@ -165,29 +160,29 @@ import {
 function task(params) {
   return new TaskImpl(params);
 }
-var TaskImpl = class _TaskImpl {
+var TaskImpl = class {
   constructor(params) {
     this.params = params;
     this.name = params.name;
   }
   name;
   with() {
-    const optsOverrider = objectOverrider(this.params.opts ?? {});
-    const createBuilder = (optsBuilder) => ({
-      opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
-      start: (run, ...args) => new _TaskImpl({ ...this.params, opts: optsBuilder.build() }).start(run, ...args)
-    });
-    return createBuilder(optsOverrider());
+    const startOpts = this.params.opts ?? {};
+    const startOptsOverrider = objectOverrider(startOpts);
+    return new TaskBuilderImpl(this, startOptsOverrider());
   }
   async start(run, ...args) {
+    return this.startWithOpts(run, this.params.opts ?? {}, ...args);
+  }
+  async startWithOpts(run, startOpts, ...args) {
     const handle = run[INTERNAL].handle;
     handle[INTERNAL].assertExecutionAllowed();
-    const inputRaw = isNonEmptyArray(args) ? args[0] : void 0;
+    const inputRaw = args[0];
     const input = await this.parse(handle, this.params.schema?.input, inputRaw, run.logger);
     const inputHash = await hashInput(input);
-    const reference = this.params.opts?.reference;
-    const path = getTaskPath(this.name, reference?.id ?? inputHash);
-    const existingTaskInfo = handle.run.tasks[path];
+    const reference = startOpts.reference;
+    const address = getTaskAddress(this.name, reference?.id ?? inputHash);
+    const existingTaskInfo = handle.run.tasks[address];
     if (existingTaskInfo) {
       await this.assertUniqueTaskReferenceId(handle, existingTaskInfo, inputHash, reference, run.logger);
     }
@@ -199,33 +194,29 @@ var TaskImpl = class _TaskImpl {
       throw new TaskFailedError(existingTaskInfo.id, state.attempts, state.error.message);
     }
     let attempts = 0;
-    const retryStrategy = this.params.opts?.retry ?? { type: "never" };
+    const retryStrategy = startOpts.retry ?? { type: "never" };
     if (existingTaskInfo?.state) {
       const taskId2 = existingTaskInfo.id;
       const state = existingTaskInfo?.state;
-      this.assertRetryAllowed(taskId2, state, retryStrategy, run.logger);
+      attempts = state.attempts;
+      this.assertRetryAllowed(taskId2, attempts, retryStrategy, run.logger);
       run.logger.debug("Retrying task", {
         "aiki.taskName": this.name,
         "aiki.taskId": taskId2,
-        "aiki.attempts": state.attempts,
+        "aiki.attempts": attempts,
         "aiki.taskStatus": state.status
       });
-      attempts = state.attempts;
-      if (state.status === "awaiting_retry" && handle.run.state.status === "running") {
-        throw new WorkflowRunSuspendedError(run.id);
-      }
     }
     attempts++;
-    const options = { retry: retryStrategy, reference };
     const { taskId } = existingTaskInfo ? await handle[INTERNAL].transitionTaskState({
       type: "retry",
       taskId: existingTaskInfo.id,
-      options,
+      options: startOpts,
       taskState: { status: "running", attempts, input }
     }) : await handle[INTERNAL].transitionTaskState({
       type: "create",
       taskName: this.name,
-      options,
+      options: startOpts,
       taskState: { status: "running", attempts, input }
     });
     const logger = run.logger.child({
@@ -299,8 +290,8 @@ var TaskImpl = class _TaskImpl {
   }
   async assertUniqueTaskReferenceId(handle, existingTaskInfo, inputHash, reference, logger) {
     if (existingTaskInfo.inputHash !== inputHash && reference) {
-      const onConflict = reference.onConflict ?? "error";
-      if (onConflict !== "error") {
+      const conflictPolicy = reference.conflictPolicy ?? "error";
+      if (conflictPolicy !== "error") {
         return;
       }
       logger.error("Reference ID already used by another task", {
@@ -321,8 +312,7 @@ var TaskImpl = class _TaskImpl {
       throw error;
     }
   }
-  assertRetryAllowed(taskId, state, retryStrategy, logger) {
-    const { attempts } = state;
+  assertRetryAllowed(taskId, attempts, retryStrategy, logger) {
     const retryParams = getRetryParams(attempts, retryStrategy);
     if (!retryParams.retriesLeft) {
       logger.error("Task retry not allowed", {
@@ -354,6 +344,18 @@ var TaskImpl = class _TaskImpl {
     throw new WorkflowRunFailedError(handle.run.id, handle.run.attempts);
   }
 };
+var TaskBuilderImpl = class _TaskBuilderImpl {
+  constructor(task2, startOptsBuilder) {
+    this.task = task2;
+    this.startOptsBuilder = startOptsBuilder;
+  }
+  opt(path, value) {
+    return new _TaskBuilderImpl(this.task, this.startOptsBuilder.with(path, value));
+  }
+  start(run, ...args) {
+    return this.task.startWithOpts(run, this.startOptsBuilder.build(), ...args);
+  }
+};
 export {
   task
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/task",
-	"version": "0.13.0",
+	"version": "0.15.0",
 	"description": "Task SDK for Aiki - define reliable tasks with automatic retries, idempotency, and error handling",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,8 +18,8 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.13.0",
-		"@aikirun/workflow": "0.13.0",
+		"@aikirun/types": "0.15.0",
+		"@aikirun/workflow": "0.15.0",
 		"@standard-schema/spec": "^1.1.0"
 	},
 	"publishConfig": {