@aikirun/worker 0.14.0 → 0.16.0

package/dist/index.d.ts

@@ -56,12 +56,14 @@ interface WorkerParams {
     name: string;
     workflows: WorkflowVersion<any, any, any, any>[];
     subscriber?: SubscriberStrategy;
-    opts?: WorkerOptions;
+    opts?: WorkerDefinitionOptions;
 }
-interface WorkerOptions {
+interface WorkerDefinitionOptions {
     maxConcurrentWorkflowRuns?: number;
     workflowRun?: WorkflowRunOptions;
     gracefulShutdownTimeoutMs?: number;
+}
+interface WorkerSpawnOptions extends WorkerDefinitionOptions {
     /**
      * Optional array of shards this worker should process.
      * When provided, the worker will only subscribe to sharded streams.
@@ -88,10 +90,6 @@ interface WorkflowRunOptions {
      */
     spinThresholdMs?: number;
 }
-interface WorkerBuilder {
-    opt<Path extends PathFromObject<WorkerOptions>>(path: Path, value: TypeOfValueAtPath<WorkerOptions, Path>): WorkerBuilder;
-    spawn: Worker["spawn"];
-}
 interface Worker {
     name: WorkerName;
     with(): WorkerBuilder;
@@ -102,5 +100,9 @@ interface WorkerHandle {
     name: WorkerName;
     stop: () => Promise<void>;
 }
+interface WorkerBuilder {
+    opt<Path extends PathFromObject<WorkerSpawnOptions>>(path: Path, value: TypeOfValueAtPath<WorkerSpawnOptions, Path>): WorkerBuilder;
+    spawn: Worker["spawn"];
+}
 
 export { type Worker, type WorkerParams, worker };

package/dist/index.js

@@ -75,38 +75,39 @@ import {
 function worker(params) {
   return new WorkerImpl(params);
 }
-var WorkerImpl = class _WorkerImpl {
+var WorkerImpl = class {
   constructor(params) {
     this.params = params;
     this.name = params.name;
   }
   name;
   with() {
-    const optsOverrider = objectOverrider(this.params.opts ?? {});
-    const createBuilder = (optsBuilder) => ({
-      opt: (path, value) => createBuilder(optsBuilder.with(path, value)),
-      spawn: (client) => new _WorkerImpl({ ...this.params, opts: optsBuilder.build() }).spawn(client)
-    });
-    return createBuilder(optsOverrider());
+    const spawnOpts = this.params.opts ?? {};
+    const spawnOptsOverrider = objectOverrider(spawnOpts);
+    return new WorkerBuilderImpl(this, spawnOptsOverrider());
   }
   async spawn(client) {
-    const handle = new WorkerHandleImpl(client, this.params);
+    return this.spawnWithOpts(client, this.params.opts ?? {});
+  }
+  async spawnWithOpts(client, spawnOpts) {
+    const handle = new WorkerHandleImpl(client, this.params, spawnOpts);
     await handle._start();
     return handle;
   }
 };
 var WorkerHandleImpl = class {
-  constructor(client, params) {
+  constructor(client, params, spawnOpts) {
     this.client = client;
     this.params = params;
+    this.spawnOpts = spawnOpts;
     this.id = crypto.randomUUID();
     this.name = params.name;
     this.workflowRunOpts = {
-      heartbeatIntervalMs: this.params.opts?.workflowRun?.heartbeatIntervalMs ?? 3e4,
-      spinThresholdMs: this.params.opts?.workflowRun?.spinThresholdMs ?? 10
+      heartbeatIntervalMs: this.spawnOpts.workflowRun?.heartbeatIntervalMs ?? 3e4,
+      spinThresholdMs: this.spawnOpts.workflowRun?.spinThresholdMs ?? 10
     };
     this.registry = workflowRegistry().addMany(this.params.workflows);
-    const reference = this.params.opts?.reference;
+    const reference = this.spawnOpts.reference;
     this.logger = client.logger.child({
       "aiki.component": "worker",
       "aiki.workerId": this.id,
@@ -126,7 +127,7 @@ var WorkerHandleImpl = class {
     const subscriberStrategyBuilder = this.client[INTERNAL].subscriber.create(
       this.params.subscriber ?? { type: "redis" },
       this.registry.getAll(),
-      this.params.opts?.shards
+      this.spawnOpts.shards
     );
     this.subscriberStrategy = await subscriberStrategyBuilder.init(this.id, {
       onError: (error) => this.handleSubscriberError(error),
@@ -149,7 +150,7 @@ var WorkerHandleImpl = class {
     if (activeWorkflowRuns.length === 0) {
       return;
     }
-    const timeoutMs = this.params.opts?.gracefulShutdownTimeoutMs ?? 5e3;
+    const timeoutMs = this.spawnOpts.gracefulShutdownTimeoutMs ?? 5e3;
     if (timeoutMs > 0) {
       await Promise.race([Promise.allSettled(activeWorkflowRuns.map((w) => w.executionPromise)), delay(timeoutMs)]);
     }
@@ -169,7 +170,7 @@ var WorkerHandleImpl = class {
     this.logger.info("Worker started", {
       "aiki.registeredWorkflows": this.params.workflows.map((w) => `${w.name}/${w.versionId}`)
     });
-    const maxConcurrentWorkflowRuns = this.params.opts?.maxConcurrentWorkflowRuns ?? 1;
+    const maxConcurrentWorkflowRuns = this.spawnOpts.maxConcurrentWorkflowRuns ?? 1;
     let nextDelayMs = this.subscriberStrategy.getNextDelay({ type: "polled", foundWork: false });
     let subscriberFailedAttempts = 0;
     while (!abortSignal.aborted) {
@@ -340,6 +341,18 @@ var WorkerHandleImpl = class {
     });
   }
 };
+var WorkerBuilderImpl = class _WorkerBuilderImpl {
+  constructor(worker2, spawnOptsBuilder) {
+    this.worker = worker2;
+    this.spawnOptsBuilder = spawnOptsBuilder;
+  }
+  opt(path, value) {
+    return new _WorkerBuilderImpl(this.worker, this.spawnOptsBuilder.with(path, value));
+  }
+  spawn(client) {
+    return this.worker.spawnWithOpts(client, this.spawnOptsBuilder.build());
+  }
+};
 export {
   worker
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aikirun/worker",
-	"version": "0.14.0",
+	"version": "0.16.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.14.0",
-		"@aikirun/client": "0.14.0",
-		"@aikirun/workflow": "0.14.0"
+		"@aikirun/types": "0.16.0",
+		"@aikirun/client": "0.16.0",
+		"@aikirun/workflow": "0.16.0"
 	},
 	"publishConfig": {
 		"access": "public"