@metaobjectsdev/codegen-ts 0.5.0-rc.1

package/src/templates/inferred-types.ts

@@ -0,0 +1,16 @@
+// Inferred types template — emits Drizzle's InferSelectModel / InferInsertModel type aliases.
+
+import { code, imp, type Code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { variableNameFromEntity } from "../naming.js";
+
+export function renderInferredTypes(entity: MetaObject): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const selectSym = imp("InferSelectModel@drizzle-orm");
+  const insertSym = imp("InferInsertModel@drizzle-orm");
+  return code`
+export type ${entity.name} = ${selectSym}<typeof ${varName}>;
+export type ${entity.name}Insert = ${insertSym}<typeof ${varName}>;
+export type ${entity.name}Update = Partial<${entity.name}Insert>;
+`;
+}

package/src/templates/projection-decl.ts

@@ -0,0 +1,146 @@
+// Projection declaration template — emits a Drizzle view declaration,
+// a Zod read schema, the TS type via z.infer, and a constants block.
+//
+// This is the read-only counterpart to entity-file.ts.
+// It does NOT emit:
+//   - Drizzle table declaration (view-only)
+//   - Zod Insert/Update schemas
+//   - Insert/Update types
+
+import { code, imp, joinCode, type Code } from "ts-poet";
+import { MetaField, MetaObject, type MetaRoot } from "@metaobjectsdev/metadata";
+import { extractViewSpec } from "../projection/extract-view-spec.js";
+import { columnNameFromField, toSnakeCase, pluralize } from "../naming.js";
+import { GENERATED_HEADER } from "../constants.js";
+import type { ColumnNamingStrategy } from "../metaobjects-config.js";
+import { renderFilterAllowlist, renderSortAllowlist } from "./filter-allowlist.js";
+import { renderFilterType } from "./filter-type.js";
+import { inferViewKind, zodTypeFor, currencyMetaFor, labelFor } from "./field-meta.js";
+
+// ---------------------------------------------------------------------------
+// Public interface
+// ---------------------------------------------------------------------------
+
+export interface ProjectionDeclOpts {
+  readonly columnNamingStrategy: ColumnNamingStrategy;
+  readonly dialect: "postgres" | "sqlite";
+  readonly apiPrefix?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Convert a PascalCase projection name to a kebab-pluralized URL path.
+ *   "ProgramSummary"  → "/program-summaries"
+ *   "CustomerSummary" → "/customer-summaries"
+ *   "Box"             → "/boxes"
+ *   "Wish"            → "/wishes"
+ */
+function pathFromProjectionName(name: string): string {
+  const kebab = toSnakeCase(pluralize(name)).replace(/_/g, "-");
+  return `/${kebab}`;
+}
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Render a TypeScript module for a projection entity. Emits:
+ *   - `<camel>View`          — Drizzle `pgView` / `sqliteView` with `.existing()`
+ *   - `<Projection>Schema`   — Zod read schema (no insert/update)
+ *   - `<Projection>`         — `z.infer` type alias
+ *   - `<Projection>` const   — constants block ($entity, $view, $path, per-field metadata)
+ *
+ * @param projection  The projection entity (has a source[dbView] child).
+ * @param root        The loader's root (all top-level objects as direct children,
+ *                    from `MetaDataLoader.load()` / `FileMetaDataLoader.loadFiles()` as `result.root`).
+ * @param opts        Column naming strategy + dialect.
+ */
+export function renderProjectionDecl(
+  projection: MetaObject,
+  root: MetaRoot,
+  opts: ProjectionDeclOpts,
+): string {
+  const { dialect, columnNamingStrategy, apiPrefix = "" } = opts;
+
+  const viewFn = dialect === "postgres" ? "pgView" : "sqliteView";
+  const viewModule =
+    dialect === "postgres" ? "drizzle-orm/pg-core" : "drizzle-orm/sqlite-core";
+  const viewSym = imp(`${viewFn}@${viewModule}`);
+  const z = imp("z@zod");
+
+  const spec = extractViewSpec(projection, root, { columnNamingStrategy });
+
+  // Collect fields: inherited from extends parent first, then projection-declared.
+  const allFields: MetaField[] = [];
+  const superModel = projection.superResolved;
+  const superName = superModel?.name ?? projection.superRef;
+  if (superName) {
+    const baseObj =
+      superModel instanceof MetaObject ? superModel : root.findObject(superName);
+    if (baseObj) {
+      // fields() returns effective fields, so inherited fields (from extends:/super:) are included.
+      for (const f of baseObj.fields()) allFields.push(f);
+    }
+  }
+  for (const f of projection.ownFields()) allFields.push(f);
+
+  const zodLines: Code[] = allFields.map(
+    (f) => code`  ${f.name}: ${z}.${zodTypeFor(f).replace(/^z\./, "")}`,
+  );
+
+  const constFieldLines: string[] = allFields.map((f) => {
+    const dbCol = columnNameFromField(f.name, columnNamingStrategy);
+    const view = inferViewKind(f);
+    const label = labelFor(f);
+    const baseEntry = `name: ${JSON.stringify(f.name)}, label: ${JSON.stringify(label)}, view: ${JSON.stringify(view)}, dbCol: ${JSON.stringify(dbCol)}`;
+    const currencyMeta = currencyMetaFor(f);
+    if (currencyMeta !== null) {
+      return `  ${f.name}: { ${baseEntry}, currency: ${JSON.stringify(currencyMeta.currency)}, locale: ${JSON.stringify(currencyMeta.locale)} },`;
+    }
+    return `  ${f.name}: { ${baseEntry} },`;
+  });
+
+  const projName = projection.name;
+  const camelName = projName.charAt(0).toLowerCase() + projName.slice(1);
+  const path = pathFromProjectionName(projName);
+  const viewName = spec.viewName;
+
+  const sections: Code[] = [
+    code`
+// View declaration — Drizzle uses this for typed SELECT queries.
+// The SQL view is created/managed by migrate-ts; .existing() tells Drizzle
+// not to attempt DDL for this declaration.
+export const ${camelName}View = ${viewSym}(${JSON.stringify(viewName)}, {}).existing();
+`,
+    code`
+export const ${projName}Schema = ${z}.object({
+${joinCode(zodLines, { on: ",\n" })}
+});
+`,
+    code`
+export type ${projName} = ${z}.infer<typeof ${projName}Schema>;
+`,
+    code`
+export const ${projName} = {
+  $entity:    ${JSON.stringify(projName)},
+  $view:      ${JSON.stringify(viewName)},
+  $path:      ${JSON.stringify(path)},
+  $apiPrefix: ${JSON.stringify(apiPrefix)},
+${constFieldLines.join("\n")}
+} as const;
+`,
+    renderFilterAllowlist(projection),
+    renderSortAllowlist(projection),
+    renderFilterType(projection),
+  ];
+
+  const body = joinCode(sections, { on: "\n" }).toString();
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${projName} (${projection.fqn()})\n`;
+  return header + body;
+}

package/src/templates/queries-file.ts

@@ -0,0 +1,56 @@
+// Queries file composer — composes all CRUD function renderers (from queries.ts) into
+// a complete <Entity>.queries.ts file with @generated header and correct imports.
+
+import { code, joinCode, type Code } from "ts-poet";
+import { MetaObject } from "@metaobjectsdev/metadata";
+import { type RenderContext } from "../render-context.js";
+import { entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
+import {
+  renderFindByIdFn,
+  renderListFn,
+  renderCreateFn,
+  renderUpdateFn,
+  renderDeleteByIdFn,
+} from "./queries.js";
+import { variableNameFromEntity } from "../naming.js";
+import { GENERATED_HEADER } from "../constants.js";
+
+export function renderQueriesFile(obj: MetaObject, ctx: RenderContext): string {
+  const entityName = obj.name;
+  // Import the entity's own file. Same target → relative "./Entity"; cross
+  // target → importBase-qualified package path.
+  const entityFileName = entityModuleSpecifier(
+    ctx.selfTarget,
+    ctx.entityModuleTarget,
+    obj.package,
+    entityName,
+    ctx.extStyle,
+  );
+  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, obj.package, ctx.dbImport);
+  const varName = variableNameFromEntity(entityName);
+
+  // Literal imports (db + entity types) live in a code block so they sort
+  // alongside ts-poet's hoisted imp() imports at the top of the body.
+  const literalImports = code`
+import { db } from ${JSON.stringify(dbImportSpec)};
+import { ${varName}, type ${entityName}, ${entityName}InsertSchema } from ${JSON.stringify(entityFileName)};
+`;
+
+  const sections: Code[] = [
+    literalImports,
+    renderFindByIdFn(obj, ctx),
+    renderListFn(obj, ctx),
+    renderCreateFn(obj, ctx),
+    renderUpdateFn(obj, ctx),
+    renderDeleteByIdFn(obj, ctx),
+  ];
+
+  // Render ts-poet body first, then prepend the @generated header so it lands
+  // at line 1 ahead of any imports.
+  const body = joinCode(sections, { on: "\n" }).toString();
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${entityName} (${obj.fqn()})\n` +
+    `// Customize via ${entityName}.extra.ts in this directory (additional queries, custom logic).\n`;
+  return header + body;
+}

