@dudousxd/nestjs-durable-core 0.85.1 → 0.85.3

package/dist/index.cjs

@@ -2745,6 +2745,7 @@ async function runSchedules(engine, schedules, nowMs, opts) {
         if (prev && (prev.status === "running" || prev.status === "suspended")) continue;
       }
     }
+    if (!(s.jitter && s.jitter > 0)) jitterFireAt.get(engine)?.delete(s.key);
     const firing = s.jitter && s.jitter > 0 ? jitterDue(engine, s, candidates, nowMs, random) : candidates;
     if (firing.length === 0) continue;
     for (const runId of firing) {
@@ -4036,7 +4037,6 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
       }));
       return unwrapCompletion(buffered.payload, `child "${id}"`);
     }
-    if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority, version);
     if (!existing) {
       await writeCheckpoint(instantCheckpoint({
         runId,
@@ -4046,6 +4046,7 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
         status: "running"
       }));
     }
+    if (!await store.getRun(id)) host.startChild(workflowName(workflow2), input, id, priority, version);
     throw new WorkflowSuspended(void 0, fanJoin([
       {
         waiterPrefix: `child:${id}`,
@@ -4664,6 +4665,7 @@ function deferred() {
 __name(deferred, "deferred");
 var pendingStateKey = /* @__PURE__ */ __name((at) => String(new Date(at).getTime()), "pendingStateKey");
 var freshPendingKey = /* @__PURE__ */ __name(() => `${Date.now()}-${globalThis.crypto.randomUUID().slice(0, 8)}`, "freshPendingKey");
+var wakeRequestToken = /* @__PURE__ */ __name((runId) => `durable:wake-after-turn:${runId}`, "wakeRequestToken");
 var CHILD_SIGNAL_PREFIX = "signal:child:";
 var DELIVER_CHUNK = 50;
 function childCompletion(child) {
@@ -7850,6 +7852,7 @@ var WorkflowEngine = class {
     const lockNow = this.clock();
     if (run.lockedBy !== this.instanceId || (run.lockedUntil ?? 0) <= lockNow) {
       if (!await this.store.tryLockRun(run.id, this.instanceId, lockNow + this.leaseMs, lockNow)) {
+        if (!this.leaseRetries.has(run.id)) this.inBackground(this.requestWakeAfterTurn(run.id));
         this.recheckAfterLease(run.id, run.lockedUntil);
         return {
           runId: run.id,
@@ -7863,12 +7866,52 @@ var WorkflowEngine = class {
       if (registered?.singleton && (result.status === "completed" || result.status === "failed" || result.status === "cancelled" || result.status === "dead")) {
         void this.singletons.wakeNext(run).catch(() => void 0);
       }
+      if (result.status === "suspended") this.inBackground(this.honorWakeRequests(run.id));
+      else if (TERMINAL_RUN_STATUSES.includes(result.status)) {
+        this.inBackground(this.takeWakeRequests(run.id));
+      }
       return result;
     } finally {
       held.stop();
     }
   }
   /**
+  * Keep a wake that found `runId`'s lease held by a turn executing elsewhere, durably, so that turn
+  * runs again once it ends instead of suspending on a snapshot that predates what the wake brought
+  * (a signal, a child's completion). The request is a buffered signal on a token no workflow waits
+  * on; the holder takes it after it releases the lease ({@link honorWakeRequests}).
+  *
+  * Written first and looked at second, against a holder that releases first and looks second:
+  * whichever look runs last sees the other side's write. So when the run is no longer executing by
+  * the time this re-reads it, the holder may have looked already, and this side takes the request
+  * and wakes the run itself once the lease is free.
+  */
+  async requestWakeAfterTurn(runId) {
+    await this.store.bufferSignal(wakeRequestToken(runId), null);
+    const run = await this.store.getRun(runId);
+    if (run?.status === "running") return;
+    if (!run) {
+      await this.takeWakeRequests(runId);
+      return;
+    }
+    if (!await this.takeWakeRequests(runId)) return;
+    if (TERMINAL_RUN_STATUSES.includes(run.status)) return;
+    this.recheckAfterLease(runId, run.lockedUntil);
+  }
+  /** After a turn that suspended released its lease: run again if a wake was kept for it. */
+  async honorWakeRequests(runId) {
+    if (!await this.takeWakeRequests(runId)) return;
+    await this.wake(runId).catch((err) => {
+      if (!(err instanceof NamespaceMismatch)) throw err;
+    });
+  }
+  /** Take every wake request kept for `runId`; true when there was one. */
+  async takeWakeRequests(runId) {
+    let taken = false;
+    while (await this.store.takeBufferedSignal(wakeRequestToken(runId))) taken = true;
+    return taken;
+  }
+  /**
   * A wake that found the run leased by another instance is dropped, and normally that is fine: the
   * holder's turn either sees what the wake wrote, or re-checks once it releases the lease
   * ({@link redriveSettledSteps}, {@link redriveSettledChildren}). Not if the holder goes down first