metaobjects 0.15.13__tar.gz → 0.16.0__tar.gz

{metaobjects-0.15.13 → metaobjects-0.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.15.13
+Version: 0.16.0
 Summary: Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port.
 Project-URL: Homepage, https://metaobjects.dev
 Project-URL: Repository, https://github.com/metaobjectsdev/metaobjects

{metaobjects-0.15.13 → metaobjects-0.16.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.15.13"
+version = "0.16.0"
 description = "Cross-language metadata standard: declare typed entities once, generate idiomatic drift-checked code across languages — Python port."
 readme = "README.md"
 requires-python = ">=3.11"

{metaobjects-0.15.13 → metaobjects-0.16.0}/src/metaobjects/codegen/KNOWN_GAPS.md

@@ -32,6 +32,14 @@ The generated router takes `dto: dict[str, Any]` for `POST` / `PATCH` /
 `PUT` request bodies and returns `Any` for responses. The repository
 `Protocol` likewise uses `Any` for the row type.
 
+**FR-036 update:** the router now DOES import the generated Pydantic models
+(`from .<Entity> import <Entity>, <Entity>Patch`) and constructs them to enforce
+field constraints over HTTP — POST validates `<Entity>(**dto)`, PATCH validates
+the all-optional `<Entity>Patch(**dto)` (present values only) → `400 {"error":"validation"}`.
+The repository seam still receives the original `dict` (preserving the FR-035
+present-key tristate + wire values), so the strong-typing simplification below
+remains for the repo/response types; only the validation import was added.
+
 This keeps the router module decoupled from sibling generated files
 (the entity-model generator emits one `@dataclass`/Pydantic model per
 entity in a separate file — wiring router→entity-model would require

{metaobjects-0.15.13 → metaobjects-0.16.0}/src/metaobjects/codegen/generators/entity_model.py

@@ -5,7 +5,14 @@ import re
 
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.meta.core.object.object_constants import OBJECT_SUBTYPE_ENTITY
 from metaobjects.meta.core.field import field_constants as fc
+from metaobjects.meta.core.identity.identity_constants import (
+    GENERATION_INCREMENT,
+    GENERATION_UUID,
+    IDENTITY_ATTR_FIELDS,
+    IDENTITY_ATTR_GENERATION,
+)
 from metaobjects.meta.core.validator import validator_constants as vc
 from metaobjects.shared.base_types import TYPE_VALIDATOR
 from metaobjects.shared.separators import PACKAGE_SEP
@@ -98,7 +105,10 @@ def _validator_constraints(field: MetaField) -> dict[str, object]:
     max_len = _first_attr(field, vc.VALIDATOR_SUBTYPE_LENGTH, vc.VALIDATOR_ATTR_MAX)
     field_max = field.attrs().get(fc.FIELD_ATTR_MAX_LENGTH)
     if _is_int(field_max):
-        max_len = field_max
+        # FR-036 A3 — strictest-wins: when BOTH a validator.length @max and a field
+        # @maxLength cap a string, the smaller bound governs (never the field attr
+        # unconditionally, which could loosen a tighter validator).
+        max_len = field_max if max_len is None else min(max_len, field_max)
     if min_len is not None:
         kwargs["min_length"] = min_len
     if max_len is not None:
@@ -127,7 +137,11 @@ def _validator_constraints(field: MetaField) -> dict[str, object]:
         # located via the resolving field.children() in _validators().
         pattern = v.attr(vc.VALIDATOR_ATTR_PATTERN)
         if isinstance(pattern, str):
-            kwargs["pattern"] = pattern
+            # FR-036 Pin 2 — a validator.regex is a FULL match. Pydantic v2 `pattern=`
+            # is search/partial (un-anchored), so wrap the authored expression in an
+            # anchored non-capturing group so alternation still spans the whole value
+            # (a redundant anchor on an already-anchored pattern matches identically).
+            kwargs["pattern"] = f"^(?:{pattern})$"
             break
 
     # ADR-0036/0037 Wave 3 — @stringFormat: hostname -> a codegen-owned canonical
@@ -137,60 +151,87 @@ def _validator_constraints(field: MetaField) -> dict[str, object]:
     if field.attrs().get(fc.FIELD_ATTR_STRING_FORMAT) == fc.STRING_FORMAT_HOSTNAME:
         kwargs["pattern"] = _HOSTNAME_REGEX
 
+    # FR-036 Pin 1 — a @required non-array string is non-empty: reject null / "" but
+    # ACCEPT whitespace-only. Emit an implicit min_length of 1, keeping the stricter
+    # floor if a validator.length @min already set one.
+    if (
+        field.sub_type == fc.FIELD_SUBTYPE_STRING
+        and not field_is_array(field)
+        and field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
+    ):
+        existing_min = kwargs.get("min_length")
+        kwargs["min_length"] = max(1, existing_min) if isinstance(existing_min, int) else 1
+
     return kwargs
 
 
-def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple[str, bool]:
-    """Return (source line, uses_field). Collects required imports into *imports*."""
-    # FR-019: a field resolving to a package-level shared enum is typed by the materialized
-    # standalone class (imported from the shared `enums` module) or — when @provided — an
-    # external module from per-port config; inline enums keep their `Literal[...]` (py_type_for).
+# Constraint kwargs are emitted in this fixed order so generated output is deterministic.
+_CONSTRAINT_ORDER = ("pattern", "ge", "le", "min_length", "max_length")
+
+
+def _constraint_parts(constraints: dict[str, object]) -> list[str]:
+    """The ``Field(...)`` constraint kwargs rendered in the stable, deterministic order."""
+    return [f"{k}={constraints[k]!r}" for k in _CONSTRAINT_ORDER if k in constraints]
+
+
+def _type_expr_for_field(
+    field: MetaField, imports: set[str], config: GenConfig
+) -> tuple[str, str | None]:
+    """The Python annotation text for *field* (arrays wrapped in ``list[...]``) plus the
+    shared-enum class name when the field resolves to one (used to render an enum
+    default). Collects any required imports into *imports*. Shared by the create-model
+    and patch-model emitters so both carry byte-identical typing.
+
+    FR-019: a field resolving to a package-level shared enum is typed by the materialized
+    standalone class (imported from the shared ``enums`` module) or — when @provided — an
+    external module; inline enums keep their ``Literal[...]`` (py_type_for)."""
     shared = (
         fr019.shared_enum_for_field(field)
         if field.sub_type == fc.FIELD_SUBTYPE_ENUM
         else None
     )
+    enum_type_name: str | None = None
     if shared is not None:
         type_name, import_line = fr019.enum_type_and_import(shared, config)
         imports.add(import_line)
+        enum_type_name = type_name
         type_expr = f"list[{type_name}]" if field_is_array(field) else type_name
     else:
         pt = py_type_for(field)
         imports.update(pt.imports)
         type_expr = pt.expr
-    # ADR-0036/0037 Wave 3 — @stringFormat: email narrows a plain string to a
-    # validated email. Bind Pydantic's idiomatic EmailStr (the Python analogue of
-    # Zod .email()); hostname stays a plain str with a codegen-owned canonical
-    # pattern= (handled in _validator_constraints). The field stays a string.
+    # ADR-0036/0037 Wave 3 — @stringFormat: email narrows a plain string to a validated
+    # email (Pydantic EmailStr, the Python analogue of Zod .email()); hostname stays a
+    # plain str with a codegen-owned canonical pattern= (in _validator_constraints).
     if (
         field.sub_type == fc.FIELD_SUBTYPE_STRING
         and field.attrs().get(fc.FIELD_ATTR_STRING_FORMAT) == fc.STRING_FORMAT_EMAIL
     ):
-        base_expr = "EmailStr"
         imports.add("from pydantic import EmailStr")
-        type_expr = f"list[{base_expr}]" if field_is_array(field) else base_expr
+        type_expr = "list[EmailStr]" if field_is_array(field) else "EmailStr"
     if field.sub_type in (fc.FIELD_SUBTYPE_OBJECT, fc.FIELD_SUBTYPE_MAP):
-        # A field.object (-> VO) and a field.map with @objectRef (-> dict[str, VO])
-        # both reference a value-object by name; import it so the annotation
-        # py_type_for emitted resolves.
+        # A field.object (-> VO) and a field.map with @objectRef (-> dict[str, VO]) both
+        # reference a value-object by name; import it so the emitted annotation resolves.
+        # @objectRef is FQN-expanded at load; the generated VOs live flat in one package,
+        # so import by the bare class name.
         ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
         if ref:
-            # @objectRef is FQN-expanded at load time; the generated VOs live
-            # flat in one package, so import by the bare class name.
             ref_name = str(ref).split("::")[-1]
             imports.add(f"from .{ref_name} import {ref_name}")
+    return type_expr, enum_type_name
+
+
+def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple[str, bool]:
+    """Return (source line, uses_field). Collects required imports into *imports*."""
+    type_expr, enum_type_name = _type_expr_for_field(field, imports, config)
     required = field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
     default_raw = field.attrs().get(fc.FIELD_ATTR_DEFAULT)
     # A server-side expression default (now(), gen_random_uuid(), CURRENT_TIMESTAMP)
     # is filled by the DB — the Python model carries no default for it (the field keeps
     # its required/optional shape). Only literal defaults become Pydantic defaults.
     has_default = default_raw is not None and not _is_sql_expr_default(default_raw)
-    enum_type_name = type_name if shared is not None else None
 
-    constraints = _validator_constraints(field)
-    # Emit kwargs in a stable order so generated output is deterministic.
-    _order = ["pattern", "ge", "le", "min_length", "max_length"]
-    parts = [f"{k}={constraints[k]!r}" for k in _order if k in constraints]
+    parts = _constraint_parts(_validator_constraints(field))
     uses_field = bool(parts)
 
     # @default — render an enum member (Type.MEMBER, UPPER_CASE) or a Python literal.
@@ -226,6 +267,106 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
     return f"    {py_name}: {annotation}{assignment}", uses_field
 
 
+def _primary_identity_field_names(entity: MetaObject) -> list[str]:
+    """The field names in the entity's primary identity (``identity.primary @fields``),
+    normalized to a list. Empty when there is no primary identity. Mirrors the TS
+    ``primaryIdentityFieldNames``."""
+    primary = entity.primary_identity()
+    if primary is None:
+        return []
+    # ADR-0039: resolving (identity attr) — an identity.primary may be inherited via extends.
+    fields = primary.get_meta_attr(IDENTITY_ATTR_FIELDS)
+    if isinstance(fields, (list, tuple)):
+        return [str(f) for f in fields]
+    if isinstance(fields, str) and fields:
+        return [s.strip() for s in fields.split(",") if s.strip()]
+    return []
+
+
+def _auto_gen_pk_field_names(entity: MetaObject) -> set[str]:
+    """Primary-key field names that the SERVER generates (``identity.primary
+    @generation: increment|uuid``) — excluded from the create-validation shape because
+    the caller never supplies them. An ``assigned`` (or ungenerated) PK is NOT excluded
+    (the caller provides it). Mirrors the TS ``autoGenPkFieldNames``."""
+    primary = entity.primary_identity()
+    if primary is None:
+        return set()
+    # ADR-0039: resolving (identity attr).
+    generation = primary.get_meta_attr(IDENTITY_ATTR_GENERATION)
+    if generation not in (GENERATION_INCREMENT, GENERATION_UUID):
+        return set()
+    return set(_primary_identity_field_names(entity))
+
+
+def _create_field_line(
+    field: MetaField, imports: set[str], config: GenConfig
+) -> tuple[str, bool]:
+    """A CREATE-model field line (FR-036): keyed by the WIRE name (``field.name``) and
+    carrying the same per-field constraints as the read model. A ``@required`` field
+    that is SERVER-FILLED — it has ANY ``@default`` (a literal OR a SQL expression such
+    as ``now()`` / ``gen_random_uuid()`` / ``CURRENT_TIMESTAMP``) or an ``@autoSet`` — is
+    emitted OPTIONAL, because the DB / trigger provides it and a POST that omits it must
+    not 400 (mirrors the TS InsertSchema ``fieldWillBeOptional``). A literal ``@default``
+    is preserved as the Python default; a SQL-expression default / ``@autoSet`` carries
+    no Python default (the server fills it). Returns (source line, uses_field)."""
+    type_expr, enum_type_name = _type_expr_for_field(field, imports, config)
+    required = field.attrs().get(fc.FIELD_ATTR_REQUIRED) is True
+    default_raw = field.attrs().get(fc.FIELD_ATTR_DEFAULT)
+    literal_default = default_raw is not None and not _is_sql_expr_default(default_raw)
+    auto_set = field.attrs().get(fc.FIELD_ATTR_AUTO_SET)
+    is_auto_set = auto_set in (fc.AUTO_SET_ON_CREATE, fc.AUTO_SET_ON_UPDATE)
+    # A field is required in the CREATE shape only when @required AND not server-filled:
+    # ANY @default (literal or SQL-expr) or @autoSet means the DB fills it, so the wire
+    # body may omit it (the FR-036 #1 regression fix).
+    server_filled = default_raw is not None or is_auto_set
+    create_required = required and not server_filled
+
+    parts = _constraint_parts(_validator_constraints(field))
+    uses_field = bool(parts)
+
+    py_name = field.name  # FR-036 #3 — validation models key by the WIRE name (field.name)
+
+    if literal_default:
+        # Preserve the literal @default (enum member or Python literal) exactly as the
+        # read model does — the caller may omit the field and the model fills the default.
+        if enum_type_name is not None and not field_is_array(field):
+            default_expr = f"{enum_type_name}.{str(default_raw).upper()}"
+        else:
+            default_expr = repr(default_raw)
+        annotation = type_expr
+        assignment = (
+            f" = Field(default={default_expr}, {', '.join(parts)})"
+            if uses_field
+            else f" = {default_expr}"
+        )
+    elif create_required:
+        annotation = type_expr
+        assignment = f" = Field({', '.join(parts)})" if uses_field else ""
+    else:
+        annotation = f"{type_expr} | None"
+        assignment = (
+            f" = Field(default=None, {', '.join(parts)})" if uses_field else " = None"
+        )
+
+    return f"    {py_name}: {annotation}{assignment}", uses_field
+
+
+def _patch_field_line(
+    field: MetaField, imports: set[str], config: GenConfig
+) -> tuple[str, bool]:
+    """A PATCH-model field line: the field is made Optional (default ``None``) yet
+    carries the SAME per-field constraints as the create model, so a present, non-null
+    value is validated with the create rules (FR-036) while an absent field is left
+    untouched. A ``@default`` is never emitted (a patch does not default a column).
+    Returns (source line, uses_field)."""
+    type_expr, _enum = _type_expr_for_field(field, imports, config)
+    parts = _constraint_parts(_validator_constraints(field))
+    py_name = field.name  # FR-036 #3 — validation models key by the WIRE name (field.name)
+    if parts:
+        return f"    {py_name}: {type_expr} | None = Field(default=None, {', '.join(parts)})", True
+    return f"    {py_name}: {type_expr} | None = None", False
+
+
 def _effective_fqn(entity: MetaObject) -> str:
     """`package::name` via the canonical :meth:`MetaData.resolution_key` — own
     package, else the file-default package (captured at parse), else the nearest
@@ -295,6 +436,76 @@ class EntityModelGenerator:
                 lines.append(f"    {d.relation_name}: list[{element}] = []")
         return lines, uses_field
 
+    def _emit_create_lines(
+        self,
+        entity: MetaObject,
+        imports: set[str],
+        config: GenConfig | None = None,
+    ) -> tuple[list[str], bool]:
+        """The ``<Name>Create`` body — the CREATE-validation shape the generated router
+        validates a POST body against (FR-036). Restates every EFFECTIVE field (own +
+        inherited via ``extends``) EXCEPT the ones the server owns: an auto-generated PK
+        (``identity.primary @generation``; FR-036 #2) and any ``@readOnly`` field
+        (FR-013) are omitted, and a ``@required`` server-filled field (``@default`` /
+        ``@autoSet``; FR-036 #1) is made optional. Keyed by the wire name; a TPH
+        subtype's discriminator is pinned to its ``Literal`` value (the route injects it
+        from the URL, so it stays optional with a default). M:N navigations are omitted
+        (a create body targets columns, not relations). Returns ``(lines, uses_field)``.
+        Override to add/transform create-model lines."""
+        cfg = config if config is not None else GenConfig(out_dir="")
+        auto_gen_pk = _auto_gen_pk_field_names(entity)
+        binding = tph_subtype_binding(entity)
+        disc_field = binding[0] if binding is not None else None
+        uses_field = False
+        lines: list[str] = []
+        # RESOLVING (fields()): the flat Create model subclasses BaseModel (not the entity
+        # base), so it restates inherited fields too — unlike the read model's own_fields
+        # subclass-emit.
+        for f in entity.fields():
+            if disc_field is not None and f.name == disc_field:
+                continue  # pinned below (prepended), never as a normal field line
+            if f.name in auto_gen_pk:
+                continue  # FR-036 #2 — a server-generated PK is never in the create body
+            if f.attrs().get(fc.FIELD_ATTR_READ_ONLY) is True:
+                continue  # FR-013 — a read-only column is DB/owner-written, not create input
+            line, used = _create_field_line(f, imports, cfg)
+            uses_field = uses_field or used
+            lines.append(line)
+        # FR-017 TPH: pin the inherited discriminator to this subtype's value (with a
+        # default so the URL-injected create body may omit it) — mirrors the read model.
+        if binding is not None:
+            disc_name, disc_value = binding
+            lines = [f'    {disc_name}: Literal["{disc_value}"] = "{disc_value}"', *lines]
+            imports.add("from typing import Literal")
+        return lines, uses_field
+
+    def _emit_patch_lines(
+        self,
+        entity: MetaObject,
+        imports: set[str],
+        config: GenConfig | None = None,
+    ) -> tuple[list[str], bool]:
+        """The ``<Name>Patch`` body: every EFFECTIVE field (own + inherited via
+        ``extends``) made Optional while retaining its create-model constraints, so the
+        generated PATCH handler can validate present, non-null values without
+        bean-validating absent ones (FR-036). The primary-key field(s) are excluded
+        (route-authoritative; FR-036 #4) and M:N navigations are omitted (a patch
+        targets columns, not relations). Returns ``(lines, uses_field)``. Override to
+        add/transform patch-model lines."""
+        cfg = config if config is not None else GenConfig(out_dir="")
+        pk_fields = set(_primary_identity_field_names(entity))
+        uses_field = False
+        lines: list[str] = []
+        # RESOLVING (fields()): the flat Patch model is self-contained (subclasses
+        # BaseModel, not the entity base), so it restates inherited fields too.
+        for f in entity.fields():
+            if f.name in pk_fields:
+                continue  # FR-036 #4 — the PK is route-authoritative, never patched
+            line, used = _patch_field_line(f, imports, cfg)
+            uses_field = uses_field or used
+            lines.append(line)
+        return lines, uses_field
+
     def render_entity_model(
         self,
         entity: MetaObject,
@@ -333,11 +544,29 @@ class EntityModelGenerator:
             imports.add("from typing import Literal")
         body = lines if lines else ["    pass"]
 
-        # Import only the pydantic names actually referenced.
+        # FR-036 — an object.entity also emits two flat validation models the generated
+        # router binds: a ``<Name>Create`` (POST-body shape: auto-gen PK / @readOnly
+        # omitted, @default/@autoSet optional, other @required required) and an
+        # all-optional ``<Name>Patch`` (PATCH-body shape: PK excluded). Both key by the
+        # WIRE name and carry the field constraints, so present values are validated with
+        # the create rules. Value objects / projections are never routed, so they emit
+        # neither (only the read model). See findings #1–#4.
+        emit_validation_models = entity.sub_type == OBJECT_SUBTYPE_ENTITY
+        create_lines: list[str] = []
+        create_uses_field = False
+        patch_lines: list[str] = []
+        patch_uses_field = False
+        if emit_validation_models:
+            create_lines, create_uses_field = self._emit_create_lines(entity, imports, config)
+            patch_lines, patch_uses_field = self._emit_patch_lines(entity, imports, config)
+
+        # Import only the pydantic names actually referenced. The main model imports
+        # BaseModel only when it has no super, but the flat Create/Patch models always
+        # subclass BaseModel, so their presence forces the import regardless.
         pyd_names: list[str] = []
-        if entity.super_data is None:
+        if entity.super_data is None or emit_validation_models:
             pyd_names.append("BaseModel")
-        if uses_field:
+        if uses_field or create_uses_field or patch_uses_field:
             pyd_names.append("Field")
 
         parts: list[str] = [
@@ -350,7 +579,22 @@ class EntityModelGenerator:
             parts += [*extra_imports, ""]
         if pyd_names:
             parts += [f"from pydantic import {', '.join(pyd_names)}", ""]
-        parts += ["", self._emit_class_header(entity, base_class), *body, ""]
+        parts += ["", self._emit_class_header(entity, base_class), *body]
+        if emit_validation_models:
+            parts += [
+                "",
+                "",
+                f"class {entity.name}Create(BaseModel):",
+                '    """GENERATED — CREATE input: auto-gen PK / @readOnly omitted; '
+                '@default/@autoSet optional; present values validated (FR-036)."""',
+                *create_lines,
+                "",
+                "",
+                f"class {entity.name}Patch(BaseModel):",
+                '    """GENERATED — PATCH input: all fields optional (PK excluded); present values validated (FR-036)."""',
+                *patch_lines,
+            ]
+        parts += [""]
         return "\n".join(parts)
 
     def _render_shared_enums_module(self, entities: list[MetaObject]) -> EmittedFile | None:

{metaobjects-0.15.13 → metaobjects-0.16.0}/src/metaobjects/codegen/generators/router_generator.py

@@ -39,6 +39,7 @@ from metaobjects.apidocs.naming import reverse_finder_fn, reverse_finder_in_fn
 from metaobjects.apidocs.naming import snake_case as _snake_case
 from metaobjects.codegen.constants import generated_header
 from metaobjects.codegen.format import ruff_format
+from metaobjects.codegen.fr010_field_mapping import is_required
 from metaobjects.codegen.generator import EmittedFile, GenContext, Generator, per_entity
 from metaobjects.codegen.generators.m2m_codegen import (
     M2mDescriptor,
@@ -89,6 +90,24 @@ def _scalar_fields(entity: MetaObject) -> list[MetaField]:
     return [f for f in entity.fields() if f.sub_type != fc.FIELD_SUBTYPE_OBJECT]
 
 
+def _required_field_names(entity: MetaObject) -> list[str]:
+    """Every @required field name — scalar AND object/jsonb (unlike
+    _scalar_fields, which drops object fields for the sort allowlist). FR-035
+    PATCH-2 guards present-null on any of these, and a @required jsonb column can
+    be nulled just like a scalar one."""
+    return [f.name for f in entity.fields() if is_required(f)]
+
+
+def _py_set_literal(names: list[str], *, frozen: bool = False) -> str:
+    """A Python set/frozenset literal from field names, matching the generated
+    allowlist idiom (one quoted name per line). Empty → ``frozenset()`` / ``set()``."""
+    empty = "frozenset()" if frozen else "set()"
+    if not names:
+        return empty
+    body = "{\n" + "".join(f'    "{name}",\n' for name in names) + "}"
+    return f"frozenset({body})" if frozen else body
+
+
 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
@@ -238,10 +257,14 @@ class RouterGenerator:
         repo_class: str,
         fields_const: str,
         ops_const: str,
+        model_name: str,
+        patch_model: str,
     ) -> 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."""
+        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)."""
         if name == "list":
             return [
                 '@router.get("")',
@@ -289,6 +312,12 @@ class RouterGenerator:
                 "    dto: dict[str, Any],",
                 f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
                 ") -> Any:",
+                "    # FR-036: run the generated field constraints (length / pattern /",
+                "    # numeric bounds) before persisting; a violation is the cross-port 400.",
+                "    try:",
+                f"        {model_name}(**dto)",
+                "    except ValidationError:",
+                '        return JSONResponse(status_code=400, content={"error": "validation"})',
                 "    return repo.create(dto)",
             ]
         if name == "update":
@@ -300,6 +329,18 @@ class RouterGenerator:
                 "    dto: dict[str, Any],",
                 f"    repo: Annotated[{repo_class}, Depends(get_repository)],",
                 ") -> Any:",
+                "    # FR-035 PATCH-2: an explicit null on a @required field is a 400 —",
+                "    # a present null on a NON-required field falls through and clears it,",
+                "    # and an OMITTED required field is untouched (never a 400).",
+                "    for _k in _REQUIRED_FIELDS:",
+                "        if _k in dto and dto[_k] is None:",
+                '            return JSONResponse(status_code=400, content={"error": "validation"})',
+                "    # FR-036: validate PRESENT, non-null values with the create rules (the",
+                "    # all-optional patch model never fires required-checks on ABSENT fields).",
+                "    try:",
+                f"        {patch_model}(**dto)",
+                "    except ValidationError:",
+                '        return JSONResponse(status_code=400, content={"error": "validation"})',
                 f"    saved = repo.update({pk_param}, dto)",
                 "    if saved is None:",
                 '        return JSONResponse(status_code=404, content={"error": "not_found"})',
@@ -385,9 +426,18 @@ class RouterGenerator:
                 if f.name not in seen:
                     seen.add(f.name)
                     sort_fields.append(f.name)
-        sort_set_body = "set()" if not sort_fields else (
-            "{\n" + "".join(f'    "{name}",\n' for name in sort_fields) + "}"
-        )
+        sort_set_body = _py_set_literal(sort_fields)
+        # 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.
+        required_names: list[str] = _required_field_names(entity)
+        req_seen = set(required_names)
+        for st in plan.subtypes:
+            for name in _required_field_names(st.entity):
+                if name not in req_seen:
+                    req_seen.add(name)
+                    required_names.append(name)
+        required_set_body = _py_set_literal(required_names, frozen=True)
 
         h = generated_header(short_name, _effective_fqn(entity)).rstrip()
         parts: list[str] = []
@@ -406,7 +456,7 @@ class RouterGenerator:
         parts.append("")
         parts.append("from fastapi import APIRouter, Depends, Query, Request, status")
         parts.append("from fastapi.responses import JSONResponse")
-        parts.append("from pydantic import BaseModel")
+        parts.append("from pydantic import BaseModel, ValidationError")
         parts.append("")
         parts.append("from metaobjects.codegen.runtime.filter_parser import (")
         parts.append("    FilterPredicate,")
@@ -414,6 +464,12 @@ class RouterGenerator:
         parts.append(")")
         parts.append("")
         parts.append(f"from .{allowlist_module} import {fields_const}, {ops_const}")
+        # FR-036: each concrete subtype's CREATE + all-optional PATCH validation models
+        # drive the field constraints run on the per-subtype POST / PATCH (sibling
+        # modules). These are the wire-shaped validation models, NOT the read model.
+        for st in plan.subtypes:
+            sub = st.entity.name
+            parts.append(f"from .{sub} import {sub}Create, {sub}Patch")
         parts.append("")
         parts.append(f'router = APIRouter(prefix="/api/{plural}", tags=["{plural}"])')
         parts.append("")
@@ -427,6 +483,9 @@ class RouterGenerator:
         parts.append(f"_SORT_ALLOWLIST: set[str] = {sort_set_body}")
         parts.append("")
         parts.append("")
+        parts.append(f"_REQUIRED_FIELDS: frozenset[str] = {required_set_body}")
+        parts.append("")
+        parts.append("")
         parts.append("def _parse_sort(raw: str) -> _SortClause | None:")
         parts.append('    """Parse `field:asc|desc`; return None for malformed / disallowed input."""')
         parts.append('    parts = raw.split(":", 1)')
@@ -480,6 +539,7 @@ class RouterGenerator:
         for st in plan.subtypes:
             seg = st.route_segment
             val = st.value
+            sub = st.entity.name  # the subtype's generated create + PATCH model classes
             sfx = st.route_segment  # handler-name suffix = URL segment (e.g. "bridge"), matches the route
             parts.extend(list_sig(f"list_{plural}_{sfx}", f"/{seg}"))
             parts.extend(self._emit_tph_list_body(f'"{val}"', fields_const, ops_const))
@@ -490,6 +550,11 @@ class RouterGenerator:
             parts.append("    dto: dict[str, Any],")
             parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
             parts.append(") -> Any:")
+            parts.append("    # FR-036: run the subtype's field constraints before persisting.")
+            parts.append("    try:")
+            parts.append(f"        {sub}Create(**dto)")
+            parts.append("    except ValidationError:")
+            parts.append('        return JSONResponse(status_code=400, content={"error": "validation"})')
             parts.append(f'    return repo.create("{val}", dto)')
             parts.append("")
             parts.append("")
@@ -511,6 +576,15 @@ class RouterGenerator:
             parts.append("    dto: dict[str, Any],")
             parts.append(f"    repo: Annotated[{repo_class}, Depends(get_repository)],")
             parts.append(") -> Any:")
+            parts.append("    # FR-035 PATCH-2: an explicit null on a @required field is a 400.")
+            parts.append("    for _k in _REQUIRED_FIELDS:")
+            parts.append("        if _k in dto and dto[_k] is None:")
+            parts.append('            return JSONResponse(status_code=400, content={"error": "validation"})')
+            parts.append("    # FR-036: validate PRESENT, non-null values with the subtype's create rules.")
+            parts.append("    try:")
+            parts.append(f"        {sub}Patch(**dto)")
+            parts.append("    except ValidationError:")
+            parts.append('        return JSONResponse(status_code=400, content={"error": "validation"})')
             parts.append(f'    saved = repo.update("{val}", {pk_param}, dto)')
             parts.append("    if saved is None:")
             parts.append('        return JSONResponse(status_code=404, content={"error": "not_found"})')
@@ -600,9 +674,10 @@ class RouterGenerator:
         ops_const = f"{upper}_FILTER_OPS_BY_FIELD"
         allowlist_module = f"{snake}_filter_allowlist"
 
-        sort_set_body = "set()" if not sort_fields else (
-            "{\n" + "".join(f'    "{name}",\n' for name in sort_fields) + "}"
-        )
+        sort_set_body = _py_set_literal(sort_fields)
+        # 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)
 
         parts: list[str] = []
         parts.append(
@@ -619,7 +694,7 @@ class RouterGenerator:
         parts.append("")
         parts.append("from fastapi import APIRouter, Depends, Query, Request, status")
         parts.append("from fastapi.responses import JSONResponse")
-        parts.append("from pydantic import BaseModel")
+        parts.append("from pydantic import BaseModel, ValidationError")
         parts.append("")
         parts.append("from metaobjects.codegen.runtime.filter_parser import (")
         parts.append("    FilterPredicate,")
@@ -627,6 +702,11 @@ class RouterGenerator:
         parts.append(")")
         parts.append("")
         parts.append(f"from .{allowlist_module} import {fields_const}, {ops_const}")
+        # FR-036: the generated CREATE + all-optional PATCH validation models drive the
+        # field constraints run on POST / PATCH. These are the WIRE-shaped validation
+        # models (auto-gen PK / @readOnly omitted from create; PK omitted from patch;
+        # both keyed by field.name), NOT the read/entity-shape model.
+        parts.append(f"from .{short_name} import {short_name}Create, {short_name}Patch")
         parts.append("")
         parts.append(f'router = APIRouter(prefix="/api/{plural}", tags=["{plural}"])')
         parts.append("")
@@ -642,6 +722,9 @@ class RouterGenerator:
         parts.append(f"_SORT_ALLOWLIST: set[str] = {sort_set_body}")
         parts.append("")
         parts.append("")
+        parts.append(f"_REQUIRED_FIELDS: frozenset[str] = {required_set_body}")
+        parts.append("")
+        parts.append("")
         parts.append('def _parse_sort(raw: str) -> _SortClause | None:')
         parts.append('    """Parse `field:asc|desc`; return None for malformed / disallowed input."""')
         parts.append('    parts = raw.split(":", 1)')
@@ -672,6 +755,8 @@ class RouterGenerator:
             repo_class=repo_class,
             fields_const=fields_const,
             ops_const=ops_const,
+            model_name=f"{short_name}Create",
+            patch_model=f"{short_name}Patch",
         )
         for i, hname in enumerate(("list", "get", "create", "update", "delete")):
             if i > 0:

{metaobjects-0.15.13 → metaobjects-0.16.0}/src/metaobjects/render/extract/extract.py

@@ -92,6 +92,12 @@ def _extract(
                     data[f.name] = coerced
                     report.add_coercion(Coercion(path, "", f.default_value, "default"))
                     report.set(path, FieldExtraction.DEFAULTED)
+                    # A default SATISFIES @required, so this field never appears in
+                    # lost_required() — which is what the generated guards key on. Record
+                    # it separately so "the document did not answer a required field"
+                    # stays askable.
+                    if f.required:
+                        report.mark_defaulted_required(path)
                     continue
             report.set(
                 path,