metaobjects 0.15.2__tar.gz → 0.15.4__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.2"
+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.2 → metaobjects-0.15.4}/src/metaobjects/codegen/runtime/filter_parser.py

@@ -14,8 +14,9 @@ Returned ``FilterParseResult`` is either:
 * ``predicates`` populated + ``error_envelope`` ``None`` — success path; the
   generated router passes ``predicates`` into the repository.
 * ``error_envelope`` non-``None`` (one of ``invalid_filter_field`` /
-  ``invalid_filter_op`` / ``invalid_filter_value``) — the generated router
-  raises ``HTTPException(status_code=400, detail=result.error_envelope)``.
+  ``invalid_filter_op`` / ``invalid_filter_value`` / ``filter.in_too_large``) —
+  the generated router raises
+  ``HTTPException(status_code=400, detail=result.error_envelope)``.
 
 Mirror of the Java ``FilterParser`` / Kotlin ``KotlinFilterAllowlistGenerator`` /
 C# ``FilterParser`` ports — same wire grammar, same error envelopes, same
@@ -35,6 +36,13 @@ _INVALID_VALUE = object()
 _ERR_FIELD = "invalid_filter_field"
 _ERR_OP = "invalid_filter_op"
 _ERR_VALUE = "invalid_filter_value"
+_ERR_IN_TOO_LARGE = "filter.in_too_large"
+
+# Cross-port cap on the number of elements in an ``in``-list. A larger list is
+# rejected with the ``filter.in_too_large`` envelope so a caller cannot force an
+# unbounded ``IN (...)`` against the DB. Matches the TypeScript ``runtime-ts``
+# filter parser's ``DEFAULT_MAX_IN_LIST``.
+MAX_IN_LIST = 100
 
 
 @dataclass(frozen=True)
@@ -85,7 +93,7 @@ def parse_filter(
     validated + coerced filter list (preserving URL order); on failure,
     ``error_envelope`` is one of the cross-port envelopes
     (``invalid_filter_field`` / ``invalid_filter_op`` /
-    ``invalid_filter_value``).
+    ``invalid_filter_value`` / ``filter.in_too_large``).
     """
     allowed_set = set(allowed_fields)
     ops_map: dict[str, frozenset[str]] = {
@@ -129,6 +137,8 @@ def parse_filter(
         coerced = _coerce_value(value, op)
         if coerced is _INVALID_VALUE:
             return FilterParseResult(error_envelope={"error": _ERR_VALUE})
+        if op == "in" and isinstance(coerced, list) and len(coerced) > MAX_IN_LIST:
+            return FilterParseResult(error_envelope={"error": _ERR_IN_TOO_LARGE})
         out.append(FilterPredicate(field=field_name, op=op, value=coerced))
 
     return FilterParseResult(predicates=out)

{metaobjects-0.15.2 → 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.2 → metaobjects-0.15.4}/src/metaobjects/registry_manifest.py

@@ -255,6 +255,15 @@ def _sorted_children(definition: TypeDefinition) -> list[dict[str, object]]:
     return children
 
 
+METAMODEL_VERSION = "0.9"
+"""Rolled-up spec-version for the cross-port registry manifest.
+
+``"0"`` = pre-1.0 / unstable (semver major-0). Flips to ``"1.0"`` at the
+1.0 vocabulary cut. Emitted as the first top-level key in the canonical
+manifest so every port's byte-comparison gate sees it at position 0.
+"""
+
+
 def build_registry_manifest(registry: TypeRegistry) -> dict[str, object]:
     """Build the canonical registry-manifest object from an assembled registry.
 
@@ -306,8 +315,9 @@ def build_registry_manifest(registry: TypeRegistry) -> dict[str, object]:
         if default_sub is not None:
             default_sub_types[type_name] = default_sub
 
