@dudousxd/nestjs-durable-core 0.34.0 → 0.35.0

package/dist/index.cjs

@@ -804,7 +804,8 @@ var SingletonGate = class {
       statuses: [
         "pending",
         "running",
-        "suspended"
+        "suspended",
+        "cancelling"
       ]
     });
     if (queued.length >= cap) {
@@ -822,7 +823,8 @@ var SingletonGate = class {
       workflow: run.workflow,
       statuses: [
         "running",
-        "suspended"
+        "suspended",
+        "cancelling"
       ]
     })).sort((a, b) => a.createdAt.getTime() - b.createdAt.getTime() || a.id.localeCompare(b.id));
     const idx = inflight.findIndex((r) => r.id === run.id);
@@ -1971,14 +1973,16 @@ var WorkflowEngine = class {
         continue;
       }
       await this.store.releaseRunLock(run.id);
-      await this.store.updateRun(run.id, {
-        status: "pending",
-        updatedAt: /* @__PURE__ */ new Date()
-      });
+      if (run.status !== "cancelling") {
+        await this.store.updateRun(run.id, {
+          status: "pending",
+          updatedAt: /* @__PURE__ */ new Date()
+        });
+      }
       await this.runDispatcher.dispatch(run.id);
       results.push({
         runId: run.id,
-        status: "pending"
+        status: run.status === "cancelling" ? "cancelling" : "pending"
       });
     }
     return results;
