@metaobjectsdev/codegen-ts 0.10.0 → 0.11.0

package/src/templates/filter-allowlist.ts

@@ -45,7 +45,7 @@ function filterableFields(entity: MetaObject, exclude?: string): MetaField[] {
   // fields() returns effective fields, so inherited fields (from extends:/super:) are included in allowlists.
   return entity
     .fields()
-    .filter((c) => c.ownAttr(FIELD_ATTR_FILTERABLE) === true && c.name !== exclude);
+    .filter((c) => c.attr(FIELD_ATTR_FILTERABLE) === true && c.name !== exclude);
 }
 
 /**
@@ -93,7 +93,7 @@ export const ${entity.name}SortAllowlist = {} as const satisfies SortAllowlist;
   }
   const rows = sortable
     .map((f) => {
-      const defaultOrder = f.ownAttr(FIELD_ATTR_SORTABLE_DEFAULT_ORDER) as string | undefined;
+      const defaultOrder = f.attr(FIELD_ATTR_SORTABLE_DEFAULT_ORDER) as string | undefined;
       const rule =
         defaultOrder === "asc" || defaultOrder === "desc"
           ? `{ defaultOrder: ${JSON.stringify(defaultOrder)} as const }`

package/src/templates/filter-shared.ts

@@ -15,10 +15,10 @@ import { FIELD_ATTR_FILTERABLE, FIELD_ATTR_SORTABLE } from "@metaobjectsdev/meta
  *   3. no @sortable     → sortable iff @filterable === true
  */
 export function isSortableField(field: MetaField): boolean {
-  const sortableAttr = field.ownAttr(FIELD_ATTR_SORTABLE);
+  const sortableAttr = field.attr(FIELD_ATTR_SORTABLE);
   if (sortableAttr === true) return true;
   if (sortableAttr === false) return false;
-  return field.ownAttr(FIELD_ATTR_FILTERABLE) === true;
+  return field.attr(FIELD_ATTR_FILTERABLE) === true;
 }
 
 /**

package/src/templates/filter-type.ts

@@ -54,7 +54,7 @@ function renderFieldUnion(field: MetaField): string {
 export function renderFilterType(entity: MetaObject, exclude?: string): Code {
   // fields() returns effective fields, so inherited fields (from extends:/super:) are included in filter types.
   const allFields = entity.fields().filter((c) => c.name !== exclude);
-  const filterableFieldsList = allFields.filter((c) => c.ownAttr(FIELD_ATTR_FILTERABLE) === true);
+  const filterableFieldsList = allFields.filter((c) => c.attr(FIELD_ATTR_FILTERABLE) === true);
   // Sort union uses isSortableField — same predicate as renderSortAllowlist to prevent
   // client/server mismatches (@filterable: true + @sortable: false must be excluded from both).
   const sortFieldNames = allFields.filter(isSortableField).map((f) => `"${f.name}"`);

package/src/templates/fr010-field-mapping.ts

@@ -76,21 +76,21 @@ export function isArray(field: MetaData): boolean {
 
 /** True iff the field's @required is explicitly true (or the string "true"). */
 export function isRequired(field: MetaData): boolean {
-  const v = field.ownAttr(FIELD_ATTR_REQUIRED);
+  const v = field.attr(FIELD_ATTR_REQUIRED);
   if (v === true) return true;
   return typeof v === "string" && v.toLowerCase() === "true";
 }
 
 /** True iff the field's @xmlText is explicitly true (the XML text-content extract marker). */
 export function xmlText(field: MetaData): boolean {
-  const v = field.ownAttr(FIELD_ATTR_XML_TEXT);
+  const v = field.attr(FIELD_ATTR_XML_TEXT);
   if (v === true) return true;
   return typeof v === "string" && v.toLowerCase() === "true";
 }
 
 /** The string members of an enum field's @values attr (empty when absent). */
 export function enumValues(field: MetaData): string[] {
-  const v = field.ownAttr(FIELD_ATTR_VALUES);
+  const v = field.attr(FIELD_ATTR_VALUES);
   if (Array.isArray(v)) return v.map((e) => String(e));
   return [];
 }
