@dudousxd/nestjs-durable-core 0.56.0 → 0.58.0

package/dist/index.cjs

@@ -1584,6 +1584,22 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       runId,
       seq: current
     });
+    const buffered = await store.takeBufferedSignal(`child:${id}`);
+    if (buffered) {
+      await store.removeSignalWaiter({
+        token: `child:${id}`,
+        runId,
+        seq: current
+      });
+      await writeCheckpoint(instantCheckpoint({
+        runId,
+        seq: current,
+        name: `signal:child:${id}`,
+        kind: "signal",
+        output: buffered.payload
+      }));
+      return unwrapCompletion(buffered.payload, `child "${id}"`);
+    }
     if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority);
     if (!existing) {
       await writeCheckpoint(instantCheckpoint({
@@ -2801,12 +2817,55 @@ var WorkflowEngine = class {
   * inline — or null if the run is unknown. The dashboard "retry" goes through here so it can't block
   * the HTTP request on workflow execution.
   */
-  async requeue(runId) {
+  async requeue(runId, _seen) {
+    const seen = _seen ?? /* @__PURE__ */ new Set();
+    if (seen.has(runId)) return null;
+    seen.add(runId);
     const run = await this.store.getRun(runId);
     if (!run) return null;
+    if (run.status === "failed" || run.status === "dead") {
+      const isFailureCompletion = /* @__PURE__ */ __name((v) => typeof v === "object" && v !== null && v.ok === false, "isFailureCompletion");
+      for (const cp of await this.store.listCheckpoints(runId)) {
+        if (cp.status === "failed") {
+          await this.store.saveCheckpoint({
+            ...cp,
+            attempts: 0,
+            wakeAt: this.clock(),
+            ...cp.error ? {
+              error: {
+                ...cp.error,
+                retryable: true
+              }
+            } : {}
+          });
+        } else if (cp.kind === "signal" && cp.name.startsWith("signal:child:") && cp.status === "completed" && isFailureCompletion(cp.output)) {
+          await this.store.saveCheckpoint({
+            ...cp,
+            status: "running",
+            output: void 0
+          });
+          const childId = cp.name.slice("signal:child:".length);
+          const parked = [];
+          for (; ; ) {
+            const buffered = await this.store.takeBufferedSignal(`child:${childId}`);
+            if (!buffered) break;
+            parked.push(buffered.payload);
+          }
+          for (const payload of parked) await this.store.bufferSignal(`child:${childId}`, payload);
+          const bufferedSuccess = parked.some((payload) => typeof payload === "object" && payload !== null && payload.ok === true);
+          if (!bufferedSuccess) {
+            const child = await this.store.getRun(childId);
+            if (child && (child.status === "failed" || child.status === "dead")) {
+              await this.requeue(childId, seen);
+            }
+          }
+        }
+      }
+    }
     await this.store.releaseRunLock(runId);
     await this.store.updateRun(runId, {
       status: "pending",
+      error: void 0,
       updatedAt: /* @__PURE__ */ new Date()
     });
     await this.runDispatcher.dispatch(runId);
@@ -3126,6 +3185,10 @@ var WorkflowEngine = class {
   */
   notifyParent(runId, completion) {
     void this.signal(`child:${runId}`, completion).catch(() => void 0);
+    const at = runId.lastIndexOf("~retry~");
+    if (at !== -1 && completion.ok) {
+      void this.signal(`child:${runId.slice(0, at)}`, completion).catch(() => void 0);
+    }
   }
   /**
   * Deferred child start shared by the in-process ctx host and the remote `startChild` command.