@dudousxd/nestjs-durable 0.43.1 → 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,
@@ -1737,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
@@ -2434,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,