@metaobjectsdev/codegen-ts 0.6.0 → 0.7.0-rc.10

package/src/templates/inferred-types.ts

@@ -1,9 +1,34 @@
 // Inferred types template — emits Drizzle's InferSelectModel / InferInsertModel type aliases,
 // plus named union types for field.enum fields.
+//
+// Also emits the structural TS interface for value-only objects (metaobjects
+// with no writable source.rdb). That path side-steps Drizzle entirely: the
+// interface is computed directly from the field tree, with `name?: T` for
+// optional fields (matching Zod's `.optional()` inference — `T | undefined` —
+// without the superfluous `| null` that Drizzle nullable columns introduce).
 
-import { code, imp, type Code } from "ts-poet";
-import type { MetaObject } from "@metaobjectsdev/metadata";
-import { FIELD_SUBTYPE_ENUM } from "@metaobjectsdev/metadata";
+import { code, imp, joinCode, type Code } from "ts-poet";
+import type { MetaObject, MetaField } from "@metaobjectsdev/metadata";
+import {
+  FIELD_SUBTYPE_ENUM,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_SUBTYPE_STRING,
+  FIELD_SUBTYPE_INT,
+  FIELD_SUBTYPE_SHORT,
+  FIELD_SUBTYPE_BYTE,
+  FIELD_SUBTYPE_LONG,
+  FIELD_SUBTYPE_DOUBLE,
+  FIELD_SUBTYPE_FLOAT,
+  FIELD_SUBTYPE_DECIMAL,
+  FIELD_SUBTYPE_CURRENCY,
+  FIELD_SUBTYPE_BOOLEAN,
+  FIELD_SUBTYPE_DATE,
+  FIELD_SUBTYPE_TIME,
+  FIELD_SUBTYPE_TIMESTAMP,
+  FIELD_SUBTYPE_CLASS,
+  FIELD_ATTR_REQUIRED,
+  FIELD_ATTR_OBJECT_REF,
+} from "@metaobjectsdev/metadata";
 import { variableNameFromEntity, toPascalCase } from "../naming.js";
 import { enumValues } from "../enum-meta.js";
 import { renderDocsFor } from "./jsdoc.js";
@@ -53,3 +78,92 @@ export function renderEnumTypeAliases(entity: MetaObject): Code | null {
 
   return lines.length > 0 ? code`${lines.join("\n")}` : null;
 }
