@dudousxd/nestjs-durable 0.30.1 → 0.31.0

package/dist/index.cjs

@@ -56,6 +56,7 @@ __export(index_exports, {
   ThinWorkflowRegistrar: () => ThinWorkflowRegistrar,
   WORKFLOW_METADATA: () => WORKFLOW_METADATA,
   Workflow: () => Workflow,
+  WorkflowEngine: () => import_nestjs_durable_core13.WorkflowEngine,
   WorkflowService: () => WorkflowService,
   entityConfigFor: () => entityConfigFor,
   getDurableStepMeta: () => getDurableStepMeta,
@@ -87,6 +88,7 @@ function Workflow(options) {
       executionTimeout: options.executionTimeout,
       inputSchema: options.inputSchema,
       validateInput: options.validateInput,
+      searchAttributes: options.searchAttributes,
       onEvent: options.onEvent,
       debounce: options.debounce,
       batch: options.batch
@@ -501,6 +503,9 @@ function unavailableRunGateway() {
     listRuns(_query) {
       return tenantGatewayUnavailable("listRuns");
     },
+    waitingFor(_runIds) {
+      return tenantGatewayUnavailable("waitingFor");
+    },
     workerHealth() {
       return tenantGatewayUnavailable("workerHealth");
     },
@@ -516,6 +521,9 @@ function unavailableRunGateway() {
     retryWithInput(_runId, _input) {
       return tenantGatewayUnavailable("retryWithInput");
     },
+    redispatchPending(_runId) {
+      return tenantGatewayUnavailable("redispatchPending");
+    },
     subscribe(_runId, _onEvent) {
       throw new Error("RunGateway.subscribe() is not available \u2014 pass `transport` to use RunGateway.");
     }
@@ -915,6 +923,14 @@ var ProxyRunGateway = class {
       kind: "workerHealth"
     });
   }
+  /** Bulk, one request for the whole id list (like `listRuns`, not one request per id). The operator
+  *  filters the reply to runs this tenant actually owns (see `RunRequestResponder`). */
+  waitingFor(runIds) {
+    return this.request({
+      kind: "waitingFor",
+      runIds
+    });
+  }
   cancel(runId, opts) {
     return this.request(opts === void 0 ? {
       kind: "cancel",
@@ -944,6 +960,12 @@ var ProxyRunGateway = class {
       input
     });
   }
+  redispatchPending(runId) {
+    return this.request({
+      kind: "redispatch",
+      runId
+    });
+  }
   subscribe(runId, onEvent) {
     const unsubscribe = this.transport.onTenantEvent?.(this.tenant, (evt) => {
       if (evt.event.runId === runId) onEvent(evt.event);
@@ -1122,6 +1144,27 @@ var RunRequestResponder = class {
         }
       };
     }
+    if (body.kind === "waitingFor") {
+      const all = await this.gateway.waitingFor(body.runIds);
+      const owned = await Promise.all(Object.entries(all).map(async ([runId, waiting]) => {
+        const runDetail = await this.gateway.getRunDetail(runId);
+        return runDetail && runDetail.run.namespace === msg.tenant ? [
+          runId,
+          waiting
+        ] : void 0;
+      }));
+      const data = {};
+      for (const entry of owned) {
+        if (entry) data[entry[0]] = entry[1];
+      }
+      return {
+        requestId: msg.requestId,
+        result: {
+          ok: true,
+          data
+        }
+      };
+    }
     const detail = await this.gateway.getRunDetail(body.runId);
     if (detail && detail.run.namespace !== msg.tenant) {
       return {
@@ -1175,6 +1218,8 @@ var RunRequestResponder = class {
         return this.gateway.continue(body.runId);
       case "retryWithInput":
         return this.gateway.retryWithInput(body.runId, body.input);
+      case "redispatch":
+        return this.gateway.redispatchPending(body.runId);
     }
   }
 };
@@ -1238,6 +1283,36 @@ var StoreRunGateway = class {
       } : run;
     });
   }
+  /**
+  * Bulk-resolve what each of `runIds` is currently parked on — for a consumer with its own filtered/
+  * paginated run listing (e.g. "which of MY suspended runs are stuck at a breakpoint") without
+  * re-deriving `listRuns`' waiter scan or querying `durable_step_checkpoints` directly. Mirrors
+  * `listRuns`' waiting computation (the SAME bulk signal-waiter scan + `resolveRunWaiting`), but ALSO
+  * bulk-fetches the currently-suspended runs to check real status: `engine.cancel` (the non-compensate
+  * path) doesn't clear a run's signal waiter row, so a cancelled run can leave an ORPHANED waiter
+  * behind — trusting waiter presence alone would wrongly report a terminal run as still waiting.
+  * Two bulk scans total (never one query per requested id), same as `listRuns`.
+  */
+  async waitingFor(runIds) {
+    if (runIds.length === 0) return {};
+    const idSet = new Set(runIds);
+    const [suspended, waiters] = await Promise.all([
+      this.store.listRuns({
+        statuses: [
+          "suspended"
+        ]
+      }),
+      this.store.listSignalWaiters("")
+    ]);
+    const waiterByRun = (0, import_nestjs_durable_core8.indexWaitersByRun)(waiters);
+    const result = {};
+    for (const run of suspended) {
+      if (!idSet.has(run.id)) continue;
+      const waiting = (0, import_nestjs_durable_core8.resolveRunWaiting)(run, waiterByRun);
+      if (waiting) result[run.id] = waiting;
+    }
+    return result;
+  }
   /** Every group the engine knows about — unscoped. A tenant proxy's request is scoped by the
   *  `RunRequestResponder` (to the requester's `@<tenant>` groups); the operator's own UI sees all. */
   workerHealth() {
@@ -1256,6 +1331,9 @@ var StoreRunGateway = class {
   retryWithInput(runId, input) {
     return this.engine.retryWithInput(runId, input);
   }
+  redispatchPending(runId) {
+    return this.engine.redispatchPending(runId);
+  }
   subscribe(runId, onEvent) {
     return this.engine.subscribe((event) => {
       if (event.runId === runId) onEvent(event);
@@ -1526,6 +1604,7 @@ var WorkflowRegistrar = class {
         singleton: meta.singleton,
         executionTimeout: meta.executionTimeout,
         validateInput,
+        searchAttributesSchema: meta.searchAttributes,
         onEvent: getOnEvents(meta, workflowCtor),
         eventBatch,
         // Uniform dispatch (opt-in): when an in-app worker is configured, register the body GROUP-SERVED
@@ -1758,6 +1837,47 @@ function assertValidRole(options) {
   }
 }
 __name(assertValidRole, "assertValidRole");
+function assertValidTopology(options) {
+  const topology = options.topology;
+  if (topology === void 0) return;
+  if (topology.role === "control-plane") {
+    if (options.store === void 0 || options.transport === void 0 && options.transports === void 0) {
+      throw new Error("topology: { role: 'control-plane' } needs `store` AND (`transport` or `transports`).\nA control-plane node is the durable operator: it owns the state store and dispatches runs to workers over a transport \u2014 without both, there is nothing for it to operate.");
+    }
+    if (options.partition !== void 0) {
+      throw new Error("topology: { role: 'control-plane' } forbids `partition`.\npartition is the WORKER queue-routing suffix \u2014 on a control-plane node, runs are dispatched to tenant partitions via each run's namespace, not via this option. Set `partition` (or `topology: { role: 'tenant', tenant }`) on the WORKER node instead.");
+    }
+    if ("tenant" in topology) {
+      throw new Error("topology: { role: 'control-plane' } forbids a `tenant` field.\ntenant names a WORKER's isolation partition \u2014 a control-plane node serves every tenant's runs (via their namespace), it isn't scoped to one itself.");
+    }
+    return;
+  }
+  if (options.connection === void 0) {
+    throw new Error(`topology: { role: 'tenant', tenant: '${topology.tenant}' } needs \`connection\`.
+A tenant is a store-less worker: it connects to the broker directly to pull its own partition of tasks instead of polling a store it does not have.`);
+  }
+  if (options.store !== void 0) {
+    throw new Error("topology: { role: 'tenant' } forbids `store`.\nA tenant is store-less BY DEFINITION \u2014 a `store` present means you actually wanted `topology: { role: 'control-plane' }` (the store-owning role).");
+  }
+  if (options.namespace !== void 0) {
+    throw new Error("topology: { role: 'tenant' } forbids `namespace`.\nnamespace is the OPERATOR's poll-scoping axis (which runs a control-plane instance drives/recovers/resumes) \u2014 a tenant worker has no poll loop for it to scope. Use this preset's `tenant` field for the worker's own routing axis instead.");
+  }
+  if (options.partition !== void 0 && options.partition !== topology.tenant) {
+    throw new Error(`topology: { role: 'tenant', tenant: '${topology.tenant}' } conflicts with \`partition: '${options.partition}'\`.
+tenant maps 1:1 onto partition (the worker queue-routing suffix) \u2014 set only \`tenant\`, or set \`partition\` to the same value.`);
+  }
+}
+__name(assertValidTopology, "assertValidTopology");
+function resolveTopology(options) {
+  const topology = options.topology;
+  if (topology === void 0 || topology.role !== "tenant") return options;
+  if (options.partition !== void 0) return options;
+  return {
+    ...options,
+    partition: topology.tenant
+  };
+}
+__name(resolveTopology, "resolveTopology");
 var RunGatewayBootstrap = class RunGatewayBootstrap2 {
   static {
     __name(this, "RunGatewayBootstrap");
@@ -1818,10 +1938,10 @@ var DurableModule = class _DurableModule {
     __name(this, "DurableModule");
   }
   static forRoot(options) {
-    assertValidRole(options);
+    _DurableModule.assertValid(options);
     return _DurableModule.build({
       provide: import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
-      useValue: options
+      useValue: resolveTopology(options)
     });
   }
   static forRootAsync(options) {
@@ -1829,12 +1949,26 @@ var DurableModule = class _DurableModule {
       provide: import_nestjs_durable_core12.DURABLE_OPTIONS_CANONICAL,
       useFactory: /* @__PURE__ */ __name(async (...args) => {
         const resolved = await options.useFactory(...args);
-        assertValidRole(resolved);
-        return resolved;
+        _DurableModule.assertValid(resolved);
+        return resolveTopology(resolved);
       }, "useFactory"),
       inject: options.inject ?? []
     });
   }
+  /**
+  * Validates role/axis constraints, in resolution order. When {@link DurableModuleOptions.topology}
+  * is set, it OWNS validation — {@link assertValidTopology}'s own store/transport/connection checks
+  * are strictly stronger than {@link assertValidRole}'s, so the topology-specific, axis-teaching
+  * message is what a `topology`-opted-in consumer sees (not the older generic one). Falls back to
+  * {@link assertValidRole} unchanged when `topology` is absent — zero behavior change.
+  */
+  static assertValid(options) {
+    if (options.topology !== void 0) {
+      assertValidTopology(options);
+      return;
+    }
+    assertValidRole(options);
+  }
   static build(optionsProvider) {
     return {
       module: _DurableModule,
@@ -1976,6 +2110,9 @@ var DurableModule = class _DurableModule {
 DurableModule = _ts_decorate12([
   (0, import_common12.Module)({})
 ], DurableModule);
+
+// src/index.ts
+var import_nestjs_durable_core13 = require("@dudousxd/nestjs-durable-core");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CONTEXT_ACCESSOR,
@@ -2013,6 +2150,7 @@ DurableModule = _ts_decorate12([
   ThinWorkflowRegistrar,
   WORKFLOW_METADATA,
   Workflow,
+  WorkflowEngine,
   WorkflowService,
   entityConfigFor,
   getDurableStepMeta,