-    # Fixed top-level key order: types, commonAttrs, defaultSubTypes.
+    # Fixed top-level key order: metamodelVersion (C4), types, commonAttrs, defaultSubTypes.
     return {
+        "metamodelVersion": METAMODEL_VERSION,
         "types": types,
         "commonAttrs": common_attrs,
         "defaultSubTypes": default_sub_types,

metaobjects-0.15.4/tests/conformance/test_provider_composition_conformance.py

@@ -0,0 +1,150 @@
+"""Provider-composition conformance runner (Python port).
+
+Five registry/provider error codes are Tier-1 cross-port invariants that the
+metadata-input -> error corpus cannot reach: they are triggered by HOW providers
+are composed and sealed, not by any metadata document. This runner gates them
+from the shared corpus at fixtures/provider-composition-conformance/.
+
+Each port supplies the SAME canonical named-provider set (see the corpus
+README). A manifest names providers by id; the runner maps names -> provider
+objects, composes, and asserts the surfaced .code. The registry-sealed scenario
+composes, seals, then runs a probe provider's register_types against the sealed
+registry.
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from metaobjects.errors import ErrorCode, ParseError
+from metaobjects.provider import Provider, compose_registry
+from metaobjects.registry import AttrSchema, ChildRule, TypeDefinition, TypeRegistry
+from metaobjects.meta.template.meta_template import MetaTemplate
+from metaobjects.shared.base_types import TYPE_ATTR
+
+# Fresh, otherwise-unused template subtype the attr-conflict / seal providers use.
+_CONFLICT_SUBTYPE = "compositionprobe"
+_CONFLICT_ATTR = "conflictAttr"
+
+
+def _corpus_root() -> Path:
+    here = Path(__file__).resolve()
+    for parent in [here, *here.parents]:
+        candidate = parent / "fixtures" / "provider-composition-conformance"
+        if candidate.is_dir():
+            return candidate
+    raise RuntimeError("could not locate fixtures/provider-composition-conformance from " + str(here))
+
+
+def _noop_provider(provider_id: str, *deps: str) -> Provider:
+    return Provider(provider_id, dependencies=tuple(deps))
+
+
+def _attr_conflict_base_provider() -> Provider:
+    """Registers a fresh test-only type carrying a single string attr."""
+    p = Provider("attr-conflict-base")
+    p.add(
+        TypeDefinition(
+            type="template",
+            sub_type=_CONFLICT_SUBTYPE,
+            factory=lambda t, s, n: MetaTemplate(t, s, n),
+            attrs=[AttrSchema(_CONFLICT_ATTR, "string")],
+            child_rules=[ChildRule(TYPE_ATTR, "*")],
+        )
+    )
+    return p
+
+
+class _AttrConflictClashProvider(Provider):
+    """Extends the base's type, redefining the same attr name -> attr conflict."""
+
+    def __init__(self) -> None:
+        super().__init__("attr-conflict-clash", dependencies=("attr-conflict-base",))
+
+    def register_types(self, registry: TypeRegistry) -> None:  # noqa: D401
+        registry.extend(
+            "template",
+            _CONFLICT_SUBTYPE,
+            attributes=[AttrSchema(_CONFLICT_ATTR, "string")],
+        )
+
+
+class _SealProbeProvider(Provider):
+    """Attempts a mutating registration — throws against a sealed registry."""
+
+    def __init__(self) -> None:
+        super().__init__("seal-probe")
+
+    def register_types(self, registry: TypeRegistry) -> None:  # noqa: D401
+        registry.register(
+            TypeDefinition(
+                type="template",
+                sub_type="sealprobe",
+                factory=lambda t, s, n: MetaTemplate(t, s, n),
+                attrs=[],
+                child_rules=[],
+            )
+        )
+
+
+def _providers() -> dict[str, Provider]:
+    return {
+        "duplicate-x": _noop_provider("duplicate-x"),
+        # Same `.id` as duplicate-x — surfaces ERR_PROVIDER_DUPLICATE_ID at compose time.
+        "duplicate-x-clone": _noop_provider("duplicate-x"),
+        "depends-on-missing": _noop_provider("depends-on-missing", "does-not-exist"),
+        "cycle-a": _noop_provider("cycle-a", "cycle-b"),
+        "cycle-b": _noop_provider("cycle-b", "cycle-a"),
+        "attr-conflict-base": _attr_conflict_base_provider(),
+        "attr-conflict-clash": _AttrConflictClashProvider(),
+        "seal-probe": _SealProbeProvider(),
+    }
+
+
+def _resolve(providers: dict[str, Provider], pid: str) -> Provider:
+    p = providers.get(pid)
+    if p is None:
+        raise ValueError(f'Unknown named provider "{pid}" in provider-composition corpus')
+    return p
+
+
+def _manifest_files() -> list[Path]:
+    return sorted(_corpus_root().glob("*.json"))
+
+
+def _error_code(exc: BaseException) -> str:
+    code = getattr(exc, "code", None)
+    if isinstance(code, ErrorCode):
+        return code.value
+    if isinstance(code, str):
+        return code
+    return "ERR_UNKNOWN"
+
+
+def test_corpus_non_empty() -> None:
+    assert len(_manifest_files()) > 0
+
+
+@pytest.mark.parametrize("manifest_path", _manifest_files(), ids=lambda p: p.name)
+def test_provider_composition(manifest_path: Path) -> None:
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    providers = _providers()
+    expected = manifest["expectedError"]
+    resolved = [_resolve(providers, pid) for pid in manifest["providers"]]
+
+    if "sealThenRegister" in manifest:
+        # Compose (must succeed), seal, then run the probe against the sealed registry.
+        registry = compose_registry(resolved)
+        registry.seal()
+        probe = _resolve(providers, manifest["sealThenRegister"])
+        with pytest.raises(ParseError) as exc_info:
+            probe.register_types(registry)
+        assert _error_code(exc_info.value) == expected
+        return
+
+    # Ordinary scenario: the compose call itself throws.
+    with pytest.raises(ParseError) as exc_info:
+        compose_registry(resolved)
+    assert _error_code(exc_info.value) == expected

{metaobjects-0.15.2 → 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.2 → 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
 # ---------------------------------------------------------------------------