@dudousxd/nestjs-durable-core 0.60.0 → 0.61.0

package/dist/index.cjs

@@ -71,8 +71,11 @@ __export(index_exports, {
   collectMetrics: () => collectMetrics,
   controlPlaneDescriptor: () => controlPlaneDescriptor,
   createStepLogger: () => createStepLogger,
+  currentStep: () => currentStep,
   currentWorkflowCtx: () => currentWorkflowCtx,
+  debug: () => debug,
   descriptorHash: () => descriptorHash,
+  error: () => error,
   eventMatchOf: () => eventMatchOf,
   eventMatches: () => eventMatches,
   eventNameOf: () => eventNameOf,
@@ -80,9 +83,11 @@ __export(index_exports, {
   eventToken: () => eventToken,
   heartbeatStatus: () => heartbeatStatus,
   indexWaitersByRun: () => indexWaitersByRun,
+  info: () => info,
   isEventToken: () => isEventToken,
   isLegacyDescriptor: () => isLegacyDescriptor,
   isWorkflowControlFlowSignal: () => isWorkflowControlFlowSignal,
+  log: () => log,
   matchesAttributes: () => matchesAttributes,
   missingCapabilities: () => missingCapabilities,
   negotiate: () => negotiate,
@@ -95,6 +100,7 @@ __export(index_exports, {
   requiredCapabilities: () => requiredCapabilities,
   resolveRouting: () => resolveRouting,
   resolveRunWaiting: () => resolveRunWaiting,
+  runInStepLogger: () => runInStepLogger,
   runInWorkflowCtx: () => runInWorkflowCtx,
   runSchedules: () => runSchedules,
   runStepHandler: () => runStepHandler,
@@ -104,7 +110,11 @@ __export(index_exports, {
   stepConfigOf: () => stepConfigOf,
   stepId: () => stepId,
   stepNameOf: () => stepNameOf,
+  sub: () => sub,
+  subEvent: () => subEvent,
+  subProcess: () => subProcess,
   tenantGroup: () => tenantGroup,
+  warn: () => warn,
   workflowName: () => workflowName
 });
 module.exports = __toCommonJS(index_exports);
@@ -281,10 +291,68 @@ function currentWorkflowCtx() {
 }
 __name(currentWorkflowCtx, "currentWorkflowCtx");
 
+// src/ambient-step.ts
+var import_node_async_hooks2 = require("async_hooks");
+var STORAGE_KEY2 = Symbol.for("nestjs-durable:ambient-step-logger");
+var globalRef2 = globalThis;
+if (!globalRef2[STORAGE_KEY2]) {
+  globalRef2[STORAGE_KEY2] = new import_node_async_hooks2.AsyncLocalStorage();
+}
+var storage2 = globalRef2[STORAGE_KEY2];
+function runInStepLogger(logger, fn) {
+  return storage2.run(logger, fn);
+}
+__name(runInStepLogger, "runInStepLogger");
+function currentStep() {
+  return storage2.getStore();
+}
+__name(currentStep, "currentStep");
+function log(level, message, data) {
+  currentStep()?.[level](message, data);
+}
+__name(log, "log");
+function debug(message, data) {
+  currentStep()?.debug(message, data);
+}
+__name(debug, "debug");
+function info(message, data) {
+  currentStep()?.info(message, data);
+}
+__name(info, "info");
+function warn(message, data) {
+  currentStep()?.warn(message, data);
+}
+__name(warn, "warn");
+function error(message, data) {
+  currentStep()?.error(message, data);
+}
+__name(error, "error");
+function sub(name, status, message, data) {
+  currentStep()?.sub(name, status, message, data);
+}
+__name(sub, "sub");
+function subEvent(e) {
+  currentStep()?.subEvent(e);
+}
+__name(subEvent, "subEvent");
+var noopSubProcessHandle = {
+  phase: /* @__PURE__ */ __name(() => noopSubProcessHandle, "phase"),
+  skip: /* @__PURE__ */ __name(() => {
+  }, "skip"),
+  fail: /* @__PURE__ */ __name(() => {
+  }, "fail")
+};
+function subProcess(name, body, opts) {
+  const logger = currentStep();
+  if (!logger) return Promise.resolve(body(noopSubProcessHandle));
+  return logger.subProcess(name, body, opts);
+}
+__name(subProcess, "subProcess");
+
 // src/control-flow-signal.ts
 var CONTROL_FLOW_SIGNAL = Symbol.for("aviary:durable:control-flow");
-function isWorkflowControlFlowSignal(error) {
-  return typeof error === "object" && error !== null && error[CONTROL_FLOW_SIGNAL] === true;
+function isWorkflowControlFlowSignal(error2) {
+  return typeof error2 === "object" && error2 !== null && error2[CONTROL_FLOW_SIGNAL] === true;
 }
 __name(isWorkflowControlFlowSignal, "isWorkflowControlFlowSignal");
 
@@ -421,11 +489,11 @@ __name(workflowName, "workflowName");
 
 // src/durable-workflow.ts
 var BINDINGS_KEY = Symbol.for("nestjs-durable:workflow-class-bindings");
-var globalRef2 = globalThis;
-if (!globalRef2[BINDINGS_KEY]) {
-  globalRef2[BINDINGS_KEY] = /* @__PURE__ */ new WeakMap();
+var globalRef3 = globalThis;
+if (!globalRef3[BINDINGS_KEY]) {
+  globalRef3[BINDINGS_KEY] = /* @__PURE__ */ new WeakMap();
 }
-var bindings = globalRef2[BINDINGS_KEY];
+var bindings = globalRef3[BINDINGS_KEY];
 function bindWorkflowClass(ctor, client) {
   bindings.set(ctor, client);
 }
@@ -556,7 +624,7 @@ function createStepLogger(events, now) {
       data
     }
   }), "push");
-  const subEvent = /* @__PURE__ */ __name((e) => events.push({
+  const subEvent2 = /* @__PURE__ */ __name((e) => events.push({
     at: now(),
     level: e.status === "failed" ? "error" : e.status === "skipped" ? "warn" : "info",
     message: e.message ?? e.phase ?? e.name,
@@ -575,7 +643,7 @@ function createStepLogger(events, now) {
       data: e.data
     }
   }), "subEvent");
-  const subProcess = /* @__PURE__ */ __name(async (name, body, opts) => {
+  const subProcess2 = /* @__PURE__ */ __name(async (name, body, opts) => {
     const id = opts?.id ?? globalThis.crypto.randomUUID();
     const group = opts?.group;
     const start = now();
@@ -587,7 +655,7 @@ function createStepLogger(events, now) {
     const emit = /* @__PURE__ */ __name((status, message, data) => {
       if (terminal) return;
       terminal = true;
-      subEvent({
+      subEvent2({
         id,
         name,
         group,
@@ -598,7 +666,7 @@ function createStepLogger(events, now) {
     }, "emit");
     const handle = {
       phase: /* @__PURE__ */ __name((phase, data) => {
-        if (!terminal) subEvent({
+        if (!terminal) subEvent2({
           id,
           name,
           group,
@@ -636,8 +704,8 @@ function createStepLogger(events, now) {
         data
       }
     }), "sub"),
-    subEvent,
-    subProcess
+    subEvent: subEvent2,
+    subProcess: subProcess2
   };
 }
 __name(createStepLogger, "createStepLogger");
@@ -671,7 +739,8 @@ async function runStepHandler(task, handler) {
     events
   } : result, "withEvents");
   try {
-    const output = await handler(task.input, createStepLogger(events, Date.now));
+    const logger = createStepLogger(events, Date.now);
+    const output = await runInStepLogger(logger, () => handler(task.input, logger));
     return withEvents({
       ...base,
       status: "completed",
@@ -1721,7 +1790,10 @@ function createWorkflowCtx(host, runId, compensations, workflow = "", searchAttr
           seq: current,
           attempt
         };
-        const body = /* @__PURE__ */ __name(() => fn(createStepLogger(events, host.clock)), "body");
+        const body = /* @__PURE__ */ __name(() => {
+          const logger = createStepLogger(events, host.clock);
+          return runInStepLogger(logger, () => fn(logger));
+        }, "body");
         const output = host.interceptStep ? await host.interceptStep(invocation, body) : await body();
         await host.completeStep({
           runId,
@@ -3023,13 +3095,13 @@ var WorkflowEngine = class {
       ];
       for (const run of inflight) {
         if (run.createdAt.getTime() > deadline) continue;
-        const error = {
+        const error2 = {
           message: "execution timeout",
           code: "execution_timeout"
         };
         await this.store.updateRun(run.id, {
           status: "cancelled",
-          error,
+          error: error2,
           updatedAt: /* @__PURE__ */ new Date()
         });
         this.emit({
@@ -3037,7 +3109,7 @@ var WorkflowEngine = class {
           runId: run.id,
           workflow: run.workflow,
           namespace: run.namespace,
-          error
+          error: error2
         });
       }
     }
@@ -3052,6 +3124,22 @@ var WorkflowEngine = class {
     for (const run of await this.store.listIncompleteRuns(this.namespace)) {
       const acquired = await this.store.tryLockRun(run.id, this.instanceId, nowMs + this.leaseMs, nowMs);
       if (!acquired) continue;
+      if (run.status === "running") {
+        const dispatched = await this.inFlightRemoteStep(run.id);
+        if (dispatched) {
+          await this.store.updateRun(run.id, {
+            status: "suspended",
+            wakeAt: this.reconcileWakeAt(dispatched.wakeAt ?? void 0),
+            updatedAt: /* @__PURE__ */ new Date()
+          });
+          await this.store.releaseRunLock(run.id);
+          results.push({
+            runId: run.id,
+            status: "suspended"
+          });
+          continue;
+        }
+      }
       const settled = await this.countRecovery(run);
       if (settled) {
         results.push(settled);
@@ -3073,6 +3161,16 @@ var WorkflowEngine = class {
     return results;
   }
   /**
+  * The remote step this run dispatched and is still awaiting a result for, if any — the signature
+  * that tells {@link recoverIncomplete} "this run's work is ON THE TRANSPORT, not in a crashed
+  * process". A `pending` remote checkpoint is written BEFORE the dispatch and settled by the
+  * worker's result, so its presence is the durable marker of an in-flight dispatched step.
+  */
+  async inFlightRemoteStep(runId) {
+    const checkpoints = await this.store.listCheckpoints(runId);
+    return checkpoints.find((cp) => cp.kind === "remote" && cp.status === "pending");
+  }
+  /**
   * Per-recovery bookkeeping (called once the lease is held): count the attempt, or — past
   * `maxRecoveryAttempts` — move a poison pill to the `dead` dead-letter state. Returns a terminal
   * result to skip the resume, or `undefined` to proceed.
@@ -3080,13 +3178,13 @@ var WorkflowEngine = class {
   async countRecovery(run) {
     const attempts = (run.recoveryAttempts ?? 0) + 1;
     if (this.maxRecoveryAttempts != null && attempts > this.maxRecoveryAttempts) {
-      const error = {
+      const error2 = {
         message: `run exceeded maxRecoveryAttempts (${this.maxRecoveryAttempts}) \u2014 moved to dead-letter`,
         code: "max_recovery_attempts"
       };
       await this.store.updateRun(run.id, {
         status: "dead",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       await this.store.releaseRunLock(run.id);
@@ -3095,18 +3193,18 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       this.notifyDead({
         ...run,
         status: "dead",
-        error,
+        error: error2,
         recoveryAttempts: attempts
       });
       return {
         runId: run.id,
         status: "dead",
-        error
+        error: error2
       };
     }
     await this.store.updateRun(run.id, {
@@ -3227,7 +3325,8 @@ var WorkflowEngine = class {
     seen.add(runId);
     const run = await this.store.getRun(runId);
     if (!run) return null;
-    if (run.status === "failed" || run.status === "dead") {
+    const resurrecting = run.status === "failed" || run.status === "dead";
+    if (resurrecting) {
       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") {
@@ -3270,6 +3369,9 @@ var WorkflowEngine = class {
     await this.store.updateRun(runId, {
       status: "pending",
       error: void 0,
+      ...resurrecting ? {
+        recoveryAttempts: 0
+      } : {},
       updatedAt: /* @__PURE__ */ new Date()
     });
     await this.runDispatcher.dispatch(runId);
@@ -3282,9 +3384,11 @@ var WorkflowEngine = class {
   * Explicitly re-dispatch every remote step of `runId` stuck `pending` — the OPERATOR escape hatch for
   * a run whose dispatched step job was LOST (worker crashed with no result, or a transport that dropped
   * the job). No automatic recovery re-drives these: a reconcile re-drive re-suspends a still-pending
-  * step by design (unless `remoteRedispatchMs` is set), `recoverIncomplete` only reclaims LEASED runs,
-  * and `requeue` just replays back to the pending guard. This re-enqueues the same `stepId` so the
-  * (idempotent) step re-runs and its result resumes the run. Safe to call on a healthy run — it re-runs
+  * step by design (unless `remoteRedispatchMs` is set), `recoverIncomplete` explicitly SKIPS a run with
+  * an in-flight `pending` remote step (it re-asserts the durably-suspended invariant instead of counting
+  * a recovery attempt — see there), and `requeue` just replays back to the pending guard. This
+  * re-enqueues the same `stepId` so the (idempotent) step re-runs and its result resumes the run.
+  * Safe to call on a healthy run — it re-runs
   * only in-flight `pending` remote steps, which are idempotent by the durable contract. Returns the
   * run's current status (with the count re-dispatched), or null if the run is unknown.
   */
@@ -3576,10 +3680,10 @@ var WorkflowEngine = class {
     });
   }
   /** Report that a `ctx.task` failed — the run resumes and throws a FatalError at the task. */
-  async failTask(runId, name, error) {
+  async failTask(runId, name, error2) {
     return this.signal(`task:${runId}:${name}`, {
       ok: false,
-      error
+      error: error2
     });
   }
   /**
@@ -3661,12 +3765,12 @@ var WorkflowEngine = class {
         status: "cancelling"
       };
     }
-    const error = {
+    const error2 = {
       message: "cancelled"
     };
     await this.store.updateRun(runId, {
       status: "cancelled",
-      error,
+      error: error2,
       updatedAt: /* @__PURE__ */ new Date()
     });
     this.emit({
@@ -3674,7 +3778,7 @@ var WorkflowEngine = class {
       runId,
       workflow: run.workflow,
       namespace: run.namespace,
-      error
+      error: error2
     });
     await this.cancelChildren(runId, opts);
     this.notifyCancelled(runId);
@@ -3689,7 +3793,7 @@ var WorkflowEngine = class {
     return {
       runId,
       status: "cancelled",
-      error
+      error: error2
     };
   }
   /**
@@ -4084,12 +4188,12 @@ var WorkflowEngine = class {
   }
   async runRemoteExecution(run, registered) {
     if (run.status === "cancelling") {
-      const error = {
+      const error2 = {
         message: "cancelled"
       };
       await this.store.updateRun(run.id, {
         status: "cancelled",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       this.emit({
@@ -4097,7 +4201,7 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       this.notifyCancelled(run.id);
       if (this.controlPlane) {
@@ -4111,7 +4215,7 @@ var WorkflowEngine = class {
       return {
         runId: run.id,
         status: "cancelled",
-        error
+        error: error2
       };
     }
     const remote = registered.remote;
@@ -4190,13 +4294,13 @@ var WorkflowEngine = class {
           status: "running"
         };
       }
-      const error = {
+      const error2 = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
       };
       await this.store.updateRun(run.id, {
         status: "failed",
-        error,
+        error: error2,
         updatedAt: /* @__PURE__ */ new Date()
       });
       this.emit({
@@ -4204,12 +4308,12 @@ var WorkflowEngine = class {
         runId: run.id,
         workflow: run.workflow,
         namespace: run.namespace,
-        error
+        error: error2
       });
       return {
         runId: run.id,
         status: "failed",
-        error
+        error: error2
       };
     }
     return this.applyDecision(run, decision);
@@ -4474,12 +4578,12 @@ var WorkflowEngine = class {
       status: "cancelling"
     };
     this.cancelRequested.delete(run.id);
-    const error = {
+    const error2 = {
       message: "cancelled"
     };
     await this.store.updateRun(run.id, {
       status: "cancelled",
-      error,
+      error: error2,
       updatedAt: /* @__PURE__ */ new Date()
     });
     this.emit({
@@ -4487,12 +4591,12 @@ var WorkflowEngine = class {
       runId: run.id,
       workflow: run.workflow,
       namespace: run.namespace,
-      error
+      error: error2
     });
     return {
       runId: run.id,
       status: "cancelled",
-      error
+      error: error2
     };
   }
   /** The run body, lease held + renewed by {@link execute}. */
@@ -4593,7 +4697,7 @@ var WorkflowEngine = class {
       if (this.cancelRequested.has(run.id)) {
         return this.compensateAndCancel(run, compensations, replay);
       }
-      const error = {
+      const error2 = {
         message: err instanceof Error ? err.message : String(err),
         stack: err instanceof Error ? err.stack : void 0
       };
@@ -4604,7 +4708,7 @@ var WorkflowEngine = class {
       });
       return this.settleRun(run, {
         kind: "failed",
-        error
+        error: error2
       });
     } finally {
       await this.store.releaseRunLock(run.id);
@@ -4693,7 +4797,7 @@ var WorkflowEngine = class {
         return;
       } catch (err) {
         if (attempt >= this.compensationRetries) {
-          const error = {
+          const error2 = {
             message: err instanceof Error ? err.message : String(err)
           };
           this.emit({
@@ -4702,7 +4806,7 @@ var WorkflowEngine = class {
             workflow: run.workflow,
             name,
             kind: "local",
-            error,
+            error: error2,
             durationMs: Date.now() - startedAt.getTime()
           });
           const cp = stepCheckpoint({
@@ -4712,7 +4816,7 @@ var WorkflowEngine = class {
             kind: "local",
             status: "failed",
             attempts: attempt,
-            error,
+            error: error2,
             enqueuedAt,
             startedAt,
             finishedAt: /* @__PURE__ */ new Date()
@@ -4968,14 +5072,14 @@ var WorkflowEngine = class {
         error: current.error
       };
     }
-    const error = {
+    const error2 = {
       message: blocked.reason,
       code: blocked.code,
       retryable: true
     };
     await this.store.updateRun(run.id, {
       status: "blocked",
-      error,
+      error: error2,
       wakeAt: this.clock() + this.blockedPollMs,
       updatedAt: /* @__PURE__ */ new Date()
     });
@@ -4984,7 +5088,7 @@ var WorkflowEngine = class {
       runId: run.id,
       workflow: run.workflow,
       namespace: run.namespace,
-      error,
+      error: error2,
       requires: blocked.requires,
       diagnostics: blocked.diagnostics
     });
@@ -4992,7 +5096,7 @@ var WorkflowEngine = class {
     return {
       runId: run.id,
       status: "blocked",
-      error
+      error: error2
     };
   }
   /** Runs parked `blocked` whose recovery poll is due (`wakeAt <= nowMs`), namespace-scoped like
@@ -6213,8 +6317,11 @@ var InMemoryTransport = class {
   collectMetrics,
   controlPlaneDescriptor,
   createStepLogger,
+  currentStep,
   currentWorkflowCtx,
+  debug,
   descriptorHash,
+  error,
   eventMatchOf,
   eventMatches,
   eventNameOf,
@@ -6222,9 +6329,11 @@ var InMemoryTransport = class {
   eventToken,
   heartbeatStatus,
   indexWaitersByRun,
+  info,
   isEventToken,
   isLegacyDescriptor,
   isWorkflowControlFlowSignal,
+  log,
   matchesAttributes,
   missingCapabilities,
   negotiate,
@@ -6237,6 +6346,7 @@ var InMemoryTransport = class {
   requiredCapabilities,
   resolveRouting,
   resolveRunWaiting,
+  runInStepLogger,
   runInWorkflowCtx,
   runSchedules,
   runStepHandler,
@@ -6246,7 +6356,11 @@ var InMemoryTransport = class {
   stepConfigOf,
   stepId,
   stepNameOf,
+  sub,
+  subEvent,
+  subProcess,
   tenantGroup,
+  warn,
   workflowName
 });
 //# sourceMappingURL=index.cjs.map