@dudousxd/nestjs-durable-core 0.54.0 → 0.55.1

package/dist/index.d.cts

@@ -1162,6 +1162,15 @@ interface Transport {
      * transports that don't partition simply omit it.
      */
     useNamespace?(namespace: string): void;
+    /**
+     * A SIBLING transport on the same broker/connection, pinned to `namespace` (explicit — never
+     * re-scoped by a later {@link useNamespace}). Powers the tenant-worker bridge preset
+     * (`topology: { role: 'control-plane', tenant, tenantWorkers: 'bridge' }`): a tenant-scoped
+     * operator pairs its namespaced primary with `withNamespace('default')` — a bare-prefix sibling —
+     * so operator-convention tenant workers (`<group>@<tenant>` under the bare prefix) are
+     * discoverable and dispatchable. Optional — transports that don't partition simply omit it.
+     */
+    withNamespace?(namespace: string): Transport;
     /** Release the transport's resources (broker workers, queues, connections) for a clean shutdown.
      *  Optional — an in-process transport has nothing to close. Called on `onApplicationShutdown`
      *  after the engine drains, so a deploy hands off instead of leaving the broker to time out. */
@@ -2618,6 +2627,19 @@ declare class WorkflowEngine {
      * knowing about the child feature.
      */
     private notifyParent;
+    /**
+     * Deferred child start shared by the in-process ctx host and the remote `startChild` command.
+     * Deferred (microtask) so a fast child can't reentrantly resume a still-suspending parent. A start
+     * that THROWS (unregistered/unroutable workflow, input validation, singleton back-pressure, store
+     * failure) must NOT be swallowed: the parent is already suspended on `child:<childId>` (the waiter
+     * is put BEFORE start on every path), so a silent drop parks it in suspended-forever, invisibly
+     * re-attempting on every recovery wake — a misconfigured remote child looks exactly like a healthy
+     * long wait. Instead the failure is delivered to that waiter like a failed child (notifyParent):
+     * the parent resumes and fails loudly with the cause. For a fire-and-forget `ctx.startChild`
+     * (spawn — no waiter) the completion is buffered; a later join by the same id consumes it and
+     * correctly observes the failed start.
+     */
+    private startChildDeferred;
     /**
      * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
      * `{ compensate: true }` to undo the saga first: the suspended run is resumed so its completed

package/dist/index.d.ts

@@ -1162,6 +1162,15 @@ interface Transport {
      * transports that don't partition simply omit it.
      */
     useNamespace?(namespace: string): void;
+    /**
+     * A SIBLING transport on the same broker/connection, pinned to `namespace` (explicit — never
+     * re-scoped by a later {@link useNamespace}). Powers the tenant-worker bridge preset
+     * (`topology: { role: 'control-plane', tenant, tenantWorkers: 'bridge' }`): a tenant-scoped
+     * operator pairs its namespaced primary with `withNamespace('default')` — a bare-prefix sibling —
+     * so operator-convention tenant workers (`<group>@<tenant>` under the bare prefix) are
+     * discoverable and dispatchable. Optional — transports that don't partition simply omit it.
+     */
+    withNamespace?(namespace: string): Transport;
     /** Release the transport's resources (broker workers, queues, connections) for a clean shutdown.
      *  Optional — an in-process transport has nothing to close. Called on `onApplicationShutdown`
      *  after the engine drains, so a deploy hands off instead of leaving the broker to time out. */
@@ -2618,6 +2627,19 @@ declare class WorkflowEngine {
      * knowing about the child feature.
      */
     private notifyParent;
+    /**
+     * Deferred child start shared by the in-process ctx host and the remote `startChild` command.
+     * Deferred (microtask) so a fast child can't reentrantly resume a still-suspending parent. A start
+     * that THROWS (unregistered/unroutable workflow, input validation, singleton back-pressure, store
+     * failure) must NOT be swallowed: the parent is already suspended on `child:<childId>` (the waiter
+     * is put BEFORE start on every path), so a silent drop parks it in suspended-forever, invisibly
+     * re-attempting on every recovery wake — a misconfigured remote child looks exactly like a healthy
+     * long wait. Instead the failure is delivered to that waiter like a failed child (notifyParent):
+     * the parent resumes and fails loudly with the cause. For a fire-and-forget `ctx.startChild`
+     * (spawn — no waiter) the completion is buffered; a later join by the same id consumes it and
+     * correctly observes the failed start.
+     */
+    private startChildDeferred;
     /**
      * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
      * `{ compensate: true }` to undo the saga first: the suspended run is resumed so its completed

package/dist/index.js

@@ -1099,6 +1099,21 @@ var TransportPool = class {
     ];
   }
   /**
+  * The first transport (in pool order) reporting a LIVE heartbeat for `group` — the one a
+  * convention-routed remote workflow must dispatch on. In a mixed pool (e.g. a tenant-scoped
+  * control plane pairing its namespaced transport with a bare-prefix one for operator-convention
+  * tenant workers), each transport sees a DIFFERENT keyspace: dispatching on `primary` while the
+  * live worker heartbeats on another transport parks the task on a queue nobody consumes. Returns
+  * `undefined` when no transport reports the group (mirrors the merged `listWorkerGroups` miss).
+  */
+  async transportWithLiveGroup(group) {
+    for (const { transport } of this.transports) {
+      if (!transport.listWorkerGroups) continue;
+      if ((await transport.listWorkerGroups()).includes(group)) return transport;
+    }
+    return void 0;
+  }
+  /**
   * Propagate the engine's `namespace` to every transport that partitions by it — so the same
   * namespace that scopes the store also scopes each transport's queues/keys. A transport that
   * doesn't partition (no `useNamespace`) is skipped. Idempotent; a transport given an explicit
@@ -2414,10 +2429,10 @@ var WorkflowEngine = class {
   * liveness changes between calls, exactly as {@link synthesizeRemoteChild} does.
   */
   async resolveRemoteByConvention(run) {
-    const liveGroups = await this.pool.listWorkerGroups();
     const group = tenantGroup(sanitizeQueueToken(run.workflow), run.namespace);
-    if (!liveGroups.includes(group)) return void 0;
-    const executor = new RemoteWorkflowExecutor(this.pool.primary, run.workflow, run.namespace);
+    const liveTransport = await this.pool.transportWithLiveGroup(group);
+    if (!liveTransport) return void 0;
+    const executor = new RemoteWorkflowExecutor(liveTransport, run.workflow, run.namespace);
     return {
       name: run.workflow,
       version: run.workflowVersion,
@@ -3036,6 +3051,27 @@ var WorkflowEngine = class {
     void this.signal(`child:${runId}`, completion).catch(() => void 0);
   }
   /**
+  * Deferred child start shared by the in-process ctx host and the remote `startChild` command.
+  * Deferred (microtask) so a fast child can't reentrantly resume a still-suspending parent. A start
+  * that THROWS (unregistered/unroutable workflow, input validation, singleton back-pressure, store
+  * failure) must NOT be swallowed: the parent is already suspended on `child:<childId>` (the waiter
+  * is put BEFORE start on every path), so a silent drop parks it in suspended-forever, invisibly
+  * re-attempting on every recovery wake — a misconfigured remote child looks exactly like a healthy
+  * long wait. Instead the failure is delivered to that waiter like a failed child (notifyParent):
+  * the parent resumes and fails loudly with the cause. For a fire-and-forget `ctx.startChild`
+  * (spawn — no waiter) the completion is buffered; a later join by the same id consumes it and
+  * correctly observes the failed start.
+  */
+  startChildDeferred(workflow, input, childId, opts) {
+    queueMicrotask(() => void this.start(workflow, input, childId, opts).catch((err) => {
+      const message = err instanceof Error ? err.message : String(err);
+      this.notifyParent(childId, {
+        ok: false,
+        error: `child workflow "${workflow}" failed to start: ${message}`
+      });
+    }));
+  }
+  /**
   * Cancel a run (e.g. from the dashboard). Returns null if the run does not exist. Pass
   * `{ compensate: true }` to undo the saga first: the suspended run is resumed so its completed
   * steps' compensations run in reverse (visible as `compensate:<step>` events), then it's marked
@@ -3859,9 +3895,9 @@ var WorkflowEngine = class {
           parallelGroup: cmd.parallelGroup
         });
         if (!await this.store.getRun(childId)) {
-          queueMicrotask(() => void this.start(cmd.workflow, cmd.input, childId, {
+          this.startChildDeferred(cmd.workflow, cmd.input, childId, {
             namespace: run.namespace
-          }).catch(() => void 0));
+          });
         }
       } else {
         throw new Error(`remote workflow command '${cmd.kind}' is not supported yet`);
@@ -4240,10 +4276,10 @@ var WorkflowEngine = class {
       // `davi-local` pipeline would stamp its `processing` child `default` and it would leak off the
       // tenant's worker pool onto the shared/dev workers.
       startChild: /* @__PURE__ */ __name((workflow, input, id, priority) => {
-        queueMicrotask(() => void this.start(workflow, input, id, {
+        this.startChildDeferred(workflow, input, id, {
           priority,
           namespace: parentNamespace
-        }).catch(() => void 0));
+        });
       }, "startChild"),
       // Deferred for the same reentrancy reason as `startChild` above. `cancel()` is already
       // idempotent on a terminal/cancelled run (returns its existing status without side effects), so