+
+// ---------------------------------------------------------------------------
+// Value-object interface emitter
+// ---------------------------------------------------------------------------
+
+const SCALAR_TS_BY_SUBTYPE: Record<string, string> = {
+  [FIELD_SUBTYPE_STRING]: "string",
+  [FIELD_SUBTYPE_CLASS]: "string",
+  [FIELD_SUBTYPE_INT]: "number",
+  [FIELD_SUBTYPE_SHORT]: "number",
+  [FIELD_SUBTYPE_BYTE]: "number",
+  [FIELD_SUBTYPE_LONG]: "number",
+  [FIELD_SUBTYPE_DOUBLE]: "number",
+  [FIELD_SUBTYPE_FLOAT]: "number",
+  [FIELD_SUBTYPE_DECIMAL]: "number",
+  [FIELD_SUBTYPE_CURRENCY]: "number",
+  [FIELD_SUBTYPE_BOOLEAN]: "boolean",
+  [FIELD_SUBTYPE_DATE]: "string",
+  [FIELD_SUBTYPE_TIME]: "string",
+  [FIELD_SUBTYPE_TIMESTAMP]: "string",
+};
+
+/** Type-alias name for a field.enum, mirroring renderEnumTypeAliases. */
+function enumTypeAliasName(entity: MetaObject, field: MetaField): string {
+  const superField = field.resolveSuper();
+  return superField !== undefined
+    ? toPascalCase(superField.name)
+    : `${entity.name}${toPascalCase(field.name)}`;
+}
+
+/**
+ * One-line TS type expression for a field on a value-only object.
+ * Returns a `Code` so cross-module `field.object` refs can be hoisted via
+ * ts-poet `imp(...)` — matching how the Zod emitter hoists `<Ref>InsertSchema`.
+ */
+function valueObjectFieldType(entity: MetaObject, field: MetaField): Code {
+  // field.object: import the referenced TS interface from its sibling module
+  // so ts-poet hoists the import. Mirrors zod-validators.ts's `<Ref>InsertSchema`
+  // import strategy, just for the type alias instead of the schema constant.
+  if (field.subType === FIELD_SUBTYPE_OBJECT) {
+    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    if (typeof ref === "string" && ref.length > 0) {
+      const refImp = imp(`${ref}@./${ref}.js`);
+      return field.isArray ? code`${refImp}[]` : code`${refImp}`;
+    }
+    return field.isArray ? code`unknown[]` : code`unknown`;
+  }
+
+  // field.enum: use the same type-alias name as renderEnumTypeAliases emits.
+  if (field.subType === FIELD_SUBTYPE_ENUM) {
+    const values = enumValues(field);
+    if (values !== undefined) {
+      const alias = enumTypeAliasName(entity, field);
+      return field.isArray ? code`${alias}[]` : code`${alias}`;
+    }
+    return field.isArray ? code`string[]` : code`string`;
+  }
+
+  const scalar = SCALAR_TS_BY_SUBTYPE[field.subType] ?? "unknown";
+  return field.isArray ? code`${scalar}[]` : code`${scalar}`;
+}
+
+/**
+ * Emit a structural `interface <Name> { ... }` for a value-only object.
+ *
+ * Optional fields use `name?: T` (matching the Zod `.optional()` inference
+ * `T | undefined`) instead of `name?: T | null`. Value objects never round-
+ * trip through Drizzle nullable columns, so the null-bridge is unnecessary
+ * here — and forces consumers into a residual cast at the call site.
+ */
+export function renderValueObjectInterface(entity: MetaObject): Code {
+  const docs = renderDocsFor(entity);
+  const docsPrefix = docs ? `${docs}\n` : "";
+
+  const lines: Code[] = [];
+  for (const field of entity.fields()) {
+    const required = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+    const optional = required ? "" : "?";
+    const tsType = valueObjectFieldType(entity, field);
+    lines.push(code`  ${field.name}${optional}: ${tsType};`);
+  }
+
+  // joinCode with "\n" interpolates each Code segment on its own line and
+  // keeps the imp() registrations intact so ts-poet hoists the imports.
+  return code`${docsPrefix}export interface ${entity.name} {
+${joinCode(lines, { on: "\n" })}
+}
+`;
+}

package/src/templates/output-parser.ts

