fix(codegen-ts): read field attributes via effective attr(), not ownAttr()

Field-level `extends` (abstract fields — a concrete field extending a package-level
abstract field to inherit `required` / `maxLength` / `default` / etc.) was silently
dropping the inherited attributes: the generators read them with `ownAttr()` (own
declarations only), so an inherited `@required` produced a NULLABLE column, an
inherited `@maxLength` was ignored, etc. Output was under-constrained — e.g. a field
`{ extends: Name }` of an abstract `Name {required, maxLength:200}` generated
`text("name")` instead of `varchar("name",{length:200}).notNull()`.

This surfaced after the collect-all rework (#52) made inherited attrs resolve as
effective-but-not-own; the generators' long-standing `ownAttr()` usage then missed
them. Switched every FIELD_ATTR_* read (57 sites across column-mapper, drizzle-schema,
zod-validators, inferred-types, entity-constants, filters, payload/extract, docs, …)
to the effective `attr()`. For a field with no `extends`, `attr() === ownAttr()`, so
this is a no-op for all existing output (codegen-ts 803/0, byte-identical goldens);
it only restores the inherited case. Identity/object/source/validator reads stay
`ownAttr()` (correctly own-only).

Also: buildFkMapForEntity now strips the package from the FK target before the lookup
(`findObject(stripPackage(targetName))`) — the YAML front-end resolves `@references`
to an FQN (`pkg::Entity`), and the un-stripped lookup dropped every FK under YAML.
Mirrors the relation-resolver, which already strips.

Tests: a YAML fixture exercising both (abstract-field required+maxLength inheritance,
and a package-qualified FK target). codegen-ts 803/0.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: dmealing

server/typescript/packages/codegen-ts/src/column-mapper.ts

@@ -170,7 +170,7 @@ function pgColumnTypeOverride(
   field: MetaField,
   timestampMode: "date" | "string" = "string",
 ): { fnName: string; fnOptions?: Record<string, unknown> } | undefined {
-  const dbColumnType = field.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE);
+  const dbColumnType = field.attr(FIELD_ATTR_DB_COLUMN_TYPE);
   if (typeof dbColumnType !== "string") return undefined;
   switch (dbColumnType) {
     case DB_COLUMN_TYPE_UUID:
@@ -191,7 +191,7 @@ function pgColumnTypeOverride(
 /** Resolve max length from validator.length child or @maxLength attr.
  *  Uses field.validators() (effective) so inherited validators are seen. */
 function getMaxLength(field: MetaField): number | undefined {
-  const lenAttr = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+  const lenAttr = field.attr(FIELD_ATTR_MAX_LENGTH);
   if (typeof lenAttr === "number") return lenAttr;
   for (const child of field.validators()) {
     if (child.subType === VALIDATOR_SUBTYPE_LENGTH) {
@@ -205,15 +205,15 @@ function getMaxLength(field: MetaField): number | undefined {
 /** Check for validator.required child OR @required attr.
  *  Uses field.validators() (effective) so inherited validators are seen. */
 function isRequired(field: MetaField): boolean {
-  if (field.ownAttr(FIELD_ATTR_REQUIRED) === true) return true;
+  if (field.attr(FIELD_ATTR_REQUIRED) === true) return true;
   return field.validators().some((child) => child.subType === VALIDATOR_SUBTYPE_REQUIRED);
 }
 
 /** The bare (package-stripped) @objectRef name on a field.object, or undefined
  *  when unset. Used as the `.$type<VO>()` target + its sibling-module import.
  *  A fully-qualified ref (acme::ai::SourceLens) strips to the short name. */
 function objectRefBaseName(field: MetaField): string | undefined {
-  const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+  const ref = field.attr(FIELD_ATTR_OBJECT_REF);
   if (typeof ref === "string" && ref.length > 0) return stripPackage(ref);
   return undefined;
 }
@@ -339,8 +339,8 @@ export function mapColumnType(
           // declared @precision/@scale (mirroring migrate-ts/expected-schema so
           // codegen and the DDL agree), falling back to a sane default.
           fnName = "numeric";
-          const precision = field.ownAttr(FIELD_ATTR_PRECISION);
-          const scale = field.ownAttr(FIELD_ATTR_SCALE);
+          const precision = field.attr(FIELD_ATTR_PRECISION);
+          const scale = field.attr(FIELD_ATTR_SCALE);
           if (typeof precision === "number" && typeof scale === "number") {
             fnOptions = { precision, scale };
           } else if (typeof precision === "number") {
@@ -414,12 +414,12 @@ export function mapColumnType(
     modifiers.push(".notNull()");
   }
 
-  if (field.ownAttr(FIELD_ATTR_UNIQUE) === true) {
+  if (field.attr(FIELD_ATTR_UNIQUE) === true) {
     modifiers.push(".unique()");
   }
 
   let defaultExpr: DefaultExpr | undefined;
-  const defaultAttr = field.ownAttr(FIELD_ATTR_DEFAULT);
+  const defaultAttr = field.attr(FIELD_ATTR_DEFAULT);
   if (defaultAttr !== undefined) {
     // SQL-expression detection runs on the raw string value — a string like
     // "CURRENT_TIMESTAMP" or "now" must be emitted as sql`...`, not a literal.

server/typescript/packages/codegen-ts/src/enum-shared.ts

@@ -62,7 +62,7 @@ export function sharedEnumForField(field: MetaField): SharedEnum | undefined {
   return {
     name: toPascalCase(decl.name),
     values,
-    provided: decl.ownAttr(FIELD_ATTR_PROVIDED) === true,
+    provided: decl.attr(FIELD_ATTR_PROVIDED) === true,
   };
 }
 

server/typescript/packages/codegen-ts/src/generators/docs-data-builder.ts

@@ -82,7 +82,7 @@ export interface BuildDocDataOpts {
  *  the documented model-field optionality. Exported so the field-shape builder
  *  reuses the EXACT same rule rather than re-deriving it. */
 export function isFieldRequired(field: MetaField): boolean {
-  if (field.ownAttr(FIELD_ATTR_REQUIRED) === true) return true;
+  if (field.attr(FIELD_ATTR_REQUIRED) === true) return true;
   return field.validators().some((v) => v.subType === VALIDATOR_SUBTYPE_REQUIRED);
 }
 
@@ -104,7 +104,7 @@ interface ValidatorParts {
 }
 
 function collectValidatorParts(field: MetaField): ValidatorParts {
-  const maxLenAttr = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+  const maxLenAttr = field.attr(FIELD_ATTR_MAX_LENGTH);
   const regexParts: string[] = [];
   const lengthParts: string[] = [];
   const numericParts: string[] = [];
@@ -143,7 +143,7 @@ function collectValidatorParts(field: MetaField): ValidatorParts {
 export function neutralTypeStr(field: MetaField): string {
   let base: string;
   if (field.subType === FIELD_SUBTYPE_OBJECT) {
-    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     base = typeof ref === "string" && ref.length > 0 ? stripPackage(ref) : "object";
   } else {
     base = field.subType;
@@ -165,7 +165,7 @@ function neutralTypeCell(field: MetaField): string {
  *  uses. Deliberately does NOT derive ANSI/ORM SQL so it can't drift vs the
  *  migrate engine or re-introduce language-specific DDL. Wrapped in backticks. */
 function storageTypeCell(field: MetaField): string {
-  const dbColumnType = field.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE);
+  const dbColumnType = field.attr(FIELD_ATTR_DB_COLUMN_TYPE);
   if (typeof dbColumnType === "string" && dbColumnType.length > 0) {
     return `\`${dbColumnType.toUpperCase()}\``;
   }
@@ -190,7 +190,7 @@ function buildConstraintRow(
   const rules: string[] = [];
 
   if (isPk) rules.push("primary key");
-  if (field.ownAttr(FIELD_ATTR_UNIQUE) === true) rules.push("unique");
+  if (field.attr(FIELD_ATTR_UNIQUE) === true) rules.push("unique");
 
   if (field.subType === FIELD_SUBTYPE_ENUM && !field.isArray) {
     const values = enumValues(field);
@@ -212,7 +212,7 @@ function buildConstraintRow(
     rules.push(`references \`${fk.targetEntity}.${fk.targetField}\``);
   }
 
-  const def = field.ownAttr(FIELD_ATTR_DEFAULT);
+  const def = field.attr(FIELD_ATTR_DEFAULT);
   if (def !== undefined) rules.push(`default: \`${String(def)}\``);
 
   const sup = field.resolveSuper();
@@ -271,7 +271,7 @@ function buildFieldRow(
   // Otherwise empty. Keeps the column noise-free for the 90% case where
   // field name and column name agree.
   const columnName = field.column;
-  const dbColumnType = field.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE);
+  const dbColumnType = field.attr(FIELD_ATTR_DB_COLUMN_TYPE);
   const columnDiffers = typeof columnName === "string" && columnName !== field.name;
   const hasPhysicalOverride = typeof dbColumnType === "string" && dbColumnType.length > 0;
   let storageCell = "";
@@ -287,7 +287,7 @@ function buildFieldRow(
   // column, plus the maxLength/length/numeric limits that used to live in
   // the separate Limits cell (collapsed in to keep the table to 5 columns).
   const rules: string[] = [];
-  if (field.ownAttr(FIELD_ATTR_UNIQUE) === true) rules.push("unique");
+  if (field.attr(FIELD_ATTR_UNIQUE) === true) rules.push("unique");
 
   if (field.subType === FIELD_SUBTYPE_ENUM && !field.isArray) {
     const values = enumValues(field);
@@ -303,7 +303,7 @@ function buildFieldRow(
   rules.push(...lengthParts, ...numericParts);
 
   // The FK reference is already encoded in typeCell — don't repeat it in rules.
-  const def = field.ownAttr(FIELD_ATTR_DEFAULT);
+  const def = field.attr(FIELD_ATTR_DEFAULT);
   if (def !== undefined) rules.push(`default: \`${String(def)}\``);
 
   const sup = field.resolveSuper();
@@ -340,10 +340,10 @@ function buildFieldDetail(
   const hasSummary = typeof summary === "string" && summary.length > 0;
   const sup = field.resolveSuper();
   const fk = fkMap.get(field.name);
-  const def = field.ownAttr(FIELD_ATTR_DEFAULT);
+  const def = field.attr(FIELD_ATTR_DEFAULT);
   const columnName = field.column;
-  const dbColumnType = field.ownAttr(FIELD_ATTR_DB_COLUMN_TYPE);
-  const isUnique = field.ownAttr(FIELD_ATTR_UNIQUE) === true;
+  const dbColumnType = field.attr(FIELD_ATTR_DB_COLUMN_TYPE);
+  const isUnique = field.attr(FIELD_ATTR_UNIQUE) === true;
   const isEnum = field.subType === FIELD_SUBTYPE_ENUM && !field.isArray;
   const enumVals = isEnum ? enumValues(field) : undefined;
   const validators = field.validators();
@@ -352,7 +352,7 @@ function buildFieldDetail(
       || v.subType === VALIDATOR_SUBTYPE_REGEX
       || v.subType === VALIDATOR_SUBTYPE_NUMERIC,
   );
-  const maxLenAttr = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+  const maxLenAttr = field.attr(FIELD_ATTR_MAX_LENGTH);
 
   // "Interesting enough to render a detail block" predicate. Plain typed
   // fields with no authored annotations get skipped — the at-a-glance Fields

server/typescript/packages/codegen-ts/src/generators/template-payload-tree.ts

@@ -58,7 +58,7 @@ export function buildEnrichedPayloadTree(
       required: isFieldRequired(f),
     };
     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" && ref.length > 0) {
         // Owner switches to the nested VO for its fields (the recursion below
         // re-derives `owner` from the resolved VO's own name).

server/typescript/packages/codegen-ts/src/payload-codegen.ts

@@ -65,7 +65,7 @@ function fieldTsType(
   ownerName: string,
 ): { type: string; refVo?: string; enumAlias?: { name: string; decl: string } } {
   if (field.subType === FIELD_SUBTYPE_OBJECT) {
-    const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+    const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     const refName = typeof ref === "string" ? ref : "unknown";
     // isArray is a structural property on MetaData, not an attr.
     const isArray = field.isArray;
@@ -96,7 +96,7 @@ function fieldTsType(
 
 /** True iff the field's @required is explicitly set to true. */
 function isFieldRequired(field: MetaData): boolean {
-  return field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+  return field.attr(FIELD_ATTR_REQUIRED) === true;
 }
 
 function emitInterface(

server/typescript/packages/codegen-ts/src/projection/extract-view-spec.ts

@@ -135,7 +135,7 @@ function sourceColumnNameFor(
   entityField: MetaData,
   ctx: ExtractContext,
 ): string {
-  const col = entityField.ownAttr(FIELD_ATTR_COLUMN);
+  const col = entityField.attr(FIELD_ATTR_COLUMN);
   if (typeof col === "string" && col !== "") return col;
   return columnNameFromField(entityField.name, ctx.columnNamingStrategy);
 }

server/typescript/packages/codegen-ts/src/templates/drizzle-schema.ts

@@ -3,7 +3,7 @@
 // plus the relations() block auto-emitted at the end.
 
 import { code, imp, joinCode, type Code } from "ts-poet";
-import { MetaObject, MetaField } from "@metaobjectsdev/metadata";
+import { MetaObject, MetaField, stripPackage } from "@metaobjectsdev/metadata";
 import {
   IDENTITY_SUBTYPE_SECONDARY, FIELD_SUBTYPE_LONG,
   IDENTITY_ATTR_FIELDS, IDENTITY_ATTR_GENERATION, IDENTITY_ATTR_UNIQUE,
@@ -184,7 +184,11 @@ function buildFkMapForEntity(obj: MetaObject, ctx: RenderContext): Map<string, F
     const fkField = fkFieldNames[0]!;
     const targetName = ref.targetEntity;
     if (!targetName) continue;
-    const targetObj = ctx.loadedRoot.findObject(targetName);
+    // @references may be authored bare OR package-qualified, and the loader can
+    // resolve it to an FQN (e.g. the YAML front-end qualifies it). Strip the
+    // package so the lookup matches the object's bare name — mirrors the
+    // relation-resolver, which already does this.
+    const targetObj = ctx.loadedRoot.findObject(stripPackage(targetName));
     if (!targetObj) continue;
     const targetPkField = ref.resolvedTargetPkField(ctx.loadedRoot) ?? "id";
     result.set(fkField, {
@@ -345,7 +349,7 @@ function renderColumn(
   // @autoSet fields: emit .$defaultFn(() => new Date().toISOString()) so Drizzle
   // inserts stamp the server-side timestamp automatically. This means callers don't
   // need to supply createdAt / updatedAt in INSERT calls — Drizzle fills them in.
-  const autoSet = field.ownAttr(FIELD_ATTR_AUTO_SET);
+  const autoSet = field.attr(FIELD_ATTR_AUTO_SET);
   const autoSetSuffix = (autoSet === "onCreate" || autoSet === "onUpdate")
     ? `.$defaultFn(() => new Date().toISOString())`
     : "";

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

@@ -160,12 +160,12 @@ function renderFieldRules(field: MetaField): string | undefined {
   }
 
   // Field-level @required attr (if not already covered by validator).
-  if (!hasRequired && field.ownAttr(FIELD_ATTR_REQUIRED) === true) {
+  if (!hasRequired && field.attr(FIELD_ATTR_REQUIRED) === true) {
     ruleParts.push(`required: ${JSON.stringify(`${humanize(field.name)} is required`)}`);
   }
 
   // Field-level @maxLength attr (if not already covered).
-  const maxLenAttr = field.ownAttr(FIELD_ATTR_MAX_LENGTH);
+  const maxLenAttr = field.attr(FIELD_ATTR_MAX_LENGTH);
   if (!hasMaxLength && typeof maxLenAttr === "number") {
     ruleParts.push(
       `maxLength: { value: ${maxLenAttr}, message: ${JSON.stringify(`Must be ${maxLenAttr} characters or fewer`)} }`,

server/typescript/packages/codegen-ts/src/templates/extract-delegate-emitter.ts

@@ -37,7 +37,7 @@ function findObject(root: MetaData, name: string): MetaData | undefined {
 
 /** The @objectRef target VO for a nested-object field, or undefined when unresolvable. */
 function refVo(field: MetaData, root: MetaData): MetaData | undefined {
-  const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+  const ref = field.attr(FIELD_ATTR_OBJECT_REF);
   if (typeof ref !== "string") return undefined;
   const direct = findObject(root, ref);
   if (direct !== undefined) return direct;

server/typescript/packages/codegen-ts/src/templates/extractor.ts

@@ -50,7 +50,7 @@ function findTemplate(root: MetaData, name: string): MetaData | undefined {
 
 /** The @objectRef target VO for a nested-object field, or undefined when unresolvable. */
 function refVo(field: MetaData, root: MetaData): MetaData | undefined {
-  const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+  const ref = field.attr(FIELD_ATTR_OBJECT_REF);
   if (typeof ref !== "string") return undefined;
   const direct = findObject(root, ref);
   if (direct !== undefined) return direct;
@@ -85,7 +85,7 @@ function enumAlias(field: MetaData, ownerName: string): string | undefined {
  * required test (boolean `true` only) so the two never skew.
  */
 function isFieldRequired(field: MetaData): boolean {
-  return field.ownAttr(FIELD_ATTR_REQUIRED) === true;
+  return field.attr(FIELD_ATTR_REQUIRED) === true;
 }
 
 /** The mirror→strict mapper name for a value-object (`toStrict<Name>`). */