@pattern-stack/codegen 0.6.7 → 0.6.8

package/CHANGELOG.md

@@ -4,6 +4,18 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.6.8] — 2026-04-28
+
+Hotfix for enum codegen in the `clean-lite-ps` template pipeline. Surfaced during integration-patterns Wave 0b: enum-typed YAML fields emitted a Drizzle `text()` column instead of a `pgEnum`, so `InferSelectModel` resolved to `string` instead of the literal-union type and forced hand-casts in consumer code (e.g. `as DecryptedIntegrationRow['status']`).
+
+### Fixed
+
+- **`fix(codegen)` — clean-lite-ps enum emission.** `templates/entity/new/clean-lite-ps/prompt-extension.js` now produces `pgEnum` declarations + column references for any field with `choices` (or `type: enum`), matching the backend pipeline at `templates/entity/new/backend/database/schema.ejs.t:66-104`. Generated entity files now contain `export const xEnum = pgEnum('x', [...])` ahead of the `pgTable(...)` block and reference `xEnum('x').notNull()` inside the column map. `pgEnum` is added to the `drizzle-orm/pg-core` import list automatically when any enum field is present. The emitted `InferSelectModel` type now narrows to the literal union — consumers can drop `as Row['status']` casts. New unit coverage: `src/__tests__/clean-lite-ps/entity-enum-template.test.ts`.
+
+### Migration note
+
+Not a breaking change for the emitted code shape (the field's TypeScript type narrows — a strict superset of what consumer code can do). Existing Postgres databases generated against 0.6.7 or earlier will need a one-time `CREATE TYPE … AS ENUM (...)` + `ALTER TABLE … ALTER COLUMN x TYPE x_enum USING x::x_enum;` migration, since the column was previously `text`. Greenfield projects, or anyone regenerating before the first migration runs, are unaffected.
+
 ## [0.6.7] — 2026-04-28
 
 Hotfix bundle for `cdp subsystem install auth-integrations`. 0.6.5 / 0.6.6 shipped the auth-integrations starter and install template, but every downstream consumer ran into four blockers on a fresh install. None of them surfaced from the source-checkout smoke (the install code resolves examples/ via the package root, which exists in dev) — they only exposed themselves through `npm install + bunx cdp subsystem install auth-integrations` against the published tarball. Bundles a fifth fix that unifies the integrations folder layout. Surfaced by integration-patterns Wave 0b.

package/package.json

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

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

@@ -18,6 +18,12 @@ import { type InferSelectModel } from 'drizzle-orm';
 import { <%= rel.relatedTable %> } from '<%= rel.importPath %>';
 <%_ } _%>
 <%_ }) _%>
