@aikirun/worker 0.18.0 → 0.20.0

package/dist/index.js

@@ -1327,18 +1327,32 @@ var WorkerHandleImpl = class {
   logger;
   abortController;
   subscriberStrategy;
+  fallbackSubscriberStrategy;
   pollPromise;
   activeWorkflowRunsById = /* @__PURE__ */ new Map();
   async _start() {
+    const workflows = this.registry.getAll();
+    const subscriberStrategyParams = this.params.subscriber ?? { type: "db" };
     const subscriberStrategyBuilder = this.client[INTERNAL7].subscriber.create(
-      this.params.subscriber ?? { type: "redis" },
-      this.registry.getAll(),
+      subscriberStrategyParams,
+      workflows,
       this.spawnOpts.shards
     );
     this.subscriberStrategy = await subscriberStrategyBuilder.init(this.id, {
       onError: (error) => this.handleSubscriberError(error),
       onStop: () => this.stop()
     });
+    if (subscriberStrategyParams.type !== "db") {
+      const fallbackSubscriberStrategyBuilder = this.client[INTERNAL7].subscriber.create(
+        { type: "db" },
+        workflows,
+        this.spawnOpts.shards
+      );
+      this.fallbackSubscriberStrategy = await fallbackSubscriberStrategyBuilder.init(this.id, {
+        onError: (error) => this.handleSubscriberError(error),
+        onStop: () => this.stop()
+      });
+    }
     this.abortController = new AbortController();
     const abortSignal = this.abortController.signal;
     this.pollPromise = this.poll(abortSignal).catch((error) => {
@@ -1387,7 +1401,7 @@ var WorkerHandleImpl = class {
         nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "at_capacity" });
         continue;
       }
-      const nextBatchResponse = await this.fetchNextWorkflowRunBatch(availableCapacity);
+      const nextBatchResponse = await this.fetchNextWorkflowRunBatch(availableCapacity, subscriberFailedAttempts);
       if (!nextBatchResponse.success) {
         subscriberFailedAttempts++;
         nextDelayMs = this.subscriberStrategy.getNextDelay({
@@ -1401,11 +1415,11 @@ var WorkerHandleImpl = class {
         nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: false });
         continue;
       }
-      await this.enqueueWorkflowRunBatch(nextBatchResponse.batch, abortSignal);
+      await this.enqueueWorkflowRunBatch(nextBatchResponse.batch, nextBatchResponse.subscriber, abortSignal);
       nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: true });
     }
   }
