metaobjects 1.1.1__tar.gz → 1.1.2__tar.gz

{metaobjects-1.1.1 → metaobjects-1.1.2}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.1.1"
+version = "1.1.2"
 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.1.1 → metaobjects-1.1.2}/src/metaobjects/cli.py

@@ -148,6 +148,7 @@ from metaobjects.render.verify import (
     verify as render_verify,
 )
 from metaobjects.shared.base_types import TYPE_OBJECT, TYPE_TEMPLATE
+from metaobjects.wire import WireFormat, wire_block, wire_candidates
 
 
 #: The error a run with no generator selection reports.
@@ -505,6 +506,7 @@ def _load_root(
     # so codegen and the runtime (both reached from an explicit-`metadata_dir` CLI
     # invocation) read the same values `gen`/`verify --codegen` would.
     result.root.naming = neutral.naming if neutral is not None else NamingRules()
+    result.root.wire = neutral.wire if neutral is not None else WireFormat()
     return result.root, []
 
 
@@ -567,6 +569,7 @@ def _load_collection_result(
         # project's ONE naming setting (read at the same rung as `libraries`); attach
         # it to the loaded root so codegen, the runtime and `verify` agree.
         result.root.naming = collection.naming
+        result.root.wire = collection.wire
     return result
 
 
@@ -2151,6 +2154,20 @@ def _verify_codegen_config(args: argparse.Namespace) -> int:
         ):
             print(naming_differs_message(candidate, used), file=sys.stderr)
             return 1
+    # The same question for the `wire` setting: it reaches the JSON every generated route
+    # writes, so "regenerate" would change the contract existing clients read.
+    used_wire = root.wire
+    for wire_candidate in wire_candidates(used_wire):
+        root.wire = wire_candidate
+        try:
+            other_errors, other_reports = compare(column_naming)
+        finally:
+            root.wire = used_wire
+        if not other_errors and all(
+            _report_clean(rep.changed, rep.missing, rep.extra) for rep in other_reports
+        ):
+            print(wire_differs_message(wire_candidate, used_wire), file=sys.stderr)
+            return 1
     if regenerable:
         print("regenerate (metaobjects gen) and commit the result.", file=sys.stderr)
     if edited_orphans:
@@ -2204,6 +2221,20 @@ def naming_differs_message(committed: NamingRules, used: NamingRules) -> str:
     )
 
 
+def wire_differs_message(committed: WireFormat, used: WireFormat) -> str:
+    """What ``verify --codegen`` says, in place of "regenerate", when the committed output was
+    generated with the ``committed`` wire format and this run's loaded root resolved ``used``
+    (ADR-0019 Amendment 2: the ``wire`` block of ``.metaobjects/config.json``)."""
+    return (
+        f"The committed output was generated with {wire_block(committed)}; this run used "
+        f"{wire_block(used)} (the wire block of .metaobjects/config.json; each key defaults to "
+        f"native). Do not regenerate: that changes the JSON the generated routes write "
+        f"(decimals, value-object null members) for clients already reading it. "
+        f"Declare {wire_block(committed)} in .metaobjects/config.json, and gen and verify "
+        f"--codegen both read it."
+    )
+
+
 #: The text-ref attrs a ``template.*`` node may carry. Each is resolved through
 #: the filesystem provider and run through the render ``verify()`` gate. A prompt
 #: / document uses ``@textRef``; an email uses subject / html / (optional) text

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/codegen/generators/router_generator.py

@@ -72,6 +72,7 @@ from metaobjects.meta.persistence.source.source_constants import (
 )
 from metaobjects.naming import DEFAULT_COLUMN_NAMING
 from metaobjects.naming_refs import ref_target
+from metaobjects.wire import WIRE_NATIVE, WireFormat, wire_of
 from metaobjects.shared.base_types import TYPE_IDENTITY
 
 from ..runtime.fr010_field_mapping import is_required
@@ -261,6 +262,64 @@ def _nested_decimals(entities: list[MetaObject]) -> dict[str, Any]:
     return out
 
 
