@metaobjectsdev/codegen-ts 0.24.5 → 1.0.0-rc.1

package/src/templates/drizzle-schema.ts

@@ -3,10 +3,11 @@
 // plus the relations() block auto-emitted at the end.
 
 import { code, imp, joinCode, type Code } from "ts-poet";
-import { MetaObject, MetaField, MetaIndex, stripPackage } from "@metaobjectsdev/metadata";
+import { MetaObject, MetaField, MetaIndex, isMetaObject, stripPackage } from "@metaobjectsdev/metadata";
 import {
   FIELD_SUBTYPE_LONG,
   IDENTITY_ATTR_FIELDS, IDENTITY_ATTR_GENERATION,
+  IDENTITY_ATTR_EXPR, IDENTITY_ATTR_USING, IDENTITY_ATTR_ORDERS, IDENTITY_ATTR_WHERE,
   GENERATION_INCREMENT, GENERATION_UUID,
   FIELD_ATTR_AUTO_SET,
   FIELD_ATTR_OBJECT_REF,
@@ -14,7 +15,11 @@ import {
 import { fieldDeclaringPackage, type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier, valueObjectModuleSpecifier } from "../import-path.js";
 import { mapColumnType, type ColumnSpec, type EnumIntCustomType } from "../column-mapper.js";
-import { tableNameFromEntity, columnNameFromField } from "../naming.js";
+import { tableNameFromEntity } from "../naming.js";
+import {
+  namesRef, physicalNameExpr, sourceSchemaExpr, indexNameExpr, columnExpr,
+} from "../names.js";
+import { resolveTableSchema } from "@metaobjectsdev/metadata";
 import { renderRelationsBlock } from "./relations-block.js";
 import { renderDocsFor } from "./jsdoc.js";
 import { collectTphSubtypeFields } from "./tph-discriminator.js";
@@ -36,6 +41,81 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
   const tableName = obj.dbTable ?? tableNameFromEntity(obj.name, ctx.columnNamingStrategy);
   const varName = ctx.collectionName(obj.name);
 
+  // §A6/§B2 — reference `<Entity>Names` instead of embedding the physical names a SECOND
+  // time. `namesRef` is undefined whenever the names generator is not active in this run
+  // (opt-in under ADR-0034 scaffold-and-own — an unconditional import would break every
+  // project that has not enabled it) or the object has no primary source — both PRESENCE
+  // guards. No per-site equality check: whenever the constant exists, it IS the name;
+  // `primaryRdbSource` (@metaobjectsdev/metadata) already refuses (throws) any object
+  // whose `@role: primary` sources disagree on a name, and BOTH branches reach it — the
+  // constant through `resolveObjectNames`, and `obj.dbTable` above on its own — so this
+  // file never has to re-check, and the literal arm is refused too rather than silently
+  // binding the inherited parent's table when the names generator is out of the run.
+  const names = namesRef(obj, ctx);
+  const tableNameExpr: Code = physicalNameExpr(names, tableName, obj);
+
+  // @schema — the table binding must land in the SAME schema the migration creates the table
+  // in. migrate-ts qualifies every table, view, index and FK it emits (`CREATE TABLE
+  // "sales"."widgets"`), and under ADR-0015 it owns where a table lives; codegen dropping the
+  // schema meant generated queries hit `public.widgets` while the migration built
+  // `sales.widgets`. Whether that surfaced depended entirely on the adopter's `search_path`,
+  // which is the worst kind of bug — it works on the machine that has it configured.
+  //
+  // Drizzle expresses this with a DIFFERENT call shape rather than a third argument:
+  // `pgSchema("sales").table(name, …)`. It is built inline rather than hoisted to a `const`
+  // so two tables in one file sharing a schema cannot collide on a generated identifier; a
+  // schema object is just a descriptor, so a second call costs nothing.
+  //
+  // sqlite/d1 are excluded because SQLite has no schema concept at all — migrate already
+  // REFUSES a non-default @schema there (expected-schema.ts), so there is nothing to honour
+  // and no divergence to close.
+  const tableSchema = dialect === "sqlite" ? undefined : resolveTableSchema(obj);
+  const schemaExpr: Code | undefined =
+    tableSchema === undefined ? undefined
+    : sourceSchemaExpr(names) ?? code`${JSON.stringify(tableSchema)}`;
+  const tableCall: Code = schemaExpr === undefined
+    ? code`${tableFnSym}`
+    : code`${imp(`pgSchema@${importModule}`)}(${schemaExpr}).table`;
+  // A column's constant, on the same terms — but resolved against the entity that DECLARES
+  // the field, which is not always `obj`. Under TPH the fold below emits a subtype's own
+  // columns into this base's table, and those columns live in the SUBTYPE's names artifact;
+  // looking them up in the base's finds nothing.
+  //
+  // This used to pass `names` for every column and call the resulting miss "normal". It was
+  // not: the base's artifact genuinely does not carry a subtype's column, so every TPH
+  // subtype column fell through to the literal while `<Sub>Names.fields.<f>.column` sat
+  // right there, already imported by the subtype's own artifact. C# never had the bug
+  // because its emitter passes the subtype entity to `ColumnRef`; this is that shape.
+  //
+  // `fromPackage` stays `obj.package` so the import path is computed relative to the file
+  // being emitted (this base's), not to the subtype's own package.
+  // THIS entity's artifact first. It already carries every INHERITED field — a concrete
+  // entity's artifact spreads its abstract parent's `fields` — so an `extends` chain needs
+  // no redirect, and taking one would be a regression: an abstract base has no source, so
+  // it has no artifact of its own to redirect TO, and the column would fall back to a
+  // literal that `obj`'s artifact was carrying all along.
+  //
+  // A miss here means the field belongs to a different entity ENTIRELY, which under TPH is
+  // exactly the subtype whose columns this base's table absorbs. Only then resolve against
+  // the declaring entity, found through the field's own parent link.
+  //
+  // `isMetaObject`, never `instanceof`: two physical copies of @metaobjectsdev/metadata in
+  // one process give the class object and the instance different identities, so the check
+  // would return false for a real node — silently.
+  const columnNameExpr = (field: MetaField, dbName: string): Code => {
+    if (names === undefined || names.resolved.fields[field.name] !== undefined) {
+      return columnExpr(names, field.name, dbName);
+    }
+    const owner = field.parent;
+    // `fromPackage` is obj's: the import path is relative to the file being emitted (this
+    // base's), not to the subtype's own package.
+    const ownerNames =
+      owner !== undefined && isMetaObject(owner) && owner !== obj
+        ? namesRef(owner, ctx, obj.package)
+        : undefined;
+    return columnExpr(ownerNames, field.name, dbName);
+  };
+
   const primary = obj.primaryIdentity();
   const rawPkFields = primary?.attr(IDENTITY_ATTR_FIELDS);
   const pkFieldsList: string[] = Array.isArray(rawPkFields)
@@ -52,20 +132,58 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
 
   // Collect secondary identities and the field names that need .unique() on
   // their column. identity.secondary is ALWAYS unique (no @unique attr) — only
-  // single-column identities propagate .unique() to the column; multi-column ones
-  // emit a callback uniqueIndex() entry instead.
-  // index.lookup is non-unique and must NOT stamp .unique() on its columns.
+  // An `identity.secondary` reaches the table ONLY as the `uniqueIndex(...)` callback
+  // emitted further down — never additionally as `.unique()` on its column.
+  //
+  // It used to do both for a single-column identity, under a comment describing an
+  // either/or ("single-column identities propagate .unique() to the column; multi-column
+  // ones emit a callback uniqueIndex() entry instead") that the code did not implement:
+  // the callback loop has no column-count condition, so a one-column secondary got a
+  // column-level unique AND a table-level unique index. `migrate-ts` emits only the index
+  // for that shape — it mirrors a `<table>_<col>_unique` constraint for `@unique` fields
+  // and nothing extra for a secondary — so the generated schema declared a constraint the
+  // database does not have, and `drizzle-kit push` run against it proposes creating one.
+  //
+  // `.unique()` still comes from the FIELD's own `@unique`, via the column mapper, which
+  // is exactly the arm migrate mirrors.
   const secondaryIdentities = obj.secondaryIdentities();
-  const uniqueFieldNames = new Set<string>();
-  for (const sec of secondaryIdentities) {
-    const fields = sec.attr(IDENTITY_ATTR_FIELDS) as string[] | undefined;
-    if (!Array.isArray(fields) || fields.length !== 1) continue; // multi-col uniques use a callback uniqueIndex, not a column flag
-    uniqueFieldNames.add(fields[0]!);
-  }
 
   const columnLines: Code[] = [];
   // Collect CHECK constraints for enum columns; emitted as table-level check() callbacks.
-  const checkConstraints: Array<{ name: string; expr: string }> = [];
+  const checkConstraints: Array<{ name: Code; expr: Code }> = [];
+  /**
+   * One CHECK entry, composed against `<Entity>Names` when the artifact is in the run.
+   *
+   * #293 — migrate's `<table>_<col>_chk` is the shared convention and it is the AUTHORITY:
+   * its suffix form is systematic across five constraint kinds and those names are already
+   * in live databases, so flipping migrate instead would emit DROP/ADD CONSTRAINT churn
+   * against production for a cosmetic difference. Referencing the constants therefore
+   * composes the IDENTICAL string at runtime rather than changing the convention — the
+   * template literal below evaluates to exactly what the literal arm spells.
+   *
+   * The expression's column goes through `sql.raw`, not `sql.identifier`: the latter QUOTES
+   * the name, which changes the constraint text migrate compares against.
+   */
+  const checkEntry = (field: MetaField, spec: ColumnSpec): { name: Code; expr: Code } => {
+    const colExpr = columnNameExpr(field, spec.dbName);
+    const values = spec.checkConstraintValues;
+    const sqlSym = imp("sql@drizzle-orm");
+    // No artifact in this run (the documented ADR-0034 opt-out) — spell both halves, which
+    // is what this file did unconditionally before.
+    if (names === undefined || values === undefined) {
+      return {
+        name: code`${JSON.stringify(`${tableName}_${spec.dbName}_chk`)}`,
+        expr: code`${spec.checkConstraint ?? ""}`,
+      };
+    }
+    // `\${` emits a literal `${` into the generated source: the name becomes a template
+    // literal and the expression an interpolation, both evaluated at run time in the
+    // consumer's code, where they produce the identical strings the literal arm spells.
+    return {
+      name: code`\`\${${tableNameExpr}}_\${${colExpr}}_chk\``,
+      expr: code`\${${sqlSym}.raw(${colExpr})} IN (${values})`,
+    };
+  };
   // Int-backed field.enum customType helpers, emitted ahead of the table. Keyed by
   // const name so a shared enum used by two fields of the SAME entity emits once.
   const enumIntTypes = new Map<string, EnumIntCustomType>();
@@ -76,7 +194,6 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
     // no longer creates.
     if (child.isDerived()) continue;
     const isPk = pkFieldNames.has(child.name);
-    const isUnique = uniqueFieldNames.has(child.name) && !isPk;
     const fkInfo = fkMap.get(child.name);
     // Compute the column spec once per field and reuse it for both the column
     // line and the CHECK collection.
@@ -85,18 +202,9 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
       enumIntTypes.set(spec.enumIntCustomType.fnConstName, spec.enumIntCustomType);
     }
     const fieldDocs = renderDocsFor(child);
-    const columnLine = renderColumn(spec, child, ctx, isPk, pkGeneration, fkInfo, isComposite, isUnique, obj.package, obj.name);
+    const columnLine = renderColumn(spec, columnNameExpr(child, spec.dbName), child, ctx, isPk, pkGeneration, fkInfo, isComposite, obj.package, obj.name);
     columnLines.push(fieldDocs ? code`  ${fieldDocs}\n${columnLine}` : columnLine);
-    if (spec.checkConstraint !== undefined) {
-      checkConstraints.push({
-        // #293 — migrate's `<table>_<col>_chk` is the shared convention, and it is the
-        // authority: its suffix form is systematic across five constraint kinds and those
-        // names are already in live databases, so flipping migrate instead would emit
-        // DROP/ADD CONSTRAINT churn against production for a cosmetic difference.
-        name: `${tableName}_${spec.dbName}_chk`,
-        expr: spec.checkConstraint,
-      });
-    }
+    if (spec.checkConstraint !== undefined) checkConstraints.push(checkEntry(child, spec));
   }
 
   // FR-017 Tier 2 — TPH single-table inheritance. When this entity is a
