metaobjects 0.15.11__tar.gz → 0.15.12__tar.gz

{metaobjects-0.15.11 → metaobjects-0.15.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.11
+Version: 0.15.12
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.15.11 → metaobjects-0.15.12}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.11"
+version = "0.15.12"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/codegen/generators/payload_vo_generator.py

@@ -63,6 +63,7 @@ from metaobjects.meta.persistence.origin.origin_constants import (
 )
 from metaobjects.meta.template import template_constants as tc
 from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.naming_refs import resolve_object_ref
 from metaobjects.shared.base_types import TYPE_OBJECT, TYPE_TEMPLATE
 from metaobjects.shared.separators import PACKAGE_SEP
 
@@ -104,6 +105,16 @@ def payload_module_name(template_name: str) -> str:
 # ---------------------------------------------------------------------------
 
 
+def _pkg_of(node: MetaData) -> str:
+    """The effective package of an object — its ``resolution_key()`` minus the
+    trailing ``::<name>`` ("" for a root-level object). Derived from the resolution
+    key so it is correct for BOTH loaded trees (file_default_package) and
+    programmatically-built trees (package only on the root)."""
+    key = node.resolution_key()
+    i = key.rfind(PACKAGE_SEP)
+    return "" if i == -1 else key[:i]
+
+
 def _resolve_object_by_short_or_fqn(root: MetaData, ref: str) -> MetaObject | None:
     """Find a ``MetaObject`` child satisfying an (already-expanded) object ref.
 
@@ -192,9 +203,14 @@ def _resolve_object_field_type(
     ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
     if not isinstance(ref, str) or not ref:
         return _fallback_type(field)
-    target = _resolve_object_by_short_or_fqn(root, ref)
-    if target is None and PACKAGE_SEP in ref:
-        target = _resolve_object_by_short_or_fqn(root, ref.rsplit(PACKAGE_SEP, 1)[-1])
+    # ADR-0042 — a nested @objectRef resolves in the DECLARING field's package
+    # (correct for a field.object inherited via extends across packages); an FQN
+    # resolves exactly. NO bare-tail short-name fallback that would bind a same-named
+    # VO in the wrong package on a cross-package collision (#191). The declaring
+    # package is taken from the parent object's resolution key so it is correct for
+    # both loaded trees (file_default_package) and programmatic trees (root package).
+    referrer_pkg = _pkg_of(field.parent) if field.parent is not None else ""
+    target = resolve_object_ref(root, ref, referrer_pkg)
     if target is None:
         return _fallback_type(field)
     nested_class = payload_class_name(target.name)

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/codegen/generators/render_helper_generator.py

@@ -62,7 +62,8 @@ from metaobjects.render.verify import (
     PayloadField,
     verify,
 )
-from metaobjects.shared.base_types import TYPE_FIELD, TYPE_OBJECT, TYPE_TEMPLATE
+from metaobjects.naming_refs import resolve_object_ref
+from metaobjects.shared.base_types import TYPE_FIELD, TYPE_TEMPLATE
 from metaobjects.shared.separators import PACKAGE_SEP
 
 _GENERATOR_NAME = "render-helper-generator"
@@ -81,30 +82,34 @@ def _py_str(s: str) -> str:
 # ---------------------------------------------------------------------------
 
 
-def _resolve_nested_object_ref(root: MetaData, reference: str) -> MetaObject | None:
+def _pkg_of(node: MetaData) -> str:
+    """The effective package of an object — its ``resolution_key()`` minus the
+    trailing ``::<name>`` ("" for a root-level object). Derived from the resolution
+    key so it is correct for BOTH loaded trees (file_default_package) and
+    programmatically-built trees (package only on the root, folded via the ancestor
+    walk in ``resolution_key()``)."""
+    key = node.resolution_key()
+    i = key.rfind(PACKAGE_SEP)
+    return "" if i == -1 else key[:i]
+
+
+def _resolve_nested_object_ref(
+    root: MetaData, reference: str, referrer_pkg: str
+) -> MetaObject | None:
     """Resolve a ``field.object``'s ``@objectRef`` to its target ``object.value``.
 
