@pattern-stack/codegen 0.4.2 → 0.4.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pattern-stack/codegen",
-  "version": "0.4.2",
+  "version": "0.4.4",
   "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,19 @@ 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.
+    // `get({ strict: false })` (not `create()`) — the handler must be a
+    // provider in its owning module so cross-module @Inject dependencies
+    // resolve. See job-worker.ts for the full rationale.
+    const handler = this.moduleRef
+      ? (this.moduleRef.get(
+          HandlerClass as unknown as new (...args: unknown[]) => unknown,
+          { strict: false },
+        ) 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,
   ) {}
 
   // ============================================================================
@@ -175,8 +177,16 @@ export class JobWorkerOrchestrator implements OnModuleInit, OnModuleDestroy {
             `the resolved pool config. Configured pools: [${[...poolConfig.keys()].join(', ')}].`,
         );
       }
+      // `pool` here is the logical pool name (e.g. 'crm_sync') — the same
+      // value the orchestrator persists into `job_run.pool` from
+      // `@JobHandler.meta.pool`, and therefore the value the worker's
+      // claim query filters on. `def.queue` is a display/routing alias
+      // (e.g. 'jobs-crm-sync') used by BullMQ-style backends for queue
+      // naming; it MUST NOT be passed as the claim-filter pool, or the
+      // worker will never match any row and the pool silently never
+      // drains. See v0.4.4 fix notes.
       const workerOptions: JobWorkerOptions = {
-        pool: def.queue,
+        pool: poolName,
         concurrency: def.concurrency,
         shutdownTimeoutMs:
           this.options.shutdownTimeoutMs ?? DEFAULT_SHUTDOWN_TIMEOUT_MS,
@@ -190,7 +200,7 @@ export class JobWorkerOrchestrator implements OnModuleInit, OnModuleDestroy {
       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}`,
       );
     }
   }
@@ -270,12 +280,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,22 @@ 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. Resolve the handler instance from Nest's DI
+    //     graph so its `@Inject` constructor params (which may come from
+    //     any module in the app graph) are satisfied. `moduleRef.create()`
+    //     would otherwise instantiate a fresh class within JobWorkerModule's
+    //     scope only — which blows up with "not a provider of the current
+    //     module" for any handler that consumes a service from a peer
+    //     module (e.g. CrmSyncJob injecting CrmSyncFactory from CrmModule).
+    //     Consequence: handlers MUST be registered as providers in their
+    //     owning module (@Injectable + `providers: [HandlerClass]`). The
+    //     @JobHandler decorator handles registry registration only, not DI.
+    //     See the jobs skill's handler-authoring.md for the registration
+    //     rule.
+    const handler = this.moduleRef.get(
+      HandlerClass as unknown as new (...args: unknown[]) => unknown,
+      { strict: false },
+    ) as JobHandlerBase<unknown>;
     const ctx: JobContext<unknown> = {
       input: claimed.input,
       run: claimed as JobRun,