@@ -0,0 +1,143 @@
+// server/typescript/packages/codegen-ts/src/templates/output-parser.ts
+//
+// Per-template renderer for template.output codegen. Walks the @payloadRef's
+// value-object into a Zod schema and emits a dual-API parser (parse + safeParse)
+// alongside the schema. The emitted file is self-contained: it derives a
+// local data type via `z.infer<typeof Schema>` and exports it as
+// `<TemplateName>Data`. Consumers wiring `promptRender()` get a structurally
+// identical payload-VO interface in `prompts.ts`; either type can be used
+// interchangeably with parse results.
+
+import {
+  type MetaData,
+  TYPE_OBJECT,
+  TYPE_FIELD,
+  TYPE_TEMPLATE,
+  TEMPLATE_SUBTYPE_OUTPUT,
+  FIELD_SUBTYPE_OBJECT,
+  FIELD_ATTR_OBJECT_REF,
+  TEMPLATE_ATTR_PAYLOAD_REF,
+} from "@metaobjectsdev/metadata";
+
+const SCALAR_ZOD: Record<string, string> = {
+  string: "z.string()",
+  class: "z.string()",
+  int: "z.number().int()",
+  short: "z.number().int()",
+  byte: "z.number().int()",
+  long: "z.number().int()",
+  double: "z.number()",
+  float: "z.number()",
+  boolean: "z.boolean()",
+};
+
+function findObject(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_OBJECT && c.name === name);
+}
+
+function findTemplate(root: MetaData, name: string): MetaData | undefined {
+  return root.ownChildren().find((c) => c.type === TYPE_TEMPLATE && c.name === name);
+}
+
+/** Render the Zod expression for a single field; recurses on @objectRef. */
+function fieldZod(field: MetaData, root: MetaData, seen: ReadonlySet<string>, depth: number): string {
+  // isArray is a native (reserved) property on MetaData, not an attr.
+  const isArray = field.isArray === true;
+  let base: string;
+  if (field.subType === FIELD_SUBTYPE_OBJECT) {
+    const refName = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    if (typeof refName !== "string") {
+      base = "z.unknown()";
+    } else if (seen.has(refName)) {
+      // Cycle guard — emit unknown for self-references (rare; lazy schemas not in scope for v1).
+      base = "z.unknown()";
+    } else {
+      const inner = findObject(root, refName);
+      base = inner ? renderObjectSchema(inner, root, new Set(seen).add(refName), depth + 1) : "z.unknown()";
+    }
+  } else {
+    base = SCALAR_ZOD[field.subType] ?? "z.unknown()";
+  }
+  return isArray ? `z.array(${base})` : base;
+}
+
+/** Render a `z.object({ ... })` for an object.value node.
+ *  At depth 0 the schema starts at column 0 (consumer's `const Foo = z.object({`),
+ *  so fields sit at 2 spaces and the closing `})` at 0 spaces — matching the
+ *  surrounding `const NameSchema = ...` statement's indent. Nested schemas
+ *  step in two spaces per depth level. */
+function renderObjectSchema(vo: MetaData, root: MetaData, seen: ReadonlySet<string>, depth: number): string {
+  const fields = vo.children().filter((c) => c.type === TYPE_FIELD);
+  const fieldIndent = "  ".repeat(depth + 1);
+  const closeIndent = "  ".repeat(depth);
+  const lines = fields.map((f) => `${fieldIndent}${f.name}: ${fieldZod(f, root, seen, depth)},`);
+  return `z.object({\n${lines.join("\n")}\n${closeIndent}})`;
+}
+
+/**
+ * Render the full output-parser file for one `template.output` node.
+ * Throws if the template isn't found, isn't a template.output, or its
+ * @payloadRef doesn't resolve to an object.value.
+ */
+export function renderOutputParser(root: MetaData, templateName: string): string {
+  const tmpl = findTemplate(root, templateName);
+  if (!tmpl) {
+    throw new Error(`template "${templateName}" not found in metadata root`);
+  }
+  if (tmpl.subType !== TEMPLATE_SUBTYPE_OUTPUT) {
+    throw new Error(`template "${templateName}" is not a template.output (got subtype "${tmpl.subType}")`);
+  }
+  const payloadRef = tmpl.ownAttr(TEMPLATE_ATTR_PAYLOAD_REF);
+  if (typeof payloadRef !== "string") {
+    throw new Error(`template "${templateName}" missing @payloadRef`);
+  }
+  const vo = findObject(root, payloadRef);
+  if (!vo) {
+    throw new Error(`template "${templateName}" @payloadRef "${payloadRef}" not found in metadata root`);
+  }
+
+  const schema = renderObjectSchema(vo, root, new Set([payloadRef]), 0);
+  const schemaName = `${templateName}Schema`;
+  const dataName = `${templateName}Data`;
+  const errorName = `${templateName}ValidationError`;
+  const parseName = `parse${templateName}`;
+  const safeParseName = `safeParse${templateName}`;
+
+  return `import { z } from "zod";
+
+const ${schemaName} = ${schema};
+
+export type ${dataName} = z.infer<typeof ${schemaName}>;
+export type ${errorName} = z.ZodError;
+
+/**
+ * Parse an LLM response into a typed ${dataName}.
+ * @throws ZodError on validation failure.
+ */
+export function ${parseName}(text: string): ${dataName} {
+  return ${schemaName}.parse(JSON.parse(text));
+}
+
+/**
+ * Parse an LLM response with explicit error handling (Result-style).
+ * Does not throw on validation failure.
+ */
+export function ${safeParseName}(
+  text: string,
+): { success: true; data: ${dataName} } | { success: false; error: ${errorName} } {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(text);
+  } catch (err) {
+    return {
+      success: false,
+      error: new z.ZodError([{ code: "custom", path: [], message: \`invalid JSON: \${(err as Error).message}\` }]),
+    };
+  }
+  const result = ${schemaName}.safeParse(parsed);
+  return result.success
+    ? { success: true, data: result.data }
+    : { success: false, error: result.error };
+}
+`;
+}

package/src/templates/projection-decl.ts

