metaobjects 0.25.0__tar.gz → 1.0.0rc5__tar.gz

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.25.0
+Version: 1.0.0rc5
 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.25.0 → metaobjects-1.0.0rc5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.25.0"
+version = "1.0.0rc5"
 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-1.0.0rc5/src/metaobjects/codegen/format.py

@@ -0,0 +1,72 @@
+"""Canonicalize emitted source via ruff: sort imports (isort), then format.
+
+Both passes read stdin / write stdout, so generated code is import-sorted AND
+formatted — i.e. `ruff check`- and `ruff format`-clean for downstream consumers."""
+from __future__ import annotations
+
+import importlib.util
+import subprocess
+import sys
+
+_STDIN_NAME = "generated.py"
+
+#: ruff is a codegen-time convenience (import-sort + format), not a runtime requirement
+#: of the emitted code. When it's absent we emit valid-but-unformatted Python rather
+#: than hard-failing the whole ``gen``.
+_RUFF_AVAILABLE = importlib.util.find_spec("ruff") is not None
+
+
+def _run_ruff(args: list[str], source: str) -> str:
+    proc = subprocess.run(
+        [sys.executable, "-m", "ruff", *args],
+        input=source,
+        capture_output=True,
+        text=True,
+    )
+    if proc.returncode != 0:
+        # A non-zero exit is read by the caller as "ruff rejected the source" — a
+        # generator bug. Two things make that reading unsafe, so record what actually
+        # happened instead of asserting a cause.
+        #
+        # First, ruff reports a source it cannot parse as exit 2 WITH stderr (measured,
+        # ruff 0.15.14: `error: Failed to parse at 1:7: ...`). So an EMPTY stderr is not
+        # a source rejection — the process did not get far enough to say anything.
+        # Second, a NEGATIVE returncode is death by signal, which is not a verdict on
+        # the source at all.
+        #
+        # This branch used to raise `ruff format failed:` — trailing off after the colon
+        # whenever stderr was empty, naming neither the exit status nor the fact that
+        # ruff never looked at the source, and sending a reader hunting a syntax error
+        # that did not exist. Always carry the status; never claim a source error for a
+        # process that did not finish, and do not guess at WHY it did not finish.
+        detail = proc.stderr.strip()
+        if proc.returncode < 0:
+            raise RuntimeError(
+                f"ruff {args[0]} was killed by signal {-proc.returncode} before it could "
+                f"format the source — this is not a source error; the formatter never ran "
+                f"to completion" + (f": {detail}" if detail else "")
+            )
+        raise RuntimeError(
+            f"ruff {args[0]} failed (exit {proc.returncode})"
+            + (
+                f": {detail}"
+                if detail
+                else " and wrote nothing to stderr — ruff reports an unparseable source"
+                     " WITH stderr, so this is not a source error"
+            )
+        )
+    return proc.stdout
+
+
+def ruff_format(source: str) -> str:
+    """Sort imports then format *source*; return the canonical text.
+
+    A no-op (returns *source* unchanged) when ruff is not installed — the emitted
+    code is still valid Python, just unformatted. Still raises RuntimeError if ruff
+    IS present but fails (e.g. a syntax error in emitted code — that's a generator bug)."""
+    if not _RUFF_AVAILABLE:
+        return source
+    sorted_src = _run_ruff(
+        ["check", "--select", "I", "--fix", "--stdin-filename", _STDIN_NAME, "-"], source
+    )
+    return _run_ruff(["format", "-"], sorted_src)

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/src/metaobjects/codegen/generators/names_generator.py

@@ -286,24 +286,28 @@ def _sources_by_role(entity: MetaObject) -> dict[str, MetaSource]:
     ADR-0039: ``children()`` RESOLVES — a source inherited via ``extends`` (the TPH
     pattern) is seen; ``own_children()`` would miss it.
 