+def _vo_shape(vo: MetaObject, seen: frozenset[str]) -> dict[str, Any]:
+    """The declared members of the value object *vo*, as ``{"f": [member, ...], "o": {member:
+    shape}}`` (``o`` for the members that are themselves value objects or maps of them). What
+    ``nullMembers: emit`` fills in; ``omit`` walks it to reach nested value objects."""
+    seen = seen | {vo.name}
+    shape: dict[str, Any] = {"f": [f.name for f in vo.fields()], "o": {}}
+    for f in vo.fields():
+        inner = _field_shape(f, seen)
+        if inner is not None:
+            shape["o"][f.name] = inner
+    return shape
+
+
+def _field_shape(f: MetaField, seen: frozenset[str]) -> dict[str, Any] | None:
+    if f.sub_type not in (fc.FIELD_SUBTYPE_OBJECT, fc.FIELD_SUBTYPE_MAP):
+        return None
+    target = object_ref_target(f)
+    if target is None or target.name in seen:
+        return None
+    shape = _vo_shape(target, seen)
+    return {"m": shape} if f.sub_type == fc.FIELD_SUBTYPE_MAP else shape
+
+
+def _wire_lines(entities: list[MetaObject], wire: WireFormat, name: str = "_WIRE") -> list[str]:
+    """The *name* constant a response of *entities* is written through: the project's ``wire``
+    setting (ADR-0019 Amendment 2) and, when ``nullMembers`` is not ``native``, the declared
+    members of each value-object field of *entities* (the first declaration of a name wins)."""
+    shapes: dict[str, Any] = {}
+    if wire.null_members != WIRE_NATIVE:
+        for entity in entities:
+            for f in entity.fields():
+                if f.name not in shapes and (shape := _field_shape(f, frozenset())) is not None:
+                    shapes[f.name] = shape
+    args = f'decimals="{wire.decimals}", null_members="{wire.null_members}"'
+    if shapes:
+        args += f", shapes={shapes!r}"
+    return ["", "", f"{name} = WireOutput({args})"]
+
+
+def _m2m_wire_name(target: str) -> str:
+    """The wire constant an M:N traversal onto *target* writes the target's rows through."""
+    return f"_WIRE_{_snake_case(target).upper()}"
+
+
+def _m2m_wire_lines(
+    descriptors: list[M2mDescriptor], object_index: dict[str, MetaObject], wire: WireFormat
+) -> list[str]:
+    """One :func:`_m2m_wire_name` constant per distinct M:N target, shaped by the TARGET's
+    value-object fields (and its TPH subtypes' when the target is a discriminator base)."""
+    lines: list[str] = []
+    for name in dict.fromkeys(d.target_entity for d in descriptors):
+        target = next(o for o in object_index.values() if o.name == name)
+        plan = tph_plan_for(target, object_index)
+        entities = [target, *(st.entity for st in plan.subtypes)] if plan is not None else [target]
+        lines.extend(_wire_lines(entities, wire, _m2m_wire_name(name)))
+    return lines
+
+
 def _decimal_limits_lines(entities: list[MetaObject]) -> list[str]:
     limits = _decimal_limits(entities)
     body = "{" + ", ".join(f'"{n}": ({p}, {sc})' for n, (p, sc) in limits.items()) + "}"
@@ -734,8 +793,8 @@ class RouterGenerator:
                 "    rows = repo.list(actual_limit, actual_offset, sort_clause, predicates)",
                 "    if with_count == 1:",
                 "        total = repo.count(predicates)",