@@ -56,7 +56,7 @@ function pathFromProjectionName(name: string): string {
  *
  * @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`).
+ *                    from `MetaDataLoader.load()` or `MetaDataLoader.fromDirectory()` as `result.root`).
  * @param opts        Column naming strategy + dialect.
  */
 export function renderProjectionDecl(

package/src/templates/queries-file.ts

@@ -4,7 +4,7 @@
 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 { entityModuleSpecifier } from "../import-path.js";
 import {
   renderFindByIdFn,
   renderListFn,
@@ -26,13 +26,27 @@ export function renderQueriesFile(obj: MetaObject, ctx: RenderContext): string {
     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
+  // The persistence-context `db` is parameter-passed into every generated CRUD
+  // helper (ADR-0008). Emit the dialect-correct Drizzle type alias so the
+  // signatures `findXxx(db: Db, ...)` typecheck without the consumer importing
+  // anything to construct one. Consumers pass any compatible Drizzle instance.
+  const dbTypeImport =
+    ctx.dialect === "postgres"
+      ? `import type { NodePgDatabase } from "drizzle-orm/node-postgres";`
+      : `import type { BaseSQLiteDatabase } from "drizzle-orm/sqlite-core";`;
+  const dbTypeAlias =
+    ctx.dialect === "postgres"
+      ? `type Db = NodePgDatabase<Record<string, never>>;`
+      : `type Db = BaseSQLiteDatabase<"async", Record<string, never>>;`;
+
+  // Literal imports (Db type + 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)};
+${dbTypeImport}
+${dbTypeAlias}
+
 import { ${varName}, type ${entityName}, ${entityName}InsertSchema } from ${JSON.stringify(entityFileName)};
 `;
 

package/src/templates/queries.ts

@@ -5,12 +5,7 @@ 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}`;
-}
+import { variableNameFromEntity, pluralize } from "../naming.js";
 
 /** Get the PK field name and its TS type for a given entity. */
 function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName: string; tsType: string } {
@@ -34,31 +29,13 @@ 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} });
+export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<${entityName} | null> {
+  const [${singularVar}] = await db.select().from(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField})).limit(1);
   return ${singularVar} ?? null;
 }
 `;