-  async fetchNextWorkflowRunBatch(size) {
+  async fetchNextWorkflowRunBatch(size, subscriberFailedAttempts) {
     if (!this.subscriberStrategy) {
       return {
         success: false,
@@ -1414,22 +1428,26 @@ var WorkerHandleImpl = class {
     }
     try {
       const batch = await this.subscriberStrategy.getNextBatch(size);
-      return {
-        success: true,
-        batch
-      };
+      return { success: true, batch, subscriber: this.subscriberStrategy };
     } catch (error) {
       this.logger.error("Error getting next workflow runs batch", {
         "aiki.error": error instanceof Error ? error.message : String(error)
       });
-      return {
-        success: false,
-        error
-      };
+      if (this.fallbackSubscriberStrategy && subscriberFailedAttempts >= 2) {
+        try {
+          const batch = await this.fallbackSubscriberStrategy.getNextBatch(size);
+          return { success: true, batch, subscriber: this.fallbackSubscriberStrategy };
+        } catch (fallbackError) {
+          this.logger.error("Fallback subscriber strategy for getting next workflow runs batch also failed", {
+            "aiki.error": fallbackError instanceof Error ? fallbackError.message : String(fallbackError)
+          });
+        }
+      }
+      return { success: false, error };
     }
   }
-  async enqueueWorkflowRunBatch(batch, abortSignal) {
-    for (const { data, meta } of batch) {
+  async enqueueWorkflowRunBatch(batch, subscriber, abortSignal) {
+    for (const { data } of batch) {
       const { workflowRunId } = data;
       if (this.activeWorkflowRunsById.has(workflowRunId)) {
         this.logger.info("Workflow already running", {
@@ -1439,8 +1457,8 @@ var WorkerHandleImpl = class {
       }
       const { run: workflowRun } = await this.client.api.workflowRun.getByIdV1({ id: workflowRunId });
       if (!workflowRun) {
-        if (meta && this.subscriberStrategy?.acknowledge) {
-          await this.subscriberStrategy.acknowledge(this.id, workflowRunId, meta).catch(() => {
+        if (subscriber.acknowledge) {
+          await subscriber.acknowledge(workflowRunId).catch(() => {
           });
         }
         continue;
@@ -1455,8 +1473,8 @@ var WorkerHandleImpl = class {
           "aiki.workflowVersionId": workflowRun.versionId,
           "aiki.workflowRunId": workflowRun.id
         });
-        if (meta && this.subscriberStrategy?.acknowledge) {
-          await this.subscriberStrategy.acknowledge(this.id, workflowRunId, meta).catch(() => {
+        if (subscriber.acknowledge) {
+          await subscriber.acknowledge(workflowRunId).catch(() => {
           });
         }
         continue;
@@ -1464,15 +1482,14 @@ var WorkerHandleImpl = class {
       if (abortSignal.aborted) {
         break;
       }
-      const workflowExecutionPromise = this.executeWorkflow(workflowRun, workflowVersion, meta);
+      const workflowExecutionPromise = this.executeWorkflow(workflowRun, workflowVersion, subscriber);
       this.activeWorkflowRunsById.set(workflowRun.id, {
         run: workflowRun,
-        executionPromise: workflowExecutionPromise,
-        meta
+        executionPromise: workflowExecutionPromise
       });
     }
   }
-  async executeWorkflow(workflowRun, workflowVersion, meta) {
+  async executeWorkflow(workflowRun, workflowVersion, subscriber) {
     const logger = this.logger.child({
       "aiki.component": "workflow-execution",
       "aiki.workflowName": workflowRun.name,
@@ -1482,11 +1499,11 @@ var WorkerHandleImpl = class {
     let heartbeatInterval;
     let shouldAcknowledge = false;
     try {
-      const heartbeat = this.subscriberStrategy?.heartbeat;
-      if (meta && heartbeat) {
+      const heartbeat = subscriber.heartbeat;
+      if (heartbeat) {
         heartbeatInterval = setInterval(() => {
           try {
-            heartbeat(workflowRun.id, meta);
+            heartbeat(workflowRun.id);
           } catch (error) {
             logger.warn("Failed to send heartbeat", {
               "aiki.error": error instanceof Error ? error.message : String(error)
@@ -1528,10 +1545,10 @@ var WorkerHandleImpl = class {
       }
     } finally {
       if (heartbeatInterval) clearInterval(heartbeatInterval);
-      if (meta && this.subscriberStrategy?.acknowledge) {
+      if (subscriber.acknowledge) {
         if (shouldAcknowledge) {
           try {
-            await this.subscriberStrategy.acknowledge(this.id, workflowRun.id, meta);
+            await subscriber.acknowledge(workflowRun.id);
           } catch (error) {
             logger.error("Failed to acknowledge message, it may be reprocessed", {
               "aiki.errorType": "MESSAGE_ACK_FAILED",

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/worker",
-	"version": "0.18.0",
+	"version": "0.20.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.18.0",
-		"@aikirun/client": "0.18.0",
-		"@aikirun/workflow": "0.18.0",
+		"@aikirun/types": "0.20.0",
+		"@aikirun/client": "0.20.0",
+		"@aikirun/workflow": "0.20.0",
 		"ulidx": "^2.4.1"
 	},
 	"publishConfig": {