-                '        return {"rows": to_wire(rows), "total": total}',
-                "    return to_wire(rows)",
+                '        return {"rows": render_wire(rows, _WIRE), "total": total}',
+                "    return render_wire(rows, _WIRE)",
             ]
         if name == "get":
             return [
@@ -747,7 +806,7 @@ class RouterGenerator:
                 f"    row = repo.find_by_id({pk_param})",
                 "    if row is None:",
                 '        return JSONResponse(status_code=404, content={"error": "not_found"})',
-                "    return to_wire(row)",
+                "    return render_wire(row, _WIRE)",
             ]
         if name == "create":
             return [
@@ -768,7 +827,7 @@ class RouterGenerator:
                 # (a fresh row's createdAt == updatedAt), ignoring any caller-supplied value.
                 *create_autoset,
                 "    try:",
-                "        return to_wire(repo.create(dto))",
+                "        return render_wire(repo.create(dto), _WIRE)",
                 *_CONSTRAINT_EXCEPT,
             ]
         if name == "update":
@@ -803,7 +862,7 @@ class RouterGenerator:
                 *_CONSTRAINT_EXCEPT,
                 "    if saved is None:",
                 '        return JSONResponse(status_code=404, content={"error": "not_found"})',
-                "    return to_wire(saved)",
+                "    return render_wire(saved, _WIRE)",
             ]
         if name == "delete":
             return [
@@ -836,8 +895,9 @@ class RouterGenerator:
             f"    {pk_param}: {pk_type},",
             f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
             ") -> list[Any]:",
-            f"    return to_wire(repo.find_related_{d.relation_name}"
-            f"({pk_param}{_target_subtype_arg(d, {d.target_discriminator})}))",
+            f"    return render_wire(repo.find_related_{d.relation_name}"
+            f"({pk_param}{_target_subtype_arg(d, {d.target_discriminator})}), "
+            f"{_m2m_wire_name(d.target_entity)})",
         ]
 
     def _emit_tph_m2m_route(
@@ -893,8 +953,9 @@ class RouterGenerator:
                 "        return []",
             ]
         lines.append(
-            f"    return to_wire(repo.find_related_{d.relation_name}"
-            f"({subtype_expr}, {pk_param}{_target_subtype_arg(d, target_discs)}))"
+            f"    return render_wire(repo.find_related_{d.relation_name}"
+            f"({subtype_expr}, {pk_param}{_target_subtype_arg(d, target_discs)}), "
+            f"{_m2m_wire_name(d.target_entity)})"
         )
         return lines
 
@@ -923,8 +984,8 @@ class RouterGenerator:
             f"    rows = {repo_var}.list({subtype_expr}, actual_limit, actual_offset, sort_clause, predicates)",
             "    if with_count == 1:",
             f"        total = {repo_var}.count({subtype_expr}, predicates)",