-    The refusal is about DISAGREEMENT, not about the count — deliberately the SAME
-    rule :func:`primary_rdb_source` already enforces for the physical name, rather
-    than a stricter one invented here. An abstract base and the child that extends it
-    may each declare a ``@role: primary`` source naming the same relation; that is
-    legal today, and refusing it would make this module stricter than the invariant
-    it exists to serve.
+    The refusal is about DISAGREEMENT, not about the count — the SAME rule
+    :func:`primary_rdb_source` enforces, which now compares the whole ADDRESS
+    (:func:`source_address_key`: kind, schema, physical name) rather than the bare
+    name. An abstract base and the child that extends it may each declare a
+    ``@role: primary`` source naming the same relation; that is legal, and refusing it
+    would make this module stricter than the invariant it exists to serve.
 
     Two sources in one role that resolve DIFFERENTLY is the real problem, and silently
     keeping one is the failure mode this artifact makes impossible: the second name is
     carried nowhere, read by nobody, and the binding quietly takes the first's.
 
-    What this sees that :func:`primary_rdb_source` cannot is the non-name half —
-    ``@kind`` and ``@schema``. That function compares physical NAMES, so two primaries
-    agreeing on the name and differing on which schema it lives in get past it and land
-    on one role key here. (Two sources reach one role key only when both are OWN
-    children or both carry an explicit structural ``name``: effective-children
-    shadowing matches on ``(type, name)``, so two UNNAMED sources across an ``extends``
-    boundary collapse into one before this ever runs.)
+    This docstring used to claim the two were "deliberately the SAME rule" while
+    describing, two paragraphs later, exactly how they differed — that function
+    compared physical NAMES, so two primaries agreeing on the name and differing on
+    ``@schema`` got past it and landed on one role key here. They are the same rule
+    now. What remains for this loop is every NON-primary role: the authority knows only
+    about ``@role: primary``, so two disagreeing REPLICAs still land here.
+
+    (Two sources reach one role key only when both are OWN children or both carry an
+    explicit structural ``name``: effective-children shadowing matches on
+    ``(type, name)``, so two UNNAMED sources across an ``extends`` boundary collapse
+    into one before this ever runs.)
     """
     out: dict[str, MetaSource] = {}
     for child in entity.children():
@@ -329,9 +333,9 @@ def _sources_by_role(entity: MetaObject) -> dict[str, MetaSource]:
             )
             raise ValueError(
                 f'{entity.name} declares more than one source.rdb with @role: "{role}", '
-                f'and they do not agree — "{existing.physical_name()}" vs '
-                f'"{child.physical_name()}" ({detail}). The names module keys sources '
-                f"by role, so the second has nowhere to go."
+                f"and they disagree on the object's physical address — "
+                f'"{existing.physical_name()}" vs "{child.physical_name()}" ({detail}). '
+                f"The names module keys sources by role, so the second has nowhere to go."
             )
     return out
 

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/src/metaobjects/codegen/generators/router_generator.py

@@ -201,6 +201,27 @@ def _py_set_literal(names: list[str], *, frozen: bool = False) -> str:
     return f"frozenset({body})" if frozen else body
 
 
+def _py_sort_default_order_literal(fields: list[MetaField]) -> str:
+    """A ``dict[str, str]`` literal of each field's DECLARED ``@sortableDefaultOrder``.
+
+    Declared orders only — a field with no ``@sortableDefaultOrder`` is absent and the
+    generated ``_parse_sort`` supplies ``"asc"``. That split matches the other four
+    ports: one place per port spells the fallback, so no port can drift by baking a
+    different default into its map.
+
+    ADR-0039: ``attrs()`` is the RESOLVING accessor in Python (``attr()`` is own-only),
+    so an ``@sortableDefaultOrder`` inherited via ``extends`` is honoured.
+    """
+    rows = []
+    for f in fields:
+        v = f.attrs().get(fc.FIELD_ATTR_SORTABLE_DEFAULT_ORDER)
+        if v in ("asc", "desc"):
+            rows.append(f'    "{f.name}": "{v}",\n')
+    if not rows:
+        return "{}"
+    return "{\n" + "".join(rows) + "}"
+
+
 def _pk_py_type(entity: MetaObject) -> PyType:
     """The Python type of the entity's primary-key path/id parameter, derived
     from the PK field's declared subtype via ``type_map.py_type_for`` — the same