-    ADR-0041: a FULLY-QUALIFIED ref (contains ``::``) resolves EXACTLY on the
-    package-qualified name (``resolution_key()``/``fqn()``) — never a bare-tail
-    fallback that would bind a same-named ``object.value`` in the WRONG package on a
-    cross-package short-name collision. A bare ref still matches by short name
-    (first-wins). Mirrors the Java/Kotlin ``resolveNestedObjectRef`` + TS
-    ``refMatchesObject``."""
+    ADR-0042: package-local — an FQN ref (contains ``::``) resolves EXACTLY on the
+    package-qualified name; a bare ref resolves in the referrer's package FIRST
+    (else a root-level object), never a same-named ``object.value`` in another
+    package via a bare-tail fallback. *referrer_pkg* is the DECLARING field's
+    package (which differs from the VO's when the field is inherited via extends
+    from an abstract VO in another package). Shares the single ``resolve_object_ref``
+    matcher. Mirrors the TS ``findObject`` in payload-field-tree.ts."""
     if not reference:
         return None
-    fqn = PACKAGE_SEP in reference
-    ref_short = reference.rsplit(PACKAGE_SEP, 1)[-1]
-    # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
-    for child in root.own_children():
-        if child.type != TYPE_OBJECT or not isinstance(child, MetaObject):
-            continue
-        if child.sub_type != OBJECT_SUBTYPE_VALUE:
-            continue
-        if fqn:
-            if child.resolution_key() == reference or child.fqn() == reference:
-                return child
-        elif child.name.rsplit(PACKAGE_SEP, 1)[-1] == ref_short:
-            return child
+    target = resolve_object_ref(root, reference, referrer_pkg)
+    if target is not None and target.sub_type == OBJECT_SUBTYPE_VALUE:
+        return target  # type: ignore[return-value]
     return None
 
 
