@metaobjectsdev/codegen-ts 0.5.0-rc.1

package/src/render-context.ts

@@ -0,0 +1,93 @@
+// RenderContext — cross-cutting state passed to every template.
+
+import type { MetaRoot } from "@metaobjectsdev/metadata";
+import type { Dialect } from "./column-mapper.js";
+import type { PkInfo } from "./pk-resolver.js";
+import type { RelationMap } from "./relation-resolver.js";
+import type { ColumnNamingStrategy } from "./metaobjects-config.js";
+import type { OutputLayout, ResolvedTarget } from "./import-path.js";
+
+/**
+ * How to format cross-entity import specifiers in generated files.
+ *   - "none" → emit `"./Foo"`. **Default.** Works for moduleResolution
+ *              "bundler"/"node", tsx, drizzle-kit's TS loader, Vite, esbuild,
+ *              and almost every modern TS toolchain.
+ *   - "js"   → emit `"./Foo.js"`. Required for Node ESM strict + TS NodeNext.
+ *              Opt in via `--ext-style js` or `codegen.extStyle = "js"`.
+ */
+export type ExtStyle = "js" | "none";
+
+export interface RenderContext {
+  dialect: Dialect;
+  loadedRoot: MetaRoot;
+  outDir: string;
+  /**
+   * Import path for { db } in generated .queries.ts files.
+   * E.g. '~/server/db'. Set via forge.config.ts codegen.dbImport.
+   */
+  dbImport: string;
+  /**
+   * Import path for { om } in generated .routes.ts files.
+   * E.g. '../index' or '@your-pkg/database'. The module is expected to export
+   * an `om()` function returning a Promise<ObjectManager>.
+   * Defaults to '../index' (one level up from outDir).
+   */
+  omImport: string;
+  /** Cross-entity import-specifier style. Defaults to "js" (Node-ESM-safe). */
+  extStyle: ExtStyle;
+  /** Column naming strategy: how field names map to DB column names. Defaults to "snake_case". */
+  columnNamingStrategy: ColumnNamingStrategy;
+  /** Path prefix applied to generated route registrations + hook fetch URLs. Defaults to "". */
+  apiPrefix: string;
+  /** Output layout mode: "flat" (default) — all files in outDir; "package" — sub-paths from entity metadata package. */
+  outputLayout: OutputLayout;
+  /** The target THIS generator emits to (drives path layout + same-target imports). */
+  selfTarget: ResolvedTarget;
+  /** Where entity files live (drives cross-target entity imports). */
+  entityModuleTarget: ResolvedTarget;
+  pkMap: Map<string, PkInfo>;
+  /** Pre-pass relation map for FK + relations() block emission. */
+  relationMap: RelationMap;
+  /** Entity name → its metadata package (undefined if the entity has no package). Built once per run. */
+  packageOf: Map<string, string | undefined>;
+}
+
+/** Optional shape — `extStyle`, `omImport`, `columnNamingStrategy`, `apiPrefix`, `outputLayout`, and `packageOf` default if omitted. `packageOf` defaults to an empty Map (correct for flat layout; `runGen` always provides the real map). */
+export type RenderContextInput = Omit<RenderContext, "extStyle" | "omImport" | "columnNamingStrategy" | "apiPrefix" | "outputLayout" | "packageOf" | "selfTarget" | "entityModuleTarget"> & {
+  extStyle?: ExtStyle;
+  omImport?: string;
+  columnNamingStrategy?: ColumnNamingStrategy;
+  apiPrefix?: string;
+  outputLayout?: OutputLayout;
+  packageOf?: Map<string, string | undefined>;
+  selfTarget?: ResolvedTarget;
+  entityModuleTarget?: ResolvedTarget;
+};
+
+/** Append the configured extension to a cross-entity module specifier. */
+export function withExt(spec: string, style: ExtStyle): string {
+  return style === "js" ? `${spec}.js` : spec;
+}
+
+/** Thin factory; applies sensible defaults for fields the caller may omit. */
+export function makeRenderContext(opts: RenderContextInput): RenderContext {
+  const outputLayout = opts.outputLayout ?? "flat";
+  const defaultTarget: ResolvedTarget = opts.selfTarget ?? {
+    name: "default",
+    outDir: opts.outDir,
+    importBase: undefined,
+    outputLayout,
+    dbImport: opts.dbImport,
+  };
+  return {
+    ...opts,
+    extStyle: opts.extStyle ?? "none",
+    omImport: opts.omImport ?? "../index",
+    columnNamingStrategy: opts.columnNamingStrategy ?? "snake_case",
+    apiPrefix: opts.apiPrefix ?? "",
+    outputLayout,
+    packageOf: opts.packageOf ?? new Map(),
+    selfTarget: defaultTarget,
+    entityModuleTarget: opts.entityModuleTarget ?? defaultTarget,
+  };
+}

