@dudousxd/nestjs-durable 0.48.0 → 0.48.2

package/dist/index.d.cts

@@ -602,6 +602,18 @@ interface DurableModuleOptions {
      * a driving instance's poll picks it up. Ignored (irrelevant) for a thin worker (no `store`).
      */
     drive?: boolean;
+    /**
+     * Whether this process CONSUMES from the broker. Defaults to `true`. Set `false` in a process that
+     * boots the module without being a worker — a CLI command, a REPL, a migration or seed script — so
+     * it doesn't compete with the real fleet: every transport that supports it (`BullMQTransport`) has
+     * its point-to-point consumers (step tasks, results, decisions, step events, start-run, run-request)
+     * parked via `deferConsumers()`, and no co-located/thin worker consumer starts. The process still
+     * dispatches and starts runs; the jobs stay on the queues for the fleet. Pair it with
+     * `drive: false` so it doesn't poll/recover runs either. To consume later in the same process, call
+     * `startConsumers()` on your transport. A transport without `deferConsumers()` (the SQL/SQS/in-process
+     * transports) keeps consuming — a warning says so.
+     */
+    consumers?: boolean;
     /** Max ms to wait for in-flight runs on shutdown before exiting. Defaults to 10000. Operator only. */
     shutdownTimeoutMs?: number;
     /**
@@ -817,6 +829,7 @@ declare class DurableStartClient {
     resume(_runId: string): Promise<void>;
     waitForRun(_runId: string, _opts?: {
         timeoutMs?: number;
+        until?: 'settled' | 'terminal';
     }): Promise<void>;
     signal(_token: string, _payload: unknown): Promise<void>;
     signalWithStart(_workflow: string, _input: unknown, _runId: string, _signal: {
@@ -1266,9 +1279,12 @@ declare class WorkflowService {
      * Resolve once a run settles — terminal (completed/failed/cancelled/dead) or suspended. `start`
      * only enqueues (a worker runs the body), so pair them when a request needs the outcome:
      * `const { runId } = await svc.start(...); const result = await svc.waitForRun(runId)`.
+     * `until: 'terminal'` waits past suspensions until the run completes/fails/is cancelled — what a
+     * delayed start (`opts.startAt`) needs, since it is `suspended` until its timer fires.
      */
     waitForRun(runId: string, opts?: {
         timeoutMs?: number;
+        until?: 'settled' | 'terminal';
     }): Promise<RunResult>;
     /** Deliver an external signal (e.g. from a webhook) to the run waiting on `token`. */
     signal(token: string, payload: unknown): Promise<RunResult | null>;

package/dist/index.d.ts

@@ -602,6 +602,18 @@ interface DurableModuleOptions {
      * a driving instance's poll picks it up. Ignored (irrelevant) for a thin worker (no `store`).
      */
     drive?: boolean;
+    /**
+     * Whether this process CONSUMES from the broker. Defaults to `true`. Set `false` in a process that
+     * boots the module without being a worker — a CLI command, a REPL, a migration or seed script — so
+     * it doesn't compete with the real fleet: every transport that supports it (`BullMQTransport`) has
+     * its point-to-point consumers (step tasks, results, decisions, step events, start-run, run-request)
+     * parked via `deferConsumers()`, and no co-located/thin worker consumer starts. The process still
+     * dispatches and starts runs; the jobs stay on the queues for the fleet. Pair it with
+     * `drive: false` so it doesn't poll/recover runs either. To consume later in the same process, call
+     * `startConsumers()` on your transport. A transport without `deferConsumers()` (the SQL/SQS/in-process
+     * transports) keeps consuming — a warning says so.
+     */
+    consumers?: boolean;
     /** Max ms to wait for in-flight runs on shutdown before exiting. Defaults to 10000. Operator only. */
     shutdownTimeoutMs?: number;
     /**
@@ -817,6 +829,7 @@ declare class DurableStartClient {
     resume(_runId: string): Promise<void>;
     waitForRun(_runId: string, _opts?: {
         timeoutMs?: number;
+        until?: 'settled' | 'terminal';
     }): Promise<void>;
     signal(_token: string, _payload: unknown): Promise<void>;
     signalWithStart(_workflow: string, _input: unknown, _runId: string, _signal: {
@@ -1266,9 +1279,12 @@ declare class WorkflowService {
      * Resolve once a run settles — terminal (completed/failed/cancelled/dead) or suspended. `start`
      * only enqueues (a worker runs the body), so pair them when a request needs the outcome:
      * `const { runId } = await svc.start(...); const result = await svc.waitForRun(runId)`.
+     * `until: 'terminal'` waits past suspensions until the run completes/fails/is cancelled — what a
+     * delayed start (`opts.startAt`) needs, since it is `suspended` until its timer fires.
      */
     waitForRun(runId: string, opts?: {
         timeoutMs?: number;
+        until?: 'settled' | 'terminal';
     }): Promise<RunResult>;
     /** Deliver an external signal (e.g. from a webhook) to the run waiting on `token`. */
     signal(token: string, payload: unknown): Promise<RunResult | null>;

package/dist/index.js

@@ -602,6 +602,7 @@ var ThinWorkerBootstrap = class {
     const options = this.options;
     const runtime = this.runtime;
     if (runtime === null || !isPureThinWorker(options) || options.connection === void 0) return;
+    if (options.consumers === false) return;
     const handle = await this.runRedisWorker({
       runtime,
       connection: options.connection,
@@ -980,6 +981,7 @@ var InAppWorkerBootstrap = class {
     const options = this.options;
     const runtime = this.runtime;
     if (runtime === null || !isCoLocatedWorker(options) || options.connection === void 0) return;
+    if (options.consumers === false) return;
     const handle = await this.runRedisWorker({
       runtime,
       connection: options.connection,
@@ -2425,6 +2427,8 @@ var WorkflowService = class {
   * Resolve once a run settles — terminal (completed/failed/cancelled/dead) or suspended. `start`
   * only enqueues (a worker runs the body), so pair them when a request needs the outcome:
   * `const { runId } = await svc.start(...); const result = await svc.waitForRun(runId)`.
+  * `until: 'terminal'` waits past suspensions until the run completes/fails/is cancelled — what a
+  * delayed start (`opts.startAt`) needs, since it is `suspended` until its timer fires.
   */
   waitForRun(runId, opts) {
     return this.engine.waitForRun(runId, opts);
@@ -2536,6 +2540,15 @@ function scopedStore(store, options) {
   });
 }
 __name(scopedStore, "scopedStore");
+function deferTransportConsumers(transport) {
+  const deferrable = transport;
+  if (typeof deferrable.deferConsumers === "function") {
+    deferrable.deferConsumers();
+    return;
+  }
+  console.warn(`[nestjs-durable] consumers: false \u2014 ${transport.constructor?.name ?? "this transport"} cannot defer its consumers and will keep consuming in this process`);
+}
+__name(deferTransportConsumers, "deferTransportConsumers");
 function assertValidRole(options) {
   const hasStore = options.store !== void 0;
   const hasConnection = options.connection !== void 0;
@@ -2762,6 +2775,14 @@ var DurableModule = class _DurableModule {
             const context = options.context ?? (accessor ? () => carrierFromAccessor(accessor) : void 0);
             const runtime = accessor ? await resolveContextRuntime() : void 0;
             const rehydrate = runtime && ((carrier, fn) => carrier && Object.keys(carrier).length > 0 ? runtime.deserialize(carrier, fn) : fn());
+            if (options.consumers === false) {
+              for (const t of [
+                transport,
+                ...(options.transports ?? []).map((n) => n.transport)
+              ]) {
+                if (t) deferTransportConsumers(t);
+              }
+            }
             const engine = new WorkflowEngine6({
               store,
               transport: transport ?? void 0,