metaobjects 0.15.3__tar.gz → 0.15.4__tar.gz

{metaobjects-0.15.3 → metaobjects-0.15.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.3
+Version: 0.15.4
 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.3 → metaobjects-0.15.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.3"
+version = "0.15.4"
 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.3 → metaobjects-0.15.4}/src/metaobjects/loader/validation_passes.py

@@ -962,6 +962,34 @@ def _relationships_by_name(obj: MetaObject) -> dict[str, MetaData]:
     return result
 
 
+def _find_reference(obj: MetaObject, name: str) -> MetaData | None:
+    """Find an ``identity.reference`` (a forward FK) by name — the "reference hop"
+    FR-024 allows in a ``@via`` path. The reference IS the FK (single source of truth
+    for direction + join column), so naming it navigates its many-to-one edge without
+    a redundant ``relationship.*``. Effective (inherited via extends:/super:)."""
+    for child in obj.children():
+        if (
+            child.type == TYPE_IDENTITY
+            and child.sub_type == IDENTITY_SUBTYPE_REFERENCE
+            and child.name == name
+        ):
+            return child
+    return None
+
+
+def _is_reference_hop(hop: MetaData) -> bool:
+    """True for an ``identity.reference`` node (a ``@via`` reference hop)."""
+    return hop.type == TYPE_IDENTITY and hop.sub_type == IDENTITY_SUBTYPE_REFERENCE
+
+
+def _hop_target_name(hop: MetaData) -> object:
+    """The target entity a ``@via`` hop points at: @objectRef (relationship) or
+    @references (reference hop)."""
+    if _is_reference_hop(hop):
+        return hop.get_meta_attr(IDENTITY_REFERENCE_ATTR_REFERENCES)
+    return hop.get_meta_attr(RELATIONSHIP_ATTR_OBJECT_REF)
+
+
 def _validate_entity_field_ref(
     ref: str,
     attr_name: str,
@@ -1078,13 +1106,15 @@ def _validate_via_path(
     hops: list[MetaData] = []
     for rel_name in segments[1:]:
         rels = _relationships_by_name(current_entity)
-        rel_node = rels.get(rel_name)
+        # FR-024: a hop may name a relationship OR a reference-only FK
+        # (identity.reference) — the reference IS a navigable many-to-one edge.
+        rel_node = rels.get(rel_name) or _find_reference(current_entity, rel_name)
         if rel_node is None:
             prefix = ".".join(valid_segments)
             errors.append(
                 MetaError(
                     f"{context} @via='{via}' — entity '{current_entity.name}' has no "
-                    f"relationship '{rel_name}' (known relationships: {sorted(rels)}). "
+                    f"relationship or reference '{rel_name}' (known relationships: {sorted(rels)}). "
                     f'Deepest valid prefix was "{prefix}".',
                     ErrorCode.ERR_INVALID_ORIGIN,
                     envelope=resolved_source(origin_node.source, referrer, via),
@@ -1093,15 +1123,17 @@ def _validate_via_path(
             return None
 
         # Advance to the referenced entity.
-        # ADR-0039: resolving — a relationship may inherit @objectRef via extends
-        # (mirrors the TS _validateViaPath `rel.attr`, which resolves —
-        # validation-passes.ts:522).
-        obj_ref = rel_node.get_meta_attr(RELATIONSHIP_ATTR_OBJECT_REF)
+        # ADR-0039: resolving — a relationship/reference may inherit its target via
+        # extends (mirrors the TS _validateViaPath which resolves). Target entity:
+        # @objectRef (relationship) or @references (reference hop).
+        obj_ref = _hop_target_name(rel_node)
         if not isinstance(obj_ref, str):
+            missing = "@references" if _is_reference_hop(rel_node) else "@objectRef"
+            kind = "reference" if _is_reference_hop(rel_node) else "relationship"
             errors.append(
                 MetaError(
-                    f"{context} @via='{via}' — relationship '{rel_name}' on entity "
-                    f"'{current_entity.name}' has no @objectRef",
+                    f"{context} @via='{via}' — {kind} '{rel_name}' on entity "
+                    f"'{current_entity.name}' has no {missing}",
                     ErrorCode.ERR_INVALID_ORIGIN,
                     envelope=resolved_source(origin_node.source, referrer, via),
                 )
@@ -1110,11 +1142,11 @@ def _validate_via_path(
 
         next_entity = object_index.get(obj_ref)
         if next_entity is None:
-            # FR5d — relationship's @objectRef points at a missing entity.
-            # target=the @objectRef value (mirrors TS validation-passes.ts L342-353).
+            # FR5d — the hop's target points at a missing entity.
+            kind = "reference" if _is_reference_hop(rel_node) else "relationship"
             errors.append(
                 MetaError(
-                    f"{context} @via='{via}' — relationship '{rel_name}' on entity "
+                    f"{context} @via='{via}' — {kind} '{rel_name}' on entity "
                     f"'{current_entity.name}' references unknown entity '{obj_ref}'",
                     ErrorCode.ERR_INVALID_ORIGIN,
                     envelope=resolved_source(origin_node.source, referrer, obj_ref),
@@ -1137,7 +1169,10 @@ def _validate_via_path(
 
 
 def _hop_cardinality(rel: MetaData) -> str | None:
-    """A hop relationship's effective @cardinality, or None when not declared."""
+    """A hop's effective @cardinality, or None when not declared. A reference hop
+    (a forward FK) is inherently to-one — a child names the parent it points at."""
+    if _is_reference_hop(rel):
+        return CARDINALITY_ONE
     # ADR-0039: resolving (@cardinality may be inherited via extends) — mirrors the
     # TS _hopCardinality which reads `rel.attr()` (resolving), NOT ownAttr.
     v = rel.get_meta_attr(RELATIONSHIP_ATTR_CARDINALITY)

{metaobjects-0.15.3 → metaobjects-0.15.4}/tests/integration/postgres_container.py

@@ -1,17 +1,31 @@
-"""Spin up a fresh Postgres container per scenario by shelling out to docker.
-
-Mirrors the TS/Java/C# integration suites. Avoids the python-testcontainers
-package + its docker API negotiation churn (the same kind of mismatch
-testcontainers-java hits against Docker Engine 29+).
+"""Obtain a fresh, isolated Postgres database per scenario.
+
+Two modes, mirroring the TS/Java/Kotlin/C# integration suites:
+
+  1. Shared sidecar (CI): if ``METAOBJECTS_TEST_PG_URL`` is set, connect to that
+     already-running Postgres and CREATE a uniquely-named database per instance
+     (dropping it on stop). No container boot / image pull on the hot path — the
+     point of the shared ``services: postgres`` CI sidecar. Each scenario still
+     gets a pristine empty database, so isolation is identical to the per-
+     container path.
+  2. Per-container (local dev): with no env var, ``docker run`` a fresh container,
+     exactly as before. Avoids the python-testcontainers package + its docker API
+     negotiation churn (the same kind of mismatch testcontainers-java hits
+     against Docker Engine 29+).
 """
 from __future__ import annotations
 
+import os
 import socket
 import subprocess
 import time
 import uuid
 from contextlib import closing
 from dataclasses import dataclass
+from urllib.parse import urlsplit
+
+# Env var naming the shared CI Postgres sidecar (admin URL). Unset = per-container.
+SHARED_PG_URL_ENV = "METAOBJECTS_TEST_PG_URL"
 
 
 @dataclass(frozen=True)
@@ -33,8 +47,21 @@ class PostgresContainer:
     DATABASE = "postgres"
 
     def __init__(self) -> None:
+        shared = os.environ.get(SHARED_PG_URL_ENV)
+        if shared:
+            self._shared = True
+            self._name = None
+            self._db_on_shared(shared)
+            return
+
+        self._shared = False
+        self._admin_url = None
         self._name = f"metaobjects-test-{uuid.uuid4().hex[:8]}"
         self._port = _pick_free_port()
+        self._info = PostgresInfo(
+            host="localhost", port=self._port, database=self.DATABASE,
+            user=self.USER, password=self.PASSWORD,
+        )
         _docker(
             "run", "-d", "--rm",
             "--name", self._name,
@@ -44,13 +71,55 @@ class PostgresContainer:
         )
         self._wait_ready()
 
-    def info(self) -> PostgresInfo:
-        return PostgresInfo(
-            host="localhost", port=self._port, database=self.DATABASE,
-            user=self.USER, password=self.PASSWORD,
+    # -- Shared-sidecar mode -------------------------------------------------
+    # CREATE a fresh, uniquely-named database on the already-running Postgres
+    # named by the admin URL; a dedicated database per scenario preserves the
+    # per-container path's "pristine empty DB" isolation.
+    def _db_on_shared(self, admin_url: str) -> None:
+        import pg8000.dbapi  # local import — pg8000 lives in the `integration` extra
+
+        parts = urlsplit(admin_url)
+        self._admin_url = admin_url
+        db_name = f"mo_test_{uuid.uuid4().hex}"
+        admin_db = parts.path.lstrip("/") or "postgres"
+        conn = pg8000.dbapi.connect(
+            host=parts.hostname, port=parts.port or 5432,
+            user=parts.username, password=parts.password, database=admin_db,
         )
+        try:
+            conn.autocommit = True  # CREATE DATABASE cannot run in a transaction
+            cur = conn.cursor()
+            cur.execute(f'CREATE DATABASE "{db_name}"')  # generated name — no user input
+        finally:
+            conn.close()
+        self._info = PostgresInfo(
+            host=parts.hostname, port=parts.port or 5432, database=db_name,
+            user=parts.username, password=parts.password,
+        )
+
+    def info(self) -> PostgresInfo:
+        return self._info
 
     def stop(self) -> None:
+        if self._shared:
+            import pg8000.dbapi
+
+            parts = urlsplit(self._admin_url)
+            admin_db = parts.path.lstrip("/") or "postgres"
+            try:
+                conn = pg8000.dbapi.connect(
+                    host=parts.hostname, port=parts.port or 5432,
+                    user=parts.username, password=parts.password, database=admin_db,
+                )
+                conn.autocommit = True
+                cur = conn.cursor()
+                cur.execute(
+                    f'DROP DATABASE IF EXISTS "{self._info.database}" WITH (FORCE)'
+                )
+                conn.close()
+            except Exception:  # noqa: BLE001 — best-effort cleanup
+                pass
+            return
         try:
             _docker("rm", "-f", self._name)
         except subprocess.CalledProcessError:

{metaobjects-0.15.3 → metaobjects-0.15.4}/tests/unit/test_validation_origin_paths.py

@@ -12,6 +12,7 @@ from metaobjects.registry import TypeRegistry
 from metaobjects.shared.base_types import (
     SUBTYPE_ROOT,
     TYPE_FIELD,
+    TYPE_IDENTITY,
     TYPE_METADATA,
     TYPE_OBJECT,
     TYPE_ORIGIN,
@@ -119,6 +120,69 @@ def _build_passthrough_tree(from_ref: str) -> MetaData:
     return root
 
 
+def _build_reference_via_tree(via: str) -> MetaData:
+    """Build a tree whose projection passthrough joins via an identity.reference
+    (a reference-only FK, no relationship) — FR-024 @via-over-reference.
+      - Program (id, title)
+      - Enrollment (id, programId, identity.reference ref_program → Program)
+      - EnrollmentView (extends Enrollment) passthrough Program.title @via *via*
+    """
+    from metaobjects.meta.core.field.meta_field import MetaField
+    from metaobjects.meta.core.object.meta_object import MetaObject
+
+    root = MetaRoot(TYPE_METADATA, SUBTYPE_ROOT, "")
+
+    program = MetaObject(TYPE_OBJECT, "entity", "Program")
+    program.add_child(MetaField(TYPE_FIELD, "long", "id"))
+    program.add_child(MetaField(TYPE_FIELD, "string", "title"))
+    root.add_child(program)
+
+    enrollment = MetaObject(TYPE_OBJECT, "entity", "Enrollment")
+    enrollment.add_child(MetaField(TYPE_FIELD, "long", "id"))
+    enrollment.add_child(MetaField(TYPE_FIELD, "long", "programId"))
+    ref = MetaData(TYPE_IDENTITY, "reference", "ref_program")
+    ref.set_attr("fields", "programId", ATTR_SUBTYPE_STRING)
+    ref.set_attr("references", "Program", ATTR_SUBTYPE_STRING)
+    enrollment.add_child(ref)
+    root.add_child(enrollment)
+
+    view = MetaObject(TYPE_OBJECT, "entity", "EnrollmentView")
+    view.super_ref = "Enrollment"
+    view.super_data = enrollment
+    field = MetaField(TYPE_FIELD, "string", "program_title")
+    origin = MetaData(TYPE_ORIGIN, "passthrough", "")
+    origin.set_attr("from", "Program.title", ATTR_SUBTYPE_STRING)
+    origin.set_attr("via", via, ATTR_SUBTYPE_STRING)
+    field.add_child(origin)
+    view.add_child(field)
+    root.add_child(view)
+
+    return root
+
+
+def _via_errors(root: MetaData) -> list[str]:
+    """ERR_INVALID_ORIGIN messages that mention the @via path (ignores unrelated passes)."""
+    errors, _ = _errors_and_warnings(root)
+    return [
+        e.message
+        for e in errors
+        if e.code == ErrorCode.ERR_INVALID_ORIGIN and "@via" in e.message
+    ]
+
+
+def test_valid_passthrough_via_reference_no_error() -> None:
+    """@via naming an identity.reference (reference-only FK) resolves — no origin error."""
+    root = _build_reference_via_tree(via="Enrollment.ref_program")
+    assert _via_errors(root) == []
+
+
+def test_invalid_passthrough_via_bad_reference() -> None:
+    """@via naming neither a relationship nor a reference → ERR_INVALID_ORIGIN."""
+    root = _build_reference_via_tree(via="Enrollment.bogus")
+    msgs = _via_errors(root)
+    assert any("bogus" in m and "no relationship or reference" in m for m in msgs), msgs
+
+
 # ---------------------------------------------------------------------------
 # Tests: origin.aggregate @via validation
 # ---------------------------------------------------------------------------