@aikirun/task 0.5.3 → 0.7.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { SerializableInput } from '@aikirun/types/error';
+import { Serializable } from '@aikirun/types/error';
 import { RetryStrategy } from '@aikirun/types/retry';
 import { TaskId } from '@aikirun/types/task';
 import { WorkflowRunContext } from '@aikirun/workflow';
@@ -22,6 +22,15 @@ type PathFromObjectInternal<T, IncludeArrayKeys extends boolean> = And<[
 type ExtractObjectType<T> = T extends object ? T : never;
 type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path extends keyof T ? T[Path] : Path extends `${infer First}.${infer Rest}` ? First extends keyof T ? undefined extends T[First] ? Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> | undefined : never : Rest extends PathFromObject<ExtractObjectType<T[First]>> ? TypeOfValueAtPath<ExtractObjectType<T[First]>, Rest> : never : never : never;
 
+interface Schema<Data> {
+    parse: (data: unknown) => Data;
+}
+interface EventDefinition<Data> {
+    _type: Data;
+    schema?: Schema<Data>;
+}
+type EventsDefinition = Record<string, EventDefinition<unknown>>;
+
 /**
  * Defines a durable task with deterministic execution and automatic retries.
  *
@@ -65,7 +74,7 @@ type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path
  * const result = await chargeCard.start(run, { cardId: "123", amount: 9999 });
  * ```
  */
-declare function task<Input extends SerializableInput = null, Output = void>(params: TaskParams<Input, Output>): Task<Input, Output>;
+declare function task<Input extends Serializable = null, Output = void>(params: TaskParams<Input, Output>): Task<Input, Output>;
 interface TaskParams<Input, Output> {
     id: string;
     handler: (input: Input) => Promise<Output>;
@@ -82,7 +91,7 @@ interface TaskBuilder<Input, Output> {
 interface Task<Input, Output> {
     id: TaskId;
     with(): TaskBuilder<Input, Output>;
-    start: <WorkflowInput, WorkflowOutput>(run: WorkflowRunContext<WorkflowInput, WorkflowOutput>, ...args: Input extends null ? [] : [Input]) => Promise<Output>;
+    start: (run: WorkflowRunContext<unknown, unknown, EventsDefinition>, ...args: Input extends null ? [] : [Input]) => Promise<Output>;
 }
 
 export { type Task, type TaskParams, task };

package/dist/index.js

@@ -142,6 +142,7 @@ function getRetryParams(attempts, strategy) {
 // task.ts
 import { INTERNAL } from "@aikirun/types/symbols";
 import { TaskFailedError } from "@aikirun/types/task";
+import { WorkflowRunSuspendedError } from "@aikirun/types/workflow-run";
 function task(params) {
   return new TaskImpl(params);
 }
@@ -162,31 +163,31 @@ var TaskImpl = class _TaskImpl {
   async start(run, ...args) {
     const handle = run[INTERNAL].handle;
     handle[INTERNAL].assertExecutionAllowed();
-    const input = isNonEmptyArray(args) ? args[0] : (
-      // this cast is okay cos if args is empty, Input must be type null
-      null
-    );
+    const input = isNonEmptyArray(args) ? args[0] : null;
     const path = await this.getPath(input);
     const taskState = handle.run.tasksState[path] ?? { status: "none" };
     if (taskState.status === "completed") {
       return taskState.output;
     }
+    if (taskState.status === "failed") {
+      throw new TaskFailedError(path, taskState.attempts, taskState.error.message);
+    }
     const logger = run.logger.child({
       "aiki.component": "task-execution",
       "aiki.taskPath": path
     });
     let attempts = 0;
     const retryStrategy = this.params.opts?.retry ?? { type: "never" };
-    if ("attempts" in taskState) {
+    if (taskState.status !== "none") {
       this.assertRetryAllowed(path, taskState.attempts, retryStrategy, logger);
-      logger.warn("Retrying task", {
+      logger.debug("Retrying task", {
         "aiki.attempts": taskState.attempts,
         "aiki.taskStatus": taskState.status
       });
       attempts = taskState.attempts;
     }
-    if (taskState.status === "failed") {
-      await this.delayIfNecessary(taskState);
+    if (taskState.status === "awaiting_retry" && handle.run.state.status === "running") {
+      throw new WorkflowRunSuspendedError(run.id);
     }
     attempts++;
     logger.info("Starting task", { "aiki.attempts": attempts });
@@ -199,37 +200,41 @@ var TaskImpl = class _TaskImpl {
   async tryExecuteTask(run, input, path, retryStrategy, currentAttempt, logger) {
     let attempts = currentAttempt;
     while (true) {
-      const attemptedAt = Date.now();
       try {
         const output = await this.params.handler(input);
         return { output, lastAttempt: attempts };
       } catch (error) {
         const serializableError = createSerializableError(error);
-        const taskFailedState = {
-          status: "failed",
-          reason: serializableError.message,
-          attempts,
-          attemptedAt,
-          error: serializableError
-        };
         const retryParams = getRetryParams(attempts, retryStrategy);
         if (!retryParams.retriesLeft) {
-          await run[INTERNAL].handle[INTERNAL].transitionTaskState(path, taskFailedState);
           logger.error("Task failed", {
             "aiki.attempts": attempts,
-            "aiki.reason": taskFailedState.reason
+            "aiki.reason": serializableError.message
+          });
+          await run[INTERNAL].handle[INTERNAL].transitionTaskState(path, {
+            status: "failed",
+            attempts,
+            error: serializableError
           });
-          throw new TaskFailedError(path, attempts, taskFailedState.reason);
+          throw new TaskFailedError(path, attempts, serializableError.message);
         }
-        const nextAttemptAt = Date.now() + retryParams.delayMs;
-        await run[INTERNAL].handle[INTERNAL].transitionTaskState(path, { ...taskFailedState, nextAttemptAt });
-        logger.debug("Task failed. Retrying", {
+        logger.debug("Task failed. It will be retried", {
           "aiki.attempts": attempts,
-          "aiki.nextAttemptAt": nextAttemptAt,
-          "aiki.reason": taskFailedState.reason
+          "aiki.nextAttemptInMs": retryParams.delayMs,
+          "aiki.reason": serializableError.message
         });
-        await delay(retryParams.delayMs);
-        attempts++;
+        if (retryParams.delayMs <= run[INTERNAL].options.spinThresholdMs) {
+          await delay(retryParams.delayMs);
+          attempts++;
+          continue;
+        }
+        await run[INTERNAL].handle[INTERNAL].transitionTaskState(path, {
+          status: "awaiting_retry",
+          attempts,
+          error: serializableError,
+          nextAttemptInMs: retryParams.delayMs
+        });
+        throw new WorkflowRunSuspendedError(run.id);
       }
     }
   }
@@ -242,19 +247,10 @@ var TaskImpl = class _TaskImpl {
       throw new TaskFailedError(path, attempts, "Task retry not allowed");
     }
   }
-  async delayIfNecessary(taskState) {
-    if (taskState.nextAttemptAt !== void 0) {
-      const now = Date.now();
-      const remainingDelay = Math.max(0, taskState.nextAttemptAt - now);
-      if (remainingDelay > 0) {
-        await delay(remainingDelay);
-      }
-    }
-  }
   async getPath(input) {
     const inputHash = await sha256(stableStringify(input));
-    const taskPath = this.params.opts?.idempotencyKey ? `${this.id}/${inputHash}/${this.params.opts.idempotencyKey}` : `${this.id}/${inputHash}`;
-    return taskPath;
+    const path = this.params.opts?.idempotencyKey ? `${this.id}/${inputHash}/${this.params.opts.idempotencyKey}` : `${this.id}/${inputHash}`;
+    return path;
   }
 };
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/task",
-	"version": "0.5.3",
+	"version": "0.7.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.5.3",
-		"@aikirun/workflow": "0.5.3"
+		"@aikirun/types": "0.7.0",
+		"@aikirun/workflow": "0.7.0"
 	},
 	"publishConfig": {
 		"access": "public"