@pattern-stack/codegen 0.2.0 → 0.3.0

package/templates/entity/new/clean-lite-ps/use-cases/update.ejs.t

@@ -0,0 +1,153 @@
+---
+to: "<%= typeof clpOutputPaths !== 'undefined' ? clpOutputPaths.updateUseCase : null %>"
+skip_if: "<%= typeof clpOutputPaths === 'undefined' || !clpOutputPaths.updateUseCase %>"
+force: true
+---
+<% if (eavEnabled) { -%>
+import { Injectable, Inject } from '@nestjs/common';
+import { DRIZZLE } from '<%= drizzleTokenImport %>';
+import type { DrizzleClient } from '<%= drizzleTypeImport %>';
+<% if (hasEmits && updateEventType) { -%>
+import { TYPED_EVENT_BUS, TypedEventBus } from '<%= eventsTokenImport %>';
+<% } -%>
+import { FieldValueService } from '../../field_values/field_value.service';
+import { <%= classNames.service %> } from '../<%= entityName %>.service';
+import type { <%= classNames.updateDto %> } from '../dto/update-<%= entityName %>.dto';
+import type { <%= classNames.entity %> } from '../<%= entityName %>.entity';
+
+/**
+ * EAV compound-write use case (ADR-13).
+ *
+ * Mirrors CreateUseCase: splits `{ fields, ...core }`, updates core columns
+ * via <%= classNames.service %> and upserts dynamic fields via
+ * FieldValueService.upsertFieldsTransactional in a single transaction.
+ * Returns null if the entity was not found.
+<% if (hasEmits && updateEventType) { -%>
+ *
+ * EXTENSION POINT (EVT-7): verify payload mapping against
+ * events/<%= updateEventType.type %>.yaml before shipping.
+<% } -%>
+ */
+@Injectable()
+export class <%= classNames.updateUseCase %> {
+  constructor(
+    private readonly <%= entityNamePlural %>: <%= classNames.service %>,
+    private readonly fields: FieldValueService,
+    @Inject(DRIZZLE) private readonly db: DrizzleClient,
+<% if (hasEmits && updateEventType) { -%>
+    @Inject(TYPED_EVENT_BUS) private readonly typedEvents: TypedEventBus,
+<% } -%>
+  ) {}
+
+  async execute(
+    id: string,
+    dto: <%= classNames.updateDto %> & { fields?: Record<string, unknown> },
+    <%= hasEmits && updateEventType ? 'opts' : '_opts' %>?: { actor?: { tenantId?: string | null; userId?: string } },
+  ): Promise<<%= classNames.entity %> | null> {
+    return this.db.transaction(async (tx) => {
+      const { fields, ...core } = dto;
+      const entity = await this.<%= entityNamePlural %>.update(id, core as <%= classNames.updateDto %>, tx);
+      if (!entity) return null;
+      if (fields && Object.keys(fields).length > 0) {
+        await this.fields.upsertFieldsTransactional(
+          '<%= entityName %>',
+          entity.id,
+          entity.userId,
+          fields,
+          tx,
+        );
+      }
+<% if (hasEmits && updateEventType) { -%>
+      // TODO: verify payload mapping against events/<%= updateEventType.type %>.yaml
+      await this.typedEvents.publish(
+        '<%= updateEventType.type %>',
+        entity.id,
+        {
+<% updateEventType.payloadMap.forEach((p) => { -%>
+          <%= p.camelKey %>: <%- p.expression %>,<% if (p.todo) { %> // TODO: <%= p.todo %><% } %>
+
+<% }) -%>
+        },
+        {
+          tx,
+          metadata: opts?.actor
+            ? { tenantId: opts.actor.tenantId, userId: opts.actor.userId }
+            : undefined,
+        },
+      );
+<% } -%>
+      return entity;
+    });
+  }
+}
+<% } else { -%>
+<% if (hasEmits && updateEventType) { -%>
+import { Injectable, Inject, NotFoundException } from '@nestjs/common';
+import { DRIZZLE } from '<%= drizzleTokenImport %>';
+import type { DrizzleClient } from '<%= drizzleTypeImport %>';
+import { TYPED_EVENT_BUS, TypedEventBus } from '<%= eventsTokenImport %>';
+import { <%= classNames.service %> } from '../<%= entityName %>.service';
+import type { <%= classNames.updateDto %> } from '../dto/update-<%= entityName %>.dto';
+import type { <%= classNames.entity %> } from '../<%= entityName %>.entity';
+
+/**
+ * EXTENSION POINT (EVT-7): verify payload mapping against
+ * events/<%= updateEventType.type %>.yaml before shipping.
+ */
+@Injectable()
+export class <%= classNames.updateUseCase %> {
+  constructor(
+    private readonly service: <%= classNames.service %>,
+    @Inject(DRIZZLE) private readonly db: DrizzleClient,
+    @Inject(TYPED_EVENT_BUS) private readonly typedEvents: TypedEventBus,
+  ) {}
+
+  async execute(
+    id: string,
+    dto: <%= classNames.updateDto %>,
+    opts?: { actor?: { tenantId?: string | null; userId?: string } },
+  ): Promise<<%= classNames.entity %> | null> {
+    return this.db.transaction(async (tx) => {
+      const entity = await this.service.update(id, dto, tx);
+      if (!entity) return null;
+      // TODO: verify payload mapping against events/<%= updateEventType.type %>.yaml
+      await this.typedEvents.publish(
+        '<%= updateEventType.type %>',
+        entity.id,
+        {
+<% updateEventType.payloadMap.forEach((p) => { -%>
+          <%= p.camelKey %>: <%- p.expression %>,<% if (p.todo) { %> // TODO: <%= p.todo %><% } %>
+
+<% }) -%>
+        },
+        {
+          tx,
+          metadata: opts?.actor
+            ? { tenantId: opts.actor.tenantId, userId: opts.actor.userId }
+            : undefined,
+        },
+      );
+      return entity;
+    });
+  }
+}
+<% } else { -%>
+import { Injectable } from '@nestjs/common';
+import { <%= classNames.service %> } from '../<%= entityName %>.service';
+import type { <%= classNames.updateDto %> } from '../dto/update-<%= entityName %>.dto';
+import type { <%= classNames.entity %> } from '../<%= entityName %>.entity';
+
+@Injectable()
+export class <%= classNames.updateUseCase %> {
+  constructor(private readonly service: <%= classNames.service %>) {}
+
+  async execute(
+    id: string,
+    dto: <%= classNames.updateDto %>,
+    _opts?: { actor?: { tenantId?: string | null; userId?: string } },
+  ): Promise<<%= classNames.entity %> | null> {
+    return this.service.update(id, dto);
+  }
+}
+<% } -%>
+<% } -%>

package/templates/entity/new/prompt.js

@@ -7,6 +7,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import yaml from "yaml";
+import pluralizePkg from "pluralize";
 import {
   BACKEND_LAYERS,
   BASE_PATHS,
@@ -220,6 +221,56 @@ function resolveBehaviors(behaviorConfigs) {
   };
 }
 
+
+// ============================================================================
+// Patterns — subprocess-local registry load (PATTERN-5)
+// ============================================================================
+//
+// The Hygen subprocess has no shared memory with the CLI process, so the
+// pattern registry is rebuilt here from scratch. Library patterns register
+// themselves as a side effect of importing the barrel; app-defined patterns
+// are loaded from `codegen.config.yaml patterns:` globs (default
+// `src/patterns/*.pattern.ts`). Both loads are deterministic and
+// side-effect-free — the registry determinism test in
+// `src/__tests__/patterns/registry.test.ts` pins down that the CLI and the
+// subprocess produce identical sorted results for the same file set.
+
+let _patternsLoadPromise = null;
+
+async function ensurePatternsRegistryLoaded() {
+  if (!_patternsLoadPromise) {
+    _patternsLoadPromise = (async () => {
+      // Side-effect import: pre-registers the five library patterns.
+      await import('../../../src/patterns/library/index.js');
+      const { loadAppPatterns } = await import('../../../src/patterns/registry.js');
+
+      // Read the `patterns:` manifest from codegen.config.yaml. Defaults
+      // to a single sensible glob when the key is absent — matches the
+      // ADR-031 default discovery shape.
+      const configPath = path.resolve(process.cwd(), 'codegen.config.yaml');
+      let manifest = ['src/patterns/*.pattern.ts'];
+      if (fs.existsSync(configPath)) {
+        try {
+          const parsed = yaml.parse(fs.readFileSync(configPath, 'utf-8'));
+          if (Array.isArray(parsed?.patterns)) {
+            manifest = parsed.patterns;
+          }
+        } catch {
+          // fall through with the default manifest; a malformed
+          // codegen.config.yaml is already surfaced by the CLI's config
+          // loader elsewhere.
+        }
+      }
+      const result = await loadAppPatterns(manifest, process.cwd());
+      for (const err of result.errors) {
+        // eslint-disable-next-line no-console
+        console.warn(`[codegen] ${err}`);
+      }
+    })();
+  }
+  return _patternsLoadPromise;
+}
+
 export default {
   prompt: async ({ args }) => {
     const yamlPath = args.yaml;
@@ -255,22 +306,18 @@ export default {
     const queriesBlock = definition.queries || null;
     const syncBlock = definition.sync || null;
     const eventsBlock = definition.events || null;
+    // EVT-7: emits is semantically 3-valued — undefined (fallback path),
+    // [] (explicit opt-out), or string[] (typed emission). Preserve the
+    // undefined/null-vs-empty distinction by refusing the || null shortcut.
+    const emitsBlock = Array.isArray(definition.emits)
+      ? definition.emits
+      : null;
 
     // Helper functions
     const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
     const camelCase = (s) => s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
     const pascalCase = (s) => capitalize(camelCase(s));
-    const pluralize = (s) => {
-      if (s.endsWith("y")) return s.slice(0, -1) + "ies";
-      if (
-        s.endsWith("s") ||
-        s.endsWith("x") ||
-        s.endsWith("ch") ||
-        s.endsWith("sh")
-      )
-        return s + "es";
-      return s + "s";
-    };
+    const pluralize = (s) => pluralizePkg.plural(s);
 
     // ============================================================================
     // UI Metadata Inference Functions
@@ -582,7 +629,9 @@ export default {
     const zodTypes = {
       string: "z.string()",
       integer: "z.number().int()",
-      decimal: "z.number()",
+      // Drizzle maps PG `numeric` to JS string — z.coerce.string() avoids
+      // silent precision loss. Aligned with clean-lite-ps (PR #42). See #43.
+      decimal: "z.coerce.string()",
       boolean: "z.boolean()",
       uuid: "z.string().uuid()",
       date: "z.coerce.date()",
@@ -962,29 +1011,6 @@ export default {
     const isCleanLitePs = architectureTarget === 'clean-lite-ps';
     const frontendEnabled = generateConfig.frontend === true;
 
-    // ============================================================================
-    // v2: Family
-    // ============================================================================
-
-    const FAMILY_REPOSITORY_MAP = {
-      'synced': 'SyncedEntityRepository',
-      'activity': 'ActivityEntityRepository',
-      'knowledge': 'KnowledgeEntityRepository',
-      'metadata': 'MetadataEntityRepository',
-    };
-
-    const FAMILY_SERVICE_MAP = {
-      'synced': 'SyncedEntityService',
-      'activity': 'ActivityEntityService',
-      'knowledge': 'KnowledgeEntityService',
-      'metadata': 'MetadataEntityService',
-    };
-
-    const family = entity.family ?? null;
-    const hasFamily = family != null;
-    const familyBaseRepository = family ? (FAMILY_REPOSITORY_MAP[family] ?? null) : null;
-    const familyBaseService = family ? (FAMILY_SERVICE_MAP[family] ?? null) : null;
-
     // ============================================================================
     // v2: Queries
     // ============================================================================
@@ -1157,11 +1183,193 @@ export default {
         })
       : [];
 
+    // ============================================================================
+    // EVT-7: emits — resolve typed events for create/update/delete use-cases.
+    // ============================================================================
+    //
+    // The `emits:` list is guaranteed-valid at this point — the CLI pre-flight
+    // (`validateEntityEmits`) has already run. Our job is to derive:
+    //   • `emitsEvents[]` — one entry per emitted type with payload + mapping.
+    //   • `createEventType` / `updateEventType` / `deleteEventType` — the specific
+    //     `<entity>_<op>` entries for the three standard CRUD use-cases.
+    //   • Payload mapping rules 1..5 (see plan §Payload mapping).
+    //
+    // We re-merge `events/*.yaml` + entity desugar here because we cannot
+    // import the TS generator helpers into a Hygen prompt. The merge is cheap
+    // and has no side effects; the validator has already proven correctness.
+
+    const hasEmits = Array.isArray(emitsBlock) && emitsBlock.length > 0;
+
+    const FIELD_TYPE_TO_TS = {
+      uuid: 'string',
+      string: 'string',
+      number: 'number',
+      boolean: 'boolean',
+      date: 'Date',
+      json: 'Record<string, unknown>',
+    };
+
+    // Load top-level events/<name>.yaml, tolerant of missing dir / bad files.
+    const loadTopLevelEventYamls = (eventsDir) => {
+      if (!fs.existsSync(eventsDir)) return new Map();
+      const byType = new Map();
+      for (const file of fs.readdirSync(eventsDir)) {
+        if (!file.endsWith('.yaml') && !file.endsWith('.yml')) continue;
+        try {
+          const content = fs.readFileSync(path.join(eventsDir, file), 'utf-8');
+          const parsed = yaml.parse(content);
+          if (parsed && typeof parsed === 'object' && typeof parsed.type === 'string') {
+            byType.set(parsed.type, parsed);
+          }
+        } catch {
+          // Silently skip — the main event-codegen-generator surfaces parse errors.
+        }
+      }
+      return byType;
+    };
+
+    // Desugar entity events: block into top-level-event shape with
+    // `{ type, direction: 'change', aggregate, payload: { <key>: { type, nullable } } }`.
+    const desugarEntityEventsInline = (entityDefinition) => {
+      const out = new Map();
+      const entityName = entityDefinition?.entity?.name;
+      const evs = entityDefinition?.events ?? [];
+      for (const ev of evs) {
+        const payload = {};
+        for (const [key, t] of Object.entries(ev.body ?? {})) {
+          payload[key] = { type: t, nullable: false };
+        }
+        out.set(ev.name, {
+          type: ev.name,
+          direction: 'change',
+          aggregate: entityName,
+          payload,
+        });
+      }
+      return out;
+    };
+
+    /**
+     * Resolve each emit name into the per-op event descriptor the templates need.
+     */
+    const resolveEmitsEvents = () => {
+      if (!hasEmits) return [];
+
+      const eventsDir = path.resolve(process.cwd(), 'events');
+      const topLevel = loadTopLevelEventYamls(eventsDir);
+      const sugar = desugarEntityEventsInline(definition);
+      // Top-level wins on collision (same policy as event-codegen-generator).
+      const merged = new Map(sugar);
+      for (const [k, v] of topLevel) merged.set(k, v);
+
+      // Build quick lookups keyed by camelCase for payload-mapping rules 3/4.
+      const entityKeysCamel = new Set(
+        processedFields.map((f) => f.camelName),
+      );
+
+      // DTO keys = the fields actually present on CreateXDto (input-eligible).
+      // The CLP + Clean DTOs derive from the same processedFields list (minus
+      // behaviors-computed fields like createdAt/updatedAt/deletedAt). We
+      // approximate here by using all processedFields — the TODO comments on
+      // each generated line make any miss visually obvious.
+      const dtoKeysCamel = new Set(
+        processedFields.map((f) => f.camelName),
+      );
+
+      return emitsBlock.map((emitName) => {
+        const ev = merged.get(emitName);
+        // `validateEntityEmits` has already guaranteed `ev` is defined. If
+        // somehow we get here with an unknown name (e.g. validator bypassed),
+        // emit a TODO-only mapping so the generated file still parses.
+        const payload = ev?.payload ?? {};
+        const payloadKeys = Object.keys(payload).sort();
+
+        const payloadMap = payloadKeys.map((snakeKey) => {
+          const field = payload[snakeKey];
+          const tsType = FIELD_TYPE_TO_TS[field.type] ?? 'unknown';
+          const tsTypeFinal = field.nullable ? `${tsType} | null` : tsType;
+          const camelKey = camelCase(snakeKey);
+
+          let expression;
+          let todo;
+
+          // Rule 1: <entity>_id or <entityName>Id → entity.id
+          if (
+            snakeKey === `${name}_id` ||
+            camelKey === `${camelName}Id`
+          ) {
+            expression = 'entity.id';
+          }
+          // Rule 2: created_by / updated_by → dto.createdBy / dto.updatedBy if present.
+          else if (snakeKey === 'created_by' || snakeKey === 'updated_by') {
+            const dtoKey = camelKey;
+            if (dtoKeysCamel.has(dtoKey)) {
+              expression = `dto.${dtoKey}`;
+            } else {
+              expression = `null as unknown as ${tsTypeFinal}`;
+              todo = `supply ${snakeKey} (not on DTO — wire from auth context)`;
+            }
+          }
+          // Rule 3: field present on just-created entity → entity.<camelKey>
+          else if (entityKeysCamel.has(camelKey)) {
+            expression = `entity.${camelKey}`;
+          }
+          // Rule 4: field present on input DTO (fallback) → dto.<camelKey>
+          else if (dtoKeysCamel.has(camelKey)) {
+            expression = `dto.${camelKey}`;
+          }
+          // Rule 5: otherwise — null placeholder + TODO.
+          else {
+            expression = `null as unknown as ${tsTypeFinal}`;
+            todo = `supply ${snakeKey}`;
+          }
+
+          return {
+            snakeKey,
+            camelKey,
+            tsType: tsTypeFinal,
+            expression,
+            todo,
+          };
+        });
+
+        return {
+          type: emitName,
+          aggregate: ev?.aggregate ?? name,
+          payloadMap,
+        };
+      });
+    };
+
+    const emitsEvents = resolveEmitsEvents();
+    const createEventType =
+      emitsEvents.find((e) => e.type === `${name}_created`) ?? null;
+    const updateEventType =
+      emitsEvents.find((e) => e.type === `${name}_updated`) ?? null;
+    const deleteEventType =
+      emitsEvents.find((e) => e.type === `${name}_deleted`) ?? null;
+
+    // Import paths for the TypedEventBus token + DrizzleClient token/type.
+    // The consumer app wires `@shared/*` aliases to the vendored subsystem
+    // sources (under `<paths.backend_src>/shared/subsystems/…`), matching
+    // where `subsystem install` drops the runtime files and where
+    // `entity new` writes the generated `events/generated/` artifacts. The
+    // `@shared/subsystems/events` path is the barrel at
+    // `<subsystems_root>/events/index.ts`.
+    const eventsTokenImport = '@shared/subsystems/events';
+    const typedEventBusImport = '@shared/subsystems/events';
+    const drizzleTokenImport = '@shared/constants/tokens';
+    const drizzleTypeImport = '@shared/types/drizzle';
+
     const locals = {
       // Database configuration
       databaseDialect,
       schemaDir: BASE_PATHS.schemaDir,
 
+      // Project layout — used by clean-lite-ps prompt-extension to compute
+      // output paths under the configured source root (paths.backend_src).
+      backendSrc: BASE_PATHS.backendSrc,
+
       // Entity names
       name,
       plural,
@@ -1352,12 +1560,6 @@ export default {
       isCleanLitePs,
       frontendEnabled,
 
-      // Family
-      family,
-      hasFamily,
-      familyBaseRepository,
-      familyBaseService,
-
       // Queries
       hasQueries,
       processedQueries,
@@ -1375,6 +1577,17 @@ export default {
       // Events
       hasEvents,
       processedEvents,
+
+      // EVT-7: emits (typed auto-emission via TypedEventBus)
+      hasEmits,
+      emitsEvents,
+      createEventType,
+      updateEventType,
+      deleteEventType,
+      eventsTokenImport,
+      typedEventBusImport,
+      drizzleTokenImport,
+      drizzleTypeImport,
     };
 
     // ========================================================================
@@ -1385,7 +1598,17 @@ export default {
     // template bodies can render without crashing; their `to:` guards resolve
     // to null which causes Hygen to skip file writing.
     // ========================================================================
+    // EVT-7 note: hasEmits / emitsEvents / *EventType / *Import locals are
+    // already in `locals` above and are architecture-neutral — CLP templates
+    // read the same locals to render typed publish blocks in their use-cases.
+
     if (isCleanLitePs) {
+      // Load app-defined patterns (if any) into the registry before the
+      // clean-lite-ps extension reads it. `loadAppPatterns` is idempotent
+      // and deterministic — calling it every run is cheap (one dynamic
+      // import per pattern file) and matches the two-process load story
+      // the registry tests pin down.
+      await ensurePatternsRegistryLoaded();
       const { buildCleanLitePsLocals } = await import('./clean-lite-ps/prompt-extension.js');
       Object.assign(locals, buildCleanLitePsLocals(definition, locals));
     } else {
@@ -1413,6 +1636,26 @@ export default {
         serviceBaseImport: '',
         repositoryInheritedMethods: [],
         serviceInheritedMethods: [],
+        // Generation toggles — needed so CLP template bodies render without crashing
+        // when architecture is 'clean'. The to:/skip_if: guards prevent file writes.
+        generateWrites: true,
+        eavEnabled: false,
+        eavValueTable: false,
+        eavDefinitionEntity: null,
+        eavDefinitionEntityPlural: null,
+        eavDefinitionPascal: null,
+        eavDefinitionPluralPascal: null,
+        hasSearchQuery: false,
+        searchQuery: null,
+        hasExternalIdTracking: false,
+        // PATTERN-5 stubs — defined even for non-CLP architectures so the
+        // CLP template bodies render without `ReferenceError`s. The
+        // to:/skip_if: guards prevent file writes, but EJS still walks the
+        // body on every template.
+        patternName: 'Base',
+        hasPatternConfig: false,
+        patternConfig: null,
+        renderPatternConfigLiteral: () => '{}',
       });
     }
 

package/templates/relationship/new/entity.ejs.t

@@ -8,9 +8,9 @@ import {
 <%_ }) _%>
 } from 'drizzle-orm/pg-core';
 import { type InferSelectModel } from 'drizzle-orm';
-import { <%= fromTable %> } from '../../<%= fromTable %>/<%= from %>.entity';
+import { <%= fromTable %> } from '../<%= fromTable %>/<%= from %>.entity';
 <%_ if (from !== to) { _%>
-import { <%= toTable %> } from '../../<%= toTable %>/<%= to %>.entity';
+import { <%= toTable %> } from '../<%= toTable %>/<%= to %>.entity';
 <%_ } _%>
 
 // ============================================================================

package/templates/relationship/new/prompt.js

@@ -11,6 +11,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import yaml from "yaml";
+import pluralizePkg from "pluralize";
 
 // ============================================================================
 // Naming Helpers (inlined to avoid import issues with Hygen)
@@ -19,12 +20,7 @@ import yaml from "yaml";
 const capitalize = (s) => s.charAt(0).toUpperCase() + s.slice(1);
 const camelCase = (s) => s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
 const pascalCase = (s) => capitalize(camelCase(s));
-const pluralize = (s) => {
-  if (s.endsWith("y")) return s.slice(0, -1) + "ies";
-  if (s.endsWith("s") || s.endsWith("x") || s.endsWith("ch") || s.endsWith("sh"))
-    return s + "es";
-  return s + "s";
-};
+const pluralize = (s) => pluralizePkg.plural(s);
 const kebabCase = (s) => s.replace(/_/g, "-");
 
 // ============================================================================
@@ -45,7 +41,7 @@ function deriveRelationshipFKColumns(config) {
 }
 
 function deriveTableName(config) {
-  return config.table ?? `${config.name}s`;
+  return config.table ?? pluralize(config.name);
 }
 
 function collectTypeNames(types) {

package/templates/relationship/new/service.ejs.t

@@ -19,7 +19,7 @@ export class <%= classNames.service %> extends WithAnalytics(
   @Optional() @Inject(EVENT_BUS)
   protected override eventBus: any = undefined;
 
-  constructor(protected readonly repository: <%= classNames.repository %>) {
+  constructor(protected override readonly repository: <%= classNames.repository %>) {
     super(repository);
   }
 

package/templates/subsystem/bridge/generated-keep.ejs.t

@@ -0,0 +1,4 @@
+---
+to: "<%= generatedKeepPath %>"
+unless_exists: true
+---

package/templates/subsystem/bridge/prompt.js

@@ -0,0 +1,36 @@
+/**
+ * Hygen prompt.js — BRIDGE-9 bridge subsystem scaffold (lean variant).
+ *
+ * Locals resolved by the CLI (src/cli/shared/bridge-scaffold-locals.ts) and
+ * forwarded as CLI args. This prompt.js coerces boolean-ish strings back into
+ * JS booleans for parity with events / sync (Hygen args arrive as strings).
+ *
+ * Invoked via:
+ *   bunx hygen subsystem bridge \
+ *     --configPath <abs> --generatedKeepPath <abs> \
+ *     --multiTenant <'true'|'false'> --appName <string>
+ *
+ * No schema template here — `bridge-delivery.schema.ts` ships unconditionally
+ * via `copyRuntime` (BRIDGE-1's `tenant_id` column is always emitted; multi-
+ * tenancy is a runtime enforcement concern, not a scaffold-time gate).
+ */
+
+function coerceBool(raw) {
+  if (raw === true) return true;
+  if (raw === false) return false;
+  if (typeof raw === "string") return raw.toLowerCase() === "true";
+  return false;
+}
+
+export default {
+  prompt: async ({ args }) => {
+    return {
+      appName: args.appName ?? "",
+      multiTenant: coerceBool(args.multiTenant),
+      configPath: args.configPath ?? "codegen.config.yaml",
+      generatedKeepPath:
+        args.generatedKeepPath ??
+        "shared/subsystems/bridge/generated/.gitkeep",
+    };
+  },
+};

package/templates/subsystem/bridge-config/codegen-config-bridge-block.ejs.t

@@ -0,0 +1,20 @@
+---
+to: "<%= configPath %>"
+inject: true
+append: true
+skip_if: "bridge:"
+---
+
+bridge:
+  # ── Backend selection (core/extension model — see CLAUDE.md) ──
+  # 'drizzle' is the production backend (bridge_delivery ledger + outbox
+  # drain integration). 'memory' is the synchronous test backend.
+  backend: drizzle
+
+  # ── Multi-tenancy (BRIDGE-8 / ADR-023) ──
+  # When true, the three enforcement sites
+  # (EventFlowService.publishAndStart, BridgeDeliveryHandler.run,
+  # DrizzleBridgeDeliveryRepo.insertDelivery) throw MissingTenantIdError
+  # when `tenantId === undefined`. Explicit `null` always passes
+  # (cross-tenant work). Pair with `BridgeModule.forRoot({ multiTenant: true })`.
+  multi_tenant: false