package/src/templates/queries.ts

@@ -0,0 +1,132 @@
+// Queries template — individual CRUD function renderers.
+// Each returns a ts-poet Code block; composed into a file by queries-file.ts.
+
+import { code, imp, type Code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { IDENTITY_ATTR_FIELDS } from "@metaobjectsdev/metadata";
+import type { RenderContext } from "../render-context.js";
+import { variableNameFromEntity, toSnakeCase, pluralize } from "../naming.js";
+
+/** Derive a stable prepared statement name. Deterministic from entity + field names. */
+function prepareName(prefix: string, entitySnakeName: string, fieldDbName: string): string {
+  return `${prefix}_${entitySnakeName}_by_${fieldDbName}`;
+}
+
+/** Get the PK field name and its TS type for a given entity. */
+function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string; tsType: string } {
+  // Use primaryIdentity() to find the primary identity (may be inherited from extends:/super:).
+  const primary = entity.primaryIdentity();
+  const rawFields = primary?.ownAttr(IDENTITY_ATTR_FIELDS);
+  const fields = Array.isArray(rawFields) ? rawFields : (typeof rawFields === "string" ? [rawFields] : undefined);
+  const pkFieldName = fields?.[0] ?? "id";
+  const pkInfo = ctx.pkMap.get(entity.name);
+  const subType = pkInfo?.fieldSubType ?? "long";
+  const tsType =
+    subType === "long" || subType === "int" || subType === "short" || subType === "byte"
+      ? "number"
+      : subType === "boolean"
+        ? "boolean"
+        : "string";
+  return { fieldName: pkFieldName, tsType };
+}
+
+export function renderFindByIdFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const entityName = entity.name;
+  const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+  const entitySnakeName = toSnakeCase(entityName);
+  const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
+  const pkSnakeName = toSnakeCase(pkField);
+  const prepName = prepareName("find", entitySnakeName, pkSnakeName);
+  const fnName = `find${entityName}ById`;
+  const prepVarName = `${fnName}Prepared`;
+  const eqSym = imp("eq@drizzle-orm");
+  const sqlSym = imp("sql@drizzle-orm");
+
+  const baseVarName = `${fnName}Base`;
+
+  // Drizzle's `.prepare()` signature differs by dialect:
+  //   - Postgres: prepare(name) — the name is used by the pg driver to cache the plan
+  //   - SQLite:   prepare()     — no name; the name arg was removed in drizzle-orm 0.41+
+  const prepArg = ctx.dialect === "postgres" ? `"${prepName}"` : "";
+
+  return code`
+const ${baseVarName} = db
+  .select()
+  .from(${varName})
+  .where(${eqSym}(${varName}.${pkField}, ${sqlSym}.placeholder(${JSON.stringify(pkField)})));
+const ${prepVarName} = ${baseVarName}.prepare(${prepArg});
+
+export async function ${fnName}(${pkField}: ${pkType}): Promise<${entityName} | null> {
+  const [${singularVar}] = await ${prepVarName}.execute({ ${pkField} });
+  return ${singularVar} ?? null;
+}
+`;
+}
+
+export function renderListFn(entity: MetaObject, _ctx: RenderContext): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const entityName = entity.name;
+  // Pluralize the PascalCase entity name, preserving capitalization
+  // (e.g., "Category" -> "Categories", not "Categorys").
+  const fnName = `list${pluralize(entityName)}`;
+
+  return code`
+export async function ${fnName}(opts?: { limit?: number; offset?: number }): Promise<${entityName}[]> {
+  let q = db.select().from(${varName}).$dynamic();
+  if (opts?.limit !== undefined) q = q.limit(opts.limit);
+  if (opts?.offset !== undefined) q = q.offset(opts.offset);
+  return q;
+}
+`;
+}
+
+export function renderCreateFn(entity: MetaObject, _ctx: RenderContext): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const entityName = entity.name;
+  const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+  const fnName = `create${entityName}`;
+  const schemaName = `${entityName}InsertSchema`;
+
+  return code`
+export async function ${fnName}(data: unknown): Promise<${entityName}> {
+  const validated = ${schemaName}.parse(data);
+  const [${singularVar}] = await db.insert(${varName}).values(validated).returning();
+  return ${singularVar}!;
+}
+`;
+}
+
+export function renderUpdateFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const entityName = entity.name;
+  const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+  const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
+  const fnName = `update${entityName}`;
+  const schemaName = `${entityName}InsertSchema`;
+  const eqSym = imp("eq@drizzle-orm");
+
+  return code`
+export async function ${fnName}(${pkField}: ${pkType}, data: unknown): Promise<${entityName} | null> {
+  const validated = ${schemaName}.partial().parse(data);
+  const [${singularVar}] = await db.update(${varName}).set(validated).where(${eqSym}(${varName}.${pkField}, ${pkField})).returning();
+  return ${singularVar} ?? null;
+}
+`;
+}
+
+export function renderDeleteByIdFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = variableNameFromEntity(entity.name);
+  const entityName = entity.name;
+  const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
+  const fnName = `delete${entityName}ById`;
+  const eqSym = imp("eq@drizzle-orm");
+
+  return code`
+export async function ${fnName}(${pkField}: ${pkType}): Promise<boolean> {
+  const result = await db.delete(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField}));
+  // SQLite (libsql/Turso) returns { rowsAffected }; postgres returns array from .returning()
+  return ('rowsAffected' in result ? result.rowsAffected : (result as unknown as unknown[]).length) > 0;
+}
+`;
+}