-            '        return {"rows": to_wire(rows), "total": total}',
-            "    return to_wire(rows)",
+            '        return {"rows": render_wire(rows, _WIRE), "total": total}',
+            "    return render_wire(rows, _WIRE)",
         ]
 
     def _render_tph_router(
@@ -933,6 +994,7 @@ class RouterGenerator:
         plan: TphPlan,
         object_index: dict[str, MetaObject],
         column_naming: str = DEFAULT_COLUMN_NAMING,
+        wire: WireFormat = WireFormat(),
     ) -> str:
         """FR-017 TPH: emit the discriminator base's router — a polymorphic collection
         at the base path + a full per-subtype CRUD set at /<base>/<segment>. The repo
@@ -1090,7 +1152,8 @@ class RouterGenerator:
         parts.append("    coerce_decimal_fields,")
         parts.append("    coerce_decimal_predicates,")
         parts.append("    parse_json_object,")
-        parts.append("    to_wire,")
+        parts.append("    WireOutput,")
+        parts.append("    render_wire,")
         parts.append(")")
         parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
@@ -1116,6 +1179,12 @@ class RouterGenerator:
         parts.append("")
         parts.append(f"_DECIMAL_FIELDS: frozenset[str] = {decimal_set_body}")
         parts.extend(_decimal_limits_lines([entity, *(st.entity for st in plan.subtypes)]))
+        parts.extend(_wire_lines([entity, *(st.entity for st in plan.subtypes)], wire))
+        parts.extend(_m2m_wire_lines(
+            [*base_m2m, *(d for st in plan.subtypes for d in sub_m2m[st.entity.name])],
+            object_index,
+            wire,
+        ))
         parts.append("")
         parts.append("")
         parts.extend(_JSON_BODY_LINES)
@@ -1207,7 +1276,7 @@ class RouterGenerator:
             # non-@autoSet hierarchy — byte-identical output).
             parts.extend(create_autoset)
             parts.append("    try:")
-            parts.append(f'        return to_wire(repo.create("{val}", dto))')
+            parts.append(f'        return render_wire(repo.create("{val}", dto), _WIRE)')
             parts.extend(_CONSTRAINT_EXCEPT)
             parts.append("")
             parts.append("")
@@ -1219,7 +1288,7 @@ class RouterGenerator:
             parts.append(f'    row = repo.find_by_id("{val}", {pk_param})')
             parts.append("    if row is None:")
             parts.append('        return JSONResponse(status_code=404, content={"error": "not_found"})')
-            parts.append("    return to_wire(row)")
+            parts.append("    return render_wire(row, _WIRE)")
             parts.append("")
             parts.append("")
             parts.append(f'@router.patch("/{seg}/{{{pk_param}}}")')
@@ -1248,7 +1317,7 @@ class RouterGenerator:
             parts.extend(_CONSTRAINT_EXCEPT)
             parts.append("    if saved is None:")
             parts.append('        return JSONResponse(status_code=404, content={"error": "not_found"})')
-            parts.append("    return to_wire(saved)")
+            parts.append("    return render_wire(saved, _WIRE)")
             parts.append("")
             parts.append("")
             parts.append(f'@router.delete("/{seg}/{{{pk_param}}}", status_code=status.HTTP_204_NO_CONTENT)')
@@ -1298,7 +1367,7 @@ class RouterGenerator:
         parts.append(f"    row = repo.find_by_id(None, {pk_param})")
         parts.append("    if row is None:")
         parts.append('        return JSONResponse(status_code=404, content={"error": "not_found"})')
-        parts.append("    return to_wire(row)")
+        parts.append("    return render_wire(row, _WIRE)")
         parts.append("")
 
         # FW-8 rule (a): every relationship the BASE resolves — every row of the
@@ -1326,6 +1395,7 @@ class RouterGenerator:
         entity: MetaObject,
         object_index: dict[str, MetaObject] | None = None,
         column_naming: str = DEFAULT_COLUMN_NAMING,
+        wire: WireFormat | None = None,
     ) -> str | None:
         """Render an entity as a FastAPI ``APIRouter`` module.
 
@@ -1342,6 +1412,8 @@ class RouterGenerator:
         source URL segment is the ENTITY name pluralized (cross-port grammar), NOT
         the physical ``@table``. Without an index, only CRUD is emitted (back-compat).
 
+        *wire* is the run's ``wire`` setting; omitted, it is read from the loaded root.
+
         *column_naming* is ``GenConfig.column_naming`` for this run — passed through
         to :func:`resolve_m2m_descriptors` so the M:N descriptor's physical junction
         columns are resolved by the SAME strategy the ``names`` generator applies to
