@pattern-stack/codegen 0.4.2 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pattern-stack/codegen",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Entity-driven code generation for full-stack TypeScript applications",
   "license": "MIT",
   "type": "module",

package/runtime/subsystems/jobs/job-orchestrator.memory-backend.ts

@@ -14,7 +14,8 @@
  * the orchestrator's mutex.
  */
 import { randomUUID } from 'node:crypto';
-import { Inject, Injectable, Logger } from '@nestjs/common';
+import { Inject, Injectable, Logger, Optional } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
 import type {
   JobDefinitionRow,
   JobRunRow,
@@ -139,6 +140,7 @@ export class MemoryJobOrchestrator implements IJobOrchestrator {
     private readonly store: MemoryJobStore,
     private readonly stepService: MemoryJobStepService,
     @Inject(JOBS_MULTI_TENANT) private readonly multiTenant: boolean,
+    @Optional() private readonly moduleRef?: ModuleRef,
   ) {}
 
   /**
@@ -590,7 +592,15 @@ export class MemoryJobOrchestrator implements IJobOrchestrator {
     }
     const meta = registration.meta;
     const HandlerClass = registration.handlerClass;
-    const handler = new HandlerClass();
+    // Match the Drizzle backend: resolve the handler through Nest's
+    // ModuleRef so `@Inject` constructor params work. ModuleRef is
+    // @Optional() — zero-dep test stubs that construct this orchestrator
+    // manually still hit the legacy `new HandlerClass()` path.
+    const handler = this.moduleRef
+      ? ((await this.moduleRef.create(
+          HandlerClass as unknown as new (...args: unknown[]) => unknown,
+        )) as JobHandlerBase<unknown>)
+      : new HandlerClass();
 
     const ctx: JobContext<unknown> = {
       input: run.input,

package/runtime/subsystems/jobs/job-worker.module.ts

@@ -29,6 +29,7 @@ import {
   type OnModuleDestroy,
   type OnModuleInit,
 } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
 import { DRIZZLE } from '../../constants/tokens';
 import type { DrizzleClient } from '../../types/drizzle';
 import { HandlerRegistry, type HandlerRegistryEntry } from './job-handler.base';
@@ -126,6 +127,7 @@ export class JobWorkerOrchestrator implements OnModuleInit, OnModuleDestroy {
      * without supplying a `DRIZZLE` provider.
      */
     @Optional() @Inject(DRIZZLE) private readonly db: DrizzleClient | null = null,
+    private readonly moduleRef?: ModuleRef,
   ) {}
 
   // ============================================================================
@@ -270,12 +272,20 @@ export class JobWorkerOrchestrator implements OnModuleInit, OnModuleDestroy {
           `pass 'workerFactory' to inject a stub.`,
       );
     }
+    if (!this.moduleRef) {
+      throw new Error(
+        `JobWorkerModule: ModuleRef not available — 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,
+      this.moduleRef,
     );
   }
 }

package/runtime/subsystems/jobs/job-worker.ts

@@ -14,6 +14,7 @@
  */
 // TODO(logging-subsystem): swap to ILogger once ADR-028 lands
 import { Inject, Injectable, Logger, type OnModuleDestroy, type OnModuleInit } from '@nestjs/common';
+import { ModuleRef } from '@nestjs/core';
 import { and, asc, desc, eq, inArray, lt, lte, sql } from 'drizzle-orm';
 import type { DrizzleClient } from '../../types/drizzle';
 import { DRIZZLE } from '../../constants/tokens';
@@ -194,6 +195,7 @@ export class JobWorker implements OnModuleInit, OnModuleDestroy {
     @Inject(JOB_RUN_SERVICE) private readonly runService: IJobRunService,
     @Inject(JOB_STEP_SERVICE) private readonly stepService: IJobStepService,
     @Inject(JOB_WORKER_OPTIONS) private readonly options: JobWorkerOptions,
+    private readonly moduleRef: ModuleRef,
   ) {
     this.pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
     this.staleSweeperIntervalMs =
@@ -419,9 +421,16 @@ export class JobWorker implements OnModuleInit, OnModuleDestroy {
     const meta = registryEntry.meta as JobHandlerMeta<unknown>;
     const HandlerClass = registryEntry.handlerClass;
 
-    // (c) Build JobContext. Phase 1: instantiate handler with no args.
-    //     DI-for-handlers lands with JOB-5's boot wiring.
-    const handler = new HandlerClass() as JobHandlerBase<unknown>;
+    // (c) Build JobContext. Instantiate handler via Nest's ModuleRef so
+    //     `@Inject` constructor params resolve. `create({ strict: false })`
+    //     walks the whole module graph for providers (handlers don't need to
+    //     be registered as providers themselves; the @JobHandler decorator
+    //     is the only registration required). A fresh instance per run
+    //     mirrors the contract handlers were authored against and keeps
+    //     run-scoped state from leaking across claims.
+    const handler = (await this.moduleRef.create(
+      HandlerClass as unknown as new (...args: unknown[]) => unknown,
+    )) as JobHandlerBase<unknown>;
     const ctx: JobContext<unknown> = {
       input: claimed.input,
       run: claimed as JobRun,