@nestjs/workflows 0.0.1 → 0.0.2

package/dist/core/results/result-waiter.d.ts

@@ -49,6 +49,11 @@ export declare class ResultWaiter<T = unknown> {
      * connections idle at that moment, and one that answers later stays open until its keep-alive timeout.
      */
     close(): Promise<void>;
+    /**
+     * Reads `id`, unless the wait settles first. It races a promise of its own, not one the whole wait shares: each
+     * race leaves a reaction on its inputs until they settle, so a shared one would keep one per poll.
+     */
+    private read;
     private add;
     private remove;
 }

package/dist/core/results/result-waiter.js

@@ -47,13 +47,11 @@ export class ResultWaiter {
         const timeoutMs = options.timeout === undefined ? Infinity : parseDuration(options.timeout);
         const deadline = performance.now() + timeoutMs;
         options.signal?.throwIfAborted();
-        let settle;
-        const settled = new Promise((resolve) => (settle = () => resolve(SETTLED)));
-        const wait = { closed: this.closed, settle };
+        const wait = { closed: this.closed };
         const nudge = () => wait.wake?.();
         const close = () => {
             wait.closed = true;
-            settle();
+            wait.settle?.();
             nudge();
         };
         this.add(id, wait);
@@ -61,7 +59,7 @@ export class ResultWaiter {
         options.signal?.addEventListener('abort', nudge);
         try {
             for (let delay = 25;; delay = Math.min(delay * 2, 1_000)) {
-                const read = wait.outcome || wait.closed ? SETTLED : await Promise.race([this.options.read(id), settled]);
+                const read = wait.outcome || wait.closed ? SETTLED : await this.read(id, wait);
                 if (wait.outcome) {
                     return unwrap(wait.outcome);
                 }
@@ -104,7 +102,7 @@ export class ResultWaiter {
         const settled = typeof outcome === 'function' ? outcome() : outcome;
         for (const wait of waits) {
             wait.outcome ??= settled;
-            wait.settle();
+            wait.settle?.();
             wait.wake?.();
         }
     }
@@ -117,6 +115,19 @@ export class ResultWaiter {
         this.closing.abort();
         await nextMacrotask();
     }
+    /**
+     * Reads `id`, unless the wait settles first. It races a promise of its own, not one the whole wait shares: each
+     * race leaves a reaction on its inputs until they settle, so a shared one would keep one per poll.
+     */
+    async read(id, wait) {
+        const settled = new Promise((resolve) => (wait.settle = () => resolve(SETTLED)));
+        try {
+            return await Promise.race([this.options.read(id), settled]);
+        }
+        finally {
+            wait.settle = undefined;
+        }
+    }
     add(id, wait) {
         let waits = this.waits.get(id);
         if (!waits) {

package/dist/core/workers/leased-worker.d.ts

@@ -49,8 +49,8 @@ export declare class LeasedWorker<T> {
     /** Claims in flight: shutdown waits for them, so nothing they claim starts unobserved. */
     private readonly claiming;
     private stopped;
-    private stop;
-    private readonly stoppedPromise;
+    /** Ends the `drain()` rounds waiting now, at shutdown. */
+    private readonly stopping;
     private wake?;
     private kicked;
     private loop?;
@@ -76,6 +76,11 @@ export declare class LeasedWorker<T> {
      * `shutdownTimeout` spent waiting for them before the rest are detached. Call it from `onModuleDestroy`.
      */
     shutdown(): Promise<void>;
+    /**
+     * Waits for `work`, or until shutdown. It races a promise of its own, not one the worker keeps: each race leaves a
+     * reaction on its inputs until they settle, so a long-lived one would keep one per round.
+     */
+    private untilStopped;
     private poll;
     private idle;
     /** Claims due items and starts executing them (before any caller sees them). */

package/dist/core/workers/leased-worker.js

@@ -43,7 +43,8 @@ export class LeasedWorker {
         /** Claims in flight: shutdown waits for them, so nothing they claim starts unobserved. */
         this.claiming = new Set();
         this.stopped = false;
-        this.stoppedPromise = new Promise((resolve) => (this.stop = resolve));
+        /** Ends the `drain()` rounds waiting now, at shutdown. */
+        this.stopping = new Set();
         this.kicked = false;
         /** When the loop next calls `produce()` (`performance.now()`). */
         this.produceAt = 0;
@@ -96,7 +97,7 @@ export class LeasedWorker {
                 break;
             }
             total += executions.length;
-            await Promise.race([Promise.all(executions), this.stoppedPromise]);
+            await this.untilStopped(Promise.all(executions));
         }
         return total;
     }
@@ -109,7 +110,9 @@ export class LeasedWorker {
             return;
         }
         this.stopped = true;
-        this.stop();
+        for (const stop of this.stopping) {
+            stop();
+        }
         this.wake?.();
         // What a claim in flight claims starts now, told to stop at once, so it is handed back before the store closes.
         await Promise.allSettled(this.claiming);
@@ -127,6 +130,24 @@ export class LeasedWorker {
         }
         await this.loop;
     }
+    /**
+     * Waits for `work`, or until shutdown. It races a promise of its own, not one the worker keeps: each race leaves a
+     * reaction on its inputs until they settle, so a long-lived one would keep one per round.
+     */
+    async untilStopped(work) {
+        let stop;
+        const stopped = new Promise((resolve) => (stop = resolve));
+        if (this.stopped) {
+            stop();
+        }
+        this.stopping.add(stop);
+        try {
+            await Promise.race([work, stopped]);
+        }
+        finally {
+            this.stopping.delete(stop);
+        }
+    }
     async poll() {
         while (!this.stopped) {
             if (this.options.produce && performance.now() >= this.produceAt) {

package/dist/services/workflow-execution.service.d.ts

@@ -151,8 +151,6 @@ export declare class WorkflowExecution {
     private readonly childCounters;
     /** The first interrupt that stops this execution (not a suspension). */
     private stoppedBy;
-    /** The step whose function is running, in that function's async context. */
-    private readonly insideStep;
     /** Each journal entry's size in bytes, by name, and their sum. */
     private readonly entrySizes;
     private journalBytes;

package/dist/services/workflow-execution.service.js

@@ -132,8 +132,6 @@ export class WorkflowExecution {
         this.childCounters = new Map();
         /** The first interrupt that stops this execution (not a suspension). */
         this.stoppedBy = null;
-        /** The step whose function is running, in that function's async context. */
-        this.insideStep = new AsyncLocalStorage();
         /** Each journal entry's size in bytes, by name, and their sum. */
         this.entrySizes = new Map();
         this.journalBytes = 0;
@@ -776,7 +774,7 @@ export class WorkflowExecution {
                 await this.write([current]);
             },
         };
-        const run = Promise.resolve().then(() => runInStepScope(ctx.idempotencyKey, () => this.insideStep.run(name, () => fn(ctx))));
+        const run = Promise.resolve().then(() => runInStepScope(ctx.idempotencyKey, () => insideStep.run({ execution: this, name, outer: insideStep.getStore() }, () => fn(ctx))));
         return Promise.race([run, watchdog]).finally(() => {
             settled = true;
             clearTimeout(overall);
@@ -805,10 +803,14 @@ export class WorkflowExecution {
      * replay, so it is a definition error, reported where it happens.
      */
     assertNotInStep(call, advice = 'Call ctx methods from run() and pass the values the step needs into it.') {
-        const step = this.insideStep.getStore();
-        if (step === undefined) {
+        let frame = insideStep.getStore();
+        while (frame && frame.execution !== this) {
+            frame = frame.outer;
+        }
+        if (!frame) {
             return;
         }
+        const step = frame.name;
         const where = step.startsWith(COMPENSATE) ? `the compensation of step "${step.slice(COMPENSATE.length)}"` : `step "${step}"`;
         throw this.setFatal(new WorkflowDefinitionError(`${this.describe()}: ${where} called ctx.${call}. A step's function runs once and replays return its ` +
             `result, so it can't use ctx. ${advice}`));
@@ -1069,6 +1071,11 @@ function conditionsOf(name, conditions) {
     return branches;
 }
 const COMPENSATE = '$compensate:';
+/**
+ * The steps whose functions are running, in their async context. One store for every execution, not one each: on
+ * Node 20 and 22, a store that ran stays in a process-wide list every async resource walks, until `disable()`.
+ */
+const insideStep = new AsyncLocalStorage();
 const PARENT_CLOSE = ['cancel', 'terminate', 'abandon'];
 /** The most a custom status (`ctx.setStatus()`) may take as JSON. */
 const MAX_CUSTOM_STATUS_BYTES = 16_384;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nestjs/workflows",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Nest - modern, fast, powerful node.js web framework (@workflows)",
   "author": "Kamil Mysliwiec",
   "license": "MIT",
@@ -69,37 +69,37 @@
     "@commitlint/cli": "21.2.3",
     "@commitlint/config-angular": "21.2.3",
     "@electric-sql/pglite": "0.5.8",
-    "@nestjs/common": "12.1.0",
-    "@nestjs/core": "12.1.0",
+    "@nestjs/common": "12.1.2",
+    "@nestjs/core": "12.1.2",
     "@nestjs/cqrs": "12.1.0",
     "@nestjs/drizzle": "0.0.1",
     "@nestjs/locks": "0.0.1",
     "@nestjs/mail": "0.0.1",
-    "@nestjs/outbox": "0.0.1",
-    "@nestjs/platform-express": "12.1.0",
-    "@nestjs/platform-fastify": "12.1.0",
-    "@nestjs/testing": "12.1.0",
+    "@nestjs/outbox": "0.1.0",
+    "@nestjs/platform-express": "12.1.2",
+    "@nestjs/platform-fastify": "12.1.2",
+    "@nestjs/testing": "12.1.2",
     "@prisma/adapter-mariadb": "7.10.0",
     "@prisma/adapter-pg": "7.10.0",
     "@prisma/client": "7.10.0",
-    "@types/node": "24.13.6",
+    "@types/node": "24.19.1",
     "@types/pg": "8.23.1",
     "drizzle-orm": "0.45.3",
     "husky": "9.1.7",
     "kysely": "0.29.6",
-    "lint-staged": "17.5.1",
+    "lint-staged": "17.6.0",
     "mysql2": "3.24.5",
-    "oxlint": "1.85.0",
-    "pg": "8.23.0",
-    "prettier": "3.9.8",
+    "oxlint": "1.87.0",
+    "pg": "8.23.1",
+    "prettier": "3.9.9",
     "prisma": "7.10.0",
     "reflect-metadata": "0.2.2",
-    "release-it": "21.1.0",
+    "release-it": "21.1.1",
     "rxjs": "7.8.2",
     "typeorm": "1.1.1",
     "typescript": "7.0.2",
-    "vite": "8.3.0",
-    "vitest": "5.0.1"
+    "vite": "8.3.3",
+    "vitest": "5.0.3"
   },
   "peerDependencies": {
     "@nestjs/common": "^11.0.0 || ^12.0.0",