@dudousxd/nestjs-durable-core 0.63.0 → 0.64.0

package/dist/index.cjs

@@ -68,6 +68,7 @@ __export(index_exports, {
   canRoute: () => canRoute,
   capableWorkers: () => capableWorkers,
   classifyWaiterToken: () => classifyWaiterToken,
+  clearDurableExecutionWrappers: () => clearDurableExecutionWrappers,
   collectMetrics: () => collectMetrics,
   controlPlaneDescriptor: () => controlPlaneDescriptor,
   createStepLogger: () => createStepLogger,
@@ -81,6 +82,7 @@ __export(index_exports, {
   eventNameOf: () => eventNameOf,
   eventPrefix: () => eventPrefix,
   eventToken: () => eventToken,
+  hasDurableExecutionWrappers: () => hasDurableExecutionWrappers,
   heartbeatStatus: () => heartbeatStatus,
   indexWaitersByRun: () => indexWaitersByRun,
   info: () => info,
@@ -100,6 +102,7 @@ __export(index_exports, {
   requiredCapabilities: () => requiredCapabilities,
   resolveRouting: () => resolveRouting,
   resolveRunWaiting: () => resolveRunWaiting,
+  runDurableExecution: () => runDurableExecution,
   runInStepLogger: () => runInStepLogger,
   runInWorkflowCtx: () => runInWorkflowCtx,
   runSchedules: () => runSchedules,
@@ -114,6 +117,7 @@ __export(index_exports, {
   subEvent: () => subEvent,
   subProcess: () => subProcess,
   tenantGroup: () => tenantGroup,
+  useDurableExecution: () => useDurableExecution,
   warn: () => warn,
   workflowName: () => workflowName
 });
@@ -599,6 +603,57 @@ function backoffDelay(attempt, options) {
 }
 __name(backoffDelay, "backoffDelay");
 
+// src/execution-hooks.ts
+var wrappers = [];
+function useDurableExecution(wrapper) {
+  wrappers.push(wrapper);
+  return () => {
+    const i = wrappers.indexOf(wrapper);
+    if (i >= 0) wrappers.splice(i, 1);
+  };
+}
+__name(useDurableExecution, "useDurableExecution");
+function clearDurableExecutionWrappers() {
+  wrappers.length = 0;
+}
+__name(clearDurableExecutionWrappers, "clearDurableExecutionWrappers");
+function hasDurableExecutionWrappers() {
+  return wrappers.length > 0;
+}
+__name(hasDurableExecutionWrappers, "hasDurableExecutionWrappers");
+async function runDurableExecution(execution, body) {
+  if (wrappers.length === 0) return body();
+  let outcome;
+  const inner = /* @__PURE__ */ __name(async () => {
+    try {
+      const value = await body();
+      outcome = {
+        ok: true,
+        value
+      };
+      return value;
+    } catch (error2) {
+      outcome = {
+        ok: false,
+        error: error2
+      };
+      throw error2;
+    }
+  }, "inner");
+  const chain = wrappers.reduceRight((next, wrapper) => () => wrapper(execution, next), inner);
+  try {
+    await chain();
+  } catch (error2) {
+    if (outcome === void 0) throw error2;
+  }
+  if (outcome === void 0) {
+    throw new Error("a durable execution wrapper returned without calling next() \u2014 the unit of work never ran");
+  }
+  if (outcome.ok) return outcome.value;
+  throw outcome.error;
+}
+__name(runDurableExecution, "runDurableExecution");
+
 // src/step-logger.ts
 function withDuration(start, now, data) {
   if (data && typeof data === "object" && "durationMs" in data) {
@@ -740,7 +795,14 @@ async function runStepHandler(task, handler) {
   } : result, "withEvents");
   try {
     const logger = createStepLogger(events, Date.now);
-    const output = await runInStepLogger(logger, () => handler(task.input, logger));
+    const output = await runDurableExecution({
+      unit: "step",
+      runId: task.runId,
+      workflow: void 0,
+      name: task.name,
+      seq: task.seq,
+      attempt: task.attempt
+    }, async () => runInStepLogger(logger, () => handler(task.input, logger)));
     return withEvents({
       ...base,
       status: "completed",
@@ -4642,8 +4704,31 @@ var WorkflowEngine = class {
       error: error2
     };
   }
-  /** The run body, lease held + renewed by {@link execute}. */
-  async runExecution(run, fn, registered) {
+  /**
+  * The run body, lease held + renewed by {@link execute}, wrapped in the registered
+  * {@link runDurableExecution} wrappers so an observability scope covers ONE WHOLE TURN.
+  *
+  * The wrap goes here — around the entire turn — rather than tightly around the `fn(ctx, input)`
+  * call, because the store writes that bracket the body (the `pending` → `running` transition, the
+  * step checkpoints, the terminal `settleRun` update) are exactly the queries an operator wants
+  * correlated to the turn that issued them. Narrowing the wrap to the body would leave them
+  * uncorrelated for the sake of a purity that buys nothing.
+  *
+  * Only the TS path is wrapped. {@link runRemoteExecution} does not execute a body at all — it
+  * dispatches a workflow task and awaits the worker's decision — so a scope opened there would
+  * describe a dispatch, not an execution, and would mislead anyone reading the trace.
+  */
+  runExecution(run, fn, registered) {
+    return runDurableExecution({
+      unit: "workflow",
+      runId: run.id,
+      workflow: run.workflow,
+      name: void 0,
+      seq: void 0,
+      attempt: void 0
+    }, () => this.runExecutionTurn(run, fn, registered));
+  }
+  async runExecutionTurn(run, fn, registered) {
     if (run.status === "cancelling") this.cancelRequested.add(run.id);
     if (run.status === "pending") {
       await this.store.updateRun(run.id, {
@@ -6403,6 +6488,7 @@ var InMemoryTransport = class {
   canRoute,
   capableWorkers,
   classifyWaiterToken,
+  clearDurableExecutionWrappers,
   collectMetrics,
   controlPlaneDescriptor,
   createStepLogger,
@@ -6416,6 +6502,7 @@ var InMemoryTransport = class {
   eventNameOf,
   eventPrefix,
   eventToken,
+  hasDurableExecutionWrappers,
   heartbeatStatus,
   indexWaitersByRun,
   info,
@@ -6435,6 +6522,7 @@ var InMemoryTransport = class {
   requiredCapabilities,
   resolveRouting,
   resolveRunWaiting,
+  runDurableExecution,
   runInStepLogger,
   runInWorkflowCtx,
   runSchedules,
@@ -6449,6 +6537,7 @@ var InMemoryTransport = class {
   subEvent,
   subProcess,
   tenantGroup,
+  useDurableExecution,
   warn,
   workflowName
 });