@@ -114,21 +222,12 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
     }
     const fieldDocs = renderDocsFor(child);
     const columnLine = renderColumn(
-      spec, child, ctx, false, undefined, fkMap.get(child.name), isComposite, false, obj.package, obj.name, true,
+      spec, columnNameExpr(child, spec.dbName), child, ctx, false, undefined, fkMap.get(child.name), isComposite, obj.package, obj.name, true,
     );
     columnLines.push(fieldDocs ? code`  ${fieldDocs}\n${columnLine}` : columnLine);
     // Enum CHECK constraints stay valid under TPH: `NULL IN (...)` is NULL
     // (not false), so other-subtype rows with NULL pass the check.
-    if (spec.checkConstraint !== undefined) {
-      checkConstraints.push({
-        // #293 — migrate's `<table>_<col>_chk` is the shared convention, and it is the
-        // authority: its suffix form is systematic across five constraint kinds and those
-        // names are already in live databases, so flipping migrate instead would emit
-        // DROP/ADD CONSTRAINT churn against production for a cosmetic difference.
-        name: `${tableName}_${spec.dbName}_chk`,
-        expr: spec.checkConstraint,
-      });
-    }
+    if (spec.checkConstraint !== undefined) checkConstraints.push(checkEntry(child, spec));
   }
 
   // Build all table callback entries
