@dudousxd/nestjs-durable 0.45.1 → 0.46.1

package/dist/index.d.cts

@@ -1065,12 +1065,12 @@ declare class StoreRunGateway implements RunGateway {
     /**
      * Bulk-resolve what each of `runIds` is currently parked on — for a consumer with its own filtered/
      * paginated run listing (e.g. "which of MY suspended runs are stuck at a breakpoint") without
-     * re-deriving `listRuns`' waiter scan or querying `durable_step_checkpoints` directly. Mirrors
-     * `listRuns`' waiting computation (the SAME bulk signal-waiter scan + `resolveRunWaiting`), but ALSO
+     * re-deriving `listRuns`' waiter read or querying `durable_step_checkpoints` directly. Mirrors
+     * `listRuns`' waiting computation (the requested runs' signal waiters + `resolveRunWaiting`), but ALSO
      * bulk-fetches the currently-suspended runs to check real status: `engine.cancel` (the non-compensate
      * path) doesn't clear a run's signal waiter row, so a cancelled run can leave an ORPHANED waiter
      * behind — trusting waiter presence alone would wrongly report a terminal run as still waiting.
-     * Two bulk scans total (never one query per requested id), same as `listRuns`.
+     * Two bulk reads total (never one query per requested id), same as `listRuns`.
      */
     waitingFor(runIds: string[]): Promise<Record<string, RunWaiting>>;
     /** Every group the engine knows about — unscoped. A tenant proxy's request is scoped by the

package/dist/index.d.ts

@@ -1065,12 +1065,12 @@ declare class StoreRunGateway implements RunGateway {
     /**
      * Bulk-resolve what each of `runIds` is currently parked on — for a consumer with its own filtered/
      * paginated run listing (e.g. "which of MY suspended runs are stuck at a breakpoint") without
-     * re-deriving `listRuns`' waiter scan or querying `durable_step_checkpoints` directly. Mirrors
-     * `listRuns`' waiting computation (the SAME bulk signal-waiter scan + `resolveRunWaiting`), but ALSO
+     * re-deriving `listRuns`' waiter read or querying `durable_step_checkpoints` directly. Mirrors
+     * `listRuns`' waiting computation (the requested runs' signal waiters + `resolveRunWaiting`), but ALSO
      * bulk-fetches the currently-suspended runs to check real status: `engine.cancel` (the non-compensate
      * path) doesn't clear a run's signal waiter row, so a cancelled run can leave an ORPHANED waiter
      * behind — trusting waiter presence alone would wrongly report a terminal run as still waiting.
-     * Two bulk scans total (never one query per requested id), same as `listRuns`.
+     * Two bulk reads total (never one query per requested id), same as `listRuns`.
      */
     waitingFor(runIds: string[]): Promise<Record<string, RunWaiting>>;
     /** Every group the engine knows about — unscoped. A tenant proxy's request is scoped by the

package/dist/index.js

@@ -1173,6 +1173,31 @@ ProxyRunGateway = _ts_decorate6([
 // src/retention-poller.ts
 import { DURABLE_OPTIONS_CANONICAL as DURABLE_OPTIONS_CANONICAL4, STATE_STORE_CANONICAL, TERMINAL_RUN_STATUSES, parseDuration } from "@dudousxd/nestjs-durable-core";
 import { Inject as Inject4, Injectable as Injectable7 } from "@nestjs/common";
+
+// src/settle-within.ts
+async function settleWithin(p, timeoutMs) {
+  let timer;
+  let timedOut = false;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => {
+      timedOut = true;
+      resolve();
+    }, timeoutMs);
+    timer.unref?.();
+  });
+  try {
+    await Promise.race([
+      p.then(void 0, () => void 0),
+      timeout
+    ]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+  return timedOut;
+}
+__name(settleWithin, "settleWithin");
+
+// src/retention-poller.ts
 function _ts_decorate7(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") {
@@ -1243,6 +1268,9 @@ var RetentionPoller = class {
   options;
   timer;
   sweeping = false;
+  stopping = false;
+  /** The sweep in flight, so shutdown can wait for it before the store closes. */
+  current;
   constructor(store, options) {
     this.store = store;
     this.options = options;
@@ -1270,8 +1298,16 @@ var RetentionPoller = class {
       this.timer.unref?.();
     }
   }
-  onModuleDestroy() {
+  /** Stop sweeping and wait for the sweep in flight (bounded by `shutdownTimeoutMs`, default 10s),
+  *  so no prune is still pending when the host closes its connection pool. */
+  async onModuleDestroy() {
     if (this.timer) clearInterval(this.timer);
+    this.stopping = true;
+    if (!this.current) return;
+    const budget = this.options.shutdownTimeoutMs ?? 1e4;
+    if (await settleWithin(this.current, budget)) {
+      console.warn(`[nestjs-durable] retention sweep still running after ${budget}ms at shutdown; continuing`);
+    }
   }
   /**
   * Prune one round.
@@ -1282,8 +1318,16 @@ var RetentionPoller = class {
   * Pruning history is the least urgent thing this package does — a `pruneTerminalRuns` that fails
   * on a locked table must cost this sweep and nothing more.
   */
-  async sweep() {
-    if (this.sweeping) return;
+  sweep() {
+    if (this.sweeping) return this.current ?? Promise.resolve();
+    const run = this.sweepOnce().finally(() => {
+      if (this.current === run) this.current = void 0;
+    });
+    this.current = run;
+    return run;
+  }
+  async sweepOnce() {
+    if (this.stopping) return;
     const retention = this.options.retention;
     const store = this.requireStore();
     const prune = store.pruneTerminalRuns;
@@ -1294,6 +1338,7 @@ var RetentionPoller = class {
       const now = Date.now();
       for (const policy of retention.policies) {
         for (let batch = 0; batch < MAX_BATCHES_PER_POLICY; batch++) {
+          if (this.stopping) return;
           const deleted = await prune.call(store, policy, now, batchSize);
           if (deleted < batchSize) break;
         }
@@ -1468,7 +1513,7 @@ var RunRequestResponder = class {
 };
 
 // src/store-run-gateway.ts
-import { STATE_STORE_CANONICAL as STATE_STORE_CANONICAL2, WorkflowEngine as WorkflowEngine2, indexWaitersByRun, mergeRunFacetRows, resolveRunWaiting } from "@dudousxd/nestjs-durable-core";
+import { STATE_STORE_CANONICAL as STATE_STORE_CANONICAL2, WorkflowEngine as WorkflowEngine2, indexWaitersByRun, listSignalWaitersOfRuns, mergeRunFacetRows, resolveRunWaiting } from "@dudousxd/nestjs-durable-core";
 import { Inject as Inject5, Injectable as Injectable8 } from "@nestjs/common";
 function _ts_decorate8(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -1526,7 +1571,7 @@ var StoreRunGateway = class {
   }
   async listRuns(query) {
     const runs = await this.store.listRuns(query);
-    const waiterByRun = indexWaitersByRun(await this.store.listSignalWaiters(""));
+    const waiterByRun = indexWaitersByRun(await listSignalWaitersOfRuns(this.store, runs.filter((run) => run.status === "suspended").map((run) => run.id)));
     return runs.map((run) => {
       const waiting = resolveRunWaiting(run, waiterByRun);
       return waiting ? {
@@ -1563,12 +1608,12 @@ var StoreRunGateway = class {
   /**
   * Bulk-resolve what each of `runIds` is currently parked on — for a consumer with its own filtered/
   * paginated run listing (e.g. "which of MY suspended runs are stuck at a breakpoint") without
-  * re-deriving `listRuns`' waiter scan or querying `durable_step_checkpoints` directly. Mirrors
-  * `listRuns`' waiting computation (the SAME bulk signal-waiter scan + `resolveRunWaiting`), but ALSO
+  * re-deriving `listRuns`' waiter read or querying `durable_step_checkpoints` directly. Mirrors
+  * `listRuns`' waiting computation (the requested runs' signal waiters + `resolveRunWaiting`), but ALSO
   * bulk-fetches the currently-suspended runs to check real status: `engine.cancel` (the non-compensate
   * path) doesn't clear a run's signal waiter row, so a cancelled run can leave an ORPHANED waiter
   * behind — trusting waiter presence alone would wrongly report a terminal run as still waiting.
-  * Two bulk scans total (never one query per requested id), same as `listRuns`.
+  * Two bulk reads total (never one query per requested id), same as `listRuns`.
   */
   async waitingFor(runIds) {
     if (runIds.length === 0) return {};
@@ -1579,7 +1624,7 @@ var StoreRunGateway = class {
           "suspended"
         ]
       }),
-      this.store.listSignalWaiters("")
+      listSignalWaitersOfRuns(this.store, runIds)
     ]);
     const waiterByRun = indexWaitersByRun(waiters);
     const result = {};
@@ -1705,6 +1750,8 @@ var TimerPoller = class {
   options;
   timer;
   polling = false;
+  /** The sweep in flight, so shutdown can wait for it instead of racing the store's close. */
+  current;
   unsubscribeEnqueued;
   constructor(engine, options) {
     this.engine = engine;
@@ -1724,9 +1771,27 @@ var TimerPoller = class {
       this.timer.unref?.();
     }
   }
-  onModuleDestroy() {
+  /**
+  * Stop polling and wait for the sweep in flight (bounded by `shutdownTimeoutMs`, default 10s).
+  * Nest runs every `onModuleDestroy` before any `onApplicationShutdown`, so returning here only once
+  * the sweep has settled means no store call is still pending when the registrar drains and the
+  * host closes its connection pool. The engine is told to stop first so a sweep working through a
+  * backlog stops locking runs instead of finishing the backlog. The time spent waiting is deducted
+  * from the later `engine.drain()`, so poll wait plus drain stay within one `shutdownTimeoutMs`.
+  */
+  async onModuleDestroy() {
     if (this.timer) clearInterval(this.timer);
     this.unsubscribeEnqueued?.();
+    if (!isDrivingOperator(this.options)) return;
+    this.engine.beginDrain?.();
+    if (!this.current) return;
+    const budget = this.options.shutdownTimeoutMs ?? 1e4;
+    const started = Date.now();
+    const timedOut = await settleWithin(this.current, budget);
+    this.engine.beginDrain?.(Date.now() - started);
+    if (timedOut) {
+      console.warn(`[nestjs-durable] timer poll still running after ${budget}ms at shutdown; continuing (it may report store errors if the host ends its pool now)`);
+    }
   }
   /**
   * One sweep of the engine's recovery work.
@@ -1743,10 +1808,18 @@ var TimerPoller = class {
   * `recoverIncomplete` says nothing about whether durable timers should still fire, and skipping
   * the rest of the tick would silently widen one subsystem's outage into all of them.
   */
-  async poll() {
-    if (this.polling) return;
+  poll() {
+    if (this.polling) return this.current ?? Promise.resolve();
     this.polling = true;
-    try {
+    const run = this.pollOnce().finally(() => {
+      this.polling = false;
+      if (this.current === run) this.current = void 0;
+    });
+    this.current = run;
+    return run;
+  }
+  async pollOnce() {
+    {
       await this.sweep("runPending", () => this.engine.runPending());
       await this.sweep("recoverIncomplete", () => this.engine.recoverIncomplete());
       await this.sweep("resumeDueTimers", () => this.engine.resumeDueTimers());
@@ -1758,8 +1831,6 @@ var TimerPoller = class {
       if (this.options.persistedSchedules) {
         await this.sweep("persistedSchedules", () => this.engine.schedules.tick());
       }
-    } finally {
-      this.polling = false;
     }
   }
   /** Run one sweep, absorbing and reporting its failure — see {@link poll}. */