@metaobjectsdev/codegen-ts 0.21.4 → 0.21.6

package/src/templates/entity-meta-file.ts

@@ -0,0 +1,51 @@
+// `<Entity>.meta.ts` — the entity descriptor, with no database in the module graph.
+//
+// The generated UI files (hooks, grid hooks, forms) value-import exactly ONE thing
+// from the entity module: the `<Entity>` descriptor const. Everything else they take
+// is `import type`, which the compiler erases. But `<Entity>.ts` also constructs the
+// Drizzle table at module scope, so that single value import dragged the entire ORM
+// into every browser bundle — measured at 716 KB for one generated hook, containing
+// `SQLiteTable` and the whole driver.
+//
+// Nothing in the UI path READS the table. The descriptor is plain data — `$table` is
+// a string, not a table object — so this was never a semantic dependency on the
+// database, only a physical one created by sharing a module. A `/* @__PURE__ */`
+// annotation on the table construction does NOT help (measured: still 716 KB), so
+// separating the module is the fix.
+//
+// Deliberately ADDITIVE. `<Entity>.ts` is untouched and still exports the descriptor,
+// so every existing import keeps working and this stays a PATCH. The UI generators
+// simply take the descriptor from here instead, and each emits this file itself —
+// byte-identical between them, which #266 collapses — rather than depending on the
+// consumer having wired an extra generator, since the entity generator is
+// scaffold-and-own (ADR-0034) and cannot be changed from the package.
+
+import { code } from "ts-poet";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { GENERATED_HEADER } from "../constants.js";
+import { renderEntityConstants } from "./entity-constants.js";
+
+/** File name (no directory) of an entity's DB-free descriptor module. */
+export function entityMetaFileName(entityName: string): string {
+  return `${entityName}.meta.ts`;
+}
+
+/** Module specifier the UI files use to reach it — a same-directory sibling. */
+export function entityMetaSpecifier(entityName: string, extStyle: string | undefined): string {
+  return `./${entityName}.meta${extStyle === "js" ? ".js" : ""}`;
+}
+
+export function renderEntityMetaFile(entity: MetaObject, apiPrefix = ""): string {
+  const body = code`
+// ${GENERATED_HEADER} — DO NOT EDIT.
+// Source metadata: ${entity.name}
+//
+// Browser-safe: this module contains ONLY the entity descriptor — plain data, no
+// Drizzle table and no database import of any kind. The generated UI files import it
+// from here so a client bundle never pulls the ORM in. \`${entity.name}.ts\` also
+// exports this descriptor, for server-side and pre-existing consumers.
+
+${renderEntityConstants(entity, apiPrefix)}
+`;
+  return body.toString();
+}

package/src/templates/projection-decl.ts

@@ -22,6 +22,7 @@ import { renderFilterAllowlist, renderSortAllowlist } from "./filter-allowlist.j
 import { renderFilterType } from "./filter-type.js";
 import { inferViewKind, currencyMetaFor, labelFor } from "./field-meta.js";
 import { renderExistingViewDecl, renderViewReadZodObject } from "./view-decl.js";
+import { primaryIdentityFieldNames } from "./zod-validators.js";
 
 // ---------------------------------------------------------------------------
 // Public interface