@@ -138,38 +237,122 @@ export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
     callbackEntries.push(buildCompositeKeyCallback(pkFieldNames, importModule));
   }
 
+  /**
+   * One index callback entry, for BOTH `identity.secondary` (unique) and `index.lookup`
+   * (non-unique). The two shapes differ only in that boolean, and migrate treats their
+   * physical attributes identically — `@expr`/`@using`/`@orders`/`@where` are registered on
+   * both by the same provider — so they are emitted by ONE function here. They used to be
+   * two near-identical loops, which is how the physical attributes came to be honoured by
+   * neither: a rule written twice is a rule that can be forgotten twice.
+   *
+   * What was missing is a SHAPE divergence, not a naming one (the names were reconciled
+   * separately). An `@expr`-only index emitted NOTHING at all here, because both loops
+   * required a non-empty `@fields` — while migrate emits it, keying off `@expr`. And
+   * `@where` never reached this file, so a PARTIAL unique index read as a FULLY unique one
+   * in the generated schema: `drizzle-kit push` would propose replacing the database's
+   * partial index with a total one, and any diff written from generated source disagreed
+   * with the database over a difference that was not real. Same class as the sqlite
+   * emitter dropping these in 0.15.21.
+   */
+  const indexEntry = (
+    // `type`/`subType` as well as `name`: the index-name resolver and the artifact's
+    // `identities` / `indexes` collections both key off which KIND of node this is, and
+    // ADR-0040 put that distinction in the type rather than in an attribute.
+    node: { name: string; type: string; subType: string; attr: (n: string) => unknown },
+    fieldNames: string[],
+    unique: boolean,
+  ): Code | undefined => {
+    const str = (n: string): string | undefined => {
+      const raw = node.attr(n);
+      return typeof raw === "string" && raw.trim().length > 0 ? raw.trim() : undefined;
+    };
+    const expr = str(IDENTITY_ATTR_EXPR);
+    // An expression index keys off @expr; a plain one needs @fields. Mirrors migrate's
+    // `if (fieldNames.length === 0 && expr === undefined) continue`.
+    if (fieldNames.length === 0 && expr === undefined) return undefined;
+
+    const sqlSym = imp("sql@drizzle-orm");
+    const indexSym = imp(`${unique ? "uniqueIndex" : "index"}@${importModule}`);
+
+    // @orders is positional against @fields; migrate only serializes it when at least one
+    // entry is `desc`, because an all-ascending array must be indistinguishable from no
+    // orders at all for diff stability. Match that exactly or the two disagree on a
+    // no-op.
+    const ordersRaw = node.attr(IDENTITY_ATTR_ORDERS);
+    const orders = Array.isArray(ordersRaw)
+      ? fieldNames.map((_, i) => (ordersRaw[i] === "desc" ? "desc" : "asc"))
+      : [];
+    const anyDesc = orders.some((o) => o === "desc");
+    const colRefs = fieldNames.map((f, i) =>
+      anyDesc ? `table.${f}.${orders[i] === "desc" ? "desc" : "asc"}()` : `table.${f}`);
+
+    // sqlite's `.on()` accepts only columns — no SQL — so an expression index is not
+    // expressible there. It is skipped rather than emitted wrong; migrate still creates it,
+    // and a Drizzle declaration that silently indexed a COLUMN instead of the expression
+    // would be a worse answer than an absent one.
+    if (expr !== undefined && dialect === "sqlite") return undefined;
+
+    // @using selects the access method and takes the columns itself, so it REPLACES .on().
+    // Postgres-only: SQLite has no USING clause. migrate omits a `btree` value as the
+    // default, and so does this — emitting it would be a spurious difference.
+    const using = dialect === "sqlite" ? undefined : str(IDENTITY_ATTR_USING);
+    const target: Code =
+      expr !== undefined ? code`${sqlSym}\`${expr}\``
+      : code`${colRefs.join(", ")}`;
+    // The CONSTANT when the artifact is in the run, the literal otherwise — and the
+    // literal arm goes through `resolveIndexName` too, so the two paths answer with one
+    // function. Both halves matter: migrate's expected-schema resolves the same name and
+    // the two spelled it independently until now, which is how codegen came to declare
+    // `idx_<table>_<col>` against an index the database actually held under
+    // `identity.name` (fdb4118f1); and an empty `index.lookup` name — which the loader
+    // accepts, unlike an identity — is refused here rather than emitting `index("")`.
+    const indexName = indexNameExpr(names, node);
+    const head: Code =
+      using !== undefined && using !== "btree"
+        ? code`${indexSym}(${indexName}).using(${JSON.stringify(using)}, ${target})`
+        : code`${indexSym}(${indexName}).on(${target})`;
+
+    // @where — the partial-index predicate, available on both dialects.
+    const where = str(IDENTITY_ATTR_WHERE);
+    return where === undefined ? head : code`${head}.where(${sqlSym}\`${where}\`)`;
+  };
+
   // identity.secondary — always unique (uniqueness is in the type, no boolean).
   for (const sec of secondaryIdentities) {
     const fields = sec.attr(IDENTITY_ATTR_FIELDS) as string[] | undefined;
-    if (!Array.isArray(fields) || fields.length === 0) continue;
-    const indexName = `idx_${tableName}_${fields.map((f) => columnNameFromField(f, ctx.columnNamingStrategy)).join("_")}`;
-    const indexSym = imp(`uniqueIndex@${importModule}`);
-    // Use the callback param `table` (not the outer varName) so TS doesn't see
+    // The identity's OWN name, which is what migrate puts in the database
+    // (`expected-schema.ts`, secondary-identity pass) and what `index.lookup` three
+    // blocks below already emits. This used to compose `idx_<table>_<col>...` by running
+    // the naming strategy over the FIELD names — two defects in one expression: the name
+    // disagreed with migrate's (so a DROP INDEX written from generated source failed, and
+    // any schema diff reported a difference that was not real), and running the strategy
+    // over a field NAME cannot see `@column`, so a declared physical column was invisible
+    // to it. Gated by `secondary-index-name-parity.test.ts`, whose fixture is de-blinded
+    // against exactly that second defect.
+    // Column refs use the callback param `table` (not the outer varName) so TS does not see
     // the table referencing itself inside its own initializer (TS7022/TS7024).
-    const cols = fields.map((f) => `table.${f}`).join(", ");
-    callbackEntries.push(code`${indexSym}(${JSON.stringify(indexName)}).on(${cols})`);
+    const entry = indexEntry(sec, Array.isArray(fields) ? fields : [], /* unique */ true);
+    if (entry !== undefined) callbackEntries.push(entry);
   }
 
   // index.lookup — always non-unique. Use MetaIndex.fields() per ADR-0039.
   for (const lookup of obj.lookupIndexes()) {
-    const fields = lookup.fields();
-    if (fields.length === 0) continue;
-    const indexSym = imp(`index@${importModule}`);
-    const cols = fields.map((f) => `table.${f}`).join(", ");
-    callbackEntries.push(code`${indexSym}(${JSON.stringify(lookup.name)}).on(${cols})`);
+    const entry = indexEntry(lookup, lookup.fields(), /* unique */ false);
+    if (entry !== undefined) callbackEntries.push(entry);
   }
 