@@ -1353,6 +1425,9 @@ class RouterGenerator:
         """
         if not emits_router(entity):
             return None
+        # ADR-0019 Amendment 2: the project's `wire` setting, from the loaded root. A caller
+        # that holds an object detached from the root (a report's read model) passes it.
+        wire = wire if wire is not None else wire_of(entity)
         # FR-017 TPH: a concrete subtype is folded into its base's single table — it
         # emits no standalone router (its CRUD lives under the base's per-subtype segment).
         if object_index is not None and is_tph_subtype(entity):
@@ -1371,7 +1446,7 @@ class RouterGenerator:
             # answering the cross-port 405 envelope. Gated by
             # fixtures/api-contract-conformance/projection/.
             if is_read_only_routed(entity):
-                return self._render_readonly_router(entity, column_naming)
+                return self._render_readonly_router(entity, column_naming, wire)
             return None
 
         # FR-017 TPH: a discriminator base emits a polymorphic collection at the base
@@ -1379,7 +1454,7 @@ class RouterGenerator:
         if object_index is not None:
             plan = tph_plan_for(entity, object_index)
             if plan is not None:
-                return self._render_tph_router(entity, plan, object_index, column_naming)
+                return self._render_tph_router(entity, plan, object_index, column_naming, wire)
 
         m2m: list[M2mDescriptor] = (
             resolve_m2m_descriptors(entity, object_index, column_naming)
@@ -1458,7 +1533,8 @@ class RouterGenerator:
         parts.append("    coerce_decimal_fields,")
         parts.append("    coerce_decimal_predicates,")
         parts.append("    parse_json_object,")
-        parts.append("    to_wire,")
+        parts.append("    WireOutput,")
+        parts.append("    render_wire,")
         parts.append(")")
         parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
@@ -1485,6 +1561,8 @@ class RouterGenerator:
         parts.append("")
         parts.append(f"_DECIMAL_FIELDS: frozenset[str] = {decimal_set_body}")
         parts.extend(_decimal_limits_lines([entity]))
+        parts.extend(_wire_lines([entity], wire))
+        parts.extend(_m2m_wire_lines(m2m, object_index or {}, wire))
         parts.append("")
         parts.append("")
         parts.extend(_JSON_BODY_LINES)
@@ -1599,6 +1677,7 @@ class RouterGenerator:
         self,
         entity: MetaObject,
         column_naming: str = DEFAULT_COLUMN_NAMING,
+        wire: WireFormat = WireFormat(),
     ) -> str:
         """Render a read-only (`@kind: view` / `materializedView`) object as a FastAPI
         ``APIRouter``: GET list + GET by id, and the four write verbs answering 405. An
@@ -1663,7 +1742,8 @@ class RouterGenerator:
         parts.append("")
         parts.append(f"from {_runtime_module('decimal_wire')} import (")
         parts.append("    coerce_decimal_predicates,")
-        parts.append("    to_wire,")
+        parts.append("    WireOutput,")
+        parts.append("    render_wire,")
         parts.append(")")
         parts.append(f"from {_runtime_module('filter_parser')} import (")
         parts.append("    FilterPredicate,")
@@ -1682,6 +1762,7 @@ class RouterGenerator:
             "_DECIMAL_FIELDS: frozenset[str] = "
             + _py_set_literal(_decimal_field_names([entity]), frozen=True)
         )
+        parts.extend(_wire_lines([entity], wire))
         parts.append("")
         parts.append("")
         parts.extend(_sort_parse_fn_lines())
@@ -1746,7 +1827,8 @@ class RouterGenerator:
             # reads (`c.config.column_naming`) — so the M:N descriptor built here
             # and the per-field constants built there can't disagree about a
             # column name within one run.
-            source = self.render_router(entity, index, c.config.column_naming)
+            wire = wire_of(c.loaded_root) if c.loaded_root is not None else None
+            source = self.render_router(entity, index, c.config.column_naming, wire)
             if source is None:
                 return []
             snake = _snake_case(entity.name)

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/codegen/runtime/decimal_wire.py

@@ -6,6 +6,8 @@ One production helper, used by the generated routers and tested against the shar
 * **W1, emit** -- :func:`format_decimal` / :func:`to_wire`: every ``Decimal`` leaves as a JSON
   string in canonical form (plain notation, no exponent, no trailing fractional zeros, zero is
   ``"0"``).
+  Which form leaves is the project's ``wire`` setting (:func:`render_wire`): ``string`` is W1,
+  ``native`` is :func:`to_native`.
 * **W2, accept** -- :func:`parse_decimal` (a request-body value) and :func:`parse_decimal_operand`
   (a filter operand): a string in the JSON-number grammar, or a JSON number; anything else is a
   ``ValueError``. Nothing goes through a ``float``: :func:`parse_json_object` reads a body with
