@pattern-stack/codegen 0.4.2 → 0.4.4

package/CHANGELOG.md

@@ -4,6 +4,23 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.4.4] — 2026-04-23
+
+### Fixed
+
+- **`fix(jobs)` #197 — SEVERITY: silent pool-level outage.** `JobWorkerModule` was passing `def.queue` (e.g. `'jobs-crm-sync'`) as the worker's claim-filter pool, but the orchestrator writes the logical `poolName` (e.g. `'crm_sync'`) into `job_run.pool` from `@JobHandler.meta.pool`. As a result, **no job in any stack using `@JobHandler` was ever claimed by a worker** — the claim query never matched a row, zero exceptions were raised, and the pool sat idle. Every consumer of the jobs subsystem since pools-and-queues diverged was affected. Fixed by passing `poolName` as the worker's `pool`. If you ran 0.4.0–0.4.3 with `@JobHandler` handlers: any jobs enqueued in that window are still pending in `job_run` with `status='pending'` and will now claim on next worker tick.
+- **`fix(jobs)` #197 — cross-module handler DI scope.** `moduleRef.create(HandlerClass)` only instantiates within `JobWorkerModule`'s scope, so any handler with a cross-module `@Inject` dep (e.g. a sync job injecting a factory from a feature module) crashed at claim time with "not a provider of the current module". The 0.4.3 `ModuleRef` fix was necessary but not sufficient. Switched to `moduleRef.get(HandlerClass, { strict: false })` in both the Drizzle worker and the in-memory orchestrator, which walks the whole DI graph. **New hard requirement**: handler classes MUST be registered as providers in their owning `@Module`. `@JobHandler` registers with the job registry, not with Nest DI — both registrations are required. Documented in `.claude/skills/jobs/handler-authoring.md`.
+
+### Added
+
+- **`feat(events)` #198 — `type: array` payload field.** Closes a silent validation hole. Payloads with list-shaped fields had no well-typed representation; the only option was `type: json`, which emits `Record<string, unknown>` / `z.record(z.unknown())`. At publish time the runtime Zod validator rejected actual arrays, the event was dropped, and downstream `bridge_delivery` rows never landed — with no surfaced error. Now: `type: array` with a required scalar `items:` (`uuid | string | number | boolean | date`) emits `T[]` + `z.array(T)`. Nested arrays / nested json inside an array are deliberately rejected — payloads are a wire format, not an embedded schema. Consumer migration: change any list-shaped payload field from `type: json` to `type: array, items: <scalar>`, re-run `codegen events`, drop any `as unknown as Record<string, unknown>` publish-site casts.
+
+## [0.4.3] — 2026-04-22
+
+### Fixed
+- **`fix(jobs)`** — handlers are now instantiated via `ModuleRef` so `@Inject()`-annotated constructor parameters resolve correctly. Applies to both the Drizzle and in-memory job backends. Before this fix, handlers with DI-injected dependencies would fail at runtime because the worker constructed them outside Nest's container. (commits e7348cd, c685a63)
+- **`fix(bridge)` #193** — bridge registry codegen is gated on the bridge subsystem being installed (PR #192), and `bridgeHandlersDir` now resolves under `paths.backend_src` instead of hard-coding `src/jobs` (PR #194). Together these close the "stray `src/shared/subsystems/bridge/generated/registry.ts` with broken `../bridge.protocol` import" bug for both the "bridge declared in config but not installed" case and the "installed with non-default backend_src so triggers were never scanned" case.
+
 ## [0.4.1] — 2026-04-21
 
 ### Added

package/dist/runtime/subsystems/bridge/bridge.module.d.ts

@@ -1,5 +1,6 @@
 import { OnModuleInit, DynamicModule } from '@nestjs/common';
 import { JobWorkerModuleOptions } from '../jobs/job-worker.module.js';
+import '@nestjs/core';
 import '../../types/drizzle.js';
 import 'drizzle-orm/node-postgres';
 import '../jobs/jobs-domain.module.js';

package/dist/runtime/subsystems/bridge/bridge.module.js