@@ -100,7 +100,7 @@ export function enumValues(field: MetaData): string[] {
  * or null when absent. Read own-attr only — `@coerceDefault` is concrete, never inherited.
  */
 export function coerceDefault(field: MetaData): string | null {
-  const v = field.ownAttr(FIELD_ATTR_COERCE_DEFAULT);
+  const v = field.attr(FIELD_ATTR_COERCE_DEFAULT);
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 
@@ -108,7 +108,7 @@ export function coerceDefault(field: MetaData): string | null {
  * FR-011: the field's `@default` member symbol (absent-fill enum value), or null when absent.
  */
 export function defaultValue(field: MetaData): string | null {
-  const v = field.ownAttr(FIELD_ATTR_DEFAULT);
+  const v = field.attr(FIELD_ATTR_DEFAULT);
   return typeof v === "string" && v.length > 0 ? v : null;
 }
 
@@ -128,7 +128,7 @@ export function resolveNormalize(field: MetaData, ownerObject: MetaData | null):
 
 /** The `@normalize` attr of a node as a NormalizeMode, or null when absent. */
 function normalizeAttrOf(node: MetaData): NormalizeMode | null {
-  const v = node.ownAttr(FIELD_ATTR_NORMALIZE);
+  const v = node.attr(FIELD_ATTR_NORMALIZE);
   return typeof v === "string" && v.length > 0 ? (v as NormalizeMode) : null;
 }
 

package/src/templates/inferred-types.ts

@@ -28,6 +28,7 @@ import {
   FIELD_ATTR_OBJECT_REF,
 } from "@metaobjectsdev/metadata";
 import { variableNameFromEntity, toPascalCase } from "../naming.js";
+import { valueObjectModuleSpecifier } from "../import-path.js";
 import { stripPackage } from "@metaobjectsdev/metadata";
 import { enumValues } from "../enum-meta.js";
 import { renderDocsFor } from "./jsdoc.js";
@@ -44,8 +45,12 @@ import type { RenderContext } from "../render-context.js";
  * to avoid a duplicate `export type <Base>`. Insert/Update keep their names
  * (no collision); they describe the physical TPH table row shape.
  */
-export function renderInferredTypes(entity: MetaObject, tphBase = false): Code {
-  const varName = variableNameFromEntity(entity.name);
+export function renderInferredTypes(entity: MetaObject, tphBase = false, ctx?: RenderContext): Code {
+  // The inferred Row/Insert types reference the Drizzle table var, so they must
+  // resolve to the SAME (possibly overridden) collection name the schema emits.
+  // ctx is optional for bare unit-test calls — those fall back to the default
+  // always-pluralize spelling.
+  const varName = ctx ? ctx.collectionName(entity.name) : variableNameFromEntity(entity.name);
   const selectSym = imp("InferSelectModel@drizzle-orm");
   const insertSym = imp("InferInsertModel@drizzle-orm");
   const docs = renderDocsFor(entity);
@@ -172,7 +177,7 @@ const SCALAR_TS_BY_SUBTYPE: Record<string, string> = {
  */
 export function fieldTsTypeString(ownerName: string, field: MetaField): string {
   if (field.subType === FIELD_SUBTYPE_OBJECT) {
-    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref === "string" && ref.length > 0) {
       const base = stripPackage(ref);
       return field.isArray ? `${base}[]` : base;
@@ -205,12 +210,18 @@ function valueObjectFieldType(entity: MetaObject, field: MetaField, ctx?: Render
   // 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);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref === "string" && ref.length > 0) {
       // @objectRef may be authored fully-qualified (acme::sales::Brief) or bare; the
-      // referenced interface + its sibling module are named by the BARE short name.
+      // referenced interface is named by the BARE short name. The import MODULE is
+      // resolved through the shared layout/package/extStyle-aware helper (the SAME
+      // one the Zod schema + Drizzle .$type<> use) so all three agree. Without a
+      // ctx (bare unit-test calls) fall back to the flat same-dir specifier.
       const base = stripPackage(ref);
-      const refImp = imp(`${base}@./${base}.js`);
+      const moduleSpec = ctx
+        ? valueObjectModuleSpecifier(base, ctx.packageOf, entity.package, ctx.outputLayout, ctx.extStyle)
+        : `./${base}.js`;
+      const refImp = imp(`${base}@${moduleSpec}`);
       return field.isArray ? code`${refImp}[]` : code`${refImp}`;
     }
     return field.isArray ? code`unknown[]` : code`unknown`;
@@ -258,7 +269,7 @@ export function renderValueObjectInterface(entity: MetaObject, ctx?: RenderConte
 
   const lines: Code[] = [];
   for (const field of entity.fields()) {
-    const required = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+    const required = field.attr(FIELD_ATTR_REQUIRED) === true;
     const optional = required ? "" : "?";
     const tsType = valueObjectFieldType(entity, field, ctx);
     lines.push(code`  ${field.name}${optional}: ${tsType};`);

package/src/templates/mermaid-er.ts

@@ -157,7 +157,7 @@ export function renderEntityNeighborhoodErBlock(
   // column?" Click-through to the VO docs answers that.
   for (const field of focal.fields()) {
     if (field.subType !== FIELD_SUBTYPE_OBJECT) continue;
-    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref !== "string" || ref.length === 0) continue;
     const targetName = ref.split("::").pop()!;
     if (classify(targetName) === undefined) continue;

package/src/templates/output-format-spec-emitter.ts

@@ -76,7 +76,7 @@ function promptFieldLiteral(field: MetaData): string {
 
   if (field.subType === FIELD_SUBTYPE_ENUM) {
     const valuesLit = stringArrayLiteral(enumValues(field));
-    const enumDocLit = propertiesMapLiteral(field.ownAttr(FIELD_ATTR_ENUM_DOC));
+    const enumDocLit = propertiesMapLiteral(field.attr(FIELD_ATTR_ENUM_DOC));
     return (
       `{ name: ${name}, kind: FieldKind.ENUM, required: ${required}, array: ${array}, ` +
       `enumValues: ${valuesLit}, enumDoc: ${enumDocLit}, example: ${example}, ` +

package/src/templates/output-parser.ts

@@ -58,7 +58,7 @@ function fieldZod(field: MetaData, root: MetaData, seen: ReadonlySet<string>, de
   const isArray = field.isArray === true;
   let base: string;
   if (field.subType === FIELD_SUBTYPE_OBJECT) {
-    const refName = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const refName = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof refName !== "string") {
       base = "z.unknown()";
     } else if (seen.has(refName)) {

package/src/templates/queries-file.ts

@@ -17,7 +17,7 @@ import {
   renderDeleteByIdFn,
   getPkInfo,
 } from "./queries.js";
-import { variableNameFromEntity, pluralize } from "../naming.js";
+import { pluralize } from "../naming.js";
 import { GENERATED_HEADER } from "../constants.js";
 import { isTphDiscriminatorBase, tphConcreteSubtypes } from "./tph-discriminator.js";
 
@@ -40,7 +40,7 @@ export function renderQueriesFile(obj: MetaObject, ctx: RenderContext): string {
     entityName,
     ctx.extStyle,
   );
-  const varName = variableNameFromEntity(entityName);
+  const varName = ctx.collectionName(entityName);
 
   // The persistence-context `db` is parameter-passed into every generated CRUD
   // helper (ADR-0008). Emit the dialect-correct Drizzle type alias so the
@@ -97,7 +97,7 @@ import { ${varName}, type ${entityName}, ${entityName}InsertSchema } from ${JSON
  */
 function renderTphQueriesFile(base: MetaObject, ctx: RenderContext): string {
   const baseName = base.name;
-  const tableVar = variableNameFromEntity(baseName);
+  const tableVar = ctx.collectionName(baseName);
   const discField = base.ownAttr(OBJECT_ATTR_DISCRIMINATOR) as string;
   const { fieldName: pkField, tsType: pkType } = getPkInfo(base, ctx);
 

package/src/templates/queries.ts

@@ -6,8 +6,6 @@ import type { MetaObject } from "@metaobjectsdev/metadata";
 import { IDENTITY_ATTR_FIELDS } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "../render-context.js";
 import {
-  variableNameFromEntity,
-  pluralize,
   findByIdFnName,
   listFnName,
   createFnName,
@@ -19,7 +17,7 @@ import {
 export 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 rawFields = primary?.attr(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);
@@ -34,7 +32,7 @@ export function getPkInfo(entity: MetaObject, ctx: RenderContext): { fieldName:
 }
 
 export function renderFindByIdFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
@@ -49,8 +47,8 @@ export async function ${fnName}(db: Db, ${pkField}: ${pkType}): Promise<${entity
 `;
 }
 
-export function renderListFn(entity: MetaObject, _ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+export function renderListFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   // Pluralize the PascalCase entity name, preserving capitalization
   // (e.g., "Category" -> "Categories", not "Categorys").
@@ -66,8 +64,8 @@ export async function ${fnName}(db: Db, opts?: { limit?: number; offset?: number
 `;
 }
 
-export function renderCreateFn(entity: MetaObject, _ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+export function renderCreateFn(entity: MetaObject, ctx: RenderContext): Code {
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const fnName = createFnName(entityName);
@@ -83,7 +81,7 @@ export async function ${fnName}(db: Db, data: unknown): Promise<${entityName}> {
 }
 
 export function renderUpdateFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const singularVar = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
@@ -101,7 +99,7 @@ export async function ${fnName}(db: Db, ${pkField}: ${pkType}, data: unknown): P
 }
 
 export function renderDeleteByIdFn(entity: MetaObject, ctx: RenderContext): Code {
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const entityName = entity.name;
   const { fieldName: pkField, tsType: pkType } = getPkInfo(entity, ctx);
   const fnName = deleteByIdFnName(entityName);

package/src/templates/relations-block.ts

@@ -6,7 +6,6 @@ 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";
 
 /**
@@ -17,7 +16,7 @@ export function renderRelationsBlock(entity: MetaObject, ctx: RenderContext): Co
   const entries = ctx.relationMap.get(entity.name);
   if (!entries || entries.length === 0) return null;
 
-  const varName = variableNameFromEntity(entity.name);
+  const varName = ctx.collectionName(entity.name);
   const relationsFn = imp("relations@drizzle-orm");
   const relationsVarName = `${varName}Relations`;
 
@@ -59,7 +58,7 @@ function renderRelationEntry(
       entry.junctionEntity,
       ctx.extStyle,
     );
-    const junctionVarSym = imp(`${variableNameFromEntity(entry.junctionEntity)}@${junctionSpec}`);
+    const junctionVarSym = imp(`${ctx.collectionName(entry.junctionEntity)}@${junctionSpec}`);
     return code`  ${entry.name}: many(${junctionVarSym})`;
   }
 
@@ -71,7 +70,7 @@ function renderRelationEntry(
     entry.targetEntity,
     ctx.extStyle,
   );
-  const targetVarSym = imp(`${variableNameFromEntity(entry.targetEntity)}@${targetSpec}`);
+  const targetVarSym = imp(`${ctx.collectionName(entry.targetEntity)}@${targetSpec}`);
 
   if (entry.cardinality === CARDINALITY_ONE) {
     const pkInfo = ctx.pkMap.get(entry.targetEntity);

package/src/templates/render-helper.ts

@@ -81,7 +81,7 @@ function derivePayloadFieldTree(
   const fields: PayloadField[] = [];
   for (const f of vo.children().filter((c) => c.type === TYPE_FIELD)) {
     if (f.subType === FIELD_SUBTYPE_OBJECT) {
-      const ref = f.ownAttr(FIELD_ATTR_OBJECT_REF);
+      const ref = f.attr(FIELD_ATTR_OBJECT_REF);
       if (typeof ref === "string") {
         fields.push({ name: f.name, fields: derivePayloadFieldTree(root, ref, nextSeen) });
         continue;

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

@@ -29,7 +29,6 @@ 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 {
@@ -97,7 +96,7 @@ export function ${handlerName}(app: ${HonoSym}<any, any, any>, deps: { db: unkno
   }
 
   // --- Vanilla / write-through entity path: full CRUD routes ---
-  const tableVar = variableNameFromEntity(entityName);
+  const tableVar = ctx.collectionName(entityName);
 
   const HonoSym = imp("t:Hono@hono");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/hono");

package/src/templates/routes-file.ts

@@ -24,7 +24,7 @@ import {
 import { type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier, entityModuleSpecifier, relativeModuleSpecifier } from "../import-path.js";
 import { GENERATED_HEADER } from "../constants.js";
-import { variableNameFromEntity, routesHandlerName } from "../naming.js";
+import { routesHandlerName } from "../naming.js";
 import { isProjection } from "../projection/projection-detector.js";
 import type { RelationEntry } from "../relation-resolver.js";
 import { isTphDiscriminatorBase, tphPlan } from "./tph-discriminator.js";
@@ -122,7 +122,7 @@ export async function ${handlerName}(fastify: ${FastifyInstanceSym}) {
   }
 
   // --- Vanilla / write-through entity path: full CRUD routes ---
-  const tableVar = variableNameFromEntity(entityName);
+  const tableVar = ctx.collectionName(entityName);
 
   const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify");
@@ -239,7 +239,7 @@ function renderM2mMount(
   fastifyVar: string,
 ): Code {
   const junctionVarSym = imp(
-    `${variableNameFromEntity(entry.junctionEntity)}@${crossEntitySpecifier(
+    `${ctx.collectionName(entry.junctionEntity)}@${crossEntitySpecifier(
       ctx.outputLayout,
       source.package,
       ctx.packageOf.get(entry.junctionEntity),
@@ -248,7 +248,7 @@ function renderM2mMount(
     )}`,
   );
   const targetVarSym = imp(
-    `${variableNameFromEntity(entry.targetEntity)}@${crossEntitySpecifier(
+    `${ctx.collectionName(entry.targetEntity)}@${crossEntitySpecifier(
       ctx.outputLayout,
       source.package,
       ctx.packageOf.get(entry.targetEntity),
@@ -312,7 +312,7 @@ function renderTphRoutesFile(base: MetaObject, ctx: RenderContext): string {
   // Single source of truth for the discriminator field + subtypes + route segments.
   const plan = tphPlan(base, ctx.loadedRoot)!;
   const discField = plan.discriminatorField;
-  const tableVar = variableNameFromEntity(baseName);
+  const tableVar = ctx.collectionName(baseName);
 
   const baseFileSpec = entityModuleSpecifier(
     ctx.selfTarget, ctx.entityModuleTarget, base.package, baseName, ctx.extStyle,

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

@@ -29,7 +29,7 @@ export function renderValueObjectFile(obj: MetaObject, apiPrefix = "", ctx?: Ren
   // but declares none of its own). In addition to the insert schema it emits a
   // full read schema `<Sub>Schema` so parse<Base>(row) can dispatch to it.
   const tphSubtype = isTphSubtype(obj);
-  const tphReadSchema = tphSubtype ? renderTphSubtypeReadSchema(obj) : null;
+  const tphReadSchema = tphSubtype ? renderTphSubtypeReadSchema(obj, ctx) : null;
   // FR-017 Tier 3: a TPH subtype also emits its field-metadata constants object
   // (the `<Sub>` const), so the React form generator can render per-field
   // labels / rules / inputs the same way it does for ordinary entities.
@@ -49,7 +49,7 @@ export function renderValueObjectFile(obj: MetaObject, apiPrefix = "", ctx?: Ren
     renderValueObjectInterface(obj, ctx),
     ...(enumAliases !== null ? [enumAliases] : []),
     ...(tphReadSchema !== null ? [tphReadSchema] : []),
-    renderInsertSchemaOnly(obj),
+    renderInsertSchemaOnly(obj, ctx),
     ...(tphConstants !== null ? [tphConstants] : []),
     ...(tphFilterAllowlist !== null ? [tphFilterAllowlist] : []),
     ...(tphSortAllowlist !== null ? [tphSortAllowlist] : []),

package/src/templates/zod-validators.ts

@@ -32,6 +32,7 @@ import { sharedEnumForField } from "../enum-shared.js";
 import { sharedEnumImportSpecifier } from "../enum-import.js";
 import { sharedEnumZodConstName } from "./enums-file.js";
 import type { RenderContext } from "../render-context.js";
+import { valueObjectModuleSpecifier } from "../import-path.js";
 
 /**
  * FR-017 Tier 1 — when this object is a TPH subtype (@discriminatorValue set
@@ -73,7 +74,7 @@ export function isTphSubtype(obj: MetaObject): boolean {
  * back from the DB arrives as `null`, not `undefined`, so the read schema must
  * accept null (the insert schema, by contrast, makes them `.optional()`).
  */
-export function renderTphSubtypeReadSchema(obj: MetaObject): Code {
+export function renderTphSubtypeReadSchema(obj: MetaObject, ctx?: RenderContext): Code {
   const z = imp("z@zod");
   const tphPin = tphDiscriminatorPin(obj);
 
@@ -83,7 +84,7 @@ export function renderTphSubtypeReadSchema(obj: MetaObject): Code {
       fieldLines.push(code`  ${child.name}: z.literal(${JSON.stringify(tphPin.value)})`);
       continue;
     }
-    const expr = zodFieldExpr(child);
+    const expr = zodFieldExpr(child, obj, ctx);
     // zodFieldExpr already appends `.optional()` for non-required fields; add
     // `.nullable()` on top so a NULL column value (the TPH default for any
     // subtype-only column) parses cleanly.
@@ -106,9 +107,9 @@ function autoGenPkFieldNames(obj: MetaObject): Set<string> {
   const out = new Set<string>();
   const primary = obj.primaryIdentity();
   if (primary) {
-    const generation = primary.ownAttr(IDENTITY_ATTR_GENERATION);
+    const generation = primary.attr(IDENTITY_ATTR_GENERATION);
     if (generation === GENERATION_INCREMENT || generation === GENERATION_UUID) {
-      const fields = primary.ownAttr(IDENTITY_ATTR_FIELDS);
+      const fields = primary.attr(IDENTITY_ATTR_FIELDS);
       const fieldsList = Array.isArray(fields) ? fields : (typeof fields === "string" ? [fields] : []);
       for (const f of fieldsList) out.add(String(f));
     }
@@ -125,7 +126,7 @@ function autoGenPkFieldNames(obj: MetaObject): Set<string> {
  * so consumer imports don't churn. A future polish PR could add a `<Name>Schema`
  * alias for clarity.
  */
-export function renderInsertSchemaOnly(obj: MetaObject): Code {
+export function renderInsertSchemaOnly(obj: MetaObject, ctx?: RenderContext): Code {
   const z = imp("z@zod");
   const autoGenPkFields = autoGenPkFieldNames(obj);
   const tphPin = tphDiscriminatorPin(obj);
@@ -136,7 +137,7 @@ export function renderInsertSchemaOnly(obj: MetaObject): Code {
     // FR-013: @readOnly fields are populated by DB / replication / external
     // owner; the application has no path to write them. Exclude from the
     // create-shape schema entirely.
-    if (child.ownAttr(FIELD_ATTR_READ_ONLY) === true) continue;
+    if (child.attr(FIELD_ATTR_READ_ONLY) === true) continue;
 
     // FR-017 Tier 1: TPH subtype pins its discriminator field to z.literal(...).
     if (tphPin !== undefined && child.name === tphPin.fieldName) {
@@ -146,14 +147,14 @@ export function renderInsertSchemaOnly(obj: MetaObject): Code {
       continue;
     }
 
-    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+    const autoSet = child.attr(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)}`);
+      insertFieldLines.push(code`  ${child.name}: ${zodFieldExpr(child, obj, ctx)}`);
     }
   }
 
@@ -200,12 +201,12 @@ export function insertSchemaFields(obj: MetaObject): SchemaFieldShape[] {
   const out: SchemaFieldShape[] = [];
   for (const child of obj.fields()) {
     if (autoGenPkFields.has(child.name)) continue;
-    if (child.ownAttr(FIELD_ATTR_READ_ONLY) === true) continue;
+    if (child.attr(FIELD_ATTR_READ_ONLY) === true) continue;
     if (tphPin !== undefined && child.name === tphPin.fieldName) {
       out.push({ name: child.name, optional: false, pinnedLiteral: tphPin.value });
       continue;
     }
-    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+    const autoSet = child.attr(FIELD_ATTR_AUTO_SET);
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
       out.push({ name: child.name, optional: true, autoSet: true });
     } else {
@@ -230,10 +231,10 @@ export function updateSchemaFields(obj: MetaObject): SchemaFieldShape[] {
   const out: SchemaFieldShape[] = [];
   for (const child of obj.fields()) {
     if (autoGenPkFields.has(child.name)) continue;
-    if (child.ownAttr(FIELD_ATTR_READ_ONLY) === true) continue;
+    if (child.attr(FIELD_ATTR_READ_ONLY) === true) continue;
     // TPH subtype discriminator: omitted from the update schema entirely.
     if (tphPin !== undefined && child.name === tphPin.fieldName) continue;
-    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+    const autoSet = child.attr(FIELD_ATTR_AUTO_SET);
     if (autoSet === AUTO_SET_ON_CREATE) {
       // Omitted: creation timestamps cannot change after creation.
       continue;
@@ -261,7 +262,7 @@ export function renderZodValidators(obj: MetaObject, ctx?: RenderContext): Code
     // The DB / trigger / replication owns the write path; the app must not
     // pass these values in POST/PATCH bodies (routesFile enforces the same
     // contract at the boundary with a 400 response).
-    if (child.ownAttr(FIELD_ATTR_READ_ONLY) === true) continue;
+    if (child.attr(FIELD_ATTR_READ_ONLY) === true) continue;
 
     // FR-017 Tier 1: TPH subtype pins its discriminator field to z.literal(...).
     // The discriminator is implicit on subtype rows (controlled by URL / insert
@@ -274,7 +275,7 @@ export function renderZodValidators(obj: MetaObject, ctx?: RenderContext): Code
       continue;
     }
 
-    const autoSet = child.ownAttr(FIELD_ATTR_AUTO_SET);
+    const autoSet = child.attr(FIELD_ATTR_AUTO_SET);
 
     // Insert schema: @autoSet fields use transform (always override client input).
     if (autoSet === AUTO_SET_ON_CREATE || autoSet === AUTO_SET_ON_UPDATE) {
@@ -326,12 +327,18 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
   // field used to collapse to z.string() / z.array(z.string()) and downstream
   // JSON Schema (e.g. LLM tool_use input_schema) lost the nested object shape.
   if (field.subType === FIELD_SUBTYPE_OBJECT) {
-    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref === "string" && ref.length > 0) {
       // @objectRef may be authored fully-qualified or bare — the referenced
-      // <Ref>InsertSchema + its sibling module use the BARE short name.
+      // <Ref>InsertSchema is named by the BARE short name. The import MODULE is
+      // resolved via the shared layout/package/extStyle-aware helper (the SAME
+      // one the field's TS type + Drizzle .$type<> use) so all three agree.
+      // Without owner/ctx (bare unit-test calls) fall back to the flat same-dir.
       const refBase = stripPackage(ref);
-      const refImp = imp(`${refBase}InsertSchema@./${refBase}.js`);
+      const moduleSpec = (ctx && owner)
+        ? valueObjectModuleSpecifier(refBase, ctx.packageOf, owner.package, ctx.outputLayout, ctx.extStyle)
+        : `./${refBase}.js`;
+      const refImp = imp(`${refBase}InsertSchema@${moduleSpec}`);
       let base: Code = code`${refImp}`;
       if (field.isArray) base = code`z.array(${base})`;
       return appendValidatorChain(base, field);
@@ -401,11 +408,11 @@ function zodFieldExpr(field: MetaField, owner?: MetaObject, ctx?: RenderContext)
 /** Mirrors the optional-or-not decision inside appendValidatorChain so the update-schema
  *  caller can avoid stacking a second `.optional()` onto an already-optional expression. */
 function fieldWillBeOptional(field: MetaField): boolean {
-  let isRequired = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+  let isRequired = field.attr(FIELD_ATTR_REQUIRED) === true;
   for (const child of field.validators()) {
     if (child.subType === VALIDATOR_SUBTYPE_REQUIRED) isRequired = true;
   }
-  const hasDefault = field.ownAttr(FIELD_ATTR_DEFAULT) !== undefined;
+  const hasDefault = field.attr(FIELD_ATTR_DEFAULT) !== undefined;
   return !isRequired || hasDefault;
 }
 
@@ -423,8 +430,8 @@ const NUMERIC_FIELD_SUBTYPES = new Set<string>([
  *  - array (any element)    → .min/.max = element count     (validator.array)
  */
 function appendValidatorChain(base: Code, field: MetaField): Code {
-  let isRequired = field.ownAttr(FIELD_ATTR_REQUIRED) === true;
-  let maxLen: number | undefined = field.ownAttr(FIELD_ATTR_MAX_LENGTH) as number | undefined;
+  let isRequired = field.attr(FIELD_ATTR_REQUIRED) === true;
+  let maxLen: number | undefined = field.attr(FIELD_ATTR_MAX_LENGTH) as number | undefined;
   let minLen: number | undefined;
   let pattern: string | undefined;
   let numMin: number | undefined;
@@ -475,7 +482,7 @@ function appendValidatorChain(base: Code, field: MetaField): Code {
   // Fields with DB-level defaults are optional in the InsertSchema: the caller
   // can omit them and the DB will fill in. Otherwise required-with-default
   // would force callers to repeat the default at every call site.
-  const hasDefault = field.ownAttr(FIELD_ATTR_DEFAULT) !== undefined;
+  const hasDefault = field.attr(FIELD_ATTR_DEFAULT) !== undefined;
   if (!isRequired || hasDefault) chain = code`${chain}.optional()`;
   return chain;
 }

package/dist/templates/extract-schema-emitter.d.ts

@@ -1,8 +0,0 @@
-import { type MetaData } from "@metaobjectsdev/metadata";
-/** Emit `extractSchema(Format.X, "rootName", [ … ])`. */
-export declare function schemaLiteral(vo: MetaData, format: string, rootName: string): string;
-/** Emit the all-nullable mirror interface declaration. */
-export declare function mirrorInterface(vo: MetaData, interfaceName: string): string;
-/** Emit `{ prop: asString(d, "prop"), … }` building the mirror from the forgiving map `d`. */
-export declare function mirrorInitializer(vo: MetaData): string;
-//# sourceMappingURL=extract-schema-emitter.d.ts.map

package/dist/templates/extract-schema-emitter.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-schema-emitter.d.ts","sourceRoot":"","sources":["../../src/templates/extract-schema-emitter.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,KAAK,QAAQ,EAId,MAAM,0BAA0B,CAAC;AAmBlC,yDAAyD;AACzD,wBAAgB,aAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAIpF;AAmDD,0DAA0D;AAC1D,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAc3E;AAED,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAAC,EAAE,EAAE,QAAQ,GAAG,MAAM,CAGtD"}