@@ -118,6 +123,10 @@ def _derive_payload_field_tree(
     if vo is None or vo.resolution_key() in seen:
         return []
     next_seen = seen | {vo.resolution_key()}
+    # A nested @objectRef resolves in the FIELD's own declaring package (below),
+    # which differs from this VO's when the field is inherited via extends from an
+    # abstract VO in another package (the bare ref was authored there).
+    vo_pkg = _pkg_of(vo)
     fields: list[PayloadField] = []
     for f in vo.children():
         if f.type != TYPE_FIELD or not isinstance(f, MetaField):
@@ -125,7 +134,8 @@ def _derive_payload_field_tree(
         if f.sub_type == fc.FIELD_SUBTYPE_OBJECT:
             ref = f.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
             if isinstance(ref, str) and ref:
-                target = _resolve_nested_object_ref(root, ref)
+                field_pkg = _pkg_of(f.parent) if f.parent is not None else vo_pkg
+                target = _resolve_nested_object_ref(root, ref, field_pkg)
                 if target is not None and target.sub_type == OBJECT_SUBTYPE_VALUE:
                     children = _derive_payload_field_tree(root, target, next_seen)
                     fields.append(PayloadField(f.name, children))
@@ -152,16 +162,20 @@ def _field_tree_literal(fields: list[PayloadField]) -> str:
 
 
 def _resolve_payload_vo(root: MetaData, payload_ref: str) -> MetaObject | None:
-    """``@payloadRef`` must resolve to an ``object.value`` (same contract as the
-    parser/prompt generators). Matches a value-object child by short name OR by the
-    last segment of a fully-qualified ``a::b::Name`` ref (FR-026 expands refs to FQN,
-    while the child node still carries the short ``name``)."""
-    ref_short = payload_ref.rsplit("::", 1)[-1]
+    """``@payloadRef`` must resolve to an ``object.value``. Package-local (ADR-0042):
+    the referrer's own package first (else a root-level object), FQN exact. The
+    referrer package is derived from the resolved match's own resolution key, so this
+    keeps the same behavior for the single-package + FQN codegen fixtures while never
+    binding a same-named VO in the wrong package (the nested @objectRef path is the
+    one #191 named — see _resolve_nested_object_ref). Matches a value-object child by
+    the package-folded resolution key OR the bare short name (FR-026 expands refs to
+    FQN, while the child node still carries the short ``name``)."""
+    ref_short = payload_ref.rsplit(PACKAGE_SEP, 1)[-1]
     # ADR-0039 sanctioned own: top-level scan on the loader ROOT (never extended, own == effective)
     for child in root.own_children():
-        if child.type != TYPE_OBJECT or not isinstance(child, MetaObject):
+        if not isinstance(child, MetaObject) or child.sub_type != OBJECT_SUBTYPE_VALUE:
             continue
-        if child.sub_type == OBJECT_SUBTYPE_VALUE and child.name in (payload_ref, ref_short):
+        if child.resolution_key() == payload_ref or child.name == ref_short:
             return child
     return None
 

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/core_types.py

@@ -374,6 +374,22 @@ for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment
         )
         break
 
+# ADR-0042 — a field.object / field.map @objectRef must RESOLVE (a dangling target
+# fails the load, closing the gap #191 surfaced as a misleading downstream error).
+# The required-attr pass owns absence (ERR_OBJECT_FIELD_WITHOUT_OBJECT_REF); this
+# reference descriptor fires only when @objectRef is present but resolves to nothing
+# → ERR_UNRESOLVED_OBJECT_REF. Mirrors the TS core-types.ts registerCoreTypeDefs.
+for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment)
+    if _def.type == TYPE_FIELD and _def.sub_type in (
+        fc.FIELD_SUBTYPE_OBJECT,
+        fc.FIELD_SUBTYPE_MAP,
+    ):
+        _def.references.append(
+            ReferenceDescriptor(
+                FIELD_ATTR_OBJECT_REF, TYPE_OBJECT, None, False, "ERR_UNRESOLVED_OBJECT_REF"
+            )
+        )
+
 # field.enum — dedicated registration with required @values attr.
 # Inherits every common field attr (column / required / unique / default /
 # maxLength / filterable / sortable / etc.) so the D2 type-coercion guard

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/errors.py

@@ -138,17 +138,13 @@ class ErrorCode(str, Enum):
     # emit this yet (the T6 guard is deferred — like TS, it belongs in the parser);
     # the enum tracks the shared corpus code so resolution/desugar stay aligned.
     ERR_RELATIVE_REF_IN_CANONICAL = "ERR_RELATIVE_REF_IN_CANONICAL"
-    # ADR-0041 — cross-package reference resolution contract. A BARE object
-    # reference (no ``::``) that names an object present in MORE THAN ONE package,
-    # with NO match in the referrer's own package, is ambiguous — the author must
-    # qualify it with the package (FQN). Applies to every object-ref-bearing attr
-    # (@objectRef / @references / @from / @of / @via heads / @parameterRef /
-    # @payloadRef / @responseRef). An FQN ref resolves exactly and is never
-    # ambiguous; a bare ref that matches the referrer's own package, or exactly one
-    # package anywhere, resolves fine. ``extends`` is intentionally NOT covered
-    # (its same-package/root-strict super-resolver yields ERR_UNRESOLVED_SUPER on a
-    # bare cross-package miss, not ambiguity).
-    ERR_AMBIGUOUS_REF = "ERR_AMBIGUOUS_REF"
+    # ADR-0042 — a field.object / field.map @objectRef does not resolve to any
+    # object in the loaded tree (a dangling target). Bare refs resolve
+    # package-locally (referrer's package, else root-level); FQN refs resolve
+    # exactly — a bare cross-package ref no longer binds elsewhere. Supersedes the
+    # retired ADR-0041 ERR_AMBIGUOUS_REF (bare = package-local ⇒ ambiguity is
+    # unreachable, so every unresolved ref fails closed with its per-attr code).
+    ERR_UNRESOLVED_OBJECT_REF = "ERR_UNRESOLVED_OBJECT_REF"
     # FR-033 — strict structural-placement vocabulary. ERR_CHILD_NOT_ALLOWED: a
     # structural child (field/identity/source/validator/… — not an attr) is placed
     # under a parent whose registered childRules do not admit it (the structural

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/loader/registered_validation.py

