feat(codegen-ts): filter Drizzle table emission via source.rdb

Discriminate table-backed entities from value-only objects (in-memory /
transit shapes — LLM tool_use payloads, REST request bodies, etc.) by
inspecting source.rdb children. Pure metadata-driven; not a typeId
discriminator — any object subtype opts out of Drizzle emission simply
by omitting source.rdb.

New source-detect helper (`hasWritableRdbSource`) checks for at least
one writable source.rdb child. The entity-file composer routes:

  isProjection(entity)           → renderProjectionDecl  (read-only view)
  !hasWritableRdbSource(entity)  → renderValueObjectFile (value-only)
  vanilla / write-through        → Drizzle table path

The new value-object file emitter produces the structural TS interface
+ Zod InsertSchema only — no sqliteTable, no Infer*Model aliases, no
FilterAllowlist/SortAllowlist, no constants object. Optional fields
land as `name?: T` (matching Zod `.optional()` inference `T | undefined`)
rather than `name?: T | null`, so consumers don't need a residual
null-bridge cast at the call site.

Fixture migration: every test fixture and imperative entity builder
that intended a Drizzle table now declares source.rdb explicitly. The
prior implicit default (any object.entity → table) is treated as a bug,
not a feature — and source.rdb-less metadata now traverses the new
value-only emission path.

Added test coverage:
- source-detect.test.ts: 5 cases (no source / table / explicit kind=table
  / kind=view / mixed CQRS)
- value-object-file.test.ts: 2 cases (full interface + InsertSchema +
  enum alias emission; required-only no-question-mark assertion)

384 tests pass (was 377 + 7 new).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/codegen-ts/src/source-detect.ts

@@ -0,0 +1,28 @@
+// Source-detect helpers — discriminate table-backed entities from value-only
+// objects (and other in-memory / transit shapes) by inspecting source.* children.
+//
+// Used by the entity-file composer to pick a streamlined "value-only" emission
+// path for metaobjects that declare no writable relational source. Pure
+// metadata-driven, not a typeId discriminator: any object subtype can opt out
+// of Drizzle table emission simply by omitting source.rdb.
+
+import { MetaSource } from "@metaobjectsdev/metadata";
+import { TYPE_SOURCE, SOURCE_SUBTYPE_RDB } from "@metaobjectsdev/metadata";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+
+/**
+ * True when the entity declares at least one writable source.rdb child.
+ * Discriminates table-backed entities (full Drizzle file: table + Insert/Update
+ * schemas + filter allowlists + constants) from value-only objects (TS
+ * interface + Zod schema only). Absence of source.rdb means in-memory /
+ * transit data — no migration, no ORM table to point at.
+ */
+export function hasWritableRdbSource(entity: MetaObject): boolean {
+  for (const child of entity.ownChildren()) {
+    if (child.type !== TYPE_SOURCE) continue;
+    if (child.subType !== SOURCE_SUBTYPE_RDB) continue;
+    if (!(child instanceof MetaSource)) continue;
+    if (child.isWritable()) return true;
+  }
+  return false;
+}

server/typescript/packages/codegen-ts/src/templates/entity-file.ts

@@ -2,8 +2,9 @@
 // into one file with the @generated header. ts-poet deduplicates imports.
 //
 // Dispatch:
-//   isProjection(entity)  → renderProjectionDecl (read-only: view declaration + Zod + filter sections)
-//   vanilla / write-through entity → Drizzle table path
+//   isProjection(entity)               → renderProjectionDecl (read-only: view declaration + Zod + filter sections)
+//   !hasWritableRdbSource(entity)      → renderValueObjectFile (in-memory / transit shape: interface + Zod schema)
+//   vanilla / write-through entity     → Drizzle table path
 
 import { joinCode, type Code } from "ts-poet";
 import type { MetaObject } from "@metaobjectsdev/metadata";