@@ -542,14 +563,17 @@ class RouterGenerator:
 
         # Sort allowlist = base scalar fields ∪ every subtype's own scalar fields, so a
         # per-subtype list can sort on a subtype-only column too. Stable order.
-        sort_fields: list[str] = [f.name for f in _scalar_fields(entity)]
+        sort_field_nodes = list(_scalar_fields(entity))
+        sort_fields: list[str] = [f.name for f in sort_field_nodes]
         seen = set(sort_fields)
         for st in plan.subtypes:
             for f in _scalar_fields(st.entity):
                 if f.name not in seen:
                     seen.add(f.name)
                     sort_fields.append(f.name)
+                    sort_field_nodes.append(f)
         sort_set_body = _py_set_literal(sort_fields)
+        sort_default_order_body = _py_sort_default_order_literal(sort_field_nodes)
         # FR-035 PATCH-2: @required fields across the base AND every subtype — an
         # explicit null on any of these is a 400 (the per-subtype update handlers
         # guard against it before the repo call). Union, stable order.
@@ -632,6 +656,9 @@ class RouterGenerator:
         parts.append(f"_SORT_ALLOWLIST: set[str] = {sort_set_body}")
         parts.append("")
         parts.append("")
+        parts.append(f"_SORT_DEFAULT_ORDER: dict[str, str] = {sort_default_order_body}")
+        parts.append("")
+        parts.append("")
         parts.append(f"_REQUIRED_FIELDS: frozenset[str] = {required_set_body}")
         parts.append("")
         parts.append("")
@@ -646,7 +673,12 @@ class RouterGenerator:
         parts.append('    parts = raw.split(":", 1)')
         parts.append("    if not parts or parts[0] not in _SORT_ALLOWLIST:")
         parts.append("        return None")
-        parts.append('    direction = parts[1].lower() if len(parts) == 2 else "asc"')
+        # `?sort=field` with no `:order` takes the field's DECLARED @sortableDefaultOrder.
+        # The "asc" fallback stays at the READ, one place per port.
+        parts.append('    direction = (')
+        parts.append('        parts[1].lower() if len(parts) == 2')
+        parts.append('        else _SORT_DEFAULT_ORDER.get(parts[0], "asc")')
+        parts.append('    )')
         parts.append('    if direction not in ("asc", "desc"):')
         parts.append("        return None")
         parts.append("    return _SortClause(field=parts[0], direction=direction)")
@@ -847,13 +879,15 @@ class RouterGenerator:
         pk = _pk_py_type(entity)
         pk_type = pk.expr
         repo_class = f"{short_name}Repository"
-        sort_fields = [f.name for f in _scalar_fields(entity)]
+        sort_field_nodes = list(_scalar_fields(entity))
+        sort_fields = [f.name for f in sort_field_nodes]
         upper = short_name.upper()
         fields_const = f"{upper}_FILTER_FIELDS"
         ops_const = f"{upper}_FILTER_OPS_BY_FIELD"
         allowlist_module = f"{snake}_filter_allowlist"
 
         sort_set_body = _py_set_literal(sort_fields)
+        sort_default_order_body = _py_sort_default_order_literal(sort_field_nodes)
         # FR-035 PATCH-2: an explicit null on a @required field (scalar or jsonb)
         # is a 400 — the update handler guards these before the repo call.
         required_set_body = _py_set_literal(_required_field_names(entity), frozen=True)
@@ -928,6 +962,9 @@ class RouterGenerator:
         parts.append(f"_SORT_ALLOWLIST: set[str] = {sort_set_body}")
         parts.append("")
         parts.append("")
+        parts.append(f"_SORT_DEFAULT_ORDER: dict[str, str] = {sort_default_order_body}")
+        parts.append("")
+        parts.append("")
         parts.append(f"_REQUIRED_FIELDS: frozenset[str] = {required_set_body}")
         parts.append("")
         parts.append("")