@@ -12,8 +12,10 @@ from ..errors import ErrorCode, MetaError
 from ..meta.core.object.meta_object import MetaObject
 from ..meta.meta_data import MetaData
 from ..meta.meta_root import MetaRoot
+from ..naming_refs import did_you_mean_hint
 from ..registry import TypeRegistry
 from ..shared.base_types import TYPE_OBJECT
+from ..shared.separators import PACKAGE_SEP
 
 
 class SymbolTable:
@@ -29,19 +31,29 @@ class SymbolTable:
         # extended, own == effective) — mirrors the TS validation-registry.
         for child in root.own_children():
             if child.type == TYPE_OBJECT and isinstance(child, MetaObject):
-                if child.name:
-                    t._index[child.name] = child
-                t._index[child.fqn()] = child
+                # ADR-0042: key by the canonical resolution key ONLY (the FQN, or
+                # the bare name for a root-level/empty-package object) — NO bare-name
+                # fallback, so a bare ref never binds a same-named object in another
+                # package. Mirrors the TS validation-registry symbol table.
                 t._index[child.resolution_key()] = child
         return t
 
-    def resolve_object(self, reference: str) -> MetaData | None:
-        return self._index.get(reference)
+    def resolve_object(self, reference: str, referrer_pkg: str) -> MetaData | None:
+        """ADR-0042 package-local resolution: FQN → exact resolution-key match;
+        bare → the referrer's own package (``<referrer_pkg>::<ref>``), else a
+        root-level object. Mirrors the TS ``resolveObject``."""
+        if PACKAGE_SEP in reference:
+            return self._index.get(reference)
+        local_key = (
+            f"{referrer_pkg}{PACKAGE_SEP}{reference}" if referrer_pkg else reference
+        )
+        return self._index.get(local_key) or self._index.get(reference)
 
 
 class ValidationContext:
-    def __init__(self, symbols: SymbolTable) -> None:
+    def __init__(self, symbols: SymbolTable, root: MetaData) -> None:
         self.symbols = symbols
+        self.root = root
         self.errors: list[MetaError] = []
 
     def error(self, code: str, node: MetaData, message: str) -> None:
@@ -55,12 +67,23 @@ class ValidationContext:
 
 
 def run(root: MetaRoot, registry: TypeRegistry) -> list[MetaError]:
-    ctx = ValidationContext(SymbolTable.build(root))
-    _walk(root, registry, ctx)
+    ctx = ValidationContext(SymbolTable.build(root), root)
+    _walk(root, registry, ctx, "")
     return ctx.errors
 
 
-def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> None:
+def _walk(
+    node: MetaData, registry: TypeRegistry, ctx: ValidationContext, referrer_pkg: str
+) -> None:
+    # ADR-0042: a top-level object establishes the package context for its subtree;
+    # nested ref-bearing nodes (relationship/field.object/identity.reference) resolve
+    # BARE refs against it. Nested nodes carry no `package`, so they inherit the
+    # enclosing object's (via file_default_package, else the threaded context).
+    pkg = (
+        (node.package or node.file_default_package or referrer_pkg)
+        if node.type == TYPE_OBJECT
+        else referrer_pkg
+    )
     type_def = registry.find(node.type, node.sub_type)
     if type_def is not None:
         for desc in type_def.references:
@@ -72,7 +95,8 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
             if not isinstance(raw, str) or raw == "":
                 continue  # absence is the required-attr pass's job
             entity_ref = raw.split(".", 1)[0] if desc.dotted_field_path else raw
-            target = ctx.symbols.resolve_object(entity_ref)
+            # ADR-0042: bare refs resolve package-local against the enclosing object.
+            target = ctx.symbols.resolve_object(entity_ref, pkg)
             # Qualify the node name with its owning entity (e.g. "Order.items") so the error
             # is locatable from the message alone, not just the source envelope.
             qname = f"{node.parent.name}.{node.name}" if node.parent and node.parent.name else node.name
