@dudousxd/nestjs-durable-core 0.61.0 → 0.62.1

package/dist/index.d.cts

@@ -3050,6 +3050,19 @@ declare class WorkflowEngine {
      *  from registrations, shows once its workers beat). Empty when no transport can introspect health
      *  (only the BullMQ transport implements `groupHealth`). */
     workerHealth(extra?: string[]): Promise<GroupHealth[]>;
+    /**
+     * The routing groups of every in-flight run's still-`pending` remote step — the queues where work is
+     * dispatched and awaiting a worker. Folded into {@link workerHealth} so a step waiting on a group
+     * that is NEITHER a registration NOR heartbeating (the exact shape of a run stuck on an offline
+     * tenant pool) still reports its backlog: without this the health scan can't "see" that queue, and
+     * the dashboard shows the run as running instead of no-worker. Only the BullMQ transport introspects
+     * health, so on any other transport this is harmless (the groups just resolve to no `groupHealth`).
+     *
+     * Cost: one `listRuns` over the non-terminal runs plus a checkpoint read each — a diagnostic-path
+     * scan, not a hot path. Scoped to `running`/`suspended`/`blocked` (a `pending` run has dispatched no
+     * step yet) and deduped to distinct groups.
+     */
+    private inflightStepGroups;
     /**
      * Persist a streamed local-step lifecycle event from a remote workflow worker (see
      * {@link WorkflowStepEvent}). A Python `@workflow` runs its `ctx.step`s inline over one turn that

package/dist/index.d.ts

@@ -3050,6 +3050,19 @@ declare class WorkflowEngine {
      *  from registrations, shows once its workers beat). Empty when no transport can introspect health
      *  (only the BullMQ transport implements `groupHealth`). */
     workerHealth(extra?: string[]): Promise<GroupHealth[]>;
+    /**
+     * The routing groups of every in-flight run's still-`pending` remote step — the queues where work is
+     * dispatched and awaiting a worker. Folded into {@link workerHealth} so a step waiting on a group
+     * that is NEITHER a registration NOR heartbeating (the exact shape of a run stuck on an offline
+     * tenant pool) still reports its backlog: without this the health scan can't "see" that queue, and
+     * the dashboard shows the run as running instead of no-worker. Only the BullMQ transport introspects
+     * health, so on any other transport this is harmless (the groups just resolve to no `groupHealth`).
+     *
+     * Cost: one `listRuns` over the non-terminal runs plus a checkpoint read each — a diagnostic-path
+     * scan, not a hot path. Scoped to `running`/`suspended`/`blocked` (a `pending` run has dispatched no
+     * step yet) and deduped to distinct groups.
+     */
+    private inflightStepGroups;
     /**
      * Persist a streamed local-step lifecycle event from a remote workflow worker (see
      * {@link WorkflowStepEvent}). A Python `@workflow` runs its `ctx.step`s inline over one turn that

package/dist/index.js

@@ -2278,6 +2278,10 @@ __name(mergeTags, "mergeTags");
 var BREAKPOINT = "breakpoint";
 var isBreakpoint = /* @__PURE__ */ __name((cp) => cp.status === "pending" && cp.name.startsWith(BREAKPOINT), "isBreakpoint");
 var versionKey = /* @__PURE__ */ __name((name, version) => `${name}@${version}`, "versionKey");