@@ -942,7 +979,12 @@ class RouterGenerator:
         parts.append('    parts = raw.split(":", 1)')
         parts.append("    if not parts or parts[0] not in _SORT_ALLOWLIST:")
         parts.append("        return None")
-        parts.append('    direction = parts[1].lower() if len(parts) == 2 else "asc"')
+        # `?sort=field` with no `:order` takes the field's DECLARED @sortableDefaultOrder.
+        # The "asc" fallback stays at the READ, one place per port.
+        parts.append('    direction = (')
+        parts.append('        parts[1].lower() if len(parts) == 2')
+        parts.append('        else _SORT_DEFAULT_ORDER.get(parts[0], "asc")')
+        parts.append('    )')
         parts.append('    if direction not in ("asc", "desc"):')
         parts.append("        return None")
         parts.append("    return _SortClause(field=parts[0], direction=direction)")

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/src/metaobjects/registry_manifest.py

@@ -255,7 +255,7 @@ def _sorted_children(definition: TypeDefinition) -> list[dict[str, object]]:
     return children
 
 
-METAMODEL_VERSION = "0.14"
+METAMODEL_VERSION = "1.0"
 """Rolled-up spec-version for the cross-port registry manifest.
 
 ``"0"`` = pre-1.0 / unstable (semver major-0). Flips to ``"1.0"`` at the

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/src/metaobjects/source_resolution.py

@@ -45,6 +45,24 @@ from metaobjects.meta.persistence.source.meta_source import MetaSource
 from metaobjects.meta.persistence.source.source_constants import SOURCE_ROLE_PRIMARY
 
 
+def source_address_key(source: MetaSource) -> str:
+    """The RESOLVED address of *source* — the same three parts the names artifact
+    compares, so the shared authority and the generated artifact cannot answer
+    "is this one object?" differently. Rendered rather than structural because
+    every port must produce a byte-identical message from it.
+
+    RAW, deliberately: an absent ``@schema`` is NOT folded into a dialect default.
+    On Postgres absent and ``"public"`` address the same relation, but on
+    SQLite/D1 they do not — the expected-schema builder rejects ANY declared
+    schema, ``"public"`` included, while an absent one is fine. Deciding what
+    "absent" means belongs to the caller's dialect, not to this layer, so
+    normalizing here would import one dialect's rule into a dialect-free tier.
+    """
+    schema = source.schema()
+    qualifier = f'"{schema}".' if schema else ""
+    return f'{qualifier}"{source.physical_name()}" ({source.effective_kind()})'
+
+
 def primary_rdb_source(entity: MetaObject) -> MetaSource | None:
     """THE primary ``source.rdb`` for *entity*, or ``None``.
 
@@ -61,7 +79,8 @@ def primary_rdb_source(entity: MetaObject) -> MetaSource | None:
 
     Raises :class:`ValueError` — mirroring the other four ports' wording exactly —
     when the resolving children carry MORE THAN ONE ``@role: primary`` source and
-    they do not agree on a physical name. Direction-blind: it compares every
+    they do not agree on a physical ADDRESS (kind, schema, physical name; see
+    :func:`source_address_key`). Direction-blind: it compares every
     primary against every other, so it does not matter which of them is writable,
     nor which was declared first. See the module docstring for why that matters.
     No downstream consumer re-checks this; the refusal lives here, once, so every
@@ -75,13 +94,14 @@ def primary_rdb_source(entity: MetaObject) -> MetaSource | None:
     if not primaries:
         return None
 
-    names = sorted({s.physical_name() for s in primaries})
-    if len(names) > 1:
-        joined = ", ".join(f'"{n}"' for n in names)
+    addresses = sorted({source_address_key(s) for s in primaries})
+    if len(addresses) > 1:
+        joined = " vs ".join(addresses)
         raise ValueError(
             f"{entity.name}: role=primary sources disagree on the object's physical "
-            f"name — {joined}. Every consumer binds ONE name. Give them matching "
-            f"physical names, or drop the extra role=primary declaration."
+            f"address — {joined}. Every consumer binds ONE address. Give them a "
+            f"matching @kind, @schema and physical name, or drop the extra "
+            f"role=primary declaration."
         )
     return primaries[0]
 

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/src/metaobjects/spec_metamodel/ui.json

