@dudousxd/nestjs-durable-core 0.74.0 → 0.75.0

package/dist/index.d.cts

@@ -3385,6 +3385,8 @@ declare class ScheduleNotFoundError extends Error {
 interface ScheduleHost {
     start(workflow: string, input: unknown, runId: string, opts?: StartOptions): Promise<RunResult>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /** True once the engine has begun shutting down; `tick` fires nothing more after that. */
+    isDraining?(): boolean;
 }
 /** Engine-level knobs for the client. */
 interface ScheduleClientOptions {
@@ -3797,6 +3799,8 @@ declare class WorkflowEngine {
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
     private readonly inflight;
     private draining;
+    /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+    private drainSpentMs;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -4050,10 +4054,25 @@ declare class WorkflowEngine {
     private findParentRunId;
     /** Track an in-flight execution so {@link drain} can wait for it. */
     private track;
+    /**
+     * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+     * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+     * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+     *
+     * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+     * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+     * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+     * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+     */
+    beginDrain(spentMs?: number): void;
     /**
      * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
      * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
      * deploy hands off cleanly instead of leaving runs to the lease timeout.
+     *
+     * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+     * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+     * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
      */
     drain(timeoutMs?: number): Promise<void>;
     /**

package/dist/index.d.ts

@@ -3385,6 +3385,8 @@ declare class ScheduleNotFoundError extends Error {
 interface ScheduleHost {
     start(workflow: string, input: unknown, runId: string, opts?: StartOptions): Promise<RunResult>;
     getRun(runId: string): Promise<WorkflowRun | null>;
+    /** True once the engine has begun shutting down; `tick` fires nothing more after that. */
+    isDraining?(): boolean;
 }
 /** Engine-level knobs for the client. */
 interface ScheduleClientOptions {
@@ -3797,6 +3799,8 @@ declare class WorkflowEngine {
     /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
     private readonly inflight;
     private draining;
+    /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+    private drainSpentMs;
     constructor(deps: WorkflowEngineDeps);
     /**
      * Register a **durable entity** (a virtual object): a keyed actor whose `handlers` run **serialized
@@ -4050,10 +4054,25 @@ declare class WorkflowEngine {
     private findParentRunId;
     /** Track an in-flight execution so {@link drain} can wait for it. */
     private track;
+    /**
+     * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+     * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+     * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+     *
+     * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+     * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+     * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+     * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+     */
+    beginDrain(spentMs?: number): void;
     /**
      * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
      * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
      * deploy hands off cleanly instead of leaving runs to the lease timeout.
+     *
+     * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+     * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+     * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
      */
     drain(timeoutMs?: number): Promise<void>;
     /**

package/dist/index.js

@@ -2187,12 +2187,14 @@ var ScheduleClient = class {
     const store = this.requireStore();
     const started = [];
     for (let round = 0; round < 50; round++) {
+      if (this.host.isDraining?.()) break;
       const due = await store.listSchedules({
         dueBy: nowMs,
         namespace: this.options.namespace,
         limit: TICK_BATCH
       });
       for (const record of due) {
+        if (this.host.isDraining?.()) return started;
         const runId = await this.fire(record, nowMs);
         if (runId) started.push(runId);
       }
@@ -3705,6 +3707,8 @@ var WorkflowEngine = class {
   /** Executions currently in flight, so a graceful shutdown can wait for them to settle. */
   inflight = /* @__PURE__ */ new Set();
   draining = false;
+  /** Wait already spent on this shutdown before `drain()` (see `beginDrain`). */
+  drainSpentMs = 0;
   constructor(deps) {
     this.store = deps.store;
     this.pool = new TransportPool(deps.transports ?? (deps.transport ? [
@@ -3753,7 +3757,8 @@ var WorkflowEngine = class {
     });
     this.schedules = new ScheduleClient(this.store, {
       start: /* @__PURE__ */ __name((workflow, input, runId, opts) => this.start(workflow, input, runId, opts), "start"),
-      getRun: /* @__PURE__ */ __name((runId) => this.store.getRun(runId), "getRun")
+      getRun: /* @__PURE__ */ __name((runId) => this.store.getRun(runId), "getRun"),
+      isDraining: /* @__PURE__ */ __name(() => this.draining, "isDraining")
     }, {
       namespace: this.namespace,
       clock: this.clock
@@ -4378,15 +4383,34 @@ var WorkflowEngine = class {
     return p;
   }
   /**
+  * Stop picking up new work without waiting: recovery, timer, schedule and timeout sweeps (and
+  * their per-run lock loops) start nothing once this is called, and {@link runOne} returns null. A
+  * poller calls it on its own shutdown so an in-flight sweep stops locking runs before it is awaited.
+  *
+  * `spentMs` is wait time ALREADY spent on this shutdown (the poller awaiting its in-flight sweep).
+  * It is deducted from the budget of a later {@link drain}, so that wait plus the drain stay within
+  * one `shutdownTimeoutMs`. Only time actually spent waiting is charged: time that merely passes
+  * between this call and `drain()` (other hooks, the HTTP server closing) never is. Calls add up.
+  */
+  beginDrain(spentMs = 0) {
+    this.draining = true;
+    this.drainSpentMs += Math.max(0, spentMs);
+  }
+  /**
   * Graceful shutdown: stop picking up new runs (recovery/timer become no-ops) and wait for
   * in-flight executions to settle, up to `timeoutMs`. Call from your app's shutdown hook so a
   * deploy hands off cleanly instead of leaving runs to the lease timeout.
+  *
+  * `timeoutMs` is the total budget for waiting on in-flight runs; any wait already reported through
+  * {@link beginDrain} (`spentMs`) is deducted, so a shutdown that already waited on the timer poll
+  * for part of it waits only for the remainder. With nothing reported, the full `timeoutMs` applies.
   */
   async drain(timeoutMs = 1e4) {
-    this.draining = true;
+    this.beginDrain();
+    const budget = Math.max(0, timeoutMs - this.drainSpentMs);
     if (this.inflight.size === 0) return;
     const timer = new Promise((resolve) => {
-      const t = setTimeout(resolve, timeoutMs);
+      const t = setTimeout(resolve, budget);
       t.unref?.();
     });
     await Promise.race([
@@ -4428,6 +4452,7 @@ var WorkflowEngine = class {
   */
   async sweepTimeouts(now = this.clock()) {
     for (const reg of new Set(this.latest.values())) {
+      if (this.draining) return;
       if (reg.executionTimeoutMs == null) continue;
       const deadline = now - reg.executionTimeoutMs;
       const inflight = [
@@ -4443,6 +4468,7 @@ var WorkflowEngine = class {
         })
       ];
       for (const run of inflight) {
+        if (this.draining) return;
         if (run.createdAt.getTime() > deadline) continue;
         const error2 = {
           message: "execution timeout",
@@ -4472,6 +4498,7 @@ var WorkflowEngine = class {
     if (this.draining) return [];
     const results = [];
     for (const listed of await this.store.listIncompleteRuns(this.namespace)) {
+      if (this.draining) break;
       const acquired = await this.store.tryLockRun(listed.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
       const run = await this.store.getRun(listed.id);
@@ -4907,8 +4934,13 @@ var WorkflowEngine = class {
     if (this.draining) return [];
     const results = [];
     for (const run of runs) {
+      if (this.draining) break;
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
+      if (this.draining) {
+        await this.store.releaseRunLock(run.id);
+        break;
+      }
       try {
         const settled = onLocked ? await onLocked(run) : void 0;
         results.push(settled ?? await this.resumeImplicit(run.id));