+function stepGroup(step, runNamespace) {
+  return tenantGroup(sanitizeQueueToken(step.name), step.partition ?? runNamespace);
+}
+__name(stepGroup, "stepGroup");
 function nextContinuationId(runId) {
   const m = runId.match(/^(.*)~(\d+)$/);
   return m ? `${m[1]}~${Number(m[2]) + 1}` : `${runId}~1`;
@@ -3778,7 +3782,8 @@ var WorkflowEngine = class {
   async workerHealth(extra = []) {
     const groups = /* @__PURE__ */ new Set([
       ...this.knownGroups(extra),
-      ...await this.pool.listWorkerGroups()
+      ...await this.pool.listWorkerGroups(),
+      ...await this.inflightStepGroups()
     ]);
     const workflowTokens = /* @__PURE__ */ new Set();
     for (const def of this.workflows.values()) {
@@ -3799,6 +3804,38 @@ var WorkflowEngine = class {
     return out;
   }
   /**
+  * The routing groups of every in-flight run's still-`pending` remote step — the queues where work is
+  * dispatched and awaiting a worker. Folded into {@link workerHealth} so a step waiting on a group
+  * that is NEITHER a registration NOR heartbeating (the exact shape of a run stuck on an offline
+  * tenant pool) still reports its backlog: without this the health scan can't "see" that queue, and
+  * the dashboard shows the run as running instead of no-worker. Only the BullMQ transport introspects
+  * health, so on any other transport this is harmless (the groups just resolve to no `groupHealth`).
+  *
+  * Cost: one `listRuns` over the non-terminal runs plus a checkpoint read each — a diagnostic-path
+  * scan, not a hot path. Scoped to `running`/`suspended`/`blocked` (a `pending` run has dispatched no
+  * step yet) and deduped to distinct groups.
+  */
+  async inflightStepGroups() {
+    const inflight = await this.store.listRuns({
+      statuses: [
+        "running",
+        "suspended",
+        "blocked"
+      ]
+    });
+    const groups = /* @__PURE__ */ new Set();
+    for (const run of inflight) {
+      for (const cp of await this.store.listCheckpoints(run.id)) {
+        if (cp.kind === "remote" && cp.status === "pending" && cp.workerGroup) {
+          groups.add(cp.workerGroup);
+        }
+      }
+    }
+    return [
+      ...groups
+    ];
+  }
+  /**
   * Persist a streamed local-step lifecycle event from a remote workflow worker (see
   * {@link WorkflowStepEvent}). A Python `@workflow` runs its `ctx.step`s inline over one turn that
   * can last minutes; the worker streams each step's start/finish so the engine checkpoints it LIVE —
@@ -4762,7 +4799,7 @@ var WorkflowEngine = class {
   */
   async dispatchCompensationAttempt(run, seq, name, def, args, attempt, replay) {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    const group = tenantGroup(sanitizeQueueToken(def.name), def.partition);
+    const group = stepGroup(def, run.namespace);
     const enqueuedAt = /* @__PURE__ */ new Date();
     const cp = stepCheckpoint({
       runId: run.id,
@@ -4810,7 +4847,12 @@ var WorkflowEngine = class {
       startStep: /* @__PURE__ */ __name((s) => this.startStep(s), "startStep"),
       completeStep: /* @__PURE__ */ __name((s) => this.completeStep(s), "completeStep"),
       failStep: /* @__PURE__ */ __name((s) => this.failStep(s), "failStep"),
-      callRemote: /* @__PURE__ */ __name((runId, seq, step, input, queue, transport, admission) => this.callRemote(runId, seq, step, input, queue, transport, replay, admission), "callRemote"),
+      // Route the dispatch by the RUN's tenant (same reason as `startChild` below): the executing
+      // engine may be an operator driving every namespace, so the token must come from the run, not
+      // from this engine. See {@link stepGroup}.
+      callRemote: /* @__PURE__ */ __name((runId, seq, step, input, queue, transport, admission) => this.callRemote(runId, seq, step, input, queue, transport, replay, admission, {
+        namespace: parentNamespace
+      }), "callRemote"),
       // Defer so a fast child can't reentrantly resume a still-running parent. Stamp the child with
       // the PARENT run's namespace (not this engine's) so a child belongs to the tenant/partition of
       // the run it was spawned from — even when an operator (namespace: undefined, drives every
@@ -4992,14 +5034,15 @@ var WorkflowEngine = class {
     });
     return blocked.filter((r) => (this.namespace === void 0 || r.namespace === void 0 || r.namespace === this.namespace) && r.wakeAt !== void 0 && r.wakeAt <= nowMs);
   }
-  async callRemote(runId, seq, step, input, queue, transport, replay, admission) {
+  async callRemote(runId, seq, step, input, queue, transport, replay, admission, routing) {
+    const group = stepGroup(step, routing?.namespace);
     const existing = replay?.get(seq) ?? await this.store.getCheckpoint(runId, seq);
     if (existing && existing.name !== step.name) {
       throw new NonDeterminismError(runId, seq, step.name, existing.name);
     }
     if (existing?.status === "completed") return existing.output;
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    if (step.timeoutMs) return this.callRemoteInMemory(runId, seq, step, input, transport);
+    if (step.timeoutMs) return this.callRemoteInMemory(runId, seq, step, input, transport, group);
     if (existing?.status === "pending") {
       if (this.remoteRedispatchMs == null) throw new WorkflowSuspended();
       if (existing.wakeAt == null) {
@@ -5033,7 +5076,7 @@ var WorkflowEngine = class {
         seq,
         name: step.name,
         stepId: existing.stepId ?? stepId(runId, seq),
-        group: existing.workerGroup ?? tenantGroup(sanitizeQueueToken(step.name), step.partition),
+        group: existing.workerGroup ?? group,
         input: existing.input,
         priority: admission?.priority,
         attempt: reAttempt,
@@ -5057,7 +5100,7 @@ var WorkflowEngine = class {
       if (this.clock() < existing.wakeAt) throw new WorkflowSuspended(existing.wakeAt);
       attempt = existing.attempts + 1;
     }
-    await this.ensureRoutable(tenantGroup(sanitizeQueueToken(step.name), step.partition), step.requires);
+    await this.ensureRoutable(group, step.requires);
     const id = stepId(runId, seq);
     if (queue && this.admission.handles(queue)) {
       const decision = await this.admission.tryAdmit(queue, {
@@ -5084,7 +5127,7 @@ var WorkflowEngine = class {
       status: "pending",
       input,
       attempts: attempt,
-      workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+      workerGroup: group,
       enqueuedAt,
       startedAt: enqueuedAt,
       finishedAt: enqueuedAt
@@ -5094,7 +5137,7 @@ var WorkflowEngine = class {
       seq,
       name: step.name,
       stepId: id,
-      group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+      group,
       input,
       priority: admission?.priority,
       attempt,
@@ -5242,9 +5285,9 @@ var WorkflowEngine = class {
     await this.admission.release(queue, id);
   }
   /** In-memory await path for a remote step with a liveness `timeoutMs` (re-dispatch on timeout). */
-  async callRemoteInMemory(runId, seq, step, input, transport) {
+  async callRemoteInMemory(runId, seq, step, input, transport, group = stepGroup(step, void 0)) {
     if (this.pool.size === 0) throw new Error("remote steps require a Transport");
-    await this.ensureRoutable(tenantGroup(sanitizeQueueToken(step.name), step.partition), step.requires);
+    await this.ensureRoutable(group, step.requires);
     const validInput = step.input ? step.input.parse(input) : input;
     const id = stepId(runId, seq);
     const enqueuedAt = /* @__PURE__ */ new Date();
@@ -5268,7 +5311,7 @@ var WorkflowEngine = class {
         seq,
         name: step.name,
         stepId: id,
-        group: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+        group,
         input: validInput,
         traceparent: this.traceparent?.(),
         context: this.context?.(),
@@ -5287,7 +5330,7 @@ var WorkflowEngine = class {
           output,
           events: resolution.events,
           attempts: attempt,
-          workerGroup: tenantGroup(sanitizeQueueToken(step.name), step.partition),
+          workerGroup: group,
           enqueuedAt,
           startedAt
         });
@@ -5615,6 +5658,43 @@ __name(collectMetrics, "collectMetrics");
 
 // src/scheduler.ts
 import { createRequire } from "node:module";
+
+// src/cron-compat.ts
+function isIndexable(value) {
+  return typeof value === "object" && value !== null || typeof value === "function";
+}
+__name(isIndexable, "isIndexable");
+function unwrapDefault(module_) {
+  if (!isIndexable(module_)) return module_;
+  if (Reflect.get(module_, "parseExpression") !== void 0) return module_;
+  if (Reflect.get(module_, "CronExpressionParser") !== void 0) return module_;
+  const inner = Reflect.get(module_, "default");
+  return inner === void 0 ? module_ : inner;
+}
+__name(unwrapDefault, "unwrapDefault");
+function v4Entry(module_) {
+  if (!isIndexable(module_)) return void 0;
+  const parse = Reflect.get(module_, "parseExpression");
+  if (typeof parse !== "function") return void 0;
+  return (expr, options) => parse.call(module_, expr, options);
+}
+__name(v4Entry, "v4Entry");
+function v5Entry(module_) {
+  if (!isIndexable(module_)) return void 0;
+  const parser = Reflect.get(module_, "CronExpressionParser");
+  if (!isIndexable(parser)) return void 0;
+  const parse = Reflect.get(parser, "parse");
+  if (typeof parse !== "function") return void 0;
+  return (expr, options) => parse.call(parser, expr, options);
+}
+__name(v5Entry, "v5Entry");
+function resolveCronParse(module_) {
+  const resolved = unwrapDefault(module_);
+  return v4Entry(resolved) ?? v5Entry(resolved);
+}
+__name(resolveCronParse, "resolveCronParse");
+
+// src/scheduler.ts
 var nodeRequire = createRequire(import.meta.url);
 var defaultSleep = /* @__PURE__ */ __name((ms) => new Promise((r) => setTimeout(r, ms)), "defaultSleep");
 function scheduledRunId(key, everyMs, nowMs) {
@@ -5623,7 +5703,7 @@ function scheduledRunId(key, everyMs, nowMs) {
 __name(scheduledRunId, "scheduledRunId");
 var cronParser;
 function loadCronParser() {
-  if (cronParser) return cronParser;
+  if (cronParser !== void 0) return cronParser;
   try {
     cronParser = nodeRequire("cron-parser");
   } catch {
@@ -5633,12 +5713,14 @@ function loadCronParser() {
 }
 __name(loadCronParser, "loadCronParser");
 function prevCronFireMs(expr, nowMs, timezone = "UTC") {
-  const parser = loadCronParser();
-  const it = parser.parseExpression(expr, {
+  const parse = resolveCronParse(loadCronParser());
+  if (!parse) {
+    throw new Error(`the installed "cron-parser" exposes neither v4's parseExpression nor v5's CronExpressionParser.parse \u2014 the supported range is ^4.0.0 || ^5.0.0.`);
+  }
+  return parse(expr, {
     currentDate: new Date(nowMs + 1),
     tz: timezone
-  });
-  return it.prev().toDate().getTime();
+  }).prev().toDate().getTime();
 }
 __name(prevCronFireMs, "prevCronFireMs");
 function scheduleRunIdAt(s, nowMs) {