+<%_ if (typeof clpEnumFields !== 'undefined' && clpEnumFields.length > 0) { _%>
+
+<%_ clpEnumFields.forEach(ef => { _%>
+export const <%= ef.enumName %> = pgEnum('<%= ef.dbName %>', [<%- ef.choices.map(c => `'${c}'`).join(', ') %>]);
+<%_ }) _%>
+<%_ } _%>
 
 export const <%= entityNamePlural %> = pgTable(
   '<%= entityNamePlural %>',

package/templates/entity/new/clean-lite-ps/prompt-extension.js

@@ -201,7 +201,7 @@ const EXTERNAL_ID_TRACKING_FIELDS = new Set([
 /**
  * Build a Drizzle column chain for a field
  */
-function buildDrizzleChain(fieldName, field, drizzleType) {
+function buildDrizzleChain(fieldName, field, drizzleType, enumName) {
   const nullable = field.nullable ?? false;
   const required = field.required ?? false;
   const hasDefault = field.default !== undefined && field.default !== null;
@@ -211,7 +211,11 @@ function buildDrizzleChain(fieldName, field, drizzleType) {
   // schemas using z.coerce.date() align with the entity type.
   // `timestamp` already defaults to Date — no mode override needed.
   let chain;
-  if (drizzleType === 'date') {
+  if (drizzleType === 'enum' && enumName) {
+    // Reference the pgEnum declaration emitted at the top of the entity file.
+    // The column name argument keeps the snake_case YAML field name.
+    chain = `${enumName}('${fieldName}')`;
+  } else if (drizzleType === 'date') {
     chain = `${drizzleType}('${fieldName}', { mode: 'date' })`;
   } else {
     chain = `${drizzleType}('${fieldName}')`;
@@ -247,7 +251,15 @@ function processFields(fields) {
     const choices = field.choices;
     const hasChoices = Array.isArray(choices) && choices.length > 0;
 
-    const drizzleType = DRIZZLE_TYPE_MAP[type] || 'text';
+    // Enum-typed fields (or any field with a `choices` list) emit a
+    // Postgres-native pgEnum declaration + column reference, so the
+    // generated `InferSelectModel` type narrows to the literal union
+    // instead of falling back to `string`. Matches the backend pipeline
+    // (templates/entity/new/backend/database/schema.ejs.t:66-104).
+    const drizzleType = hasChoices
+      ? 'enum'
+      : (DRIZZLE_TYPE_MAP[type] || 'text');
+    const enumName = hasChoices ? camelCase(fieldName) + 'Enum' : null;
     const tsType = hasChoices
       ? choices.map((c) => `'${c}'`).join(' | ')
       : (TS_TYPE_MAP[type] || 'unknown');
@@ -255,7 +267,7 @@ function processFields(fields) {
       ? `z.enum([${choices.map((c) => `'${c}'`).join(', ')}])`
       : (ZOD_TYPE_MAP[type] || 'z.unknown()');
 
-    const drizzleChain = buildDrizzleChain(fieldName, field, drizzleType);
+    const drizzleChain = buildDrizzleChain(fieldName, field, drizzleType, enumName);
 
     processed.push({
       name: fieldName,
@@ -271,6 +283,7 @@ function processFields(fields) {
       drizzleChain,
       choices,
       hasChoices,
+      enumName,
     });
   }
 
@@ -355,6 +368,12 @@ function collectDrizzleImports(processedFields, belongsTo, hasTimestamps, hasSof
   const imports = new Set(['pgTable', 'uuid']);
 
   for (const field of processedFields) {
+    if (field.drizzleType === 'enum') {
+      // Enum columns reference a `pgEnum` declaration emitted at the top
+      // of the entity file; the helper itself comes from drizzle-orm/pg-core.
+      imports.add('pgEnum');
+      continue;
+    }
     const importName = DRIZZLE_IMPORT_MAP[field.drizzleType];
     if (importName) imports.add(importName);
   }
@@ -783,6 +802,18 @@ export function buildCleanLitePsLocals(definition, baseLocals) {
   const fkFieldNames = new Set(belongsTo.map((r) => r.field));
   const nonFkFields = processedFields.filter((f) => !fkFieldNames.has(f.name));
 
+  // Enum field declarations — surface a separate collection so the entity
+  // template can emit `export const xEnum = pgEnum('x', [...])` ahead of
+  // the `pgTable(...)` block. Both FK-filtered and unfiltered processing
+  // include the same enum fields; they're never FKs.
+  const clpEnumFields = processedFields
+    .filter((f) => f.hasChoices && f.enumName)
+    .map((f) => ({
+      enumName: f.enumName,
+      dbName: f.name,
+      choices: f.choices,
+    }));
+
   // Drizzle imports needed
   const drizzleEntityImports = collectDrizzleImports(processedFields, belongsTo, hasTimestamps, hasSoftDelete, hasExternalIdTracking);
   // Whether relations() import is needed
@@ -980,6 +1011,7 @@ export function buildCleanLitePsLocals(definition, baseLocals) {
     // Drizzle
     clpDrizzleImports: drizzleEntityImports,
     clpHasRelationsBlock: hasRelationsBlock,
+    clpEnumFields,
 
     // Declarative queries
     processedQueries,