@@ -7,7 +7,7 @@
       "children": [
         { "type": "attr", "subType": "boolean", "name": "filterable", "min": 0, "max": 1, "description": "When true, the field is exposed in generated CRUD filter allowlists (Project D filter layer)." },
         { "type": "attr", "subType": "boolean", "name": "sortable", "min": 0, "max": 1, "description": "When true, the field is exposed in generated CRUD sort allowlists. Inherits from @filterable by default; set false to opt out." },
-        { "type": "attr", "subType": "string", "name": "sortableDefaultOrder", "min": 0, "max": 1, "allowedValues": ["asc", "desc"], "description": "Default sort direction applied when this field is the default sort field." },
+        { "type": "attr", "subType": "string", "name": "sortableDefaultOrder", "min": 0, "max": 1, "allowedValues": ["asc", "desc"], "description": "Direction a sort takes when it names this field but omits the order: a ?sort=<field> with no :order, and a layout.dataGrid whose @defaultSortField names it with no @defaultSortOrder. Defaults to 'asc'." },
         { "type": "attr", "subType": "boolean", "name": "formExclude", "min": 0, "max": 1, "description": "When true, the field is omitted from generated forms. Inert on fields for which no form is generated (e.g. projection/derived fields)." }
       ]
     },
@@ -24,7 +24,7 @@
       "children": [
         { "type": "attr", "subType": "int", "name": "pageSize", "min": 0, "max": 1, "description": "Number of rows per page in the generated data grid." },
         { "type": "attr", "subType": "string", "name": "defaultSortField", "min": 0, "max": 1, "description": "Field name the grid is sorted by on initial render. Must reference an actual field on the entity." },
-        { "type": "attr", "subType": "string", "name": "defaultSortOrder", "min": 0, "max": 1, "allowedValues": ["asc", "desc"], "description": "Initial sort direction for the default sort field: 'asc' or 'desc'." },
+        { "type": "attr", "subType": "string", "name": "defaultSortOrder", "min": 0, "max": 1, "allowedValues": ["asc", "desc"], "description": "Initial sort direction for the default sort field: 'asc' or 'desc'. When omitted, the named field's @sortableDefaultOrder applies." },
         { "type": "attr", "subType": "boolean", "name": "filterable", "min": 0, "max": 1, "description": "When true, the generated grid exposes column filtering UI." },
         { "type": "attr", "subType": "filter", "name": "filter", "min": 0, "max": 1, "description": "Structured preset filter object applied to the grid at the metadata level. Desugared to canonical { field: { op: value } } form at parse time." },
         { "type": "attr", "subType": "string", "name": "columns", "isArray": true, "min": 0, "max": 1, "description": "Flat ordered list of field names to display as grid columns." }

metaobjects-1.0.0rc5/tests/codegen/test_format.py

@@ -0,0 +1,85 @@
+from metaobjects.codegen.format import ruff_format
+
+
+def test_ruff_format_canonicalizes() -> None:
+    messy = "x={'a':1,'b':2}\n"
+    out = ruff_format(messy)
+    assert out == 'x = {"a": 1, "b": 2}\n'
+
+
+def test_ruff_format_is_idempotent() -> None:
+    src = "y = [1, 2, 3]\n"
+    assert ruff_format(ruff_format(src)) == ruff_format(src)
+
+
+def test_ruff_format_sorts_imports() -> None:
+    # stdlib before third-party before first-party-relative (PEP 8 / isort groups).
+    src = "from .local import L\nimport os\n\nfrom pydantic import BaseModel\n"
+    out = ruff_format(src)
+    assert out.index("import os") < out.index("from pydantic") < out.index("from .local import L")
+
+
+def test_ruff_format_no_op_when_ruff_absent(monkeypatch) -> None:
+    """ruff is a codegen-time convenience, not a runtime requirement — when it's not
+    installed, ruff_format returns the source unformatted (still valid Python) rather
+    than crashing the whole gen run."""
+    import metaobjects.codegen.format as fmt
+
+    monkeypatch.setattr(fmt, "_RUFF_AVAILABLE", False)
+    messy = "x={'a':1}\n"
+    assert fmt.ruff_format(messy) == messy
+
+
+def test_killed_ruff_says_it_was_killed_and_names_the_signal(monkeypatch) -> None:
+    """A ruff process killed by a signal must not be reported as a source error.
+
+    `_run_ruff` treats a non-zero exit as "ruff rejected the source", which is the
+    generator bug `ruff_format`'s docstring describes. But a process killed by a
+    signal returns a NEGATIVE code and writes no stderr, so that path produced
+    `ruff format failed:` — a message naming neither the cause nor the fact that
+    ruff never ran. Observed on a CI box running five lanes at once.
+    """
+    import subprocess
+
+    import metaobjects.codegen.format as fmt
+
+    def killed(*_a, **_k):
+        return subprocess.CompletedProcess(args=[], returncode=-9, stdout="", stderr="")
+
+    monkeypatch.setattr(fmt.subprocess, "run", killed)
+
+    try:
+        fmt.ruff_format("x = 1\n")
+    except RuntimeError as e:
+        msg = str(e)
+    else:
+        raise AssertionError("expected RuntimeError")
+
+    # It must say the process was killed, and by which signal, so the reader is not
+    # left hunting a syntax error in emitted code that ruff never looked at.
+    assert "killed" in msg
+    assert "9" in msg
+    assert msg.rstrip().endswith(")") or "signal" in msg
+
+
+def test_nonzero_ruff_with_no_stderr_still_names_the_exit_code(monkeypatch) -> None:
+    """The other half: a genuine non-zero exit that happens to print nothing must
+    still carry its exit code, rather than trailing off after the colon."""
+    import subprocess
+
+    import metaobjects.codegen.format as fmt
+
+    def quiet_failure(*_a, **_k):
+        return subprocess.CompletedProcess(args=[], returncode=2, stdout="", stderr="")
+
+    monkeypatch.setattr(fmt.subprocess, "run", quiet_failure)
+
+    try:
+        fmt.ruff_format("x = 1\n")
+    except RuntimeError as e:
+        msg = str(e)
+    else:
+        raise AssertionError("expected RuntimeError")
+
+    assert "2" in msg
+    assert not msg.rstrip().endswith(":")

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/tests/codegen/test_names_extends_chain.py

@@ -389,18 +389,22 @@ def test_two_sources_in_one_role_that_AGREE_are_legal() -> None:
     assert src.count("ROLECHILD_SOURCE_PRIMARY_TABLE: Final") == 1
 
 
-def test_two_sources_in_one_role_that_DISAGREE_are_refused_naming_both() -> None:
+def test_a_schema_disagreement_in_the_primary_role_is_refused_by_the_AUTHORITY() -> None:
     """...and the disagreement is the real problem, because keeping one silently is the
     failure this artifact makes impossible: the second name would be carried nowhere,
     read by nobody, while the binding quietly took the first's.
 
-    A ``@schema`` disagreement is the arm this module owns, and it is what makes the
-    check non-redundant: ``primary_rdb_source`` compares physical NAMES only, so two
-    primaries agreeing on the name and differing on which SCHEMA it lives in get past
-    it and land on one role key here. (A ``@kind`` disagreement in the primary role is
-    unreachable — the loader refuses a read-only primary outright,
-    ``ERR_ENTITY_PRIMARY_SOURCE_READONLY``; a physical-NAME disagreement is refused one
-    level down, by ``primary_rdb_source``.)
+    This test used to assert the message came from THIS module, and documented why:
+    ``primary_rdb_source`` compared physical NAMES only, so two primaries agreeing on
+    the name and differing on which SCHEMA it lives in got past it and landed on one
+    role key here. That gap is closed — the authority now compares the whole ADDRESS
+    (kind, schema, physical name), so it refuses one level down and this module never
+    sees the shape.
+
+    Why it was closed rather than left: the weaker key did not merely accept the model,
+    it made the accepted answer PORT-DEPENDENT. ``primaries[0]`` is the inherited source
+    in Python/TS/C# (``children()`` puts the super's entries first) and the own source
+    on the JVM, so this exact model bound one schema in three ports and the other in two.
     """
     model = _role_model(
         {"source.rdb": {"name": "child_src", "@table": "zz_shared", "@schema": "zz_other"}}
@@ -408,8 +412,36 @@ def test_two_sources_in_one_role_that_DISAGREE_are_refused_naming_both() -> None
     with pytest.raises(ValueError) as exc:
         _render(model, "RoleChild")
     message = str(exc.value)
-    assert '@role: "primary"' in message
-    assert "zz_shared" in message
+    assert "disagree on the object's physical address" in message
+    # The ADDRESS, not the bare name: the names agree here, so a message naming only
+    # "zz_shared" would describe two identical things as different.
+    assert '"zz_other"."zz_shared"' in message
+    assert '"zz_shared" (table)' in message
+
+
+def test_two_REPLICAS_that_disagree_are_still_refused_by_this_module() -> None:
+    """The per-role check here is not redundant with the authority: the authority only
+    knows about ``@role: primary``. Two sources sharing any OTHER role key still land
+    here, and the second still has nowhere to go in a map keyed by role.
+
+    Without this case, closing the primary-role gap would leave the whole per-role loop
+    unexercised — a check nothing reaches is a check that can rot.
+    """
+    # The child keeps a primary that AGREES with the base's — `validate_source_roles` is
+    # own-only, so a child declaring replicas alone fails the load with
+    # ERR_SOURCE_NO_PRIMARY before this module is ever reached.
+    model = _role_model({"source.rdb": {"name": "child_src", "@table": "zz_shared"}})
+    model["metadata.root"]["children"][1]["object.entity"]["children"].extend(
+        [
+            {"source.rdb": {"name": "r1", "@table": "zz_replica", "@role": "replica"}},
+            {"source.rdb": {"name": "r2", "@table": "zz_elsewhere", "@role": "replica"}},
+        ]
+    )
+    with pytest.raises(ValueError) as exc:
+        _render(model, "RoleChild")
+    message = str(exc.value)
+    assert '@role: "replica"' in message
+    assert "disagree on the object's physical address" in message
 
 
 TPH_MODEL = {

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/tests/integration/api_contract_server.py

@@ -40,6 +40,14 @@ from .postgres_container import PostgresInfo
 # fields outside it elicit the cross-port 400 invalid_sort envelope.
 _SORT_ALLOWLIST: frozenset[str] = frozenset({"id", "name", "createdAt"})
 
+# Cross-port contract: each field's DECLARED @sortableDefaultOrder — the direction a
+# `?sort=<field>` carrying no `:dir` takes. Hardcoded from meta.json for the same reason
+# the allowlist above is: this is the hand-rolled fixed point the generated routers are
+# measured against, so it must not reach the generator's code to agree with it. A field
+# absent here declares nothing and takes the "asc" fallback at the read — one place per
+# port spells the default.
+_SORT_DEFAULT_ORDER: dict[str, str] = {"createdAt": "desc"}
+
 # Per-entity FR-009 filter allowlist for Author. Mirror of what
 # `filter_allowlist_generator` would emit for the Author entity (the
 # integration test is hand-wired so we duplicate the constants here; the
@@ -446,7 +454,13 @@ def make_app(repo: AuthorRepository) -> FastAPI:
             field = parts[0]
             if field not in _SORT_ALLOWLIST:
                 return JSONResponse(status_code=400, content={"error": "invalid_sort"})
-            direction = parts[1].lower() if len(parts) == 2 else "asc"
+            # No `:dir` supplied -> the named field's declared @sortableDefaultOrder, and
+            # "asc" when it declares none. The explicit branch is untouched, so a
+            # caller-supplied order always beats the declaration.
+            direction = (
+                parts[1].lower() if len(parts) == 2
+                else _SORT_DEFAULT_ORDER.get(field, "asc")
+            )
             if direction not in ("asc", "desc"):
                 return JSONResponse(status_code=400, content={"error": "invalid_sort"})
             sort_field, sort_dir = field, direction.upper()

{metaobjects-0.25.0 → metaobjects-1.0.0rc5}/uv.lock

@@ -250,7 +250,7 @@ wheels = [
 
 [[package]]
 name = "metaobjects"
-version = "0.24.5"
+version = "0.25.0"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },

metaobjects-0.25.0/src/metaobjects/codegen/format.py

@@ -1,42 +0,0 @@
-"""Canonicalize emitted source via ruff: sort imports (isort), then format.
-
-Both passes read stdin / write stdout, so generated code is import-sorted AND
-formatted — i.e. `ruff check`- and `ruff format`-clean for downstream consumers."""
-from __future__ import annotations
-
-import importlib.util
-import subprocess
-import sys
-
-_STDIN_NAME = "generated.py"
-
-#: ruff is a codegen-time convenience (import-sort + format), not a runtime requirement
-#: of the emitted code. When it's absent we emit valid-but-unformatted Python rather
-#: than hard-failing the whole ``gen``.
-_RUFF_AVAILABLE = importlib.util.find_spec("ruff") is not None
-
-
-def _run_ruff(args: list[str], source: str) -> str:
-    proc = subprocess.run(
-        [sys.executable, "-m", "ruff", *args],
-        input=source,
-        capture_output=True,
-        text=True,
-    )
-    if proc.returncode != 0:
-        raise RuntimeError(f"ruff {args[0]} failed: {proc.stderr.strip()}")
-    return proc.stdout
-
-
-def ruff_format(source: str) -> str:
-    """Sort imports then format *source*; return the canonical text.
-
-    A no-op (returns *source* unchanged) when ruff is not installed — the emitted
-    code is still valid Python, just unformatted. Still raises RuntimeError if ruff
-    IS present but fails (e.g. a syntax error in emitted code — that's a generator bug)."""
-    if not _RUFF_AVAILABLE:
-        return source
-    sorted_src = _run_ruff(
-        ["check", "--select", "I", "--fix", "--stdin-filename", _STDIN_NAME, "-"], source
-    )
-    return _run_ruff(["format", "-"], sorted_src)

metaobjects-0.25.0/tests/codegen/test_format.py

@@ -1,30 +0,0 @@
-from metaobjects.codegen.format import ruff_format
-
-
-def test_ruff_format_canonicalizes() -> None:
-    messy = "x={'a':1,'b':2}\n"
-    out = ruff_format(messy)
-    assert out == 'x = {"a": 1, "b": 2}\n'
-
-
-def test_ruff_format_is_idempotent() -> None:
-    src = "y = [1, 2, 3]\n"
-    assert ruff_format(ruff_format(src)) == ruff_format(src)
-
-
-def test_ruff_format_sorts_imports() -> None:
-    # stdlib before third-party before first-party-relative (PEP 8 / isort groups).
-    src = "from .local import L\nimport os\n\nfrom pydantic import BaseModel\n"
-    out = ruff_format(src)
-    assert out.index("import os") < out.index("from pydantic") < out.index("from .local import L")
-
-
-def test_ruff_format_no_op_when_ruff_absent(monkeypatch) -> None:
-    """ruff is a codegen-time convenience, not a runtime requirement — when it's not
-    installed, ruff_format returns the source unformatted (still valid Python) rather
-    than crashing the whole gen run."""
-    import metaobjects.codegen.format as fmt
-
-    monkeypatch.setattr(fmt, "_RUFF_AVAILABLE", False)
-    messy = "x={'a':1}\n"
-    assert fmt.ruff_format(messy) == messy