@@ -20,7 +22,7 @@ import dataclasses
 import json
 import re
 from decimal import Context, Decimal, InvalidOperation
-from typing import Any, Iterable
+from typing import Any, Callable, Iterable
 
 #: A string body value and a filter operand: the JSON-number grammar. An exponent is allowed on
 #: input only. No sign other than ``-``, no leading zeros, no bare point, no whitespace.
@@ -245,17 +247,81 @@ def coerce_decimal_predicates(
     return out, None
 
 
-def to_wire(value: Any) -> Any:
-    """W1 over a whole response: every ``Decimal`` in *value* (a row, a list of rows, the
-    ``{"rows", "total"}`` envelope, a Pydantic model) as its canonical string. Everything else
-    is left for the framework's encoder."""
+def _render(value: Any, decimal: Callable[[Decimal], str]) -> Any:
+    """*value* with every ``Decimal`` (at any depth of a dict, list or Pydantic model) as the
+    string *decimal* makes of it; everything else is left for the framework's encoder."""
     if isinstance(value, Decimal):
-        return format_decimal(value)
+        return decimal(value)
     if isinstance(value, dict):
-        return {k: to_wire(v) for k, v in value.items()}
+        return {k: _render(v, decimal) for k, v in value.items()}
     if isinstance(value, (list, tuple)):
-        return [to_wire(v) for v in value]
+        return [_render(v, decimal) for v in value]
     dump = getattr(value, "model_dump", None)
     if callable(dump):
-        return to_wire(dump())
+        return _render(dump(), decimal)
     return value
+
+
+def to_wire(value: Any) -> Any:
+    """W1 over a whole response: every ``Decimal`` in *value* (a row, a list of rows, the
+    ``{"rows", "total"}`` envelope, a Pydantic model) as its canonical string."""
+    return _render(value, format_decimal)
+
+
+def to_native(value: Any) -> Any:
+    """The ``native`` decimal form over a whole response: every ``Decimal`` as ``str(value)``,
+    which is what Pydantic v2 writes for one and keeps the value's scale (``Decimal("12.50")``
+    is ``"12.50"``). FastAPI's own encoder would turn a ``Decimal`` in a plain dict row into a
+    ``float``, which is lossy; a string is the exact form."""
+    return _render(value, str)
+
+
+@dataclasses.dataclass(frozen=True)
+class WireOutput:
+    """The ``wire`` project setting (ADR-0019 Amendment 2) a generated router writes with.
+
+    *decimals* is ``native`` or ``string``; *null_members* is ``native``, ``emit`` or ``omit``.
+    *shapes* names, per value-object field of the entity, its declared members:
+    ``{"f": [member, ...], "o": {member: shape}}``, or ``{"m": shape}`` for a ``field.map`` of
+    value objects (the shape applies to each value)."""
+
+    decimals: str = "native"
+    null_members: str = "native"
+    shapes: dict[str, Any] = dataclasses.field(default_factory=dict)
+
+
+def render_wire(value: Any, wire: WireOutput) -> Any:
+    """A response *value* (a row, a list of rows, a Pydantic model) in the form *wire* asks
+    for. Input rules do not depend on *wire*."""
+    if wire.null_members != "native" and wire.shapes:
+        value = _shape_members(value, wire)
+    return to_wire(value) if wire.decimals == "string" else to_native(value)
+
+
+def _shape_members(value: Any, wire: WireOutput) -> Any:
+    """Apply ``omit`` / ``emit`` to the value-object fields of every row in *value*. A row's
+    other fields (a top-level ``null`` among them) are untouched."""
+    if isinstance(value, (list, tuple)):
+        return [_shape_members(v, wire) for v in value]
+    dump = getattr(value, "model_dump", None)
+    if callable(dump):
+        value = dump()
+    if not isinstance(value, dict):
+        return value
+    out: dict[str, Any] = {}
+    for k, v in value.items():
+        out[k] = _shape_vo(v, wire.shapes[k], wire.null_members) if k in wire.shapes else v
+    return out
+
+
+def _shape_vo(value: Any, shape: dict[str, Any], mode: str) -> Any:
+    if isinstance(value, list):
+        return [_shape_vo(v, shape, mode) for v in value]
+    if not isinstance(value, dict):
+        return value
+    if "m" in shape:
+        return {k: _shape_vo(v, shape["m"], mode) for k, v in value.items()}
+    members = {k: _shape_vo(v, shape["o"][k], mode) if k in shape["o"] else v for k, v in value.items()}
+    if mode == "omit":
+        return {k: v for k, v in members.items() if v is not None}
+    return {**{name: None for name in shape["f"]}, **members}

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/config/dependencies.py

@@ -17,6 +17,7 @@ from typing import Any, Callable, Sequence
 from metaobjects.errors import ErrorCode, ParseError
 from metaobjects.meta.meta_data import MetaData
 from metaobjects.naming import NamingRules, package_of_resolution_key
+from metaobjects.wire import WireFormat
 from metaobjects.registry_manifest import METAMODEL_VERSION
 from metaobjects.shared.base_types import TYPE_OBJECT
 
@@ -659,6 +660,10 @@ class Collection:
     #: codegen, the runtime and `verify` all read the same values.
     naming: NamingRules
 
+    #: ADR-0019 Amendment 2 — this project's `wire` setting, read at the same rung;
+    #: attached to the loaded root beside `naming`.
+    wire: WireFormat = WireFormat()
+
     def imported(self, fqn: str) -> bool:
         """Is `fqn` in a package one of this project's dependencies owns?"""
         return package_of_resolution_key(fqn) in self.imported_packages

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/config/neutral_config.py

@@ -7,6 +7,7 @@ from pathlib import Path
 
 from metaobjects.errors import ErrorCode, ParseError
 from metaobjects.naming import COLUMN_NAMING_STRATEGIES, TABLE_NAMING_RULES, NamingRules
+from metaobjects.wire import WIRE_DECIMALS, WIRE_NULL_MEMBERS, WireFormat
 
 #: The DEFAULT value of `sources` when the key is absent or empty — never a
 #: requirement, and never assumed to exist by any other code path.
@@ -75,6 +76,12 @@ class NeutralConfig:
     #: every column.
     naming: NamingRules
 
+    #: ADR-0019 Amendment 2 — the `wire` block: the OUTPUT form of a generated REST
+    #: surface (decimals, value-object null members). Absent or `{}` ⇒ `native` for both.
+    #: Attached to the loaded root (`MetaRoot.wire`) beside `naming`; validated HERE
+    #: for the same reason `naming` is.
+    wire: WireFormat = WireFormat()
+
 
 def find_project_dir(start: Path) -> Path | None:
     """The nearest directory at or above *start* that holds ``.metaobjects/config.json``,
@@ -167,6 +174,7 @@ def read_neutral_config(config_dir: Path) -> NeutralConfig | None:
     migrate_scope = _read_migrate_scope(raw, path)
     libraries = _read_libraries(raw, path)
     naming = _read_naming(raw, path)
+    wire = _read_wire(raw, path)
 
     # Unknown top-level keys are IGNORED by design — see the module docstring.
     return NeutralConfig(
@@ -176,6 +184,7 @@ def read_neutral_config(config_dir: Path) -> NeutralConfig | None:
         migrate_scope=migrate_scope,
         libraries=libraries,
         naming=naming,
+        wire=wire,
     )
 
 
@@ -296,6 +305,39 @@ def _read_naming(raw: dict[str, object], path: Path) -> NamingRules:
     return NamingRules(columns=columns, tables=tables)
 
 
+#: Every key the `wire` block accepts, and the ONLY ones it accepts (refused, not ignored, like `naming`).
+_WIRE_KEYS = ("decimals", "nullMembers")
+
+
+def _read_wire(raw: dict[str, object], path: Path) -> WireFormat:
+    """ADR-0019 Amendment 2 — the `wire` block. Absent or `{}` ⇒ `native` for both keys.
+    Refuses a non-object `wire`, an unknown key, or a value outside the closed set a key
+    accepts: a mistake must not silently fall back to the default and change the JSON an
+    API writes."""
+    if "wire" not in raw:
+        return WireFormat()
+    wire = raw["wire"]
+    if not isinstance(wire, dict):
+        raise ParseError(f'{path}: "wire" must be an object', code=ErrorCode.ERR_COLLECTION_NOT_FOUND)
+    for key in wire:
+        if key not in _WIRE_KEYS:
+            raise ParseError(
+                f'{path}: "wire" has an unknown key "{key}" (expected "decimals" and/or "nullMembers")',
+                code=ErrorCode.ERR_COLLECTION_NOT_FOUND,
+            )
+    values: dict[str, str] = {}
+    for key, allowed in (("decimals", WIRE_DECIMALS), ("nullMembers", WIRE_NULL_MEMBERS)):
+        value = wire.get(key, allowed[0])
+        if not isinstance(value, str) or value not in allowed:
+            choices = ", ".join(f'"{a}"' for a in allowed)
+            raise ParseError(
+                f'{path}: "wire.{key}" must be one of {choices}, got {json.dumps(value)}',
+                code=ErrorCode.ERR_COLLECTION_NOT_FOUND,
+            )
+        values[key] = value
+    return WireFormat(decimals=values["decimals"], null_members=values["nullMembers"])
+
+
 def _validate_dependency_spec(dep: object, path: Path) -> dict[str, str]:
     """Validate one entry of `dependencies` (DESIGN §3.1) and return it
     normalized. Mirrors the TS `DependencySpecSchema` union in

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/config/source_resolver.py

@@ -7,6 +7,7 @@ from typing import Callable
 from metaobjects.errors import ErrorCode, ParseError
 from metaobjects.loader.sources import DirectorySource
 from metaobjects.naming import NamingRules, package_of_resolution_key
+from metaobjects.wire import WireFormat
 from metaobjects.scope import compile_scope, matches_scope
 
 from .dependencies import (
@@ -155,6 +156,7 @@ def _collection_from_own_files(
     migrate_scope: list[str] | None = cfg.migrate_scope if cfg is not None else None
     libraries: list[str] = cfg.libraries if cfg is not None else []
     naming: NamingRules = cfg.naming if cfg is not None else NamingRules()
+    wire: WireFormat = cfg.wire if cfg is not None else WireFormat()
 
     lock = read_lock(root)
     dependencies: list[ResolvedDependency] = (
@@ -185,6 +187,7 @@ def _collection_from_own_files(
         ),
         libraries=tuple(libraries),
         naming=naming,
+        wire=wire,
     )
 
 

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/loader/meta_data_loader.py

@@ -59,10 +59,12 @@ def _apply_discovered_naming(result: "LoadResult", start: Path) -> None:
     *start*) to the loaded root; warn once when there is none and the default applies."""
     from ..config.neutral_config import find_project_dir
     from ..naming import attach_naming
+    from ..wire import attach_wire
 
     project = find_project_dir(start if start.is_dir() else start.parent)
     if project is not None:
         attach_naming(result.root, project)
+        attach_wire(result.root, project)
         return
     warnings.warn(
         f"no .metaobjects/config.json found at or above {start}: physical names use the "

{metaobjects-1.1.1 → metaobjects-1.1.2}/src/metaobjects/meta/meta_root.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 from ..naming import NamingRules
+from ..wire import WireFormat
 from .meta_data import MetaData
 
 
@@ -16,3 +17,7 @@ class MetaRoot(MetaData):
         # after loading — never during construction, since the loader seeds an empty
         # root before any file is read.
         self.naming: NamingRules = NamingRules()
+        # ADR-0019 Amendment 2 — the project `wire` setting (output form of the generated
+        # REST surface), attached by the same project-aware loads as `naming`; read with
+        # `wire_of()`. `native` for both keys until a load attaches the project's own.
+        self.wire: WireFormat = WireFormat()