@aikirun/worker 0.23.1 → 0.24.1

package/README.md

@@ -15,14 +15,12 @@ import { worker } from "@aikirun/worker";
 import { client } from "@aikirun/client";
 import { orderWorkflowV1 } from "./workflows.ts";
 
-// Set AIKI_API_KEY env variable or pass apiKey option
 const aikiClient = client({
 	url: "http://localhost:9850",
-	redis: { host: "localhost", port: 6379 },
+	apiKey: "your-api-key",
 });
 
 const aikiWorker = worker({
-	name: "order-worker",
 	workflows: [orderWorkflowV1],
 });
 
@@ -31,7 +29,6 @@ const handle = await aikiWorker.spawn(aikiClient);
 // Graceful shutdown
 process.on("SIGTERM", async () => {
 	await handle.stop();
-	await aikiClient.close();
 	process.exit(0);
 });
 ```
@@ -43,6 +40,7 @@ process.on("SIGTERM", async () => {
 - **Heartbeat Monitoring** - Detect and recover stuck workflows
 - **Graceful Shutdown** - Complete active work before stopping
 - **Sharding** - Route workflows to specific workers
+- **Pluggable Subscribers** - Swap work discovery transport (DB polling default, Redis Streams via `@aikirun/subscriber-redis`, or bring your own)
 
 ## Documentation
 

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { Client, SubscriberStrategy } from '@aikirun/client';
-import { WorkerName, WorkerId } from '@aikirun/types/worker';
-import { WorkflowVersion } from '@aikirun/workflow';
+import { Client } from '@aikirun/types/client';
+import { CreateSubscriber } from '@aikirun/types/subscriber';
+import { WorkerId } from '@aikirun/types/worker';
+import { WorkflowExecutionOptions, AnyWorkflowVersion } from '@aikirun/workflow';
 
 type NonEmptyArray<T> = [T, ...T[]];
 
@@ -25,17 +26,15 @@ type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path
  * execution, which returns a handle for controlling the running worker.
  *
  * @param params - Worker configuration parameters
- * @param params.name - Unique worker name for identification and monitoring
  * @param params.workflows - Array of workflow versions this worker can execute
- * @param params.subscriber - Message subscriber strategy (default: redis)
+ * @param params.subscriber - Optional subscriber factory for work discovery (default: DB polling)
  * @returns Worker definition, call spawn(client) to begin execution
  *
  * @example
  * ```typescript
  * export const myWorker = worker({
- *   name: "order-worker",
  *   workflows: [orderWorkflowV1, paymentWorkflowV1],
- *   opts: {
+ *   options: {
  *     maxConcurrentWorkflowRuns: 10,
  *   },
  * });
@@ -44,20 +43,18 @@ type TypeOfValueAtPath<T extends object, Path extends PathFromObject<T>> = Path
  *
  * process.on("SIGINT", async () => {
  *   await handle.stop();
- *   await client.close();
  * });
  * ```
  */
 declare function worker(params: WorkerParams): Worker;
 interface WorkerParams {
-    name: string;
-    workflows: WorkflowVersion<any, any, any, any>[];
-    subscriber?: SubscriberStrategy;
-    opts?: WorkerDefinitionOptions;
+    workflows: AnyWorkflowVersion[];
+    subscriber?: CreateSubscriber;
+    options?: WorkerDefinitionOptions;
 }
 interface WorkerDefinitionOptions {
     maxConcurrentWorkflowRuns?: number;
-    workflowRun?: WorkflowRunOptions;
+    workflowRun?: WorkflowExecutionOptions;
     gracefulShutdownTimeoutMs?: number;
 }
 interface WorkerSpawnOptions extends WorkerDefinitionOptions {
@@ -75,26 +72,12 @@ interface WorkerSpawnOptions extends WorkerDefinitionOptions {
         id: string;
     };
 }
-interface WorkflowRunOptions {
-    heartbeatIntervalMs?: number;
-    /**
-     * Threshold for spinning vs persisting delays (default: 10ms).
-     *
-     * Delays <= threshold: In-memory wait (fast, no history, not durable)
-     * Delays > threshold: Server state transition (history recorded, durable)
-     *
-     * Set to 0 to record all delays in transition history.
-     */
-    spinThresholdMs?: number;
-}
 interface Worker {
-    name: WorkerName;
     with(): WorkerBuilder;
     spawn: <AppContext>(client: Client<AppContext>) => Promise<WorkerHandle>;
 }
 interface WorkerHandle {
     id: WorkerId;
-    name: WorkerName;
     stop: () => Promise<void>;
 }
 interface WorkerBuilder {