@@ -17,6 +18,8 @@ import { renderFilterType } from "./filter-type.js";
 import { GENERATED_HEADER } from "../constants.js";
 import { isProjection } from "../projection/projection-detector.js";
 import { renderProjectionDecl } from "./projection-decl.js";
+import { hasWritableRdbSource } from "../source-detect.js";
+import { renderValueObjectFile } from "./value-object-file.js";
 
 /**
  * Render-time options for the entity-file composer.
@@ -51,6 +54,14 @@ export function renderEntityFile(
     });
   }
 
+  // --- Value-only path (no writable source.rdb: in-memory / transit shape) ---
+  // No Drizzle table, no migration footprint. Consumers that need to validate
+  // the shape (LLM tool_use input_schema, REST body parsing) use the Zod
+  // schema; consumers that need the type use the interface.
+  if (!hasWritableRdbSource(entity)) {
+    return renderValueObjectFile(entity);
+  }
+
   // --- Vanilla / write-through entity path ---
   const enumAliases = renderEnumTypeAliases(entity);
   const sections: Code[] = [

server/typescript/packages/codegen-ts/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" })}
+}
+`;
+}

server/typescript/packages/codegen-ts/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;
+}

server/typescript/packages/codegen-ts/src/templates/zod-validators.ts

@@ -26,19 +26,64 @@ import {
 import { enumValues, zodEnumExpr } from "../enum-meta.js";
 import { renderDocsFor } from "./jsdoc.js";
 
-export function renderZodValidators(obj: MetaObject): Code {
-  const z = imp("z@zod");
+/** Auto-generated PK field names that should be omitted from InsertSchema. */
+function autoGenPkFieldNames(obj: MetaObject): Set<string> {
+  const out = new Set<string>();
   const primary = obj.primaryIdentity();
-  const autoGenPkFields = new Set<string>();
   if (primary) {
     const generation = primary.ownAttr(IDENTITY_ATTR_GENERATION);
     if (generation === GENERATION_INCREMENT || generation === GENERATION_UUID) {
       const fields = primary.ownAttr(IDENTITY_ATTR_FIELDS);
       const fieldsList = Array.isArray(fields) ? fields : (typeof fields === "string" ? [fields] : []);
-      for (const f of fieldsList) autoGenPkFields.add(String(f));
+      for (const f of fieldsList) out.add(String(f));
+    }
+  }
+  return out;
+}
+
+/**
+ * Emit ONLY the `<Name>InsertSchema`. Used by the value-object file emitter
+ * for metaobjects with no writable source.rdb — those have no PATCH/update
+ * semantics, so emitting an UpdateSchema would be misleading.
+ *
+ * The schema name is kept as `<Name>InsertSchema` even for pure value objects
+ * so consumer imports don't churn. A future polish PR could add a `<Name>Schema`
+ * alias for clarity.
+ */
+export function renderInsertSchemaOnly(obj: MetaObject): Code {
+  const z = imp("z@zod");
+  const autoGenPkFields = autoGenPkFieldNames(obj);
+
+  const insertFieldLines: Code[] = [];
+  for (const child of obj.fields()) {
+    if (autoGenPkFields.has(child.name)) continue;
+
+    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+
+    if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
+      insertFieldLines.push(
+        code`  ${child.name}: z.string().optional().transform(() => new Date().toISOString())`,
+      );
+    } else {
+      insertFieldLines.push(code`  ${child.name}: ${zodFieldExpr(child)}`);
     }
   }
 
