fix(codegen): read inherited attrs via effective accessor across TS/Python/Kotlin + regression gates (#57, #56)

* test(gate): RED tripwires for inherit-without-restate codegen bug (#56)

Two failing gates (RED until #56 is fixed) asserting codegen reads INHERITED attrs via
the effective accessor, not own-only:

- TS (codegen-ts): an identity.primary that inherits @fields via node-level extends
  without restating it must still yield a primary key. pk-resolver reads
  primary.ownAttr(@fields) → undefined → the entity is dropped from the PK map → no PK.

- Python (codegen): a field that inherits @required via extends (abstract-field reuse)
  must generate as a REQUIRED Pydantic field, not Optional. entity_model reads
  field.attr(@required) — which in this port is OWN-ONLY despite the name — so the
  inherited @required is invisible and `label: str | None = None` is wrongly emitted.

Both assert the CORRECT behavior and turn green when the ownAttr→attr fix lands (see #56
for the full cross-port inventory). Intentional RED tripwire PR — do not merge until #56
is fixed; then these become the permanent regression gate.

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

* test(gate): add Kotlin tripwire for inherit-without-restate (#56)

Kotlin (codegen-kotlin): a field that inherits @maxlength via extends (abstract-field
reuse) without restating it must emit varchar with the inherited length, but
KotlinTypeMapper reads @maxlength own-only → falls back to the 255 default. Confirmed
RED: emits varchar("label", 255) for an inherited @maxlength=80.

Completes the confirmed-port coverage (Python + Kotlin) alongside the latent TS edge.

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

* fix(codegen): read inherited attributes via the effective accessor, not own-only (#56)

Completes the #56 fix across the three affected ports (the gates in this PR now pass).
Builds on #55, which fixed the TS *field*-attr reads.

- TS (codegen-ts): identity @fields/@generation/@unique reads switched ownAttr → attr
  (pk-resolver, drizzle-schema, zod-validators, queries, docs-data-builder). #55 fixed
  field reads but not identity reads, so a BaseEntity-inherited PK was still dropped.

- Python (codegen): ~17 field-attr reads switched field.attr(X) → field.attrs().get(X).
  Python's attr() is OWN-ONLY despite the name (the footgun); attrs() is the effective
  map. Covers @required/@maxLength/@objectRef/@default/@values/@isArray/@filterable/
  @enumAlias/@enumDoc/@column. (Validator/origin/template reads left own — correct as-is.)

- Kotlin (codegen-kotlin): field-attr reads switched getMetaAttr/hasMetaAttr(..., false)
  → (..., true) for @maxLength/@storage/@objectRef/@filterable (TypeMapper,
  ExposedTableGenerator, EntityGenerator, RenderHelperGenerator, FilterAllowlist).

Node-level reads (identity/relationship via effective iterators) and the validation
reference-walk (validate-at-declaration) are deliberately left own-only.

Gates green: TS codegen-ts 883 + react/tanstack 69 + whole-workspace typecheck clean;
Python 1207; Kotlin codegen-kotlin 35. C# and Java codegen need no change (their attr
accessors already default effective / inherit whole nodes).

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

---------

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinEntityGenerator.kt

@@ -221,8 +221,8 @@ open class KotlinEntityGenerator : MultiFileDirectGeneratorBase<MetaObject>() {
 
     /** Read the `@objectRef` attr off a field (own-only); null if absent. */
     private fun readObjectRef(field: MetaField<*>): String? {
-        if (!field.hasMetaAttr(ObjectField.ATTR_OBJECTREF, false)) return null
-        return runCatching { field.getMetaAttr(ObjectField.ATTR_OBJECTREF, false).valueAsString }
+        if (!field.hasMetaAttr(ObjectField.ATTR_OBJECTREF, true)) return null
+        return runCatching { field.getMetaAttr(ObjectField.ATTR_OBJECTREF, true).valueAsString }
             .getOrNull()
     }
 

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinExposedTableGenerator.kt

@@ -486,14 +486,14 @@ open class KotlinExposedTableGenerator : MultiFileDirectGeneratorBase<MetaObject
 
     /** Read the `@storage` attr (own-only); null when absent. */
     private fun readStorage(field: ObjectField): String? {
-        if (!field.hasMetaAttr(ATTR_STORAGE, false)) return null
-        return runCatching { field.getMetaAttr(ATTR_STORAGE, false).valueAsString }.getOrNull()
+        if (!field.hasMetaAttr(ATTR_STORAGE, true)) return null
+        return runCatching { field.getMetaAttr(ATTR_STORAGE, true).valueAsString }.getOrNull()
     }
 
     /** Read the `@objectRef` attr (own-only); null when absent. */
     private fun readObjectRef(field: ObjectField): String? {
-        if (!field.hasMetaAttr(ObjectField.ATTR_OBJECTREF, false)) return null
-        return runCatching { field.getMetaAttr(ObjectField.ATTR_OBJECTREF, false).valueAsString }
+        if (!field.hasMetaAttr(ObjectField.ATTR_OBJECTREF, true)) return null
+        return runCatching { field.getMetaAttr(ObjectField.ATTR_OBJECTREF, true).valueAsString }
             .getOrNull()
     }
 

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinFilterAllowlistGenerator.kt

@@ -167,8 +167,8 @@ open class KotlinFilterAllowlistGenerator : MultiFileDirectGeneratorBase<MetaObj
 
         /** True iff `field` carries `@filterable: true` as a metadata attribute. */
         private fun isFilterable(field: MetaField<*>): Boolean {
-            if (!field.hasMetaAttr(ATTR_FILTERABLE, false)) return false
-            val raw = runCatching { field.getMetaAttr(ATTR_FILTERABLE, false).value }.getOrNull()
+            if (!field.hasMetaAttr(ATTR_FILTERABLE, true)) return false
+            val raw = runCatching { field.getMetaAttr(ATTR_FILTERABLE, true).value }.getOrNull()
             return when (raw) {
                 is Boolean -> raw
                 is String -> raw.equals("true", ignoreCase = true)

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinRenderHelperGenerator.kt

@@ -254,8 +254,8 @@ open class KotlinRenderHelperGenerator : MultiFileDirectGeneratorBase<MetaObject
      * `object.value` is found.
      */
     private fun resolveNestedObjectRef(loader: MetaDataLoader, field: ObjectField): MetaObject? {
-        if (!field.hasMetaAttr(MetaObject.ATTR_OBJECT_REF, false)) return null
-        val ref = field.getMetaAttr(MetaObject.ATTR_OBJECT_REF, false).valueAsString
+        if (!field.hasMetaAttr(MetaObject.ATTR_OBJECT_REF, true)) return null
+        val ref = field.getMetaAttr(MetaObject.ATTR_OBJECT_REF, true).valueAsString
         if (ref.isNullOrEmpty()) return null
         val refShort = ref.substringAfterLast("::")
         for (obj in loader.metaObjects) {

server/java/codegen-kotlin/src/main/kotlin/com/metaobjects/generator/kotlin/KotlinTypeMapper.kt

@@ -412,9 +412,9 @@ object KotlinTypeMapper {
 
     /** Resolve @maxLength on a StringField; default 255. */
     private fun stringMaxLength(field: StringField): Int {
-        if (!field.hasMetaAttr(StringField.ATTR_MAX_LENGTH, false)) return 255
+        if (!field.hasMetaAttr(StringField.ATTR_MAX_LENGTH, true)) return 255
         val raw = runCatching {
-            field.getMetaAttr(StringField.ATTR_MAX_LENGTH, false).value
+            field.getMetaAttr(StringField.ATTR_MAX_LENGTH, true).value
         }.getOrNull()
         return when (raw) {
             is Number -> raw.toInt()

server/java/codegen-kotlin/src/test/kotlin/com/metaobjects/generator/kotlin/InheritWithoutRestateGateTest.kt

@@ -0,0 +1,47 @@
+package com.metaobjects.generator.kotlin
+
+import com.metaobjects.metadata.ktx.loadString
+import java.nio.file.Files
+import kotlin.test.Test
+import kotlin.test.assertTrue
+
+/**
+ * GATE / TRIPWIRE for issue #56 — Kotlin codegen must read INHERITED field attributes via
+ * the effective accessor, not own-only. This test asserts the CORRECT behavior and is RED
+ * until #56 is fixed: a `field.string` that inherits `@maxLength` via `extends`
+ * (abstract-field reuse) without restating it must emit `varchar("...", <inherited>)`, but
+ * `KotlinTypeMapper` reads `@maxLength` own-only → falls back to the 255 default. See #56.
+ */
+class InheritWithoutRestateGateTest {
+
+    private val fixture = """{
+      "metadata.root": { "package": "test", "children": [
+        { "object.entity": { "name": "Base", "abstract": true, "children": [
+            { "field.string": { "name": "baseLabel", "@maxLength": 80, "@required": true } }
+        ] } },
+        { "object.entity": { "name": "Widget", "children": [
+            { "field.long":   { "name": "id" } },
+            { "field.string": { "name": "label", "extends": "test::Base.baseLabel" } },
+            { "source.rdb":   { "@table": "widgets" } },
+            { "identity.primary": { "name": "pk", "@fields": ["id"], "@generation": "increment" } }
+        ] } }
+      ] }
+    }""".trimIndent()
+
+    @Test
+    fun `inherited maxLength emits the inherited varchar length, not the 255 default`() {
+        val outDir = Files.createTempDirectory("ktgate-")
+        try {
+            val gen = KotlinExposedTableGenerator()
+            gen.setArgs(mapOf("outputDir" to outDir.toString()))
+            gen.execute(loadString("test", fixture))
+
+            val src = Files.readString(outDir.resolve("test/WidgetTable.kt"))
+            // RED until #56 is fixed: inherited @maxLength=80 should win, not the 255 fallback.
+            assertTrue("varchar(\"label\", 80)" in src,
+                "expected inherited @maxLength=80 on the label column, got:\n$src")
+        } finally {
+            outDir.toFile().deleteRecursively()
+        }
+    }
+}

server/python/src/metaobjects/codegen/extract_delegate_emitter.py

@@ -47,7 +47,7 @@ def ref_vo(field: MetaData, root: MetaData) -> MetaData | None:
     """The ``@objectRef`` target VO for a nested-object field, or ``None`` when
     unresolvable. Matches first on the full ref, then the trailing simple-name
     segment (mirrors the runtime ``_resolve_object_ref`` short-name fallback)."""
-    ref = field.attr(fc.FIELD_ATTR_OBJECT_REF)
+    ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
     if not isinstance(ref, str) or not ref:
         return None
     direct = _find_object(root, ref)

server/python/src/metaobjects/codegen/extract_schema_emitter.py

@@ -53,7 +53,7 @@ def _field_spec_literal(field: MetaData, owner: MetaData) -> str:
 
     if field.sub_type == fc.FIELD_SUBTYPE_ENUM:
         values_lit = fm.string_list_literal(fm.enum_values(field))
-        alias_lit = fm.properties_map_literal(field.attr(fc.FIELD_ATTR_ENUM_ALIAS))
+        alias_lit = fm.properties_map_literal(field.attrs().get(fc.FIELD_ATTR_ENUM_ALIAS))
         # FR-011: resolve the three new enum args (field → object.value → "strip" for
         # normalize). Keep the back-compat 4-arg form when nothing is set; otherwise
         # emit the 7-arg form (..., coerce_default, normalize, default_value).

server/python/src/metaobjects/codegen/fr010_field_mapping.py

@@ -34,12 +34,12 @@ def fields(vo: MetaData) -> list[MetaData]:
 def is_array(field: MetaData) -> bool:
     """Array-ness from either form: the node property (programmatic build) or the
     ``@isArray`` attr (how metadata loads from JSON)."""
-    return bool(field.is_array) or field.attr(KEY_IS_ARRAY) is True
+    return bool(field.is_array) or field.attrs().get(KEY_IS_ARRAY) is True
 
 
 def is_required(field: MetaData) -> bool:
     """``@required`` — accepts a bool ``True`` or the string ``"true"``."""
-    v = field.attr(fc.FIELD_ATTR_REQUIRED)
+    v = field.attrs().get(fc.FIELD_ATTR_REQUIRED)
     if v is True:
         return True
     return isinstance(v, str) and v.lower() == "true"
@@ -49,15 +49,15 @@ def xml_text(field: MetaData) -> bool:
     """``@xmlText`` — the XML text-content extract marker (accepts a bool ``True`` or the
     string ``"true"``). When set, codegen bakes a ``FieldSpec.text_content_field(...)``.
     Mirrors the TS ``xmlText(field)`` helper."""
-    v = field.attr(TEMPLATE_ATTR_XML_TEXT)
+    v = field.attrs().get(TEMPLATE_ATTR_XML_TEXT)
     if v is True:
         return True
     return isinstance(v, str) and v.lower() == "true"
 
 
 def enum_values(field: MetaData) -> list[str]:
     """The string members of an enum field's ``@values`` attr (empty when absent)."""
-    v = field.attr(fc.FIELD_ATTR_VALUES)
+    v = field.attrs().get(fc.FIELD_ATTR_VALUES)
     if isinstance(v, (list, tuple)):
         return [str(x) for x in v]
     return []

server/python/src/metaobjects/codegen/generators/entity_model.py

@@ -57,7 +57,7 @@ def _validator_constraints(field: MetaField) -> dict[str, object]:
     # String length: validator.length @min/@max + field @maxLength (max wins per field attr).
     min_len = _first_attr(field, vc.VALIDATOR_SUBTYPE_LENGTH, vc.VALIDATOR_ATTR_MIN)
     max_len = _first_attr(field, vc.VALIDATOR_SUBTYPE_LENGTH, vc.VALIDATOR_ATTR_MAX)
-    field_max = field.attr(fc.FIELD_ATTR_MAX_LENGTH)
+    field_max = field.attrs().get(fc.FIELD_ATTR_MAX_LENGTH)
     if _is_int(field_max):
         max_len = field_max
     if min_len is not None:
@@ -110,14 +110,14 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
         imports.update(pt.imports)
         type_expr = pt.expr
     if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
-        ref = field.attr(fc.FIELD_ATTR_OBJECT_REF)
+        ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
         if ref:
             # @objectRef is FQN-expanded at load time; the generated VOs live
             # flat in one package, so import by the bare class name.
             ref_name = str(ref).split("::")[-1]
             imports.add(f"from .{ref_name} import {ref_name}")
-    required = field.attr(fc.FIELD_ATTR_REQUIRED) is True
-    default_raw = field.attr(fc.FIELD_ATTR_DEFAULT)
+    required = field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
+    default_raw = field.attrs().get(fc.FIELD_ATTR_DEFAULT)
     has_default = default_raw is not None
     enum_type_name = type_name if shared is not None else None