@everystack/cli 0.3.0 → 0.3.4

package/src/cli/migration-generate.ts

@@ -86,6 +86,9 @@ export function unmodeledTables(models: ModelDescriptor[], current: SchemaSnapsh
  */
 export function generateMigrationSql(models: ModelDescriptor[], current: SchemaSnapshot, opts: GenerateOptions = {}): string[] {
   const schema = opts.schema ?? 'public';
+  // A table's schema comes from the model first (package tables live in dist/ops/auth),
+  // then the call default — so one run spans schemas.
+  const schemaOf = (m: ModelDescriptor): string => m.schema ?? schema;
   const desiredEnums = compileEnums(models);
   const desired: SchemaSnapshot = { tables: models.map((m) => compileTableSchema(m, { schema })), enums: desiredEnums };
   const declaredTables = new Set(desired.tables.map((t) => t.table));
@@ -99,7 +102,7 @@ export function generateMigrationSql(models: ModelDescriptor[], current: SchemaS
   const renames = compileRenames(models, { schema });
   const changes = diffSchema(desired, scopedCurrent, renames);
 
-  const modelByTable = new Map(models.map((m) => [`${schema}.${m.table}`, m]));
+  const modelByTable = new Map(models.map((m) => [`${schemaOf(m)}.${m.table}`, m]));
   const emitted = emitSchemaSql(changes, {
     createTable: (change) => {
       const model = modelByTable.get(change.table);

package/src/cli/model-api.ts

@@ -18,6 +18,7 @@
 export * from './schema-compile.js';
 export * from './schema-introspect.js';
 export * from './schema-diff.js';
+export * from './schema-source.js';
 export * from './model-render.js';
 export * from './migration-compile.js';
 export * from './migration-generate.js';

package/src/cli/schema-compile.ts

@@ -40,6 +40,7 @@ export function modelConstraintSpecs(model: ModelDescriptor): { uniques: UniqueC
   const checks: CheckConstraint[] = [];
   const indexes: IndexSchema[] = [];
   let checkIndex = 0;
+  const usedIndexNames = new Set<string>();
   for (const con of model.constraints) {
     if (con.kind === 'unique') {
       const cols = con.columns.map(toSnakeCase);
@@ -48,8 +49,16 @@ export function modelConstraintSpecs(model: ModelDescriptor): { uniques: UniqueC
       checks.push({ name: `${model.table}_check_${checkIndex++}`, expr: con.predicate });
     } else if (con.kind === 'index') {
       const cols = con.columns.map(toSnakeCase);
+      // Disambiguate multiple indexes over the same columns — e.g. a full index plus a
+      // partial one (`familyId` and `familyId WHERE status='active'`): the name must be
+      // unique within the table for CREATE to succeed. The diff matches indexes by content
+      // (columns + uniqueness + predicate), never by name, so the suffix never affects the
+      // round-trip. Declaration order is deterministic, so the name is stable across calls.
+      let name = `${model.table}_${cols.join('_')}_index`;
+      for (let n = 2; usedIndexNames.has(name); n++) name = `${model.table}_${cols.join('_')}_index_${n}`;
+      usedIndexNames.add(name);
       indexes.push({
-        name: `${model.table}_${cols.join('_')}_index`,
+        name,
         columns: cols,
         unique: con.isUnique,
         ...(con.predicate ? { where: con.predicate } : {}),
@@ -77,6 +86,12 @@ const PG_TYPE: Record<string, string> = {
 };
 
 function pgType(spec: FieldSpec): string {
+  // An array is the base type with `[]` appended — `text` → `text[]`, exactly as
+  // `format_type` spells it.
+  return spec.isArray ? `${scalarPgType(spec)}[]` : scalarPgType(spec);
+}
+
+function scalarPgType(spec: FieldSpec): string {
   // Parameterized types build their own canonical string — exactly as `format_type`
   // spells it (no space after the comma; `varchar` is `character varying`; a
   // precision-only numeric carries scale 0), so an unchanged column round-trips clean.
@@ -132,7 +147,7 @@ export function modelForeignKeys(model: ModelDescriptor): ForeignKey[] {
     out.push({
       name: `${model.table}_${col}_${target.table}_${targetPk}_fk`,
       columns: [col],
-      refTable: target.table,
+      refTable: refTableName(target),
       refColumns: [targetPk],
       ...refActions(field.spec),
     });
@@ -146,7 +161,7 @@ export function modelForeignKeys(model: ModelDescriptor): ForeignKey[] {
     out.push({
       name: `${model.table}_${cols.join('_')}_${target.table}_${refCols.join('_')}_fk`,
       columns: cols,
-      refTable: target.table,
+      refTable: refTableName(target),
       refColumns: refCols,
       ...refActions(con),
     });
@@ -155,6 +170,22 @@ export function modelForeignKeys(model: ModelDescriptor): ForeignKey[] {
   return out;
 }
 
+/**
+ * The referenced table's name as the FK should carry it — schema-qualified for a non-public
+ * target (`auth.users`), bare for a public one (`uploads`). A cross-schema FK (auth → auth, or
+ * public → auth) must name the schema, and `pg_get_constraintdef` deparses it qualified when the
+ * target schema is off the search_path — so the desired side must match, or an unchanged auth FK
+ * would read as drift. public stays bare because it is on the search_path (the proven output).
+ */
+function refTableName(target: ModelDescriptor): string {
+  return target.schema && target.schema !== 'public' ? `${target.schema}.${target.table}` : target.table;
+}
+
+/** Quote each dot-separated part of a (possibly schema-qualified) name: `auth.users` → `"auth"."users"`. */
+function quoteParts(name: string): string {
+  return name.split('.').map((p) => `"${p}"`).join('.');
+}
+
 /** The ` ON DELETE … ON UPDATE …` clause for a FK, or '' when both are the default. */
 function refActionSql(fk: { onDelete?: string; onUpdate?: string }): string {
   let s = '';
@@ -168,11 +199,22 @@ function defaultExpr(spec: FieldSpec): string | null {
   switch (spec.defaultKind) {
     case 'now': return 'now()';
     case 'random': return 'gen_random_uuid()';
-    case 'value': return literal(spec.default);
+    case 'value':
+      return spec.isArray && Array.isArray(spec.default) ? arrayLiteral(spec.default) : literal(spec.default);
     default: return null;
   }
 }
 
+/**
+ * A Postgres array literal for a default — `[]` → `'{}'`, `['a','b']` → `'{"a","b"}'`.
+ * The introspected form carries a `::type[]` cast (`'{}'::text[]`) that `normalizeDefault`
+ * strips, so the bare literal round-trips.
+ */
+function arrayLiteral(arr: unknown[]): string {
+  const elems = arr.map((v) => (typeof v === 'string' ? `"${v.replace(/"/g, '\\"')}"` : String(v)));
+  return `'{${elems.join(',')}}'`;
+}
+
 function literal(value: unknown): string {
   if (typeof value === 'string') return `'${value.replace(/'/g, "''")}'`;
   if (typeof value === 'boolean') return value ? 'true' : 'false';
@@ -278,6 +320,18 @@ export interface CompileTableOptions {
   indent?: string;
 }
 
+/**
+ * A model's table as a quoted SQL name — schema-qualified only for a non-public
+ * schema. Drizzle leaves `public` tables bare (`"posts"`), and the example's
+ * brownfield DDL matches that, so a public model stays unqualified; a package
+ * table in its own schema becomes `"dist"."blobs"`.
+ */
+export function qualifiedTable(model: ModelDescriptor): string {
+  return model.schema && model.schema !== 'public'
+    ? `"${model.schema}"."${model.table}"`
+    : `"${model.table}"`;
+}
+
 /**
  * `CREATE TABLE` for a model's fields. Single-column primary keys are inline;
  * composite keys and uniques become table constraints, named the way drizzle
@@ -322,7 +376,7 @@ export function compileCreateTable(model: ModelDescriptor, opts: CompileTableOpt
     lines.push(`${indent}CONSTRAINT "${ck.name}" CHECK (${ck.expr})`);
   }
 
-  return `CREATE TABLE "${model.table}" (\n${lines.join(',\n')}\n);`;
+  return `CREATE TABLE ${qualifiedTable(model)} (\n${lines.join(',\n')}\n);`;
 }
 
 /**
@@ -337,7 +391,7 @@ export function compileCreateTable(model: ModelDescriptor, opts: CompileTableOpt
  * helpers, so they never disagree.)
  */
 export function compileTableSchema(model: ModelDescriptor, opts: { schema?: string } = {}): TableSchema {
-  const schema = opts.schema ?? 'public';
+  const schema = model.schema ?? opts.schema ?? 'public';
   const entries = Object.entries(model.fields);
 
   const columns = entries.map(([name, field]) => ({
@@ -410,9 +464,12 @@ export function foreignKeySql(model: ModelDescriptor): string[] {
   return modelForeignKeys(model).map((fk) => {
     const cols = fk.columns.map((c) => `"${c}"`).join(', ');
     const refCols = fk.refColumns.map((c) => `"${c}"`).join(', ');
+    // Both sides are schema-qualified for a non-public table — `ALTER TABLE "auth"."identities"`
+    // and `REFERENCES "auth"."users"` — so a cross-schema FK targets the right table. public
+    // stays bare-but-quoted (`"uploads"`), preserving the proven output.
     return (
-      `ALTER TABLE "${model.table}" ADD CONSTRAINT "${fk.name}" ` +
-      `FOREIGN KEY (${cols}) REFERENCES "${fk.refTable}"(${refCols})${refActionSql(fk)};`
+      `ALTER TABLE ${qualifiedTable(model)} ADD CONSTRAINT "${fk.name}" ` +
+      `FOREIGN KEY (${cols}) REFERENCES ${quoteParts(fk.refTable)}(${refCols})${refActionSql(fk)};`
     );
   });
 }
@@ -425,9 +482,9 @@ export function foreignKeySql(model: ModelDescriptor): string[] {
  * this map to turn a drop+add into a `RENAME COLUMN`.
  */
 export function compileRenames(models: ModelDescriptor[], opts: { schema?: string } = {}): RenameMap {
-  const schema = opts.schema ?? 'public';
   const map: RenameMap = {};
   for (const model of models) {
+    const schema = model.schema ?? opts.schema ?? 'public';
     for (const [name, field] of Object.entries(model.fields)) {
       const from = field.spec.renamedFrom;
       if (!from) continue;

package/src/cli/schema-diff.ts

@@ -509,7 +509,10 @@ function addConstraintSql(table: string, c: ConstraintSpec): string {
     case 'unique': return `${head} UNIQUE (${colList(c.columns)});`;
     case 'check': return `${head} CHECK ${wrapOnce(c.expr)};`;
     case 'foreignKey': {
-      let s = `${head} FOREIGN KEY (${colList(c.columns)}) REFERENCES ${quote(c.refTable)}(${colList(c.refColumns)})`;
+      // refTable may be schema-qualified (`auth.users`) for a cross-schema FK — quote each part,
+      // not the whole string, or `"auth.users"` reads as one identifier.
+      const refTable = c.refTable.split('.').map(quote).join('.');
+      let s = `${head} FOREIGN KEY (${colList(c.columns)}) REFERENCES ${refTable}(${colList(c.refColumns)})`;
       if (c.onDelete) s += ` ON DELETE ${c.onDelete.toUpperCase()}`;
       if (c.onUpdate) s += ` ON UPDATE ${c.onUpdate.toUpperCase()}`;
       return `${s};`;

package/src/cli/schema-source.ts

@@ -0,0 +1,416 @@
+/**
+ * `compileDrizzleSource` — the typed-runtime-table slice of the one generator.
+ *
+ * The sibling of `compileTableSchema` (SQL DDL) and `compileTableContract` (RLS):
+ * those compile a {@link ModelDescriptor} to a migration target; this compiles it
+ * to drizzle-orm TypeScript SOURCE TEXT. The emitted `schema.generated.ts`, when
+ * imported, yields the SAME runtime table `toDrizzleTable(model)` builds — but as
+ * literal, fully-typed declarations, so the SSR loaders keep their precise column
+ * types (`toDrizzleTable`'s loop-built table infers `<any>`; literal source does
+ * not). One hand-authored source (`models/*.ts`), the drizzle schema a generated,
+ * drift-guarded artifact.
+ *
+ * The column mapping mirrors `toDrizzleTable` exactly, expressed as text. The two
+ * documented divergences from a hand-written schema (see docs/plans/model-drizzle-codegen.md):
+ *
+ *  - Cross-schema FKs (e.g. `profiles.id → auth.users.id`) are OMITTED — the model
+ *    can't express a reference to a non-Model table, so neither can the emitter.
+ *  - `relationName` strings are synthesized deterministically (the `Relation` type
+ *    carries no name); only the pairing of a belongsTo with its inverse hasMany
+ *    matters, which the synthesis guarantees.
+ *
+ * Pure and deterministic: imports sorted, declarations in model order, relation
+ * keys in declared order — re-running on the same models is byte-identical.
+ *
+ * Input is a `@everystack/model` ModelDescriptor (type-only — no runtime dep).
+ */
+
+import type { ModelDescriptor, FieldSpec } from '@everystack/model';
+
+/** `author_id` is the SQL identifier; `authorId` the field key. The single snake-case rule. */
+function toSnakeCase(name: string): string {
+  return name.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+
+/** `image_variants` → `imageVariants` (a snake table name to its camelCase drizzle export var). */
+function toCamelCase(name: string): string {
+  return name.replace(/_([a-z0-9])/g, (_, c: string) => c.toUpperCase());
+}
+
+/** A JS/TS string literal — single-quoted, the example's style. */
+function strLiteral(value: string): string {
+  return `'${value.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+/** A `.default(<v>)` argument literal for a value default (the JSON forms drizzle accepts). */
+function defaultValueLiteral(value: unknown): string {
+  if (typeof value === 'string') return strLiteral(value);
+  if (typeof value === 'boolean') return value ? 'true' : 'false';
+  if (value === null) return 'null';
+  if (typeof value === 'number') return String(value);
+  // Arrays / objects: a JSON literal is valid TS for jsonb defaults.
+  return JSON.stringify(value);
+}
+
+/**
+ * The drizzle pg-core column builder *call* for a field — `text('bio')`,
+ * `timestamp('created_at', { withTimezone: true })`, `uuid('id')` — exactly the
+ * type + args `toDrizzleTable`'s `baseColumn` produces, as source text. Returns
+ * the call and the builder name it used (so the import set can be collected).
+ */
+function baseColumnSource(columnName: string, spec: FieldSpec): { call: string; builder: string } {
+  const n = strLiteral(columnName);
+  switch (spec.type) {
+    case 'text':
+      return { call: `text(${n})`, builder: 'text' };
+    case 'uuid':
+      return { call: `uuid(${n})`, builder: 'uuid' };
+    case 'integer':
+      return { call: `integer(${n})`, builder: 'integer' };
+    case 'bigint':
+      return { call: `bigint(${n}, { mode: 'number' })`, builder: 'bigint' };
+    case 'bigserial':
+      return { call: `bigserial(${n}, { mode: 'number' })`, builder: 'bigserial' };
+    case 'boolean':
+      return { call: `boolean(${n})`, builder: 'boolean' };
+    case 'timestamptz':
+      return { call: `timestamp(${n}, { withTimezone: true })`, builder: 'timestamp' };
+    case 'timestamp':
+      return { call: `timestamp(${n})`, builder: 'timestamp' };
+    case 'date':
+      return { call: `date(${n})`, builder: 'date' };
+    case 'numeric':
+      return spec.precision !== undefined
+        ? { call: `numeric(${n}, { precision: ${spec.precision}, scale: ${spec.scale} })`, builder: 'numeric' }
+        : { call: `numeric(${n})`, builder: 'numeric' };
+    case 'varchar':
+      return spec.length !== undefined
+        ? { call: `varchar(${n}, { length: ${spec.length} })`, builder: 'varchar' }
+        : { call: `varchar(${n})`, builder: 'varchar' };
+    case 'jsonb':
+      return { call: `jsonb(${n})`, builder: 'jsonb' };
+    case 'enum': {
+      if (!spec.enumName) throw new Error('enum field is missing enumName');
+      return { call: `${enumConstName(spec.enumName)}(${n})`, builder: enumConstName(spec.enumName) };
+    }
+    default: {
+      const exhaustive: never = spec.type;
+      throw new Error(`Unsupported field type: ${String(exhaustive)}`);
+    }
+  }
+}
+
+/** The hoisted const name for an enum type. `status` → `statusEnum`. */
+function enumConstName(enumName: string): string {
+  return `${toCamelCase(enumName)}Enum`;
+}
+
+/** The single primary-key field key for a model (FK targets reference its column). */
+function primaryKeyKey(model: ModelDescriptor): string {
+  const pk = model.primaryKey[0];
+  if (!pk) throw new Error(`Referenced model "${model.table}" has no primary key`);
+  return pk;
+}
+
+/** A model's `field key → snake column name` map (for relation `fields:`/`references:` text). */
+function columnKeys(model: ModelDescriptor): Map<string, string> {
+  const m = new Map<string, string>();
+  for (const key of Object.keys(model.fields)) m.set(key, toSnakeCase(key));
+  return m;
+}
+
+/**
+ * The modifier chain for a column, in `toDrizzleTable` order: notNull, unique,
+ * default, primaryKey (single-PK only), references. Cross-schema references are
+ * impossible to model, so only in-set targets are emitted. `usedBuilders` collects
+ * the table-extra/import builders the references clause needs (none today).
+ */
+function columnModifiers(
+  spec: FieldSpec,
+  isComposite: boolean,
+  modelsByDescriptor: Map<ModelDescriptor, { camel: string }>,
+): string {
+  let s = '';
+  if (spec.isArray) s += '.array()';
+  if (spec.isNotNull) s += '.notNull()';
+  if (spec.isUnique) s += '.unique()';
+
+  if (spec.defaultKind === 'now') s += '.defaultNow()';
+  else if (spec.defaultKind === 'random') s += '.defaultRandom()';
+  else if (spec.defaultKind === 'value') s += `.default(${defaultValueLiteral(spec.default)})`;
+
+  if (spec.isPrimaryKey && !isComposite) s += '.primaryKey()';
+
+  if (spec.references) {
+    const target = (spec.references as () => ModelDescriptor)();
+    const entry = modelsByDescriptor.get(target);
+    if (entry) {
+      const parentPk = primaryKeyKey(target);
+      const opts: string[] = [];
+      if (spec.onDelete) opts.push(`onDelete: ${strLiteral(spec.onDelete)}`);
+      if (spec.onUpdate) opts.push(`onUpdate: ${strLiteral(spec.onUpdate)}`);
+      const optsText = opts.length ? `, { ${opts.join(', ')} }` : '';
+      s += `.references(() => ${entry.camel}.${parentPk}${optsText})`;
+    }
+    // A reference to a model OUTSIDE the emitted set (a cross-schema FK) is omitted —
+    // the runtime + relations never needed it; the DB constraint stays unmanaged.
+  }
+
+  return s;
+}
+
+/** An unordered table-pair key, so `(follows, profiles)` and `(profiles, follows)` collide. */
+function pairKey(a: string, b: string): string {
+  return a < b ? `${a}\x00${b}` : `${b}\x00${a}`;
+}
+
+/**
+ * A relation that needs a `relationName` carries one keyed by `(childTable,
+ * fkColumnKey)` — the same string on the belongsTo (child) and the inverse hasMany
+ * (parent), so drizzle pairs them. Derived from the model's OWN relation graph:
+ * a belongsTo names `(thisTable, column)`; a hasMany names `(targetTable, column)`
+ * — both resolve to the child table holding the FK and the FK column key, so the
+ * two sides agree without coordination.
+ */
+interface RelationNaming {
+  /** All synthesized names, keyed by `(childTable, fkColumnKey)`. */
+  needsName: Set<string>;
+}
+
+function relationPairId(childTable: string, fkColumnKey: string): string {
+  return `${childTable}\x00${fkColumnKey}`;
+}
+
+function synthesizedName(childTable: string, fkColumnKey: string): string {
+  return `${childTable}_${toSnakeCase(fkColumnKey)}`;
+}
+
+/**
+ * Decide which relations need a `relationName`: only pairs of tables connected by
+ * MORE than one relation. Counts every relation (both sides) per unordered table
+ * pair; a pair counted more than once flags every relation between those two tables.
+ */
+function planRelationNames(models: ModelDescriptor[]): RelationNaming {
+  // Ambiguity is per DISTINCT FK column connecting a table pair — NOT per relation
+  // declaration. profiles<->posts is one FK (author_id) declared from both sides
+  // (belongsTo + its inverse hasMany): drizzle pairs them by table, no name needed.
+  // profiles<->follows is TWO FKs (follower_id, following_id): drizzle cannot tell
+  // which hasMany pairs which belongsTo, so every relation on that pair needs a name.
+  //
+  // Each relation resolves to a (childTable, fkColumnKey) — the child table holds the
+  // FK column. Count distinct such pairs per unordered table pair.
+  const fkColumnsByPair = new Map<string, Set<string>>();
+  for (const model of models) {
+    for (const rel of Object.values(model.relations)) {
+      const other = rel.target().table;
+      const childTable = rel.kind === 'belongsTo' ? model.table : other;
+      const k = pairKey(model.table, other);
+      let set = fkColumnsByPair.get(k);
+      if (!set) {
+        set = new Set<string>();
+        fkColumnsByPair.set(k, set);
+      }
+      set.add(relationPairId(childTable, rel.column));
+    }
+  }
+
+  const needsName = new Set<string>();
+  for (const model of models) {
+    for (const rel of Object.values(model.relations)) {
+      const other = rel.target().table;
+      const k = pairKey(model.table, other);
+      // Ambiguous when more than one distinct FK column connects the two tables.
+      if ((fkColumnsByPair.get(k)?.size ?? 0) <= 1) continue;
+      const childTable = rel.kind === 'belongsTo' ? model.table : other;
+      needsName.add(relationPairId(childTable, rel.column));
+    }
+  }
+  return { needsName };
+}
+
+/** The `relationName: '…'` fragment for a relation, or '' when the pair is unambiguous. */
+function relationNameFragment(
+  model: ModelDescriptor,
+  rel: { kind: 'belongsTo' | 'hasMany'; column: string; target: () => ModelDescriptor },
+  naming: RelationNaming,
+): string {
+  const other = rel.target().table;
+  const childTable = rel.kind === 'belongsTo' ? model.table : other;
+  const id = relationPairId(childTable, rel.column);
+  if (!naming.needsName.has(id)) return '';
+  return `, relationName: ${strLiteral(synthesizedName(childTable, rel.column))}`;
+}
+
+export interface CompileDrizzleSourceOptions {
+  /** Reserved for parity with the DDL compiler's `schema` option. Unused in the emit. */
+  schema?: string;
+}
+
+/**
+ * Emit the full text of a `schema.generated.ts` from a set of Models: hoisted
+ * `pgEnum`s, one `pgTable` per model (columns + table-extras), then a
+ * `relations()` block per model that declares any. The output is what an app's
+ * hand-written `db/schema.ts` is replaced by — fully-typed, derived, drift-guarded.
+ */
+export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: CompileDrizzleSourceOptions = {}): string {
+  // A private model is package-owned — its drizzle runtime table ships with the
+  // package (e.g. @everystack/storage/schema), so it never appears in the app's
+  // generated schema. (The migration generator still emits its SQL + authz.) The
+  // command and the drift guard both call this, so filtering here keeps them in sync.
+  const models = allModels.filter((m) => !m.private);
+
+  const modelsByDescriptor = new Map<ModelDescriptor, { camel: string }>();
+  for (const model of models) modelsByDescriptor.set(model, { camel: toCamelCase(model.table) });
+
+  // --- Collect enums (deduped by name, sorted) -----------------------------
+  const enumsByName = new Map<string, readonly string[]>();
+  for (const model of models) {
+    for (const f of Object.values(model.fields)) {
+      const { type, enumName, enumValues } = f.spec;
+      if (type !== 'enum' || !enumName) continue;
+      const values = enumValues ?? [];
+      const existing = enumsByName.get(enumName);
+      if (existing && existing.join(',') !== values.join(',')) {
+        throw new Error(`enum '${enumName}' is declared with conflicting values: [${existing}] vs [${values}]`);
+      }
+      if (!existing) enumsByName.set(enumName, values);
+    }
+  }
+  const enumNames = [...enumsByName.keys()].sort((a, b) => a.localeCompare(b));
+
+  // --- Track which pg-core builders + drizzle-orm symbols are used ----------
+  const pgCoreBuilders = new Set<string>();
+  pgCoreBuilders.add('pgTable');
+  if (enumNames.length) pgCoreBuilders.add('pgEnum');
+
+  const relationNaming = planRelationNames(models);
+  const anyRelations = models.some((m) => Object.keys(m.relations).length > 0);
+
+  // --- Emit each table -------------------------------------------------------
+  const tableBlocks: string[] = [];
+  for (const model of models) {
+    const camel = toCamelCase(model.table);
+    const isComposite = model.primaryKey.length > 1;
+
+    const colLines: string[] = [];
+    for (const [key, builder] of Object.entries(model.fields)) {
+      const spec = builder.spec;
+      const { call, builder: pgBuilder } = baseColumnSource(toSnakeCase(key), spec);
+      pgCoreBuilders.add(pgBuilder);
+      const mods = columnModifiers(spec, isComposite, modelsByDescriptor);
+      colLines.push(`  ${key}: ${call}${mods},`);
+    }
+
+    // Table-extras: composite PK, then table-level unique/check constraints.
+    const extras: string[] = [];
+    if (isComposite) {
+      pgCoreBuilders.add('primaryKey');
+      const cols = model.primaryKey.map((k) => `t.${k}`).join(', ');
+      extras.push(`  primaryKey({ columns: [${cols}] }),`);
+    }
+    for (const con of model.constraints) {
+      if (con.kind === 'unique') {
+        pgCoreBuilders.add('unique');
+        const cols = con.columns.map((k) => `t.${k}`).join(', ');
+        extras.push(`  unique().on(${cols}),`);
+      } else if (con.kind === 'check') {
+        pgCoreBuilders.add('check');
+        pgCoreBuilders.add('sql'); // imported from 'drizzle-orm', handled below
+        extras.push(`  check(${strLiteral(`${model.table}_check`)}, sql.raw(${strLiteral(con.predicate)})),`);
+      }
+      // 'index' / 'foreignKey' table constraints are not materialized on the runtime
+      // drizzle table object (mirrors toDrizzleTable), so they are omitted here.
+    }
+
+    const cols = `{\n${colLines.join('\n')}\n}`;
+    let block: string;
+    if (extras.length) {
+      block = `export const ${camel} = pgTable(${strLiteral(model.table)}, ${cols}, (t) => [\n${extras.join('\n')}\n]);`;
+    } else {
+      block = `export const ${camel} = pgTable(${strLiteral(model.table)}, ${cols});`;
+    }
+    tableBlocks.push(block);
+  }
+
+  // --- Emit relations() blocks ----------------------------------------------
+  const relationBlocks: string[] = [];
+  for (const model of models) {
+    const relEntries = Object.entries(model.relations);
+    if (relEntries.length === 0) continue;
+    const camel = toCamelCase(model.table);
+
+    const usesOne = relEntries.some(([, r]) => r.kind === 'belongsTo');
+    const usesMany = relEntries.some(([, r]) => r.kind === 'hasMany');
+    const helpers = [usesOne ? 'one' : null, usesMany ? 'many' : null].filter(Boolean).join(', ');
+
+    const lines: string[] = [];
+    for (const [key, rel] of relEntries) {
+      const target = rel.target();
+      const targetCamel = toCamelCase(target.table);
+      const nameFrag = relationNameFragment(model, rel, relationNaming);
+      if (rel.kind === 'belongsTo') {
+        // belongsTo(() => Target, column, references?) -> one(...)
+        const thisCol = rel.column; // FK FIELD KEY on this model
+        const targetPk = rel.references ?? primaryKeyKey(target);
+        lines.push(
+          `  ${key}: one(${targetCamel}, { fields: [${camel}.${thisCol}], references: [${targetCamel}.${targetPk}]${nameFrag} }),`,
+        );
+      } else {
+        // hasMany(() => Target, column, references?) -> many(...)
+        if (nameFrag) {
+          lines.push(`  ${key}: many(${targetCamel}, {${nameFrag.replace(/^, /, ' ')} }),`);
+        } else {
+          lines.push(`  ${key}: many(${targetCamel}),`);
+        }
+      }
+    }
+
+    relationBlocks.push(
+      `export const ${camel}Relations = relations(${camel}, ({ ${helpers} }) => ({\n${lines.join('\n')}\n}));`,
+    );
+  }
+
+  // --- Header ----------------------------------------------------------------
+  const header = [
+    '// GENERATED by `everystack db:generate` from models/. Do not edit.',
+    '//',
+    '// Cross-schema foreign keys (e.g. profiles.id -> auth.users.id) are intentionally',
+    '// omitted: a Model cannot reference a table outside the model set, so the runtime',
+    '// table and its relations() never carry that FK. The DB constraint stays untouched.',
+  ].join('\n');
+
+  // --- Imports ---------------------------------------------------------------
+  // pg-core: sorted, enum consts are not imports (they're declared below), `sql`
+  // comes from 'drizzle-orm', not pg-core — strip both from the pg-core set.
+  const enumConsts = new Set(enumNames.map(enumConstName));
+  const usesSqlRaw = pgCoreBuilders.has('sql');
+  const pgCoreNames = [...pgCoreBuilders].filter((b) => !enumConsts.has(b) && b !== 'sql').sort((a, b) => a.localeCompare(b));
+
+  const importLines: string[] = [];
+  importLines.push(`import { ${pgCoreNames.join(', ')} } from 'drizzle-orm/pg-core';`);
+
+  const drizzleOrmNames: string[] = [];
+  if (anyRelations) drizzleOrmNames.push('relations');
+  if (usesSqlRaw) drizzleOrmNames.push('sql');
+  drizzleOrmNames.sort((a, b) => a.localeCompare(b));
+  if (drizzleOrmNames.length) {
+    importLines.push(`import { ${drizzleOrmNames.join(', ')} } from 'drizzle-orm';`);
+  }
+
+  // --- Enum declarations -----------------------------------------------------
+  const enumDecls = enumNames.map((name) => {
+    const values = enumsByName.get(name) ?? [];
+    const valsText = values.map((v) => strLiteral(v)).join(', ');
+    return `export const ${enumConstName(name)} = pgEnum(${strLiteral(name)}, [${valsText}]);`;
+  });
+
+  // --- Assemble --------------------------------------------------------------
+  const sections: string[] = [];
+  sections.push(header);
+  sections.push(importLines.join('\n'));
+  if (enumDecls.length) sections.push(enumDecls.join('\n'));
+  for (const block of tableBlocks) sections.push(block);
+  for (const block of relationBlocks) sections.push(block);
+
+  return sections.join('\n\n') + '\n';
+}