@@ -152,15 +153,18 @@ export function renderProjectionDecl(
   const camelName = projName.charAt(0).toLowerCase() + projName.slice(1);
   const path = pathFromProjectionName(projName);
 
+  // The projection's primary-identity fields type non-null in the view decl +
+  // read schema even without @required (a PK is never NULL; see ViewDeclOpts).
+  const pkFieldNames: ReadonlySet<string> = new Set(primaryIdentityFieldNames(projection));
   const sections: Code[] = [
     ...(includeViewDecl
       ? [renderExistingViewDecl(allFields, viewName, `${camelName}View`, {
-          dialect, columnNamingStrategy, timestampMode, voRef,
+          dialect, columnNamingStrategy, timestampMode, voRef, pkFieldNames,
         })]
       : []),
     code`
 export const ${projName}Schema = ${renderViewReadZodObject(allFields, {
-  dialect, columnNamingStrategy, timestampMode, voRef,
+  dialect, columnNamingStrategy, timestampMode, voRef, pkFieldNames,
 })};
 `,
     code`

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

@@ -29,7 +29,7 @@ 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 { isProjection } from "../projection/projection-detector.js";
+import { isProjection, isWriteThrough } from "../projection/projection-detector.js";
 
 export function renderRoutesFileHono(entity: MetaObject, ctx: RenderContext): string {
   const entityName = entity.name;
@@ -98,6 +98,16 @@ export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unkno
   // --- Vanilla / write-through entity path: full CRUD routes ---
   const tableVar = ctx.collectionName(entityName);
 
+  // #214: a write-through entity reads through its replica view so derived origin.*
+  // columns are present. Without this the Hono adapter returned rows missing every
+  // derived field the generated type and Zod schema promise, and a filter or sort on
+  // one — both ALLOWED by the generated allowlists — hit a column the table does not
+  // have, producing a 500. Fastify has done this since #214; Hono was simply never
+  // wired, exactly as it was never wired for #286's `.all()`/`.get()` fix.
+  const writeThrough = isWriteThrough(entity);
+  const camelName = entityName.charAt(0).toLowerCase() + entityName.slice(1);
+  const readViewLine = writeThrough ? `\n    readView: ${camelName}View,` : "";
+
   const HonoSym = imp("t:Hono@hono");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/hono");
 
@@ -108,7 +118,7 @@ import {
   ${entityName}InsertSchema,
   ${entityName}UpdateSchema,
   ${entityName}FilterAllowlist,
-  ${entityName}SortAllowlist,
+  ${entityName}SortAllowlist,${writeThrough ? `\n  ${camelName}View,` : ""}
 } from ${JSON.stringify(entityFileSpec)};
 `;
 
@@ -127,7 +137,7 @@ export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unkno
     app,
     path: ${pathExpr},
     db: deps.db,
-    table: ${tableVar},
+    table: ${tableVar},${readViewLine}
     insertSchema: ${entityName}InsertSchema,
     updateSchema: ${entityName}UpdateSchema,
     filterAllowlist: ${entityName}FilterAllowlist,

package/src/templates/view-decl.ts

@@ -29,6 +29,15 @@ export interface ViewDeclOpts {
    * `RenderContext.resolveValueObjectName` + `valueObjectModuleSpecifier`.
    */
   readonly voRef: (field: MetaField) => { name: string; module: string };
+  /**
+   * Field names of the owning object's PRIMARY identity (see
+   * `primaryIdentityFieldNames` in zod-validators). A PK column sits on the FROM
+   * side of every synthesized view, so it is never NULL even when the field
+   * carries no `@required` — the view column gets `.notNull()` and the read
+   * schema stays non-nullable, matching the generated api-docs, queries and
+   * UpdateSchema, all of which already treat the PK as non-null.
+   */
+  readonly pkFieldNames: ReadonlySet<string>;
 }
 
 /**
@@ -49,9 +58,13 @@ function viewColumnLine(f: MetaField, opts: ViewDeclOpts): Code {
   // typing) and `.notNull()` (shapes the SELECT type) carry to an existing view;
   // `.primaryKey()`/`.default()`/`.references()`/`.unique()` are table-DDL concerns
   // and invalid on a `.existing()` view declaration. Preserve the canonical order.
-  const viewModifiers = spec.modifiers
-    .filter((m) => m === ".array()" || m === ".notNull()")
-    .join("");
+  // A primary-identity column additionally gains `.notNull()`: on the table side
+  // its non-null comes from `.primaryKey()` (which the view cannot carry), so
+  // without this the view SELECT type — and the Zod read schema derived from it —
+  // typed the PK `T | null` for a column that can never be NULL.
+  const kept = spec.modifiers.filter((m) => m === ".array()" || m === ".notNull()");
+  if (opts.pkFieldNames.has(f.name) && !kept.includes(".notNull()")) kept.push(".notNull()");
+  const viewModifiers = kept.join("");
   // Narrow the column to its resolved element/value type — `.$type<…>()` — mirroring
   // the entity column so the read row is typed (not `unknown`) and an array column
   // reads as `T[]`, not `T`.
@@ -113,10 +126,13 @@ export function renderViewReadZodObject(fields: readonly MetaField[], opts: View
   const { dialect, columnNamingStrategy, timestampMode } = opts;
   const z = imp("z@zod");
   const lines: Code[] = fields.map((f) => {
-    const nullable =
-      mapColumnType(f, dialect, columnNamingStrategy, timestampMode).modifiers.includes(".notNull()")
-        ? ""
-        : ".nullable()";
+    // Non-null when the column is `.notNull()` OR it is a primary-identity
+    // field — a PK is never NULL, but its table-side non-null is expressed via
+    // `.primaryKey()`, not a `.notNull()` modifier (see viewColumnLine above).
+    const nonNull =
+      mapColumnType(f, dialect, columnNamingStrategy, timestampMode).modifiers.includes(".notNull()") ||
+      opts.pkFieldNames.has(f.name);
+    const nullable = nonNull ? "" : ".nullable()";
     const hasObjectRef =
       f.subType === FIELD_SUBTYPE_OBJECT &&
       typeof f.attr(FIELD_ATTR_OBJECT_REF) === "string" &&

package/src/templates/zod-validators.ts

@@ -129,8 +129,9 @@ ${joinCode(fieldLines, { on: ",\n" })}
 }
 
 /** Field names participating in the object's PRIMARY identity, normalized to a
- *  list. Empty when the object has no primary identity. */
-function primaryIdentityFieldNames(obj: MetaObject): string[] {
+ *  list. Empty when the object has no primary identity. Exported for the
+ *  view-decl read-schema path, which must type PK columns non-null too. */
+export function primaryIdentityFieldNames(obj: MetaObject): string[] {
   const primary = obj.primaryIdentity();
   if (!primary) return [];
   const fields = primary.attr(IDENTITY_ATTR_FIELDS);