@@ -2097,7 +2101,7 @@ var WorkflowEngine = class {
   * `start` when a call site needs the outcome — `await start(...); const r = await waitForRun(id)`.
   */
   waitForRun(runId, opts) {
-    const isSettled = /* @__PURE__ */ __name((s) => s !== "pending" && s !== "running", "isSettled");
+    const isSettled = /* @__PURE__ */ __name((s) => s !== "pending" && s !== "running" && s !== "cancelling", "isSettled");
     const toResult = /* @__PURE__ */ __name((run) => ({
       runId,
       status: run.status,
@@ -2261,8 +2265,19 @@ var WorkflowEngine = class {
         error: run.error
       };
     }
+    if (run.status === "cancelling") {
+      return {
+        runId,
+        status: "cancelling"
+      };
+    }
     if (opts?.compensate && (run.status === "suspended" || run.status === "running")) {
       this.cancelRequested.add(runId);
+      await this.store.updateRun(runId, {
+        status: "cancelling",
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      run.status = "cancelling";
       if (this.controlPlane) {
         void this.controlPlane.publishControl({
           kind: "cancel",
@@ -2276,7 +2291,7 @@ var WorkflowEngine = class {
       await this.cancelChildren(runId, opts);
       return {
         runId,
-        status: run.status
+        status: "cancelling"
       };
     }
     const error = {
@@ -2667,6 +2682,36 @@ var WorkflowEngine = class {
     };
   }
   async runRemoteExecution(run, registered) {
+    if (run.status === "cancelling") {
+      const error = {
+        message: "cancelled"
+      };
+      await this.store.updateRun(run.id, {
+        status: "cancelled",
+        error,
+        updatedAt: /* @__PURE__ */ new Date()
+      });
+      this.emit({
+        type: "run.failed",
+        runId: run.id,
+        workflow: run.workflow,
+        error
+      });
+      this.notifyCancelled(run.id);
+      if (this.controlPlane) {
+        void this.controlPlane.publishControl({
+          kind: "cancel",
+          runId: run.id,
+          from: this.instanceId
+        }).catch(() => void 0);
+      }
+      await this.store.releaseRunLock(run.id);
+      return {
+        runId: run.id,
+        status: "cancelled",
+        error
+      };
+    }
     const remote = registered.remote;
     if (run.status === "pending") {
       await this.store.updateRun(run.id, {
@@ -2760,6 +2805,15 @@ var WorkflowEngine = class {
         status: "cancelled"
       };
     }
+    const fresh = await this.store.getRun(run.id);
+    if (fresh && (fresh.status === "cancelled" || fresh.status === "completed" || fresh.status === "dead")) {
+      return {
+        runId: run.id,
+        status: fresh.status,
+        output: fresh.output,
+        error: fresh.error
+      };
+    }
     const wakeAt = await this.applyCommands(run, decision.commands);
     return this.settleRun(run, {
       kind: "suspended",
@@ -2927,8 +2981,41 @@ var WorkflowEngine = class {
     }
     return wakeAt;
   }
+  /**
+  * Undo the registered saga compensations in reverse and settle the run `cancelled`. Shared by EVERY
+  * exit path of a run with a compensating cancel in flight — whether the resumed replay returned,
+  * suspended, hit continue-as-new, or threw — so a cancel is never lost just because the body didn't
+  * stop at a suspension point. Clears the in-memory cancel flag.
+  */
+  async compensateAndCancel(run, compensations) {
+    this.cancelRequested.delete(run.id);
+    for (let i = compensations.length - 1; i >= 0; i -= 1) {
+      const comp = compensations[i];
+      if (comp) await this.runCompensation(run, comp);
+    }
+    const error = {
+      message: "cancelled"
+    };
+    await this.store.updateRun(run.id, {
+      status: "cancelled",
+      error,
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    this.emit({
+      type: "run.failed",
+      runId: run.id,
+      workflow: run.workflow,
+      error
+    });
+    return {
+      runId: run.id,
+      status: "cancelled",
+      error
+    };
+  }
   /** The run body, lease held + renewed by {@link execute}. */
   async runExecution(run, fn, registered) {
+    if (run.status === "cancelling") this.cancelRequested.add(run.id);
     if (run.status === "pending") {
       await this.store.updateRun(run.id, {
         status: "running",
@@ -2941,7 +3028,7 @@ var WorkflowEngine = class {
         workflow: run.workflow
       });
     }
-    if (registered?.singleton && !await this.singletons.admit(run, registered.singleton)) {
+    if (run.status !== "cancelling" && registered?.singleton && !await this.singletons.admit(run, registered.singleton)) {
       const wakeAt = this.singletons.retryWakeAt();
       await this.store.updateRun(run.id, {
         status: "suspended",
@@ -2966,12 +3053,14 @@ var WorkflowEngine = class {
     const ctx = createWorkflowCtx(this.ctxHostFor(replay), run.id, compensations, run.workflow);
     try {
       const output = await fn(ctx, run.input);
+      if (this.cancelRequested.has(run.id)) return this.compensateAndCancel(run, compensations);
       return this.settleRun(run, {
         kind: "completed",
         output
       });
     } catch (err) {
       if (err instanceof ContinueAsNew) {
+        if (this.cancelRequested.has(run.id)) return this.compensateAndCancel(run, compensations);
         await this.store.updateRun(run.id, {
           status: "completed",
           output: void 0,
@@ -2995,37 +3084,13 @@ var WorkflowEngine = class {
         };
       }
       if (err instanceof WorkflowSuspended) {
-        if (this.cancelRequested.has(run.id)) {
-          this.cancelRequested.delete(run.id);
-          for (let i = compensations.length - 1; i >= 0; i -= 1) {
-            const comp = compensations[i];
-            if (comp) await this.runCompensation(run, comp);
-          }
-          const error2 = {
-            message: "cancelled"
-          };
-          await this.store.updateRun(run.id, {
-            status: "cancelled",
-            error: error2,
-            updatedAt: /* @__PURE__ */ new Date()
-          });
-          this.emit({
-            type: "run.failed",
-            runId: run.id,
-            workflow: run.workflow,
-            error: error2
-          });
-          return {
-            runId: run.id,
-            status: "cancelled",
-            error: error2
-          };
-        }
+        if (this.cancelRequested.has(run.id)) return this.compensateAndCancel(run, compensations);
         return this.settleRun(run, {
           kind: "suspended",
           wakeAt: err.wakeAt
         });
       }
+      if (this.cancelRequested.has(run.id)) return this.compensateAndCancel(run, compensations);
       const error = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
@@ -3979,7 +4044,7 @@ var InMemoryStateStore = class {
   async listIncompleteRuns() {
     return [
       ...this.runs.values()
-    ].filter((r) => r.status === "running").map((r) => ({
+    ].filter((r) => r.status === "running" || r.status === "cancelling").map((r) => ({
       ...r
     }));
   }