package/src/templates/relations-block.ts

@@ -0,0 +1,65 @@
+// Relations block template — emits the Drizzle relations() block for one entity.
+// Derived from the RelationMap pre-pass (relation-resolver.ts).
+
+import { code, imp, joinCode, type Code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { CARDINALITY_ONE, CARDINALITY_MANY } from "@metaobjectsdev/metadata";
+import { type RenderContext } from "../render-context.js";
+import { crossEntitySpecifier } from "../import-path.js";
+import { variableNameFromEntity } from "../naming.js";
+import type { RelationEntry } from "../relation-resolver.js";
+
+/**
+ * Render the relations() block for one entity.
+ * Returns null if the entity has no relations to emit.
+ */
+export function renderRelationsBlock(entity: MetaObject, ctx: RenderContext): Code | null {
+  const entries = ctx.relationMap.get(entity.name);
+  if (!entries || entries.length === 0) return null;
+
+  const varName = variableNameFromEntity(entity.name);
+  const relationsFn = imp("relations@drizzle-orm");
+  const relationsVarName = `${varName}Relations`;
+
+  const hasOne = entries.some((e) => e.cardinality === CARDINALITY_ONE);
+  const hasMany = entries.some((e) => e.cardinality === CARDINALITY_MANY);
+
+  const paramParts: string[] = [];
+  if (hasOne) paramParts.push("one");
+  if (hasMany) paramParts.push("many");
+  const params = `{ ${paramParts.join(", ")} }`;
+
+  const thisEntityPackage = entity.package;
+  const lines: Code[] = entries.map((entry) =>
+    renderRelationEntry(entry, ctx, varName, thisEntityPackage),
+  );
+
+  return code`export const ${relationsVarName} = ${relationsFn}(${varName}, (${params}) => ({
+${joinCode(lines, { on: ",\n", trim: false })}
+}));
+`;
+}
+
+function renderRelationEntry(
+  entry: RelationEntry,
+  ctx: RenderContext,
+  thisVarName: string,
+  thisEntityPackage: string | undefined,
+): Code {
+  // Use imp() for cross-entity references so ts-poet tracks and emits the import.
+  const targetSpec = crossEntitySpecifier(
+    ctx.outputLayout,
+    thisEntityPackage,
+    ctx.packageOf.get(entry.targetEntity),
+    entry.targetEntity,
+    ctx.extStyle,
+  );
+  const targetVarSym = imp(`${variableNameFromEntity(entry.targetEntity)}@${targetSpec}`);
+
+  if (entry.cardinality === CARDINALITY_ONE) {
+    const pkInfo = ctx.pkMap.get(entry.targetEntity);
+    const targetPkField = pkInfo?.fieldName ?? "id";
+    return code`  ${entry.name}: one(${targetVarSym}, { fields: [${thisVarName}.${entry.fkField ?? "id"}], references: [${targetVarSym}.${targetPkField}] })`;
+  }
+  return code`  ${entry.name}: many(${targetVarSym})`;
+}

package/src/templates/routes-file.ts

@@ -0,0 +1,179 @@
+// Fastify route template — emits a per-entity routes file that delegates
+// CRUD verbs to helpers from @metaobjectsdev/runtime-ts/drizzle-fastify.
+//
+// Dispatch logic:
+//   isProjection(entity)  → mountReadOnlyCrudRoutes (GET list + GET :id only)
+//   vanilla / write-through entity → mountCrudRoutes (all 5 CRUD verbs)
+//
+// apiPrefix behaviour:
+//   ""        → flat mount: mountCrudRoutes({ fastify, ... })
+//   "/api"    → wrapped:    fastify.register(async (instance) => {
+//                             mountCrudRoutes({ fastify: instance, ... });
+//                           }, { prefix: "/api" });
+//
+// The user's Drizzle `db` instance is imported from ctx.dbImport (matching
+// the existing queries-file template). The entity's Drizzle table const is
+// imported alongside the Zod schemas + constants from the sibling Entity.ts.
+
+import { code, imp } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { type RenderContext } from "../render-context.js";
+import { entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
+import { GENERATED_HEADER } from "../constants.js";
+import { variableNameFromEntity } from "../naming.js";
+import { isProjection } from "../projection/projection-detector.js";
+
+export function renderRoutesFile(entity: MetaObject, ctx: RenderContext): string {
+  const entityName = entity.name;
+  const handlerName = `${entityName.charAt(0).toLowerCase()}${entityName.slice(1)}Routes`;
+  // Import the entity's own file. Same target → relative "./Entity"; cross
+  // target → importBase-qualified package path.
+  const entityFileSpec = entityModuleSpecifier(
+    ctx.selfTarget,
+    ctx.entityModuleTarget,
+    entity.package,
+    entityName,
+    ctx.extStyle,
+  );
+  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, entity.package, ctx.dbImport);
+
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${entityName} (${entity.fqn()})\n` +
+    `// Customize via ${entityName}.extra.ts in this directory (e.g., auth, additional handlers).\n`;
+
+  // --- Projection path: read-only routes (GET list + GET :id) ---
+  if (isProjection(entity)) {
+    const camelName = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+    const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
+    const mountReadOnlyCrudRoutesSym = imp(
+      "mountReadOnlyCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify",
+    );
+
+    const literalImports = code`
+import { db } from ${JSON.stringify(dbImportSpec)};
+import {
+  ${entityName},
+  ${camelName}View,
+  ${entityName}FilterAllowlist,
+  ${entityName}SortAllowlist,
+} from ${JSON.stringify(entityFileSpec)};
+`;
+
+    const body = ctx.apiPrefix
+      ? code`
+/**
+ * Mount read-only REST endpoints for ${entityName} (projection — view-backed, no writes).
+ *
+ * Exposes GET list + GET :id only. POST/PATCH/DELETE return 405.
+ * Customize: register this as-is, or import individual route helpers from
+ * @metaobjectsdev/runtime-ts/drizzle-fastify.
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+  await fastify.register(async (instance) => {
+    ${mountReadOnlyCrudRoutesSym}({
+      fastify: instance,
+      path: ${entityName}.$path,
+      db,
+      view: ${camelName}View,
+      filterAllowlist: ${entityName}FilterAllowlist,
+      sortAllowlist: ${entityName}SortAllowlist,
+      dialect: ${JSON.stringify(ctx.dialect)},
+    });
+  }, { prefix: ${JSON.stringify(ctx.apiPrefix)} });
+}
+`
+      : code`
+/**
+ * Mount read-only REST endpoints for ${entityName} (projection — view-backed, no writes).
+ *
+ * Exposes GET list + GET :id only. POST/PATCH/DELETE return 405.
+ * Customize: register this as-is, or import individual route helpers from
+ * @metaobjectsdev/runtime-ts/drizzle-fastify.
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+  ${mountReadOnlyCrudRoutesSym}({
+    fastify,
+    path: ${entityName}.$path,
+    db,
+    view: ${camelName}View,
+    filterAllowlist: ${entityName}FilterAllowlist,
+    sortAllowlist: ${entityName}SortAllowlist,
+    dialect: ${JSON.stringify(ctx.dialect)},
+  });
+}
+`;
+
+    return header + literalImports.toString() + body.toString();
+  }
+
+  // --- Vanilla / write-through entity path: full CRUD routes ---
+  const tableVar = variableNameFromEntity(entityName);
+
+  const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
+  const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify");
+
+  const literalImports = code`
+import { db } from ${JSON.stringify(dbImportSpec)};
+import {
+  ${entityName},
+  ${tableVar},
+  ${entityName}InsertSchema,
+  ${entityName}UpdateSchema,
+  ${entityName}FilterAllowlist,
+  ${entityName}SortAllowlist,
+} from ${JSON.stringify(entityFileSpec)};
+`;
+
+  const body = ctx.apiPrefix
+    ? code`
+/**
+ * Mount the 5 standard REST endpoints for ${entityName} using Drizzle directly.
+ *
+ * Customize: register this as-is for stock CRUD, OR import the per-verb
+ * helpers (mountListRoute, mountGetRoute, ...) from
+ * @metaobjectsdev/runtime-ts/drizzle-fastify and mix with your own handlers
+ * (auth, side effects, etc.).
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+  await fastify.register(async (instance) => {
+    ${mountCrudRoutesSym}({
+      fastify: instance,
+      path: ${entityName}.$path,
+      db,
+      table: ${tableVar},
+      insertSchema: ${entityName}InsertSchema,
+      updateSchema: ${entityName}UpdateSchema,
+      filterAllowlist: ${entityName}FilterAllowlist,
+      sortAllowlist: ${entityName}SortAllowlist,
+      dialect: ${JSON.stringify(ctx.dialect)},
+    });
+  }, { prefix: ${JSON.stringify(ctx.apiPrefix)} });
+}
+`
+    : code`
+/**
+ * Mount the 5 standard REST endpoints for ${entityName} using Drizzle directly.
+ *
+ * Customize: register this as-is for stock CRUD, OR import the per-verb
+ * helpers (mountListRoute, mountGetRoute, ...) from
+ * @metaobjectsdev/runtime-ts/drizzle-fastify and mix with your own handlers
+ * (auth, side effects, etc.).
+ */
+export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
+  ${mountCrudRoutesSym}({
+    fastify,
+    path: ${entityName}.$path,
+    db,
+    table: ${tableVar},
+    insertSchema: ${entityName}InsertSchema,
+    updateSchema: ${entityName}UpdateSchema,
+    filterAllowlist: ${entityName}FilterAllowlist,
+    sortAllowlist: ${entityName}SortAllowlist,
+    dialect: ${JSON.stringify(ctx.dialect)},
+  });
+}
+`;
+
+  return header + literalImports.toString() + body.toString();
+}