@pattern-stack/codegen 0.8.0 → 0.9.0

package/templates/relationship/new/prompt.js

@@ -203,10 +203,13 @@ function processFields(fields) {
 function zodChainForCreate(field) {
   const { type, nullable, required, hasDefault, hasChoices, choices } = field;
 
+  // Nullability and optionality are independent — see the clean-lite-ps copy of
+  // this function for the rationale (nullable-and-optional fields must get both
+  // `.nullable()` and `.optional()`, not just `.nullable()`).
   if (hasChoices) {
-    const base = `z.enum([${choices.map((c) => `'${c}'`).join(", ")}])`;
-    if (!required && !nullable) return base + ".optional()";
-    if (nullable) return base + ".nullable()";
+    let base = `z.enum([${choices.map((c) => `'${c}'`).join(", ")}])`;
+    if (nullable) base += ".nullable()";
+    if (!required) base += ".optional()";
     return base;
   }
 
@@ -215,8 +218,8 @@ function zodChainForCreate(field) {
     base += `.default(${field.default ?? false})`;
     return base;
   }
-  if (nullable) return base + ".nullable()";
-  if (!required) return base + ".optional()";
+  if (nullable) base += ".nullable()";
+  if (!required) base += ".optional()";
   return base;
 }
 

package/templates/subsystem/jobs/worker.ejs.t

@@ -5,13 +5,30 @@ unless_exists: true
 /**
  * Standalone job worker entrypoint — emitted by `codegen subsystem install jobs`.
  *
- * Boots a Nest application context (NO HTTP listener) wiring the jobs domain
- * module plus JobWorkerModule in `standalone` mode. Run with:
+ * Boots a Nest application context (NO HTTP listener) wiring the full
+ * subsystem barrel (`SUBSYSTEM_MODULES` — events + jobs + bridge + sync, in
+ * dependency order) plus `JobWorkerModule.forRoot({ mode: 'standalone',
+ * allPools: true })`. Run with:
  *
  *   bun worker.ts
  *
+ * Why the barrel + `allPools`:
+ *   - The events subsystem's outbox drain and the bridge's fanout wrappers
+ *     run as `job_run` rows in the RESERVED `events_*` pools. A worker that
+ *     only polls the non-reserved pools (`interactive`, `batch`, …) leaves
+ *     those lanes stranded — `BridgeDeliveryHandler` never fires and durable
+ *     event→job fanout silently stops.
+ *   - `allPools: true` activates every pool in the resolved config, reserved
+ *     lanes included, so this single standalone process drains both user work
+ *     and the framework's reserved lanes.
+ *   - Importing `SUBSYSTEM_MODULES` (rather than `JobsDomainModule` alone)
+ *     registers `EVENT_BUS` / `JOB_ORCHESTRATOR` / `BRIDGE_*` so the
+ *     framework `@framework/bridge_delivery` handler resolves its DI deps.
+ *     `BridgeModule`'s reserved-pool guard short-circuits to pass because
+ *     `allPools` is set.
+ *
  * Embedded mode (single-process) is configured by importing
- * JobWorkerModule.forRoot({ mode: 'embedded' }) inside AppModule instead —
+ * `JobWorkerModule.forRoot({ mode: 'embedded' })` inside AppModule instead —
  * see the commented guidance injected into `src/main.ts`.
  *
  * SIGTERM triggers graceful shutdown bounded by SHUTDOWN_TIMEOUT_MS; after the
@@ -23,16 +40,22 @@ import { Logger, Module } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 
 import { DatabaseModule } from '@shared/database/database.module';
-import { JobsDomainModule } from '@shared/subsystems/jobs/jobs-domain.module';
 import { JobWorkerModule } from '@shared/subsystems/jobs/job-worker.module';
+import { SUBSYSTEM_MODULES } from '@generated/subsystems';
 
 const SHUTDOWN_TIMEOUT_MS = 30_000;
 
 @Module({
   imports: [
     DatabaseModule,
-    JobsDomainModule.forRoot({ backend: 'drizzle' }),
-    JobWorkerModule.forRoot({ mode: 'standalone' }),
+    // Events + Jobs + Bridge + Sync (dependency-ordered) from the generated
+    // barrel. This is the same composition AppModule imports — keeping the
+    // worker's DI graph identical to the HTTP app's so handlers resolve the
+    // same way in both processes.
+    ...SUBSYSTEM_MODULES,
+    // `allPools: true` drains the reserved `events_*` lanes (events outbox +
+    // bridge wrappers) alongside the user pools.
+    JobWorkerModule.forRoot({ mode: 'standalone', allPools: true }),
   ],
 })
 class WorkerAppModule {}
@@ -72,7 +95,7 @@ async function bootstrap(): Promise<void> {
     void shutdown('SIGINT');
   });
 
-  logger.log('job worker started (standalone mode)');
+  logger.log('job worker started (standalone mode, all pools)');
 }
 
 bootstrap().catch((err) => {

package/templates/subsystem/sync/sync-audit.schema.ejs.t

@@ -19,14 +19,16 @@ force: true
  *       is owned by the sync subsystem's runtime protocol
  *       (`sync-field-diff.protocol.ts` from SYNC-2).
  *
- * ## `tenant_id` columns — scaffold-time conditional
+ * ## `tenant_id` columns — always emitted
  *
- * When `sync.multi_tenant: true` in `codegen.config.yaml`, this schema
- * emits `tenant_id` as a nullable text column on all three tables. The
- * `SYNC_MULTI_TENANT` DI flag (SYNC-6) enforces non-null at runtime
- * across the orchestrator + Drizzle backends. Enabling post-install
- * requires reinstalling this subsystem (`subsystem install sync --force
- * --force-config`) plus an Atlas migration.
+ * `tenant_id` is emitted as a nullable text column on all three tables
+ * REGARDLESS of `sync.multi_tenant` — the runtime sync code (cursor store +
+ * run recorder) references `tenant_id` unconditionally, so a `multi_tenant:
+ * false` consumer that omitted the column failed to type-check (the column
+ * was referenced but absent). The `SYNC_MULTI_TENANT` DI flag (SYNC-6) gates
+ * non-null *enforcement* at runtime; it does not gate the column's existence
+ * (mirrors the jobs subsystem). Under `multi_tenant: false` the column simply
+ * stays null.
  *
  * See SYNC-1 / SYNC-6 in epic #60 for the decision rationale.
  */
@@ -98,9 +100,7 @@ export const syncSubscriptions = pgTable(
     config: jsonb('config').notNull().default({}).$type<Record<string, unknown>>(),
     cursor: jsonb('cursor').$type<unknown>(),
     lastSyncAt: timestamp('last_sync_at', { withTimezone: true }),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
     createdAt: timestamp('created_at', { withTimezone: true }).notNull().defaultNow(),
     updatedAt: timestamp('updated_at', { withTimezone: true }).notNull().defaultNow(),
   },
@@ -141,9 +141,7 @@ export const syncRuns = pgTable(
       .notNull()
       .defaultNow(),
     completedAt: timestamp('completed_at', { withTimezone: true }),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
   },
   (t) => ({
     idxSyncRunsSubscriptionStartedAt: index(
@@ -178,9 +176,7 @@ export const syncRunItems = pgTable(
     createdAt: timestamp('created_at', { withTimezone: true })
       .notNull()
       .defaultNow(),
-<% if (multiTenant) { -%>
-    tenantId: text('tenant_id'),                // scaffold-time conditional — see sync.multi_tenant
-<% } -%>
+    tenantId: text('tenant_id'),                // always emitted — the runtime sync code (cursor store + run recorder) references tenant_id unconditionally; SYNC_MULTI_TENANT gates enforcement, not the column's existence (mirrors jobs)
   },
   (t) => ({
     idxSyncRunItemsRunCreatedAt: index('idx_sync_run_items_run_created_at').on(