@@ -80,7 +104,7 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
                 ctx.error(
                     desc.error_code, node,
                     f'{node.type}.{node.sub_type} "{qname}" @{desc.attr} "{raw}" '
-                    f"does not resolve to an object.",
+                    f"does not resolve to an object.{did_you_mean_hint(ctx.root, entity_ref)}",
                 )
             elif target.type != desc.target_type or (
                 desc.target_sub_type is not None and target.sub_type != desc.target_sub_type
@@ -101,4 +125,4 @@ def _walk(node: MetaData, registry: TypeRegistry, ctx: ValidationContext) -> Non
     # node once at its declaration site (own children); inherited nodes are
     # validated where they are declared. Mirrors the TS ``node.ownChildren()`` walk.
     for child in node.own_children():
-        _walk(child, registry, ctx)
+        _walk(child, registry, ctx, pkg)

{metaobjects-0.15.11 → metaobjects-0.15.12}/src/metaobjects/loader/validate_source_parameter_ref.py

@@ -34,40 +34,27 @@ from ..meta.core.object.object_constants import (
     OBJECT_SUBTYPE_ENTITY,
     OBJECT_SUBTYPE_VALUE,
 )
+from ..naming_refs import resolve_object_ref
 from ..shared.base_types import TYPE_OBJECT, TYPE_SOURCE
-from ..shared.separators import PACKAGE_SEP
 
 _CALLABLE_KINDS = frozenset({SOURCE_KIND_STORED_PROC, SOURCE_KIND_TABLE_FUNCTION})
 
 
 def validate_source_parameter_ref(root: MetaData, errors: list[MetaError]) -> None:
-    # Pre-index every object by name, fqn AND resolution key so resolution costs
-    # O(1) per source. FR-032 (ADR-0032): @parameterRef is FULLY QUALIFIED after
-    # the desugar/sweep (e.g. ``acme::ParamVO``), which is the package-folded
-    # resolution_key() (objects keep a bare fqn() per FR5d), so the index must
-    # carry that key too. Mirrors the C# @parameterRef ResolutionKey() index.
     # ADR-0039 (mirrors the TS validate-source-parameter-ref): resolving is the
     # default. Root has no super, so children()==own_children() here, but the
     # inheritable reads below RESOLVE — @parameterRef on the source, the parameter
     # value-object's fields, and the referenced entity's field can all be inherited
     # via extends. The SOURCE iteration stays own (a source is validated on the
     # entity that declares it), as does origin.* (never inherits; ADR-0029).
-    object_index: dict[str, MetaData] = {}
-    for obj in root.children():
-        if obj.type != TYPE_OBJECT:
-            continue
-        object_index[obj.name] = obj
-        fqn = (
-            f"{obj.package}{PACKAGE_SEP}{obj.name}"
-            if obj.package
-            else obj.name
-        )
-        object_index[fqn] = obj
-        object_index[obj.resolution_key()] = obj
-
     for obj in root.children():
         if obj.type != TYPE_OBJECT:
             continue
+        # ADR-0042 — a bare @parameterRef resolves package-local (this object's
+        # package, else root-level); an FQN resolves exactly. Shares the single
+        # resolve_object_ref matcher — NO bare-name-anywhere fallback (which would
+        # silently bind a same-named value-object in another package).
+        referrer_pkg = obj.package or obj.file_default_package or ""
         for source in obj.own_children():
             if source.type != TYPE_SOURCE or source.sub_type != SOURCE_SUBTYPE_RDB:
                 continue
@@ -93,7 +80,7 @@ def validate_source_parameter_ref(root: MetaData, errors: list[MetaError]) -> No
                 )
                 continue
 
-            target = object_index.get(ref)
+            target = resolve_object_ref(root, ref, referrer_pkg)
             if target is None:
                 errors.append(
                     MetaError(