package/src/runner.ts

@@ -0,0 +1,178 @@
+import { join } from "node:path";
+import type { MetaData, MetaObject } from "@metaobjectsdev/metadata";
+import { MetaRoot } from "@metaobjectsdev/metadata";
+import type { Generator, GenContext, EmittedFile } from "./generator.js";
+import type { MetaobjectsGenConfig } from "./metaobjects-config.js";
+import { normalizeConfig, DEFAULT_TARGET_NAME } from "./metaobjects-config.js";
+import type { ResolvedTarget } from "./import-path.js";
+import { buildPkMap } from "./pk-resolver.js";
+import { buildRelationMap } from "./relation-resolver.js";
+import { makeRenderContext } from "./render-context.js";
+import { decideAndWrite, type WriteResult, type MergeStrategy } from "./overwrite-policy.js";
+
+/** JS-identifier-shape only. Prevents filesystem traversal when metadata comes
+ *  from untrusted sources (e.g. MCP). Mirrors the guard in legacy generate.ts. */
+const VALID_ENTITY_NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+
+export interface RunGenOpts {
+  config: MetaobjectsGenConfig;
+  metadata: MetaData;
+  /** Optional whitelist of entity names. */
+  entityFilter?: string[];
+  /** Overwrite strategy passed to decideAndWrite. Defaults to "overwrite". */
+  mergeStrategy?: MergeStrategy;
+}
+
+export interface RunGenResult {
+  files: WriteResult[];
+  warnings: string[];
+}
+
+export async function runGen(opts: RunGenOpts): Promise<RunGenResult> {
+  const warnings: string[] = [];
+  const strategy = opts.mergeStrategy ?? "overwrite";
+
+  // loadMemory now returns MetaRoot; guard here also covers callers that pass a
+  // plain MetaData (e.g. test helpers that build trees programmatically).
+  if (!(opts.metadata instanceof MetaRoot)) {
+    throw new Error("runGen: opts.metadata must be a loaded MetaRoot.");
+  }
+  const root = opts.metadata;
+
+  // 1. Resolve entities (filter + safety check).
+  const allObjects = root.objects();
+  const entityFilter = opts.entityFilter;
+  const filtered = entityFilter
+    ? allObjects.filter((o) => entityFilter.includes(o.name))
+    : allObjects;
+  if (filtered.length === 0) {
+    const reason = opts.entityFilter
+      ? "no object children match the provided entityFilter"
+      : "root has no object children";
+    warnings.push(`No entities to generate — ${reason}.`);
+    return { files: [], warnings };
+  }
+
+  const safeEntities: MetaObject[] = [];
+  for (const entity of filtered) {
+    if (!VALID_ENTITY_NAME.test(entity.name)) {
+      warnings.push(
+        `Skipping entity with unsafe name "${entity.name}" — must match /^[A-Za-z_][A-Za-z0-9_]*$/.`,
+      );
+      continue;
+    }
+    safeEntities.push(entity);
+  }
+  if (safeEntities.length === 0) {
+    return { files: [], warnings };
+  }
+
+  // 2. Resolve targets + entity-module target.
+  const config = normalizeConfig(opts.config);
+  const targets = config.targets;
+  const targetOf = (g: Generator): ResolvedTarget => {
+    const name = g.target ?? DEFAULT_TARGET_NAME;
+    const t = targets[name];
+    if (!t) {
+      throw new Error(
+        `Generator "${g.name}" references unknown target "${name}". ` +
+        `Valid targets: ${Object.keys(targets).join(", ")}.`,
+      );
+    }
+    return t;
+  };
+  // Validate all target references up front.
+  for (const g of config.generators) targetOf(g);
+
+  const entityGen = config.generators.find((g) => g.emitsEntityModule);
+  const entityModuleTarget = entityGen ? targetOf(entityGen) : targets[DEFAULT_TARGET_NAME]!;
+
+  const needsCrossTarget = config.generators.some(
+    (g) => (g.target ?? DEFAULT_TARGET_NAME) !== entityModuleTarget.name,
+  );
+  if (needsCrossTarget && entityModuleTarget.importBase === undefined) {
+    throw new Error(
+      `Target "${entityModuleTarget.name}" holds the entity modules that other ` +
+      `targets import, but has no importBase. Set importBase on it (e.g. ` +
+      `"@your-pkg/database/generated").`,
+    );
+  }
+
+  // 3. Build shared render state once.
+  const pkMap = buildPkMap(root);
+  const relationMap = buildRelationMap(root);
+  const packageOf = new Map<string, string | undefined>(
+    root.objects().map((o) => [o.name, o.package]),
+  );
+
+  // 4. Run each generator with a per-target render context; collect with full path.
+  const emitted: { fullPath: string; content: string; generatedBy: string }[] = [];
+  for (const generator of config.generators) {
+    const selfTarget = targetOf(generator);
+    const renderContext = makeRenderContext({
+      dialect: config.dialect,
+      loadedRoot: root,
+      outDir: selfTarget.outDir,
+      dbImport: selfTarget.dbImport,
+      extStyle: config.extStyle,
+      columnNamingStrategy: config.columnNamingStrategy,
+      apiPrefix: config.apiPrefix,
+      outputLayout: selfTarget.outputLayout,
+      pkMap,
+      relationMap,
+      packageOf,
+      selfTarget,
+      entityModuleTarget,
+    });
+    const ctx: GenContext = {
+      entities: safeEntities,
+      loadedRoot: root,
+      matches: (e) => generator.filter?.(e) ?? true,
+      config: {
+        outDir: selfTarget.outDir,
+        extStyle: config.extStyle,
+        dbImport: selfTarget.dbImport,
+        dialect: config.dialect,
+        outputLayout: selfTarget.outputLayout,
+      },
+      renderContext,
+      warn: (msg) => warnings.push(`[${generator.name}] ${msg}`),
+    };
+
+    let files: EmittedFile[];
+    try {
+      files = await generator.generate(ctx);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new Error(`[${generator.name}] ${msg}`);
+    }
+
+    for (const file of files) {
+      const fullPath = join(selfTarget.outDir, file.path);
+      const collision = emitted.find((prev) => prev.fullPath === fullPath);
+      if (collision) {
+        throw new Error(
+          `Output path collision: "${fullPath}" emitted by both ` +
+          `"${collision.generatedBy}" and "${generator.name}". ` +
+          `Adjust one generator's filter or output path.`,
+        );
+      }
+      emitted.push({ fullPath, content: file.content, generatedBy: generator.name });
+    }
+  }
+
+  // 5. Write phase.
+  const writes: WriteResult[] = [];
+  for (const file of emitted) {
+    const result = decideAndWrite(file.fullPath, file.content, strategy);
+    writes.push(result);
+    if (result.status === "refused") {
+      warnings.push(
+        `Refused to overwrite ${file.fullPath}: file exists without @generated header. ` +
+        `Move to a different outDir, delete the file, or add the header to opt in.`,
+      );
+    }
+  }
+
+  return { files: writes, warnings };
+}