-  // Emit table-level CHECK constraints for enum fields.
+  // Emit table-level CHECK constraints for enum fields. Both halves are composed by
+  // `checkEntry` above, which owns the constant-vs-literal decision for the pair.
   for (const { name, expr } of checkConstraints) {
     const checkSym = imp(`check@${importModule}`);
     const sqlSym = imp("sql@drizzle-orm");
-    callbackEntries.push(code`${checkSym}(${JSON.stringify(name)}, ${sqlSym}\`${expr}\`)`);
+    callbackEntries.push(code`${checkSym}(${name}, ${sqlSym}\`${expr}\`)`);
   }
 
   let tableBlock: Code;
   if (callbackEntries.length > 0) {
     tableBlock = code`
-export const ${varName} = ${tableFnSym}(${JSON.stringify(tableName)}, {
+export const ${varName} = ${tableCall}(${tableNameExpr}, {
 ${joinCode(columnLines, { on: ",\n", trim: false })}
 }, (table) => [
   ${joinCode(callbackEntries, { on: ",\n  ", trim: false })}
@@ -177,7 +360,7 @@ ${joinCode(columnLines, { on: ",\n", trim: false })}
 `;
   } else {
     tableBlock = code`
-export const ${varName} = ${tableFnSym}(${JSON.stringify(tableName)}, {
+export const ${varName} = ${tableCall}(${tableNameExpr}, {
 ${joinCode(columnLines, { on: ",\n", trim: false })}
 });
 `;
@@ -309,13 +492,16 @@ function inlineObjectLiteral(obj: Record<string, unknown>): string {
 /** Render one column line (field name + Drizzle column expression). */
 function renderColumn(
   spec: ColumnSpec,
+  // §A6 — the column's physical name as an EXPRESSION: either the `<Entity>Names` constant
+  // or the same literal as before. Passed in rather than derived here so one call site owns
+  // the decision (and the equality check that makes it byte-safe).
+  dbNameExpr: Code,
   field: MetaField,
   ctx: RenderContext,
   isPk: boolean,
   pkGeneration: string | undefined,
   fkInfo: FkInfo | undefined,
   isComposite: boolean,
-  isUnique: boolean = false,
   entityPackage: string | undefined = undefined,
   // Name of the entity this column belongs to — used to detect a self-referential
   // FK (target entity === this entity), which Drizzle emits without a self-import.
@@ -332,12 +518,11 @@ function renderColumn(
       ? spec.enumIntCustomType.fnConstName
       : imp(`${spec.fnName}@${spec.importModule}`);
 
-  const dbNameLit = JSON.stringify(spec.dbName);
   let baseCall: Code;
   if (spec.fnOptions !== undefined && Object.keys(spec.fnOptions).length > 0) {
-    baseCall = code`${fnSym}(${dbNameLit}, ${inlineObjectLiteral(spec.fnOptions)})`;
+    baseCall = code`${fnSym}(${dbNameExpr}, ${inlineObjectLiteral(spec.fnOptions)})`;
   } else {
-    baseCall = code`${fnSym}(${dbNameLit})`;
+    baseCall = code`${fnSym}(${dbNameExpr})`;
   }
 
   let pkSuffix = "";
@@ -350,10 +535,10 @@ function renderColumn(
         // Postgres: bigserial for long (8-byte), serial for int (4-byte).
         if (field.subType === FIELD_SUBTYPE_LONG) {
           const bigserialSym = imp(`bigserial@${spec.importModule}`);
-          baseCall = code`${bigserialSym}(${dbNameLit}, { mode: "number" })`;
+          baseCall = code`${bigserialSym}(${dbNameExpr}, { mode: "number" })`;
         } else {
           const serialSym = imp(`serial@${spec.importModule}`);
-          baseCall = code`${serialSym}(${dbNameLit})`;
+          baseCall = code`${serialSym}(${dbNameExpr})`;
         }
         pkSuffix = isComposite ? "" : ".primaryKey()";
       }
@@ -370,14 +555,17 @@ function renderColumn(
   }
 
   let modifiersStr = pkSuffix;
-  // Append .unique() for secondary-identity fields (isPk guard already excluded PKs upstream).
-  if (isUnique) modifiersStr += ".unique()";
+  // No `isUnique` parameter here any more, and its absence is the fix rather than a tidy-up.
+  // A single-column `identity.secondary` used to append `.unique()` on top of the constraint
+  // migrate already emits under the identity's own name, so codegen declared one constraint
+  // the database does not have. When that producer was removed both call sites started
+  // passing a literal `false`, leaving a parameter whose every branch was unreachable — a
+  // dead switch that reads like a live one. `spec.modifiers` carries whatever uniqueness the
+  // column genuinely has, and the loop below is the only thing that applies it.
   for (const m of spec.modifiers) {
     // Single-column PKs imply notNull/unique; avoid emitting them twice.
     // Composite-PK columns are NOT declared with .primaryKey(), so they DO need .notNull().
     if (isPk && !isComposite && (m === ".notNull()" || m === ".unique()")) continue;
-    // Avoid double-emitting .unique() if it was already appended above.
-    if (isUnique && m === ".unique()") continue;
     // TPH subtype-only column: never .notNull() / .unique() — rows of other
     // subtypes store NULL, so neither constraint can hold across the table.
     if (forceNullable && (m === ".notNull()" || m === ".unique()")) continue;