+  const insertSchemaName = `${obj.name}InsertSchema`;
+  const docs = renderDocsFor(obj);
+  const docsPrefix = docs ? `${docs}\n` : "";
+
+  return code`
+${docsPrefix}export const ${insertSchemaName} = ${z}.object({
+${joinCode(insertFieldLines, { on: ",\n" })}
+});
+`;
+}
+
+export function renderZodValidators(obj: MetaObject): Code {
+  const z = imp("z@zod");
+  const autoGenPkFields = autoGenPkFieldNames(obj);
+
   const insertFieldLines: Code[] = [];
   const updateFieldLines: Code[] = [];
   for (const child of obj.fields()) {

server/typescript/packages/codegen-ts/test/_meta-build.ts

@@ -22,6 +22,8 @@ import {
   IDENTITY_SUBTYPE_REFERENCE,
   IDENTITY_SUBTYPE_PRIMARY,
   IDENTITY_SUBTYPE_SECONDARY,
+  SOURCE_SUBTYPE_RDB,
+  SOURCE_ATTR_TABLE,
   MetaRoot,
   MetaObject,
   MetaField,
@@ -100,3 +102,18 @@ export function metaObject(subType: string, name: string): MetaObject {
 export function metaField(subType: string, name: string): MetaField {
   return meta(new TypeId(TYPE_FIELD, subType), name) as MetaField;
 }
+
+/**
+ * Attach a writable source.rdb child (table-backed source) to the given entity.
+ * Use in imperative test builders that need the entity to flow through the
+ * Drizzle code path — the value-only emission path is taken when no writable
+ * source.rdb child is present, so tests that hand-build entities without one
+ * now bypass the Drizzle output. Helper centralizes the wiring so the table
+ * name and source-attr shape stay consistent with the YAML/JSON fixtures.
+ */
+export function attachRdbSource(entity: MetaObject, table: string): MetaObject {
+  const source = meta(new TypeId(TYPE_SOURCE, SOURCE_SUBTYPE_RDB), "source") as MetaSource;
+  source.setAttr(SOURCE_ATTR_TABLE, table);
+  entity.addChild(source);
+  return entity;
+}

server/typescript/packages/codegen-ts/test/fixtures/filter-fixture.json

@@ -5,6 +5,7 @@
         "object.entity": {
           "name": "Subscriber",
           "children": [
+            { "source.rdb": { "@table": "subscribers" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "email", "@filterable": true } },
             { "field.string": { "name": "firstName", "@filterable": true } },
@@ -27,6 +28,7 @@
         "object.entity": {
           "name": "Product",
           "children": [
+            { "source.rdb": { "@table": "products" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "title" } },
             { "field.decimal": { "name": "price", "@sortable": true } },

server/typescript/packages/codegen-ts/test/fixtures/packaged-shape.json

@@ -6,6 +6,7 @@
           "name": "Order",
           "package": "shop::commerce",
           "children": [
+            { "source.rdb": { "@table": "orders" } },
             { "field.long": { "name": "id" } },
             { "field.long": { "name": "customerId", "@required": true } },
             { "field.long": { "name": "productId", "@required": true } },
@@ -23,6 +24,7 @@
           "name": "Product",
           "package": "shop::commerce",
           "children": [
+            { "source.rdb": { "@table": "products" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "name", "@required": true, "@maxLength": 200 } },
             { "field.long": { "name": "tagId", "@required": true } },
@@ -37,6 +39,7 @@
           "name": "Customer",
           "package": "shop::users",
           "children": [
+            { "source.rdb": { "@table": "customers" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "email", "@required": true, "@maxLength": 255 } },
             { "identity.primary": { "name": "primary", "@fields": ["id"], "@generation": "increment" } }
@@ -47,6 +50,7 @@
         "object.entity": {
           "name": "Tag",
           "children": [
+            { "source.rdb": { "@table": "tags" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "label", "@required": true, "@maxLength": 100 } },
             { "field.long": { "name": "customerId", "@required": true } },

server/typescript/packages/codegen-ts/test/fixtures/single-entity.json

@@ -6,6 +6,7 @@
         "object.entity": {
           "name": "Post",
           "children": [
+            { "source.rdb": { "@table": "posts" } },
             { "field.long": { "name": "id" } },
             { "field.string": { "name": "title", "@required": true, "@maxLength": 200 } },
             { "field.string": { "name": "body" } },