@aikirun/worker 0.20.0 → 0.22.0

package/dist/index.js

@@ -674,7 +674,6 @@ function createEventMulticaster(workflowName, workflowVersionId, eventName, sche
 // ../workflow/run/handle.ts
 import { INTERNAL as INTERNAL3 } from "@aikirun/types/symbols";
 import {
-  isTerminalWorkflowRunStatus,
   WorkflowRunNotExecutableError,
   WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError3
 } from "@aikirun/types/workflow-run";
@@ -714,9 +713,6 @@ var WorkflowRunHandleImpl = class {
     const { run: currentRun } = await this.api.workflowRun.getByIdV1({ id: this.run.id });
     this._run = currentRun;
   }
-  // TODO: instead checking the current state, use the transition history
-  // because it is possible for a workflow to flash though a state
-  // and the handle will never know that the workflow hit that state
   async waitForStatus(status, options) {
     return this.waitForStatusByPolling(status, options);
   }
@@ -730,49 +726,37 @@ var WorkflowRunHandleImpl = class {
     const delayMs = options?.interval ? toMilliseconds(options.interval) : 1e3;
     const maxAttempts = options?.timeout ? Math.ceil(toMilliseconds(options.timeout) / delayMs) : Number.POSITIVE_INFINITY;
     const retryStrategy = { type: "fixed", maxAttempts, delayMs };
-    const loadState = async () => {
-      await this.refresh();
-      return this.run.state;
+    const afterStateTransitionId = this._run.stateTransitionId;
+    const hasTerminated = async () => {
+      const { terminated } = await this.api.workflowRun.hasTerminatedV1({
+        id: this._run.id,
+        afterStateTransitionId
+      });
+      return terminated;
     };
-    const isNeitherExpectedNorTerminal = (state) => state.status !== expectedStatus && !isTerminalWorkflowRunStatus(state.status);
-    if (!Number.isFinite(maxAttempts) && !options?.abortSignal) {
-      const maybeResult2 = await withRetry(loadState, retryStrategy, {
-        shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
-      }).run();
-      if (maybeResult2.state === "timeout") {
+    const shouldRetryOnResult = async (terminated) => !terminated;
+    const maybeResult = options?.abortSignal ? await withRetry(hasTerminated, retryStrategy, {
+      abortSignal: options.abortSignal,
+      shouldRetryOnResult
+    }).run() : await withRetry(hasTerminated, retryStrategy, { shouldRetryOnResult }).run();
+    if (maybeResult.state === "timeout") {
+      if (!Number.isFinite(maxAttempts)) {
         throw new Error("Something's wrong, this should've never timed out");
       }
-      if (maybeResult2.result.status !== expectedStatus) {
-        return {
-          success: false,
-          cause: "run_terminated"
-        };
-      }
-      return {
-        success: true,
-        state: maybeResult2.result
-      };
+      return { success: false, cause: "timeout" };
     }
-    const maybeResult = options?.abortSignal ? await withRetry(loadState, retryStrategy, {
-      abortSignal: options.abortSignal,
-      shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
-    }).run() : await withRetry(loadState, retryStrategy, {
-      shouldRetryOnResult: async (state) => isNeitherExpectedNorTerminal(state)
-    }).run();
-    this.logger.info("Maybe result", { maybeResult });
-    if (maybeResult.state === "completed") {
-      if (maybeResult.result.status !== expectedStatus) {
-        return {
-          success: false,
-          cause: "run_terminated"
-        };
-      }
+    if (maybeResult.state === "aborted") {
+      return { success: false, cause: "aborted" };
+    }
+    maybeResult.state;
+    await this.refresh();
+    if (this._run.state.status === expectedStatus) {
       return {
         success: true,
-        state: maybeResult.result
+        state: this._run.state
       };
     }
-    return { success: false, cause: maybeResult.state };
+    return { success: false, cause: "run_terminated" };
   }
   async cancel(reason) {
     await this.transitionState({ status: "cancelled", reason });
@@ -846,7 +830,7 @@ function isWorkflowRunRevisionConflictError(error) {
 // ../workflow/run/handle-child.ts
 import { INTERNAL as INTERNAL4 } from "@aikirun/types/symbols";
 import {
-  isTerminalWorkflowRunStatus as isTerminalWorkflowRunStatus2,
+  isTerminalWorkflowRunStatus,
   WorkflowRunRevisionConflictError as WorkflowRunRevisionConflictError4,
   WorkflowRunSuspendedError as WorkflowRunSuspendedError3
 } from "@aikirun/types/workflow-run";
@@ -894,7 +878,7 @@ function createStatusWaiter(handle, parentRun, childWorkflowRunWaitQueues, logge
           state: existingChildWorkflowRunWait.childWorkflowRunState
         };
       }
-      if (isTerminalWorkflowRunStatus2(childWorkflowRunStatus)) {
+      if (isTerminalWorkflowRunStatus(childWorkflowRunStatus)) {
         logger.debug("Child workflow run reached termnial state", {
           "aiki.childWorkflowTerminalStatus": childWorkflowRunStatus
         });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/worker",
-	"version": "0.20.0",
+	"version": "0.22.0",
 	"description": "Worker SDK for Aiki - execute workflows and tasks with durable state management and automatic recovery",
 	"type": "module",
 	"main": "./dist/index.js",
@@ -18,9 +18,9 @@
 		"build": "tsup"
 	},
 	"dependencies": {
-		"@aikirun/types": "0.20.0",
-		"@aikirun/client": "0.20.0",
-		"@aikirun/workflow": "0.20.0",
+		"@aikirun/types": "0.22.0",
+		"@aikirun/client": "0.22.0",
+		"@aikirun/workflow": "0.22.0",
 		"ulidx": "^2.4.1"
 	},
 	"publishConfig": {