package/src/templates/barrel.ts

@@ -0,0 +1,23 @@
+// Barrel template — emits index.ts with one export per entity, alphabetical.
+
+import { GENERATED_HEADER } from "../constants.js";
+import { type ExtStyle } from "../render-context.js";
+import { barrelModuleSpecifier, type ResolvedTarget } from "../import-path.js";
+
+export interface BarrelEntry {
+  name: string;
+  package: string | undefined;
+}
+
+export function renderBarrel(
+  entries: BarrelEntry[],
+  extStyle: ExtStyle,
+  selfTarget: ResolvedTarget,
+  entityModuleTarget: ResolvedTarget,
+): string {
+  const sorted = [...entries].sort((a, b) => a.name.localeCompare(b.name));
+  const exports = sorted
+    .map((e) => `export * from ${JSON.stringify(barrelModuleSpecifier(selfTarget, entityModuleTarget, e.package, e.name, extStyle))};`)
+    .join("\n");
+  return `// ${GENERATED_HEADER} — DO NOT EDIT.\n${exports}\n`;
+}

package/src/templates/drizzle-schema.ts

@@ -0,0 +1,286 @@
+// Drizzle schema template — emits a single sqliteTable() or pgTable() definition,
+// with FK .references() on FK columns derived from relationship children,
+// plus the relations() block auto-emitted at the end.
+
+import { code, imp, joinCode, type Code } from "ts-poet";
+import { MetaObject, MetaField } from "@metaobjectsdev/metadata";
+import {
+  IDENTITY_SUBTYPE_SECONDARY, FIELD_SUBTYPE_LONG,
+  IDENTITY_ATTR_FIELDS, IDENTITY_ATTR_GENERATION, IDENTITY_ATTR_UNIQUE,
+  GENERATION_INCREMENT, GENERATION_UUID,
+  FIELD_ATTR_AUTO_SET,
+} from "@metaobjectsdev/metadata";
+import { type RenderContext } from "../render-context.js";
+import { crossEntitySpecifier } from "../import-path.js";
+import { mapColumnType } from "../column-mapper.js";
+import { tableNameFromEntity, variableNameFromEntity, columnNameFromField } from "../naming.js";
+import { renderRelationsBlock } from "./relations-block.js";
+
+/**
+ * Render the Drizzle table definition for one entity, including:
+ * - FK .references() on FK columns derived from relationship children
+ * - relations() block at the end of the section
+ *
+ * Returns a Code object so ts-poet can deduplicate imports when this composes
+ * with the rest of the entity file. Biome formatting runs after composition.
+ */
+export function renderDrizzleSchema(obj: MetaObject, ctx: RenderContext): Code {
+  const dialect = ctx.dialect;
+  const tableFn = dialect === "sqlite" ? "sqliteTable" : "pgTable";
+  const importModule = dialect === "sqlite" ? "drizzle-orm/sqlite-core" : "drizzle-orm/pg-core";
+  const tableFnSym = imp(`${tableFn}@${importModule}`);
+
+  const tableName = obj.dbTable ?? tableNameFromEntity(obj.name, ctx.columnNamingStrategy);
+  const varName = variableNameFromEntity(obj.name);
+
+  const primary = obj.primaryIdentity();
+  const rawPkFields = primary?.ownAttr(IDENTITY_ATTR_FIELDS);
+  const pkFieldsList: string[] = Array.isArray(rawPkFields)
+    ? rawPkFields as string[]
+    : typeof rawPkFields === "string"
+      ? rawPkFields.split(",").map((f) => f.trim()).filter(Boolean)
+      : [];
+  const pkFieldNames = new Set<string>(pkFieldsList);
+  const pkGeneration = primary?.ownAttr(IDENTITY_ATTR_GENERATION) as string | undefined;
+
+  const fkMap = buildFkMapForEntity(obj, ctx);
+
+  const isComposite = pkFieldNames.size > 1;
+
+  // Collect secondary identities and the field names that need .unique() on
+  // their column. Only single-column UNIQUE identities propagate .unique() to
+  // the column — non-unique indexes emit a separate index() callback entry
+  // (handled below) and must not stamp .unique() on the underlying column.
+  const secondaryIdentities = obj.secondaryIdentities();
+  const uniqueFieldNames = new Set<string>();
+  for (const sec of secondaryIdentities) {
+    const uniqueAttr = sec.ownAttr(IDENTITY_ATTR_UNIQUE);
+    if (uniqueAttr === false) continue; // explicit non-unique → don't mark column
+    const fields = sec.ownAttr(IDENTITY_ATTR_FIELDS) as string[] | undefined;
+    if (!Array.isArray(fields) || fields.length !== 1) continue; // multi-col uniques use a callback index, not a column flag
+    uniqueFieldNames.add(fields[0]!);
+  }
+
+  const columnLines: Code[] = [];
+  for (const child of obj.fields()) {
+    const isPk = pkFieldNames.has(child.name);
+    const isUnique = uniqueFieldNames.has(child.name) && !isPk;
+    const fkInfo = fkMap.get(child.name);
+    columnLines.push(renderColumn(child, ctx, isPk, pkGeneration, fkInfo, isComposite, isUnique, obj.package));
+  }
+
+  // Build all table callback entries
+  const callbackEntries: Code[] = [];
+
+  if (isComposite && primary !== undefined) {
+    callbackEntries.push(buildCompositeKeyCallback(pkFieldNames, importModule));
+  }
+
+  for (const sec of secondaryIdentities) {
+    const fields = sec.ownAttr(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("_")}`;
+    // @unique on the identity defaults to true (preserves back-compat with
+    // foundations fixtures that assumed secondary identities were always
+    // unique). Explicit @unique: false → ordinary non-unique index.
+    const uniqueAttr = sec.ownAttr(IDENTITY_ATTR_UNIQUE);
+    const isUnique = uniqueAttr !== false;
+    const indexFn = isUnique ? "uniqueIndex" : "index";
+    const indexSym = imp(`${indexFn}@${importModule}`);
+    // Use the callback param `table` (not the outer varName) so TS doesn't 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})`);
+  }
+
+  let tableBlock: Code;
+  if (callbackEntries.length > 0) {
+    tableBlock = code`
+export const ${varName} = ${tableFnSym}(${JSON.stringify(tableName)}, {
+${joinCode(columnLines, { on: ",\n", trim: false })}
+}, (table) => [
+  ${joinCode(callbackEntries, { on: ",\n  ", trim: false })}
+]);
+`;
+  } else {
+    tableBlock = code`
+export const ${varName} = ${tableFnSym}(${JSON.stringify(tableName)}, {
+${joinCode(columnLines, { on: ",\n", trim: false })}
+});
+`;
+  }
+
+  // Emit the relations() block (returns null if no relations).
+  const relationsBlock = renderRelationsBlock(obj, ctx);
+
+  if (relationsBlock === null) {
+    return tableBlock;
+  }
+
+  return joinCode([tableBlock, relationsBlock], { on: "\n" });
+}
+
+interface FkInfo {
+  targetVarName: string;    // e.g., "users"
+  targetEntityName: string; // e.g., "User" — used for the import path
+  targetPkField: string;    // e.g., "id"
+}
+
+/** Pre-pass: map fkFieldName → FkInfo for this entity's effective (own + inherited) identity.reference children. */
+function buildFkMapForEntity(obj: MetaObject, ctx: RenderContext): Map<string, FkInfo> {
+  const result = new Map<string, FkInfo>();
+  for (const ref of obj.referenceIdentities()) {
+    // @enforce: false → logical-only reference. Skip the .references() emission;
+    // the column stays plain. Drizzle's relations() block (driven by
+    // relation-resolver) still includes the relationship for query navigation.
+    if (!ref.enforce) continue;
+    const fkFieldNames = ref.fields;
+    if (fkFieldNames.length === 0) continue;
+    const fkField = fkFieldNames[0]!;
+    const targetName = ref.targetEntity;
+    if (!targetName) continue;
+    const targetObj = ctx.loadedRoot.findObject(targetName);
+    if (!targetObj) continue;
+    const targetPkField = ref.resolvedTargetPkField(ctx.loadedRoot) ?? "id";
+    result.set(fkField, {
+      targetVarName: variableNameFromEntity(targetObj.name),
+      targetEntityName: targetObj.name,
+      targetPkField,
+    });
+  }
+  return result;
+}
+
+/**
+ * Build the `primaryKey({ columns: [table.f1, table.f2] })` Code expression
+ * for composite primary keys. Uses imp() so ts-poet tracks the import.
+ */
+function buildCompositeKeyCallback(
+  pkFieldNames: Set<string>,
+  importModule: string,
+): Code {
+  const primaryKeySym = imp(`primaryKey@${importModule}`);
+  const columnRefs = Array.from(pkFieldNames)
+    .map((f) => `table.${f}`)
+    .join(", ");
+  return code`${primaryKeySym}({ columns: [${columnRefs}] })`;
+}
+
+/** Build a JS-style object literal string (not JSON.stringify which uses quoted keys). */
+function inlineObjectLiteral(obj: Record<string, unknown>): string {
+  const entries = Object.entries(obj).map(([k, v]) => `${k}: ${JSON.stringify(v)}`);
+  return `{ ${entries.join(", ")} }`;
+}
+
+/** Render one column line (field name + Drizzle column expression). */
+function renderColumn(
+  field: MetaField,
+  ctx: RenderContext,
+  isPk: boolean,
+  pkGeneration: string | undefined,
+  fkInfo: FkInfo | undefined,
+  isComposite: boolean,
+  isUnique: boolean = false,
+  entityPackage: string | undefined = undefined,
+): Code {
+  const spec = mapColumnType(field, ctx.dialect, ctx.columnNamingStrategy);
+  const fnSym = 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)})`;
+  } else {
+    baseCall = code`${fnSym}(${dbNameLit})`;
+  }
+
+  let pkSuffix = "";
+  if (isPk) {
+    if (pkGeneration === GENERATION_INCREMENT) {
+      if (ctx.dialect === "sqlite") {
+        // Composite PKs don't use .primaryKey() per-column; table callback owns it.
+        pkSuffix = isComposite ? "" : ".primaryKey({ autoIncrement: true })";
+      } else {
+        // 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" })`;
+        } else {
+          const serialSym = imp(`serial@${spec.importModule}`);
+          baseCall = code`${serialSym}(${dbNameLit})`;
+        }
+        pkSuffix = isComposite ? "" : ".primaryKey()";
+      }
+    } else if (pkGeneration === GENERATION_UUID) {
+      pkSuffix = isComposite
+        ? ""
+        : ctx.dialect === "sqlite"
+          ? ".primaryKey().$defaultFn(() => crypto.randomUUID())"
+          : ".primaryKey().defaultRandom()";
+    } else {
+      // No generation: natural PK. Composite hands off to table callback.
+      pkSuffix = isComposite ? "" : ".primaryKey()";
+    }
+  }
+
+  let modifiersStr = pkSuffix;
+  // Append .unique() for secondary-identity fields (isPk guard already excluded PKs upstream).
+  if (isUnique) modifiersStr += ".unique()";
+  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;
+    modifiersStr += m;
+  }
+
+  // sqlDefaultSegment must be a Code segment (not a raw string) so ts-poet tracks
+  // the `sql` import via imp(); a raw `.default(sql`...`)` would leave `sql`
+  // unresolved in the generated file.
+  let sqlDefaultSegment: Code | null = null;
+  if (spec.defaultExpr !== undefined && !isPk) {
+    if (spec.defaultExpr.kind === "now") {
+      if (ctx.dialect === "sqlite") {
+        const sqlSym = imp("sql@drizzle-orm");
+        sqlDefaultSegment = code`.default(${sqlSym}\`CURRENT_TIMESTAMP\`)`;
+      } else {
+        modifiersStr += `.defaultNow()`;
+      }
+    } else if (spec.defaultExpr.kind === "sqlExpr") {
+      const sqlSym = imp("sql@drizzle-orm");
+      // Raw SQL keyword/expression — emit as sql`<raw>` for both dialects.
+      sqlDefaultSegment = code`.default(${sqlSym}\`${spec.defaultExpr.raw}\`)`;
+    } else {
+      // literal
+      modifiersStr += `.default(${JSON.stringify(spec.defaultExpr.value)})`;
+    }
+  }
+
+  // FK .references() uses imp() so ts-poet tracks the cross-entity import.
+  let fkRefSegment: Code | null = null;
+  if (fkInfo !== undefined && !isPk) {
+    const targetSpec = crossEntitySpecifier(
+      ctx.outputLayout,
+      entityPackage,
+      ctx.packageOf.get(fkInfo.targetEntityName),
+      fkInfo.targetEntityName,
+      ctx.extStyle,
+    );
+    const targetVarSym = imp(`${fkInfo.targetVarName}@${targetSpec}`);
+    fkRefSegment = code`.references(() => ${targetVarSym}.${fkInfo.targetPkField})`;
+  }
+
+  // @autoSet fields: emit .$defaultFn(() => new Date().toISOString()) so Drizzle
+  // inserts stamp the server-side timestamp automatically. This means callers don't
+  // need to supply createdAt / updatedAt in INSERT calls — Drizzle fills them in.
+  const autoSet = field.ownAttr(FIELD_ATTR_AUTO_SET);
+  const autoSetSuffix = (autoSet === "onCreate" || autoSet === "onUpdate")
+    ? `.$defaultFn(() => new Date().toISOString())`
+    : "";
+
+  const columnLine = code`  ${field.name}: ${baseCall}${modifiersStr}${autoSetSuffix}${sqlDefaultSegment ?? ""}${fkRefSegment ?? ""}`;
+  return spec.leadingComment !== undefined
+    ? code`  // ${spec.leadingComment}\n${columnLine}`
+    : columnLine;
+}