@@ -14,7 +14,7 @@ var __decorateParam = (index4, decorator) => (target, key2) => decorator(target,
 import {
   Inject as Inject12,
   Module as Module3,
-  Optional as Optional6
+  Optional as Optional7
 } from "@nestjs/common";
 
 // runtime/subsystems/jobs/job-worker.module.ts
@@ -23,7 +23,7 @@ import {
   Injectable as Injectable8,
   Logger as Logger4,
   Module as Module2,
-  Optional
+  Optional as Optional2
 } from "@nestjs/common";
 
 // runtime/constants/tokens.ts
@@ -797,7 +797,7 @@ DrizzleJobStepService = __decorateClass([
 
 // runtime/subsystems/jobs/job-orchestrator.memory-backend.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2 } from "@nestjs/common";
+import { Inject as Inject4, Injectable as Injectable4, Logger as Logger2, Optional } from "@nestjs/common";
 var QUEUED_RUN_AT = /* @__PURE__ */ new Date(864e13);
 var TERMINAL_STATUSES2 = [
   "completed",
@@ -834,14 +834,16 @@ var PromiseMutex = class {
   }
 };
 var MemoryJobOrchestrator = class {
-  constructor(store, stepService, multiTenant) {
+  constructor(store, stepService, multiTenant, moduleRef) {
     this.store = store;
     this.stepService = stepService;
     this.multiTenant = multiTenant;
+    this.moduleRef = moduleRef;
   }
   store;
   stepService;
   multiTenant;
+  moduleRef;
   logger = new Logger2(MemoryJobOrchestrator.name);
   mutex = new PromiseMutex();
   handlerRegistry = /* @__PURE__ */ new Map();
@@ -1182,7 +1184,10 @@ var MemoryJobOrchestrator = class {
     }
     const meta = registration.meta;
     const HandlerClass = registration.handlerClass;
-    const handler = new HandlerClass();
+    const handler = this.moduleRef ? this.moduleRef.get(
+      HandlerClass,
+      { strict: false }
+    ) : new HandlerClass();
     const ctx = {
       input: run.input,
       run,
@@ -1362,7 +1367,8 @@ var MemoryJobOrchestrator = class {
 };
 MemoryJobOrchestrator = __decorateClass([
   Injectable4(),
-  __decorateParam(2, Inject4(JOBS_MULTI_TENANT))
+  __decorateParam(2, Inject4(JOBS_MULTI_TENANT)),
+  __decorateParam(3, Optional())
 ], MemoryJobOrchestrator);
 function classifyError(err, policy, currentAttempts) {
   if (!policy) return "fail";
@@ -1826,12 +1832,13 @@ function serialiseError2(err, attempt, retryable) {
   };
 }
 var JobWorker = class {
-  constructor(db, orchestrator, runService, stepService, options) {
+  constructor(db, orchestrator, runService, stepService, options, moduleRef) {
     this.db = db;
     this.orchestrator = orchestrator;
     this.runService = runService;
     this.stepService = stepService;
     this.options = options;
+    this.moduleRef = moduleRef;
     this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     this.staleSweeperIntervalMs = options.staleSweeperIntervalMs ?? DEFAULT_STALE_SWEEPER_INTERVAL_MS;
     this.staleThresholdMs = options.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
@@ -1848,6 +1855,7 @@ var JobWorker = class {
   runService;
   stepService;
   options;
+  moduleRef;
   logger = new Logger3(JobWorker.name);
   shuttingDown = false;
   inFlight = /* @__PURE__ */ new Set();
@@ -2019,7 +2027,10 @@ var JobWorker = class {
     }
     const meta = registryEntry.meta;
     const HandlerClass = registryEntry.handlerClass;
-    const handler = new HandlerClass();
+    const handler = this.moduleRef.get(
+      HandlerClass,
+      { strict: false }
+    );
     const ctx = {
       input: claimed.input,
       run: claimed,
@@ -2179,18 +2190,20 @@ JobWorker = __decorateClass([
 var DEFAULT_SHUTDOWN_TIMEOUT_MS2 = 3e4;
 var JOB_WORKER_MODULE_OPTIONS = /* @__PURE__ */ Symbol("JOB_WORKER_MODULE_OPTIONS");
 var JobWorkerOrchestrator = class {
-  constructor(orchestrator, runService, stepService, options, db = null) {
+  constructor(orchestrator, runService, stepService, options, db = null, moduleRef) {
     this.orchestrator = orchestrator;
     this.runService = runService;
     this.stepService = stepService;
     this.options = options;
     this.db = db;
+    this.moduleRef = moduleRef;
   }
   orchestrator;
   runService;
   stepService;
   options;
   db;
+  moduleRef;
   logger = new Logger4(JobWorkerOrchestrator.name);
   workers = [];
   // ============================================================================
@@ -2217,7 +2230,7 @@ var JobWorkerOrchestrator = class {
         );
       }
       const workerOptions = {
-        pool: def.queue,
+        pool: poolName,
         concurrency: def.concurrency,
         shutdownTimeoutMs: this.options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS2
       };
@@ -2225,7 +2238,7 @@ var JobWorkerOrchestrator = class {
       worker.onModuleInit();
       this.workers.push(worker);
       this.logger.log(
-        `JobWorker started: pool='${def.queue}' concurrency=${def.concurrency}`
+        `JobWorker started: pool='${poolName}' (queue='${def.queue}') concurrency=${def.concurrency}`
       );
     }
   }
@@ -2289,12 +2302,18 @@ var JobWorkerOrchestrator = class {
         `JobWorkerModule: in-process worker spawning requires the Drizzle backend (no DRIZZLE provider available). Memory-mode tests must pass 'workerFactory' to inject a stub.`
       );
     }
+    if (!this.moduleRef) {
+      throw new Error(
+        `JobWorkerModule: ModuleRef not available \u2014 cannot construct JobWorker with handler DI support. Ensure the orchestrator is resolved through the Nest container (not instantiated manually in tests).`
+      );
+    }
     return new JobWorker(
       this.db,
       this.orchestrator,
       this.runService,
       this.stepService,
-      workerOptions
+      workerOptions,
+      this.moduleRef
     );
   }
 };
@@ -2304,7 +2323,7 @@ JobWorkerOrchestrator = __decorateClass([
   __decorateParam(1, Inject7(JOB_RUN_SERVICE)),
   __decorateParam(2, Inject7(JOB_STEP_SERVICE)),
   __decorateParam(3, Inject7(JOB_WORKER_MODULE_OPTIONS)),
-  __decorateParam(4, Optional()),
+  __decorateParam(4, Optional2()),
   __decorateParam(4, Inject7(DRIZZLE))
 ], JobWorkerOrchestrator);
 var JobWorkerModule = class {
@@ -2456,7 +2475,7 @@ var MemoryBridgeDeliveryRepo = class {
 };
 
 // runtime/subsystems/bridge/bridge-delivery.drizzle-backend.ts
-import { Inject as Inject8, Injectable as Injectable9, Optional as Optional2 } from "@nestjs/common";
+import { Inject as Inject8, Injectable as Injectable9, Optional as Optional3 } from "@nestjs/common";
 import { eq as eq5, and as and5 } from "drizzle-orm";
 
 // runtime/subsystems/bridge/bridge-delivery.schema.ts
@@ -2649,16 +2668,16 @@ var DrizzleBridgeDeliveryRepo = class {
 DrizzleBridgeDeliveryRepo = __decorateClass([
   Injectable9(),
   __decorateParam(0, Inject8(DRIZZLE)),
-  __decorateParam(1, Optional2()),
+  __decorateParam(1, Optional3()),
   __decorateParam(1, Inject8(BRIDGE_MULTI_TENANT))
 ], DrizzleBridgeDeliveryRepo);
 
 // runtime/subsystems/bridge/bridge-outbox-drain-hook.ts
-import { Inject as Inject10, Injectable as Injectable11, Logger as Logger6, Optional as Optional4 } from "@nestjs/common";
+import { Inject as Inject10, Injectable as Injectable11, Logger as Logger6, Optional as Optional5 } from "@nestjs/common";
 import { randomUUID as randomUUID5 } from "crypto";
 
 // runtime/subsystems/bridge/bridge-delivery-handler.ts
-import { Inject as Inject9, Injectable as Injectable10, Logger as Logger5, Optional as Optional3 } from "@nestjs/common";
+import { Inject as Inject9, Injectable as Injectable10, Logger as Logger5, Optional as Optional4 } from "@nestjs/common";
 
 // runtime/subsystems/events/events.tokens.ts
 var EVENT_BUS = "EVENT_BUS";
@@ -2751,7 +2770,7 @@ BridgeDeliveryHandler = __decorateClass([
   __decorateParam(1, Inject9(JOB_ORCHESTRATOR)),
   __decorateParam(2, Inject9(EVENT_BUS)),
   __decorateParam(3, Inject9(BRIDGE_REGISTRY)),
-  __decorateParam(4, Optional3()),
+  __decorateParam(4, Optional4()),
   __decorateParam(4, Inject9(BRIDGE_MULTI_TENANT))
 ], BridgeDeliveryHandler);
 
@@ -2828,12 +2847,12 @@ var BridgeOutboxDrainHook = class {
 };
 BridgeOutboxDrainHook = __decorateClass([
   Injectable11(),
-  __decorateParam(0, Optional4()),
+  __decorateParam(0, Optional5()),
   __decorateParam(0, Inject10(BRIDGE_REGISTRY))
 ], BridgeOutboxDrainHook);
 
 // runtime/subsystems/bridge/event-flow.service.ts
-import { Inject as Inject11, Injectable as Injectable12, Optional as Optional5 } from "@nestjs/common";
+import { Inject as Inject11, Injectable as Injectable12, Optional as Optional6 } from "@nestjs/common";
 var EventFlowService = class {
   constructor(db, eventBus, orchestrator, bridgeRepo, registry = {}, multiTenant = false) {
     this.db = db;
@@ -2909,9 +2928,9 @@ EventFlowService = __decorateClass([
   __decorateParam(1, Inject11(EVENT_BUS)),
   __decorateParam(2, Inject11(JOB_ORCHESTRATOR)),
   __decorateParam(3, Inject11(BRIDGE_DELIVERY_REPO)),
-  __decorateParam(4, Optional5()),
+  __decorateParam(4, Optional6()),
   __decorateParam(4, Inject11(BRIDGE_REGISTRY)),
-  __decorateParam(5, Optional5()),
+  __decorateParam(5, Optional6()),
   __decorateParam(5, Inject11(BRIDGE_MULTI_TENANT))
 ], EventFlowService);
 
@@ -2989,7 +3008,7 @@ var BridgeModule = class {
 };
 BridgeModule = __decorateClass([
   Module3({}),
-  __decorateParam(0, Optional6()),
+  __decorateParam(0, Optional7()),
   __decorateParam(0, Inject12(JOB_WORKER_MODULE_OPTIONS))
 ], BridgeModule);
 export {