@dudousxd/nestjs-durable 0.43.0 → 0.43.2

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
@@ -16,6 +18,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -25,6 +35,7 @@ __export(index_exports, {
   DEAD_LETTER_METADATA: () => DEAD_LETTER_METADATA,
   DURABLE_STEP_METADATA: () => DURABLE_STEP_METADATA,
   DURABLE_WORKER_RUNNERS: () => DURABLE_WORKER_RUNNERS,
+  DURABLE_WORKER_RUNTIME: () => DURABLE_WORKER_RUNTIME,
   DeadLetter: () => DeadLetter,
   DurableModule: () => DurableModule,
   DurableStartClient: () => DurableStartClient,
@@ -313,9 +324,29 @@ function attributesOf(workflow, run) {
 __name(attributesOf, "attributesOf");
 
 // src/durable-start-client.ts
-var import_durable_worker = require("@dudousxd/durable-worker");
 var import_nestjs_durable_core3 = require("@dudousxd/nestjs-durable-core");
 var import_common = require("@nestjs/common");
+
+// src/worker-sdk.ts
+async function workerSdk() {
+  try {
+    return await import("@dudousxd/durable-worker");
+  } catch (cause) {
+    throw new Error("@dudousxd/durable-worker is not installed. It is an optional peer needed only by the roles that run workflow bodies (`connection` set on DurableModule.forRoot) \u2014 install it, or drop `connection`.", {
+      cause
+    });
+  }
+}
+__name(workerSdk, "workerSdk");
+var startRun = /* @__PURE__ */ __name(async (connection, options) => (await workerSdk()).startRun(connection, options), "startRun");
+var runRedisWorker = /* @__PURE__ */ __name(async (options) => (await workerSdk()).runRedisWorker(options), "runRedisWorker");
+async function createWorkerRuntime(options) {
+  const { DurableWorkerRuntime: Runtime } = await workerSdk();
+  return new Runtime(options);
+}
+__name(createWorkerRuntime, "createWorkerRuntime");
+
+// src/durable-start-client.ts
 function _ts_decorate(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -341,7 +372,7 @@ var DurableStartClient = class {
   }
   async start(workflow, input, runId = globalThis.crypto.randomUUID(), opts) {
     const name = (0, import_nestjs_durable_core3.workflowName)(workflow);
-    await (0, import_durable_worker.startRun)(this.options.connection, {
+    await startRun(this.options.connection, {
       tenant: this.tenant,
       workflow: name,
       input,
@@ -408,7 +439,6 @@ function tenantUnsupported(method) {
 __name(tenantUnsupported, "tenantUnsupported");
 
 // src/durable-worker.module.ts
-var import_durable_worker2 = require("@dudousxd/durable-worker");
 var import_nestjs_durable_core4 = require("@dudousxd/nestjs-durable-core");
 var import_common2 = require("@nestjs/common");
 var import_core = require("@nestjs/core");
@@ -469,6 +499,7 @@ function _ts_param(paramIndex, decorator) {
 }
 __name(_ts_param, "_ts_param");
 var RUN_REDIS_WORKER = Symbol("nestjs-durable:run-redis-worker");
+var DURABLE_WORKER_RUNTIME = Symbol("nestjs-durable:worker-runtime");
 var DURABLE_WORKER_RUNNERS = Symbol("nestjs-durable:worker-runners");
 function isPureThinWorker(options) {
   return options.store === void 0 && options.connection !== void 0;
@@ -487,8 +518,9 @@ var ThinWorkflowRegistrar = class {
     this.options = options;
   }
   onModuleInit() {
-    if (!isPureThinWorker(this.options)) return;
-    scanWorkflows(this.discovery, (meta, instance, origin) => this.runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input), {
+    const runtime = this.runtime;
+    if (runtime === null || !isPureThinWorker(this.options)) return;
+    scanWorkflows(this.discovery, (meta, instance, origin) => runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input), {
       version: meta.version,
       ...meta.requires !== void 0 ? {
         requires: meta.requires
@@ -501,11 +533,12 @@ var ThinWorkflowRegistrar = class {
 };
 ThinWorkflowRegistrar = _ts_decorate2([
   (0, import_common2.Injectable)(),
+  _ts_param(1, (0, import_common2.Inject)(DURABLE_WORKER_RUNTIME)),
   _ts_param(2, (0, import_common2.Inject)(import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
-    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinWorkflowRegistrar);
@@ -524,18 +557,20 @@ var ThinStepRegistrar = class {
     this.options = options;
   }
   onModuleInit() {
-    if (!isPureThinWorker(this.options)) return;
-    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => this.runtime.registerStep(meta.name, handler));
+    const runtime = this.runtime;
+    if (runtime === null || !isPureThinWorker(this.options)) return;
+    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => runtime.registerStep(meta.name, handler));
   }
 };
 ThinStepRegistrar = _ts_decorate2([
   (0, import_common2.Injectable)(),
+  _ts_param(2, (0, import_common2.Inject)(DURABLE_WORKER_RUNTIME)),
   _ts_param(3, (0, import_common2.Inject)(import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
     typeof import_core.DiscoveryService === "undefined" ? Object : import_core.DiscoveryService,
     typeof import_core.MetadataScanner === "undefined" ? Object : import_core.MetadataScanner,
-    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions
   ])
 ], ThinStepRegistrar);
@@ -548,17 +583,18 @@ var ThinWorkerBootstrap = class {
   runRedisWorker;
   runnersSink;
   runners = [];
-  constructor(runtime, options, runRedisWorker, runnersSink) {
+  constructor(runtime, options, runRedisWorker2, runnersSink) {
     this.runtime = runtime;
     this.options = options;
-    this.runRedisWorker = runRedisWorker;
+    this.runRedisWorker = runRedisWorker2;
     this.runnersSink = runnersSink;
   }
   async onApplicationBootstrap() {
     const options = this.options;
-    if (!isPureThinWorker(options) || options.connection === void 0) return;
+    const runtime = this.runtime;
+    if (runtime === null || !isPureThinWorker(options) || options.connection === void 0) return;
     const handle = await this.runRedisWorker({
-      runtime: this.runtime,
+      runtime,
       connection: options.connection,
       ...options.partition !== void 0 ? {
         partition: options.partition
@@ -582,12 +618,13 @@ var ThinWorkerBootstrap = class {
 };
 ThinWorkerBootstrap = _ts_decorate2([
   (0, import_common2.Injectable)(),
+  _ts_param(0, (0, import_common2.Inject)(DURABLE_WORKER_RUNTIME)),
   _ts_param(1, (0, import_common2.Inject)(import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL)),
   _ts_param(2, (0, import_common2.Inject)(RUN_REDIS_WORKER)),
   _ts_param(3, (0, import_common2.Inject)(DURABLE_WORKER_RUNNERS)),
   _ts_metadata2("design:type", Function),
   _ts_metadata2("design:paramtypes", [
-    typeof import_durable_worker2.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker2.DurableWorkerRuntime,
+    Object,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
     typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
     Array
@@ -596,7 +633,7 @@ ThinWorkerBootstrap = _ts_decorate2([
 function thinWorkerProviders() {
   return [
     {
-      provide: import_durable_worker2.DurableWorkerRuntime,
+      provide: DURABLE_WORKER_RUNTIME,
       // The runtime's `WorkflowWorker` falls back to its own `group` ctor param as the WORKFLOW's
       // `workflowPartition` for any `ctx.step` call (see `workflow-context.ts`'s `resolveCallGroup`)
       // — that fallback MUST equal this module's own `partition`, or a dispatched step's decision
@@ -604,16 +641,20 @@ function thinWorkerProviders() {
       // to. Explicit `''` (never
       // `undefined`) so it does NOT fall through to `WorkflowWorker`'s unrelated `'workflows'`
       // default parameter.
-      useFactory: /* @__PURE__ */ __name((options) => new import_durable_worker2.DurableWorkerRuntime({
+      //
+      // The role gate lives HERE, not just in the consumers: constructing the runtime resolves the
+      // optional `@dudousxd/durable-worker` peer, so an operator that never runs a worker must not
+      // reach this branch at all.
+      useFactory: /* @__PURE__ */ __name((options) => isPureThinWorker(options) ? createWorkerRuntime({
         workflowGroup: options.partition ?? ""
-      }), "useFactory"),
+      }) : null, "useFactory"),
       inject: [
         import_nestjs_durable_core4.DURABLE_OPTIONS_CANONICAL
       ]
     },
     {
       provide: RUN_REDIS_WORKER,
-      useValue: import_durable_worker2.runRedisWorker
+      useValue: runRedisWorker
     },
     {
       provide: DURABLE_WORKER_RUNNERS,
@@ -833,7 +874,6 @@ EntityService = _ts_decorate4([
 ], EntityService);
 
 // src/in-app-worker.ts
-var import_durable_worker3 = require("@dudousxd/durable-worker");
 var import_nestjs_durable_core7 = require("@dudousxd/nestjs-durable-core");
 var import_common5 = require("@nestjs/common");
 var import_core3 = require("@nestjs/core");
@@ -886,17 +926,18 @@ var InAppWorkerBootstrap = class {
   runRedisWorker;
   runnersSink;
   runners = [];
-  constructor(discovery, metadataScanner, options, runtime, runRedisWorker, runnersSink) {
+  constructor(discovery, metadataScanner, options, runtime, runRedisWorker2, runnersSink) {
     this.discovery = discovery;
     this.metadataScanner = metadataScanner;
     this.options = options;
     this.runtime = runtime;
-    this.runRedisWorker = runRedisWorker;
+    this.runRedisWorker = runRedisWorker2;
     this.runnersSink = runnersSink;
   }
   onModuleInit() {
-    if (!isCoLocatedWorker(this.options)) return;
-    scanWorkflows(this.discovery, (meta, instance, origin) => this.runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input), {
+    const runtime = this.runtime;
+    if (runtime === null || !isCoLocatedWorker(this.options)) return;
+    scanWorkflows(this.discovery, (meta, instance, origin) => runtime.registerWorkflow(meta.name, (ctx, input) => instance.run(ctx, input), {
       version: meta.version,
       ...meta.requires !== void 0 ? {
         requires: meta.requires
@@ -905,13 +946,14 @@ var InAppWorkerBootstrap = class {
         origin
       } : {}
     }));
-    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => this.runtime.registerStep(meta.name, handler));
+    scanSteps(this.discovery, this.metadataScanner, (meta, handler) => runtime.registerStep(meta.name, handler));
   }
   async onApplicationBootstrap() {
     const options = this.options;
-    if (!isCoLocatedWorker(options) || options.connection === void 0) return;
+    const runtime = this.runtime;
+    if (runtime === null || !isCoLocatedWorker(options) || options.connection === void 0) return;
     const handle = await this.runRedisWorker({
-      runtime: this.runtime,
+      runtime,
       connection: options.connection,
       ...options.partition !== void 0 ? {
         partition: options.partition
@@ -944,7 +986,7 @@ InAppWorkerBootstrap = _ts_decorate5([
     typeof import_core3.DiscoveryService === "undefined" ? Object : import_core3.DiscoveryService,
     typeof import_core3.MetadataScanner === "undefined" ? Object : import_core3.MetadataScanner,
     typeof DurableModuleOptions === "undefined" ? Object : DurableModuleOptions,
-    typeof import_durable_worker3.DurableWorkerRuntime === "undefined" ? Object : import_durable_worker3.DurableWorkerRuntime,
+    Object,
     typeof RunRedisWorkerFn === "undefined" ? Object : RunRedisWorkerFn,
     Array
   ])
@@ -968,16 +1010,20 @@ function inAppWorkerProviders() {
       // to. Explicit `''` (never
       // `undefined`) so it does NOT fall through to `WorkflowWorker`'s unrelated `'workflows'`
       // default parameter.
-      useFactory: /* @__PURE__ */ __name((options) => new import_durable_worker3.DurableWorkerRuntime({
+      //
+      // The role gate lives HERE, not just in the consumer: constructing the runtime resolves the
+      // optional `@dudousxd/durable-worker` peer, so an operator that never runs a worker must not
+      // reach this branch at all.
+      useFactory: /* @__PURE__ */ __name((options) => isCoLocatedWorker(options) ? createWorkerRuntime({
         workflowGroup: options.partition ?? ""
-      }), "useFactory"),
+      }) : null, "useFactory"),
       inject: [
         import_nestjs_durable_core7.DURABLE_OPTIONS_CANONICAL
       ]
     },
     {
       provide: IN_APP_RUN_REDIS_WORKER,
-      useValue: import_durable_worker3.runRedisWorker
+      useValue: runRedisWorker
     },
     {
       provide: IN_APP_WORKER_RUNNERS,
@@ -1238,6 +1284,15 @@ var RetentionPoller = class {
   onModuleDestroy() {
     if (this.timer) clearInterval(this.timer);
   }
+  /**
+  * Prune one round.
+  *
+  * Never rejects, for the same reason {@link TimerPoller.poll} does not: it is awaited inside
+  * `onApplicationBootstrap` (so a rejection propagates into the host's `bootstrap()` and kills the
+  * process) and fired as `void` on the interval (so a rejection is an unhandled one, also fatal).
+  * Pruning history is the least urgent thing this package does — a `pruneTerminalRuns` that fails
+  * on a locked table must cost this sweep and nothing more.
+  */
   async sweep() {
     if (this.sweeping) return;
     const retention = this.options.retention;
@@ -1254,6 +1309,8 @@ var RetentionPoller = class {
           if (deleted < batchSize) break;
         }
       }
+    } catch (error) {
+      console.error("[nestjs-durable] retention sweep failed; retrying next interval:", error);
     } finally {
       this.sweeping = false;
     }
@@ -1648,7 +1705,11 @@ var TimerPoller = class {
   }
   async onApplicationBootstrap() {
     if (!isDrivingOperator(this.options)) return;
-    this.unsubscribeEnqueued = this.engine.onEnqueued((runId) => void this.engine.runOne(runId));
+    this.unsubscribeEnqueued = this.engine.onEnqueued((runId) => {
+      void this.engine.runOne(runId).catch((error) => {
+        console.error(`[nestjs-durable] could not run enqueued run ${runId}:`, error);
+      });
+    });
     await this.poll();
     const intervalMs = this.options.timerPollMs ?? 1e3;
     if (intervalMs > 0) {
@@ -1660,22 +1721,45 @@ var TimerPoller = class {
     if (this.timer) clearInterval(this.timer);
     this.unsubscribeEnqueued?.();
   }
+  /**
+  * One sweep of the engine's recovery work.
+  *
+  * **This method never rejects, and that is a hard requirement rather than defensiveness.** It has
+  * exactly two callers and a rejection out of either one kills the process: on boot it is awaited
+  * inside `onApplicationBootstrap`, so the rejection propagates through `NestApplication.init()`
+  * into the host's `bootstrap()`; on the interval it is a fire-and-forget `void`, so it surfaces as
+  * an unhandled rejection. Both are fatal, and both re-occur on the next boot with the same state,
+  * so a single unrecoverable run crash-loops every worker in the deployment — taking down every
+  * other workflow with it. A poll that goes wrong must cost this tick, not the pod.
+  *
+  * Each sweep is isolated separately because they are independent: a store that fails
+  * `recoverIncomplete` says nothing about whether durable timers should still fire, and skipping
+  * the rest of the tick would silently widen one subsystem's outage into all of them.
+  */
   async poll() {
     if (this.polling) return;
     this.polling = true;
     try {
-      await this.engine.runPending();
-      await this.engine.recoverIncomplete();
-      await this.engine.resumeDueTimers();
-      await this.engine.sweepTimeouts();
+      await this.sweep("runPending", () => this.engine.runPending());
+      await this.sweep("recoverIncomplete", () => this.engine.recoverIncomplete());
+      await this.sweep("resumeDueTimers", () => this.engine.resumeDueTimers());
+      await this.sweep("sweepTimeouts", () => this.engine.sweepTimeouts());
       const schedules = this.options.schedules;
       if (schedules && schedules.length > 0) {
-        await (0, import_nestjs_durable_core10.runSchedules)(this.engine, schedules, Date.now());
+        await this.sweep("schedules", () => (0, import_nestjs_durable_core10.runSchedules)(this.engine, schedules, Date.now()));
       }
     } finally {
       this.polling = false;
     }
   }
+  /** Run one sweep, absorbing and reporting its failure — see {@link poll}. */
+  async sweep(name, run) {
+    try {
+      await run();
+    } catch (error) {
+      console.error(`[nestjs-durable] timer poll: ${name} failed; continuing:`, error);
+    }
+  }
 };
 TimerPoller = _ts_decorate9([
   (0, import_common9.Injectable)(),
@@ -1699,15 +1783,15 @@ var import_core4 = require("@nestjs/core");
 
 // src/input-validation.ts
 function classValidatorInput(cls) {
-  let cv;
-  let ct;
-  try {
-    cv = require("class-validator");
-    ct = require("class-transformer");
-  } catch {
-    throw new Error('@Workflow({ inputSchema }) needs the optional peers "class-validator" and "class-transformer" \u2014 install them, or pass a `validateInput` function instead.');
-  }
   return async (input) => {
+    let cv;
+    let ct;
+    try {
+      cv = await import("class-validator");
+      ct = await import("class-transformer");
+    } catch {
+      throw new Error('@Workflow({ inputSchema }) needs the optional peers "class-validator" and "class-transformer" \u2014 install them, or pass a `validateInput` function instead.');
+    }
     const instance = ct.plainToInstance(cls, input);
     const errors = await cv.validate(instance, {
       whitelist: true
@@ -2396,6 +2480,7 @@ var import_nestjs_durable_core15 = require("@dudousxd/nestjs-durable-core");
   DEAD_LETTER_METADATA,
   DURABLE_STEP_METADATA,
   DURABLE_WORKER_RUNNERS,
+  DURABLE_WORKER_RUNTIME,
   DeadLetter,
   DurableModule,
   DurableStartClient,