metaobjects 1.1.1__tar.gz → 1.1.3__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.1.1"
+version = "1.1.3"
 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.3}/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.3}/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()) + "}"
@@ -599,6 +658,12 @@ def _auth_docstring_paragraph(*, read_only: bool) -> str:
     )
 
 
+#: The most rows a report list answers when no cap is configured, the same default in every
+#: port. With no ``limit`` a report answers every row up to the cap and is refused above it,
+#: never truncated.
+DEFAULT_REPORT_MAX_ROWS = 10_000
+
+
 class RouterGenerator:
     """One ``<entity_snake>_router.py`` per routed object (FastAPI ``APIRouter``):
     full CRUD for a writable source, read-only for a view-backed one.
@@ -630,6 +695,13 @@ class RouterGenerator:
 
     name = "router-generator"
 
+    def __init__(self, report_max_rows: int = DEFAULT_REPORT_MAX_ROWS) -> None:
+        """*report_max_rows* is the row cap of a served report's list route: with no ``limit``
+        the route answers every row up to it, and one more row (or a ``limit`` above it) is
+        ``400 {"error": "report_too_large", "maxRows": N}``. Reports only; an entity's list
+        keeps its paging."""
+        self.report_max_rows = report_max_rows
+
     def _emit_repository_protocol(
         self, repo_class: str, m2m: list[M2mDescriptor], pk_type: str
     ) -> list[str]:
@@ -699,12 +771,81 @@ class RouterGenerator:
         create_autoset: list[str] = (),
         update_autoset: list[str] = (),
         frozen_strip: list[str] = (),
+        report_max_rows: int | None = None,
     ) -> list[str]:
         """One CRUD route handler block, dispatched by *name*
         (``list`` / ``get`` / ``create`` / ``update`` / ``delete``). Override to
         change a handler's body / decorators / response shape. *model_name* /
         *patch_model* are the generated create + all-optional PATCH Pydantic models
-        used to run field constraints on POST / PATCH (FR-036)."""
+        used to run field constraints on POST / PATCH (FR-036). *report_max_rows* is
+        passed only for a served report's ``list``: every row up to that cap, refused above it."""
+        if name == "list" and report_max_rows is not None:
+            return [
+                '@router.get("")',
+                f"def list_{plural}(",
+                "    request: Request,",
+                f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
+                "    limit: str | None = Query(None),",
+                "    offset: str | None = Query(None),",
+                "    sort: str | None = Query(None),",
+                '    with_count: int | None = Query(None, alias="withCount"),',
+                ") -> Any:",
+                f"    max_rows = {report_max_rows}",
+                "    too_large = JSONResponse(",
+                '        status_code=400, content={"error": "report_too_large", "maxRows": max_rows}',
+                "    )",
+                "    requested_limit: int | None = None",
+                "    if limit is not None:",
+                "        if not (limit.isascii() and limit.isdigit()) or int(limit) < 1:",
+                "            return JSONResponse(",
+                "                status_code=400,",
+                "                content={",
+                '                    "error": "pagination.invalid_value",',
+                '                    "param": "limit",',
+                '                    "value": limit,',
+                '                    "expected": f"an integer from 1 to {max_rows}",',
+                "                },",
+                "            )",
+                "        requested_limit = int(limit)",
+                "        if requested_limit > max_rows:",
+                "            return too_large",
+                "    actual_offset = 0",
+                "    if offset is not None:",
+                "        if not (offset.isascii() and offset.isdigit()):",
+                "            return JSONResponse(",
+                "                status_code=400,",
+                "                content={",
+                '                    "error": "pagination.invalid_value",',
+                '                    "param": "offset",',
+                '                    "value": offset,',
+                '                    "expected": "a non-negative integer (0 or more)",',
+                "                },",
+                "            )",
+                "        actual_offset = int(offset)",
+                "    sort_clause: _SortClause | None = None",
+                "    if sort is not None:",
+                "        sort_clause = _parse_sort(sort)",
+                "        if sort_clause is None:",
+                '            return JSONResponse(status_code=400, content={"error": "invalid_sort", "field": sort.split(":", 1)[0]})',
+                f"    filter_result = parse_filter(request.query_params, {fields_const}, {ops_const})",
+                "    if filter_result.error_envelope is not None:",
+                "        return JSONResponse(status_code=400, content=filter_result.error_envelope)",
+                "    predicates, decimal_error = coerce_decimal_predicates(",
+                "        filter_result.predicates, _DECIMAL_FIELDS",
+                "    )",
+                "    if decimal_error is not None:",
+                "        return JSONResponse(status_code=400, content=decimal_error)",
+                "    # With no limit the repository is asked for one row past the cap, so the",
+                "    # refusal comes before any body is written.",
+                "    fetch_limit = requested_limit if requested_limit is not None else max_rows + 1",
+                "    rows = repo.list(fetch_limit, actual_offset, sort_clause, predicates)",
+                "    if requested_limit is None and len(rows) > max_rows:",
+                "        return too_large",
+                "    if with_count == 1:",
+                "        total = repo.count(predicates)",
+                '        return {"rows": render_wire(rows, _WIRE), "total": total}',
+                "    return render_wire(rows, _WIRE)",
+            ]
         if name == "list":
             return [
                 '@router.get("")',
@@ -734,8 +875,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 +888,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 +909,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 +944,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 +977,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 +1035,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 +1066,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 +1076,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 +1234,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 +1261,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 +1358,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 +1370,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 +1399,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 +1449,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 +1477,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 +1494,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 +1507,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 +1528,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 +1536,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 +1615,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 +1643,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 +1759,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 +1824,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 +1844,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())
@@ -1722,6 +1885,9 @@ class RouterGenerator:
             # handlers do not read these; they are required by the shared signature.
             model_name="",
             patch_model="",
+            # Only a report is capped; passed for it alone so an adopter's `_emit_route_handler`
+            # override that does not take the keyword keeps working for a projection.
+            **({"report_max_rows": self.report_max_rows} if is_report else {}),
         )
         for i, hname in enumerate(("list", "get") if item_route else ("list",)):
             if i > 0:
@@ -1746,7 +1912,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)
@@ -1774,11 +1941,12 @@ def render_router(
     return RouterGenerator().render_router(entity, object_index, column_naming)
 
 
-def router_generator() -> Generator:
+def router_generator(report_max_rows: int = DEFAULT_REPORT_MAX_ROWS) -> Generator:
     """Generator factory: one ``<entity_snake>_router.py`` per routed object —
-    full CRUD for a writable source, read-only for a view-backed one.
+    full CRUD for a writable source, read-only for a view-backed one. *report_max_rows*
+    is the row cap of a served report's list route (default 10000).
 
     Returns a :class:`RouterGenerator` (subclassable extension seam). Skips objects
     without a ``source.rdb`` child and the non-collection read-only kinds
     (storedProc / tableFunction)."""
-    return RouterGenerator()
+    return RouterGenerator(report_max_rows)

{metaobjects-1.1.1 → metaobjects-1.1.3}/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.3}/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