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>

Author: dmealing

server/python/tests/codegen/test_inherit_without_restate_gate.py

@@ -0,0 +1,54 @@
+"""GATE / TRIPWIRE for issue #56 — codegen must read inherited attributes via the
+EFFECTIVE accessor (``attrs()``), not the own-only ``attr()`` (which, despite its
+name, does NOT walk the ``extends`` super chain in this port).
+
+This test asserts the CORRECT behavior and is RED until #56 is fixed: a field that
+inherits ``@required`` via ``extends`` (abstract-field reuse) without restating it must
+generate as a REQUIRED Pydantic field, not ``Optional``. ``entity_model.py`` currently
+reads ``field.attr(@required)`` (own-only) → the inherited ``@required`` is invisible →
+the field is wrongly emitted as optional. See #56 for the full cross-port inventory.
+"""
+from __future__ import annotations
+
+from metaobjects import MetaDataLoader
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.codegen.generators.entity_model import render_entity_model
+
+_MODEL = """
+{ "metadata.root": { "package": "test", "children": [
+  { "object.entity": { "name": "Base", "abstract": true, "children": [
+    { "field.string": { "name": "baseLabel", "@required": true, "@maxLength": 80 } }
+  ] } },
+  { "object.entity": { "name": "Widget", "children": [
+    { "source.rdb": { "@table": "widgets" } },
+    { "field.long": { "name": "id" } },
+    { "field.string": { "name": "label", "extends": "test::Base.baseLabel" } },
+    { "identity.primary": { "name": "primary", "@fields": ["id"], "@generation": "increment" } }
+  ] } }
+] } }
+"""
+
+
+def _widget() -> MetaObject:
+    result = MetaDataLoader.from_string(_MODEL)
+    assert not result.errors, [str(e) for e in result.errors]
+    widget = next(c for c in result.root.children()
+                  if getattr(c, "name", None) == "Widget")
+    assert isinstance(widget, MetaObject)
+    return widget
+
+
+def test_inherited_required_field_generates_as_required() -> None:
+    widget = _widget()
+    label = next(f for f in widget.fields() if f.name == "label")
+
+    # Root cause: effective sees the inherited @required; own-only does not.
+    assert label.attrs().get("required") is True   # effective
+    assert label.attr("required") is None           # own-only misses it (the trap)
+
+    # The gate: an inherited @required must produce a REQUIRED field, not Optional.
+    # RED until #56 is fixed (entity_model reads field.attr(@required) own-only).
+    source = render_entity_model(widget)
+    assert "label: str" in source, source
+    assert "label: Optional" not in source, source
+    assert "label: str | None" not in source, source

server/typescript/packages/codegen-ts/test/inherit-without-restate.gate.test.ts

@@ -0,0 +1,59 @@
+// GATE / TRIPWIRE for issue #56 — codegen must read inherited attributes via the
+// EFFECTIVE accessor (attr / attrs), not the OWN-ONLY accessor (ownAttr).
+//
+// These tests assert the CORRECT behavior and are RED until #56 is fixed. When the
+// ownAttr→attr fix lands, they go green and this becomes the permanent regression gate.
+// See issue #56 for the full cross-port inventory of own-only reads.
+
+import { describe, test, expect } from "bun:test";
+import { MetaDataLoader, InMemoryStringSource } from "@metaobjectsdev/metadata";
+import { buildPkMap } from "../src/pk-resolver.js";
+
+async function loadModel(children: unknown[]) {
+  const json = JSON.stringify({ "metadata.root": { package: "test", children } });
+  const result = await new MetaDataLoader().load([new InMemoryStringSource(json)]);
+  expect(result.errors).toEqual([]);
+  return result.root;
+}
+
+describe("inherit-without-restate gate (#56)", () => {
+  // An identity.primary that inherits @fields via node-level `extends` (ADR-0029) without
+  // restating it. pk-resolver.ts reads primary.ownAttr(@fields) → undefined → the entity
+  // is silently dropped from the PK map → generated schema has NO primary key.
+  test("identity.primary extends a base identity (no @fields restated) still yields a PK", async () => {
+    const root = await loadModel([
+      {
+        "object.entity": {
+          name: "BaseEntity",
+          abstract: true,
+          children: [
+            { "field.long": { name: "id" } },
+            { "identity.primary": { name: "primary", "@fields": ["id"], "@generation": "increment" } },
+          ],
+        },
+      },
+      {
+        "object.entity": {
+          name: "Widget",
+          children: [
+            { "source.rdb": { "@table": "widgets" } },
+            { "field.long": { name: "id" } },
+            { "identity.primary": { name: "primary", extends: "test::BaseEntity.primary" } },
+          ],
+        },
+      },
+    ]);
+
+    const widget = root.objects().find((o) => o.name === "Widget")!;
+    const primary = widget.ownChildren().find((c) => c.type === "identity")!;
+
+    // Root cause documented: effective sees the inherited value; own-only does not.
+    expect(primary.attr("fields")).toEqual(["id"]);
+    expect(primary.ownAttr("fields")).toBeUndefined();
+
+    // The gate: the entity must have a primary key. RED until #56 is fixed
+    // (pk-resolver currently drops Widget because it reads ownAttr(@fields)).
+    const pkMap = buildPkMap(root);
+    expect([...pkMap.keys()]).toContain("Widget");
+  });
+});