@aikirun/worker 0.24.0 → 0.24.2

package/dist/index.js

@@ -52,8 +52,108 @@ var objectOverrider = (defaultObj) => (obj) => {
   return createBuilder([]);
 };
 
+// ../../lib/retry/strategy.ts
+function getRetryParams(attempts, strategy) {
+  const strategyType = strategy.type;
+  switch (strategyType) {
+    case "never":
+      return {
+        retriesLeft: false
+      };
+    case "fixed":
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      return {
+        retriesLeft: true,
+        delayMs: strategy.delayMs
+      };
+    case "exponential": {
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      const delayMs = strategy.baseDelayMs * (strategy.factor ?? 2) ** (attempts - 1);
+      return {
+        retriesLeft: true,
+        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
+      };
+    }
+    case "jittered": {
+      if (attempts >= strategy.maxAttempts) {
+        return {
+          retriesLeft: false
+        };
+      }
+      const base = strategy.baseDelayMs * (strategy.jitterFactor ?? 2) ** (attempts - 1);
+      const delayMs = Math.random() * base;
+      return {
+        retriesLeft: true,
+        delayMs: Math.min(delayMs, strategy.maxDelayMs ?? Number.POSITIVE_INFINITY)
+      };
+    }
+    default:
+      return strategyType;
+  }
+}
+
+// ../subscriber/db/db-subscriber.ts
+function dbSubscriber(params) {
+  const { api, options } = params;
+  const intervalMs = options?.intervalMs ?? 1e3;
+  const maxRetryIntervalMs = options?.maxRetryIntervalMs ?? 3e4;
+  const atCapacityIntervalMs = options?.atCapacityIntervalMs ?? 500;
+  const claimMinIdleTimeMs = options?.claimMinIdleTimeMs ?? 9e4;
+  const getNextDelay = (delayParams) => {
+    switch (delayParams.type) {
+      case "polled":
+      case "heartbeat":
+        return intervalMs;
+      case "at_capacity":
+        return atCapacityIntervalMs;
+      case "retry": {
+        const retryParams = getRetryParams(delayParams.attemptNumber, {
+          type: "jittered",
+          maxAttempts: Number.POSITIVE_INFINITY,
+          baseDelayMs: intervalMs,
+          maxDelayMs: maxRetryIntervalMs
+        });
+        if (!retryParams.retriesLeft) {
+          return maxRetryIntervalMs;
+        }
+        return retryParams.delayMs;
+      }
+      default:
+        return delayParams;
+    }
+  };
+  return (context) => {
+    const { workerId, workflows, shards } = context;
+    const workflowFilters = !isNonEmptyArray(shards) ? workflows.map((workflow) => ({ name: workflow.name, versionId: workflow.versionId })) : workflows.flatMap(
+      (workflow) => shards.map((shard) => ({ name: workflow.name, versionId: workflow.versionId, shard }))
+    );
+    return {
+      getNextDelay,
+      async getNextBatch(size) {
+        const response = await api.workflowRun.claimReadyV1({
+          workerId,
+          workflows: workflowFilters,
+          limit: size,
+          claimMinIdleTimeMs
+        });
+        return response.runs.map((run) => ({
+          data: { workflowRunId: run.id }
+        }));
+      },
+      heartbeat: (workflowRunId) => api.workflowRun.heartbeatV1({ id: workflowRunId })
+    };
+  };
+}
+
 // worker.ts
-import { dbSubscriber } from "@aikirun/subscriber-db";
 import {
   executeWorkflowRun,
   getSystemWorkflows,

package/package.json

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