@@ -72,7 +49,7 @@ export function renderListFn(entity: MetaObject, _ctx: RenderContext): Code {
   const fnName = `list${pluralize(entityName)}`;
 
   return code`
-export async function ${fnName}(opts?: { limit?: number; offset?: number }): Promise<${entityName}[]> {
+export async function ${fnName}(db: Db, 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);
@@ -89,7 +66,7 @@ export function renderCreateFn(entity: MetaObject, _ctx: RenderContext): Code {
   const schemaName = `${entityName}InsertSchema`;
 
   return code`
-export async function ${fnName}(data: unknown): Promise<${entityName}> {
+export async function ${fnName}(db: Db, data: unknown): Promise<${entityName}> {
   const validated = ${schemaName}.parse(data);
   const [${singularVar}] = await db.insert(${varName}).values(validated).returning();
   return ${singularVar}!;
@@ -107,7 +84,7 @@ export function renderUpdateFn(entity: MetaObject, ctx: RenderContext): Code {
   const eqSym = imp("eq@drizzle-orm");
 
   return code`
-export async function ${fnName}(${pkField}: ${pkType}, data: unknown): Promise<${entityName} | null> {
+export async function ${fnName}(db: Db, ${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;
@@ -123,10 +100,11 @@ export function renderDeleteByIdFn(entity: MetaObject, ctx: RenderContext): Code
   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;
+export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<boolean> {
+  // Use .returning() unconditionally — supported on SQLite ≥3.35 (covers D1, libsql/Turso)
+  // and Postgres. Result is an array of deleted rows; presence implies success.
+  const deleted = await db.delete(${varName}).where(${eqSym}(${varName}.${pkField}, ${pkField})).returning();
+  return deleted.length > 0;
 }
 `;
 }

package/src/templates/routes-file-hono.ts

@@ -0,0 +1,142 @@
+// Hono route template — emits a per-entity routes file that delegates
+// CRUD verbs to helpers from @metaobjectsdev/runtime-ts/hono.
+//
+// Hono parallel of templates/routes-file.ts. Two emit-shape differences
+// vs the Fastify flavor, both reflecting Hono idioms rather than contract
+// drift:
+//
+//   1) Exported function shape — `registerXxxRoutes(app, deps)` instead of
+//      `xxxRoutes(fastify)`. Workers/Bun consumers typically pass `db`
+//      through a per-request deps object (so a Worker can attach the
+//      D1 client pulled off bindings) rather than reaching for a
+//      module-level singleton. The Fastify flavor uses `import { db }`
+//      because Fastify apps are long-lived Node processes where a
+//      singleton is the norm. Both flavors talk to mountCrudRoutes /
+//      mountReadOnlyCrudRoutes with identical wire behavior.
+//
+//   2) apiPrefix is composed into the resource path (`${apiPrefix}${path}`)
+//      rather than wrapping the registration. Hono has no fastify.register
+//      / prefix-wrapping primitive; sub-apps via `app.route(prefix, sub)`
+//      exist but bloat the generated code. String concat is simpler and
+//      produces identical URL grammar.
+//
+// Dispatch logic mirrors Fastify:
+//   isProjection(entity)              → mountReadOnlyCrudRoutes (GET list + GET :id)
+//   vanilla / write-through entity    → mountCrudRoutes (all 5 CRUD verbs)
+
+import { code, imp } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { type RenderContext } from "../render-context.js";
+import { entityModuleSpecifier } from "../import-path.js";
+import { GENERATED_HEADER } from "../constants.js";
+import { variableNameFromEntity } from "../naming.js";
+import { isProjection } from "../projection/projection-detector.js";
+
+export function renderRoutesFileHono(entity: MetaObject, ctx: RenderContext): string {
+  const entityName = entity.name;
+  const handlerName = `register${entityName}Routes`;
+
+  const entityFileSpec = entityModuleSpecifier(
+    ctx.selfTarget,
+    ctx.entityModuleTarget,
+    entity.package,
+    entityName,
+    ctx.extStyle,
+  );
+
+  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`;
+
+  // Path composition: apiPrefix is a literal string in the URL.
+  const pathExpr = ctx.apiPrefix
+    ? `\`${ctx.apiPrefix}\${${entityName}.$path}\``
+    : `${entityName}.$path`;
+
+  // --- Projection path: read-only routes (GET list + GET :id) ---
+  if (isProjection(entity)) {
+    const camelName = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+    const HonoSym = imp("t:Hono@hono");
+    const mountReadOnlyCrudRoutesSym = imp(
+      "mountReadOnlyCrudRoutes@@metaobjectsdev/runtime-ts/hono",
+    );
+
+    const literalImports = code`
+import {
+  ${entityName},
+  ${camelName}View,
+  ${entityName}FilterAllowlist,
+  ${entityName}SortAllowlist,
+} from ${JSON.stringify(entityFileSpec)};
+`;
+
+    const body = 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/hono.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: consumer-defined Hono bindings/variables
+export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unknown }): void {
+  ${mountReadOnlyCrudRoutesSym}({
+    app,
+    path: ${pathExpr},
+    db: deps.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 HonoSym = imp("t:Hono@hono");
+  const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/hono");
+
+  const literalImports = code`
+import {
+  ${entityName},
+  ${tableVar},
+  ${entityName}InsertSchema,
+  ${entityName}UpdateSchema,
+  ${entityName}FilterAllowlist,
+  ${entityName}SortAllowlist,
+} from ${JSON.stringify(entityFileSpec)};
+`;
+
+  const body = 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/hono and mix with your own handlers
+ * (auth, side effects, etc.).
+ */
+// biome-ignore lint/suspicious/noExplicitAny: consumer-defined Hono bindings/variables
+export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unknown }): void {
+  ${mountCrudRoutesSym}({
+    app,
+    path: ${pathExpr},
+    db: deps.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();
+}

package/src/templates/value-object-file.ts

@@ -0,0 +1,30 @@
+// Value-object file composer — emits a streamlined "value-only" module for
+// metaobjects with no writable source.rdb child. Output is just the TS
+// interface + the Zod schema (and enum type aliases when applicable); no
+// Drizzle table, no Infer*Model aliases, no filter allowlists, no constants
+// object.
+//
+// Dispatch: entity-file.ts routes here when hasWritableRdbSource(entity) is
+// false. The entity may still have read-only source.* children (those are
+// handled by the projection path before this one is reached).
+
+import { joinCode, type Code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { renderValueObjectInterface, renderEnumTypeAliases } from "./inferred-types.js";
+import { renderInsertSchemaOnly } from "./zod-validators.js";
+import { GENERATED_HEADER } from "../constants.js";
+
+export function renderValueObjectFile(obj: MetaObject): string {
+  const enumAliases = renderEnumTypeAliases(obj);
+  const sections: Code[] = [
+    renderValueObjectInterface(obj),
+    ...(enumAliases !== null ? [enumAliases] : []),
+    renderInsertSchemaOnly(obj),
+  ];
+  const body = joinCode(sections, { on: "\n" }).toString();
+  const header =
+    `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
+    `// Source metadata: ${obj.name} (${obj.fqn()})\n` +
+    `// Customize via ${obj.name}.extra.ts in this directory.\n`;
+  return header + body;
+}