metaobjects 0.19.2__tar.gz → 0.19.4__tar.gz

{metaobjects-0.19.2 → metaobjects-0.19.4}/PKG-INFO

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

{metaobjects-0.19.2 → metaobjects-0.19.4}/pyproject.toml

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

{metaobjects-0.19.2 → metaobjects-0.19.4}/src/metaobjects/cli.py

@@ -573,6 +573,16 @@ _TEMPLATE_TEXT_REF_ATTRS = (
 )
 
 
+def _attr_str_list(raw: object) -> list[str] | None:
+    """Coerce a string-array attr (a list, or a single string) to ``list[str]``; ``None``
+    when absent — the shape :func:`render.verify` expects for required_slots/required_tags."""
+    if isinstance(raw, str):
+        return [raw]
+    if isinstance(raw, (list, tuple)):
+        return [str(x) for x in raw]
+    return None
+
+
 def _verify_templates(args: argparse.Namespace) -> int:
     """``verify --templates`` — the template/prompt ``{{field}}`` ↔ payload drift gate.
 
@@ -659,6 +669,16 @@ def _verify_templates(args: argparse.Namespace) -> int:
             error_count += 1
             continue
 
+        # #193/#230: @requiredSlots/@requiredTags are a template.prompt concept — enforced ONLY on
+        # the prompt path (the email/document output gate does not apply them per-part; the #193
+        # cross-port consensus). A prompt whose body omits a required output tag →
+        # ERR_OUTPUT_TAG_MISSING (drift, fails); an unused required slot → ERR_REQUIRED_SLOT_UNUSED
+        # (warning). This brings Python to parity with TS/Java/C# (previously it enforced neither).
+        is_prompt = tmpl.sub_type == tc.TEMPLATE_SUBTYPE_PROMPT
+        # ADR-0039: resolving read — an inherited @requiredSlots/@requiredTags is honored.
+        req_slots = _attr_str_list(tmpl.get_meta_attr(tc.TEMPLATE_ATTR_REQUIRED_SLOTS)) if is_prompt else None
+        req_tags = _attr_str_list(tmpl.get_meta_attr(tc.TEMPLATE_ATTR_REQUIRED_TAGS)) if is_prompt else None
+
         for ref in refs:
             text = provider.resolve(ref)
             if text is None:
@@ -670,12 +690,14 @@ def _verify_templates(args: argparse.Namespace) -> int:
                 error_count += 1
                 continue
             checked += 1
-            for e in render_verify(text, fields, provider=provider):
+            for e in render_verify(
+                text, fields, provider=provider,
+                required_slots=req_slots, required_tags=req_tags,
+            ):
                 if e.code == ERR_REQUIRED_SLOT_UNUSED:
-                    continue  # warning, not drift
+                    continue  # an unused required slot is a warning, not drift
                 print(
-                    f"error: [{tmpl.name}] ref '{ref}' — {e.code}: "
-                    f"{{{{{e.path}}}}} not on payload VO '{payload_ref}'.",
+                    f"error: [{tmpl.name}] ref '{ref}' — {e.code}: {e.path}",
                     file=sys.stderr,
                 )
                 error_count += 1

{metaobjects-0.19.2 → metaobjects-0.19.4}/src/metaobjects/codegen/generators/payload_vo_generator.py

@@ -69,6 +69,13 @@ from metaobjects.shared.separators import PACKAGE_SEP
 
 _GENERATOR_NAME = "payload-vo-generator"
 
+# ADR-0044 backstop error code — a codegen-time (not loader) error, peer of the
+# render tier's ERR_VAR_NOT_ON_PAYLOAD. Declared LOCALLY here for the same reason
+# the TS reference (codegen-ts/src/payload-codegen.ts) declares it locally rather
+# than in the shared cross-port ledger: promoting it to the ledger is coordinated
+# with the Java/Kotlin follow-up so no port reddens on a code it doesn't yet emit.
+ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
+
 
 # ---------------------------------------------------------------------------
 # Naming helpers (snake_case mirrors the router/output-parser local helpers).
@@ -193,13 +200,17 @@ def _resolve_object_field_type(
     field: MetaField,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """A plain ``field.object`` (``@objectRef``, no origin child) — resolve to the
-    nested ``<TargetShortName>Payload`` (single) or ``list[<TargetShortName>Payload]``
-    (array). The target VO is scheduled for in-file emission (per-file dedupe, same
-    mechanism as ``origin.collection``). Falls back to the bare type-map form when the
-    ``@objectRef`` can't be resolved (defensive — loader validation gates it first)."""
+    nested payload class (single) or ``list[...]`` (array). The class name comes
+    from the ADR-0044 *name_map* (bare ``<Short>Payload`` when unique in the module
+    closure, package-qualified on a cross-package short-name collision). The target
+    VO is scheduled for in-file emission, deduped by ``resolution_key()`` (NOT
+    ``fqn()``, which returns the bare name and would collapse two same-short-name
+    VOs from different packages into one). Falls back to the bare type-map form when
+    the ``@objectRef`` can't be resolved (defensive — loader validation gates it)."""
     ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
     if not isinstance(ref, str) or not ref:
         return _fallback_type(field)
@@ -211,12 +222,14 @@ def _resolve_object_field_type(
     # both loaded trees (file_default_package) and programmatic trees (root package).
     referrer_pkg = _pkg_of(field.parent) if field.parent is not None else ""
     target = resolve_object_ref(root, ref, referrer_pkg)
-    if target is None:
+    if not isinstance(target, MetaObject):  # narrows MetaData|None -> MetaObject
         return _fallback_type(field)
-    nested_class = payload_class_name(target.name)
-    target_fqn = target.fqn()
-    if target_fqn not in emitted_nested_fqns:
-        emitted_nested_fqns.add(target_fqn)
+    target_key = target.resolution_key()
+    # name_map was populated by the ADR-0044 closure walk (pass 1/2), which visits
+    # the identical targets; the fallback guards a defensive gap only.
+    nested_class = name_map.get(target_key) or payload_class_name(target.name)
+    if target_key not in emitted_nested_keys:
+        emitted_nested_keys.add(target_key)
         nested_emit_queue.append((target, nested_class))
     if type_map.field_is_array(field):
         return f"list[{nested_class}]", set()
@@ -345,16 +358,20 @@ def _resolve_collection_type(
     root: MetaData,
     fallback: MetaField,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """``origin.collection @via "Parent.rel"`` — walk Parent's relationship to
-    its ``@objectRef`` target, schedule a nested ``<TargetShortName>Payload``
-    for in-file emission, return ``list[<TargetShortName>Payload]``.
-
-    Dedupe is per-file via *emitted_nested_fqns* — if the same target is
-    referenced by two fields in the same payload module, only one nested
-    class is emitted. Cross-file dedupe would leave forward-references
-    dangling (see the module docstring)."""
+    its ``@objectRef`` target, schedule a nested payload class for in-file
+    emission, return ``list[<NestedClass>]``. The class name comes from the
+    ADR-0044 *name_map* (bare when unique in the module closure, package-qualified
+    on a cross-package short-name collision).
+
+    Dedupe is per-file via *emitted_nested_keys*, keyed by ``resolution_key()`` —
+    if the same target is referenced by two fields in the same payload module,
+    only one nested class is emitted; two same-short-name targets in DIFFERENT
+    packages are NOT collapsed (each keeps its own key + qualified name).
+    Cross-file dedupe would leave forward-references dangling (module docstring)."""
     via = origin.attr(ORIGIN_ATTR_VIA)  # ADR-0039 sanctioned own: origin.* never inherits (ADR-0029)
     if not isinstance(via, str) or not via:
         return _fallback_type(fallback)
@@ -374,11 +391,10 @@ def _resolve_collection_type(
     target = _resolve_object_by_short_or_fqn(root, target_ref)
     if target is None:
         return _fallback_type(fallback)
-    # MetaData.name is the short name (no `::`); see _resolve_object_by_short_or_fqn.
-    nested_class = payload_class_name(target.name)
-    target_fqn = target.fqn()
-    if target_fqn not in emitted_nested_fqns:
-        emitted_nested_fqns.add(target_fqn)
+    target_key = target.resolution_key()
+    nested_class = name_map.get(target_key) or payload_class_name(target.name)
+    if target_key not in emitted_nested_keys:
+        emitted_nested_keys.add(target_key)
         nested_emit_queue.append((target, nested_class))
     return f"list[{nested_class}]", set()
 
@@ -393,8 +409,9 @@ def _resolve_field_type(
     field: MetaField,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
     enum_aliases: dict[str, str],
+    name_map: dict[str, str],
 ) -> tuple[str, set[str]]:
     """Resolve the Python annotation for one payload-VO field, honoring any
     ``origin.*`` child. Falls back to ``type_map.py_type_for`` when none.
@@ -415,7 +432,7 @@ def _resolve_field_type(
         # reference an undefined bare entity name (Pydantic "not fully defined").
         if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
             return _resolve_object_field_type(
-                field, root, nested_emit_queue, emitted_nested_fqns
+                field, root, nested_emit_queue, emitted_nested_keys, name_map
             )
         # A ``field.enum`` → Literal[...] (inline) or a named module alias (shared).
         enum_type = _enum_field_type(field, enum_aliases)
@@ -429,11 +446,142 @@ def _resolve_field_type(
         return _resolve_aggregate_type(origin, root, field)
     if origin.sub_type == "collection":
         return _resolve_collection_type(
-            origin, root, field, nested_emit_queue, emitted_nested_fqns
+            origin, root, field, nested_emit_queue, emitted_nested_keys, name_map
         )
     return _fallback_type(field)
 
 
+# ---------------------------------------------------------------------------
+# ADR-0044 — collision-scoped nested-payload naming (three-pass pipeline).
+#
+# A payload module is a SINGLE self-contained file, so its `@objectRef` /
+# `origin.collection` closure is the collision domain (ADR-0044's "closure of the
+# payload root(s) emitted into one artifact"). Two value-objects sharing a bare
+# short name across packages (`acme::alpha::Note` + `acme::beta::Note`, both
+# reachable from one payload) must emit as DISTINCT classes — the pre-ADR-0044
+# code deduped by `fqn()` (which returns the BARE name here), collapsing them to
+# one class, last-wins, silently dropping the second shape. Pass 1 collects the
+# closure keyed by `resolution_key()` (the true package-qualified FQN); pass 2
+# assigns names as a pure function of the closure (bare when unique, package-
+# qualified on collision, hard fail on a still-colliding derived name); pass 3
+# (the existing emit path) uses the name map for both declaration and reference.
+# ---------------------------------------------------------------------------
+
+
+def _package_qualified_name(pkg: str, short_name: str) -> str:
+    """ADR-0044 — PascalCase each ``::``-segment of *pkg*, concatenate, append the
+    bare *short_name* (``acme::alpha`` + ``Note`` → ``AcmeAlphaNote``). A root-level
+    (empty-package) node keeps its bare short name — the loader's own-package
+    uniqueness already precludes two root-level VOs sharing a name, so this can't
+    silently under-qualify."""
+    if pkg == "":
+        return short_name
+    return "".join(_pascal(seg) for seg in pkg.split(PACKAGE_SEP)) + short_name
+
+
+def _nested_target_of(field: MetaField, root: MetaData) -> MetaObject | None:
+    """The nested-payload target VO a *field* contributes to the module closure,
+    or ``None`` when it contributes no nested class. Mirrors the resolution in
+    :func:`_resolve_object_field_type` (a plain ``field.object`` ``@objectRef``)
+    and :func:`_resolve_collection_type` (``origin.collection`` ``@via``) EXACTLY,
+    so the ADR-0044 closure walk and the emission walk agree on the target set.
+    ``origin.passthrough`` / ``origin.aggregate`` yield scalar types (no nested
+    class) and so contribute nothing."""
+    origin = _find_origin_child(field)
+    if origin is None:
+        if field.sub_type != fc.FIELD_SUBTYPE_OBJECT:
+            return None
+        ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
+        if not isinstance(ref, str) or not ref:
+            return None
+        referrer_pkg = _pkg_of(field.parent) if field.parent is not None else ""
+        target = resolve_object_ref(root, ref, referrer_pkg)
+        return target if isinstance(target, MetaObject) else None
+    if origin.sub_type == "collection":
+        via = origin.attr(ORIGIN_ATTR_VIA)  # ADR-0039 sanctioned own: origin.* never inherits
+        if not isinstance(via, str) or not via:
+            return None
+        parts = _split_dotted_ref(via)
+        if parts is None:
+            return None
+        parent_name, rel_name = parts
+        parent = _resolve_object_by_short_or_fqn(root, parent_name)
+        if parent is None:
+            return None
+        rel = _find_relationship_on(parent, rel_name)
+        if rel is None:
+            return None
+        target_ref = rel.object_ref()
+        if not target_ref:
+            return None
+        return _resolve_object_by_short_or_fqn(root, target_ref)
+    return None
+
+
+def _collect_nested_closure(
+    root: MetaData,
+    payload_vo: MetaObject,
+    closure: dict[str, MetaObject],
+    seen: set[str],
+) -> None:
+    """ADR-0044 pass 1 — walk *payload_vo*'s transitive nested-payload closure,
+    collecting each target VO keyed by ``resolution_key()`` (never ``fqn()`` —
+    which returns the bare name and would collapse a cross-package short-name
+    collision). *seen* is seeded with the primary payload VO's key so the primary
+    (which is named after the TEMPLATE, outside the VO-short-name collision
+    domain) is never treated as a nested class, and doubles as the cycle guard."""
+    for field in payload_vo.fields():
+        if not isinstance(field, MetaField):
+            continue
+        target = _nested_target_of(field, root)
+        if target is None:
+            continue
+        key = target.resolution_key()
+        if key in seen:
+            continue
+        seen.add(key)
+        closure[key] = target
+        _collect_nested_closure(root, target, closure, seen)
+
+
+def _assign_nested_names(closure: dict[str, MetaObject]) -> dict[str, str]:
+    """ADR-0044 pass 2 — ``resolution_key()`` → emitted class name. A PURE function
+    of the closure's ``(key, short-name, package)`` triples, never of traversal
+    order: a bare short name unique in the closure emits ``<Short>Payload``
+    (byte-identical to pre-ADR-0044 output); a short-name collision emits EVERY
+    member under its package-qualified derived name
+    (``<PkgSegmentsPascal><Short>Payload``). If two distinct keys still derive the
+    same name, fail loud with ``ERR_PAYLOAD_NAME_COLLISION`` — never silently
+    collide a second time."""
+    by_short: dict[str, list[str]] = {}
+    for key, node in closure.items():
+        by_short.setdefault(node.name, []).append(key)
+
+    name_map: dict[str, str] = {}
+    for short, keys in by_short.items():
+        if len(keys) == 1:
+            name_map[keys[0]] = payload_class_name(short)
+            continue
+        for key in keys:
+            node = closure[key]
+            name_map[key] = payload_class_name(_package_qualified_name(_pkg_of(node), short))
+
+    # Backstop — sorted by key so both the emptiness of the colliding set and the
+    # pair named in the message are a pure function of the closure, not dict order.
+    owner: dict[str, str] = {}
+    for key in sorted(name_map):
+        emitted = name_map[key]
+        existing = owner.get(emitted)
+        if existing is not None and existing != key:
+            raise ValueError(
+                f"{ERR_PAYLOAD_NAME_COLLISION}: payload record name collision: "
+                f'"{emitted}" derives from both "{existing}" and "{key}" — rename one '
+                "value-object or move it to a package that derives a distinct name"
+            )
+        owner[emitted] = key
+    return name_map
+
+
 # ---------------------------------------------------------------------------
 # Class-block emission.
 # ---------------------------------------------------------------------------
@@ -444,10 +592,11 @@ def _emit_payload_class(
     payload_vo: MetaObject,
     root: MetaData,
     nested_emit_queue: list[tuple[MetaObject, str]],
-    emitted_nested_fqns: set[str],
+    emitted_nested_keys: set[str],
     extra_imports: set[str],
     enum_aliases: dict[str, str],
     docstring: str,
+    name_map: dict[str, str],
 ) -> list[str]:
     """Build the source lines for one Pydantic ``BaseModel`` subclass."""
     lines: list[str] = [f"class {class_name}(BaseModel):", f'    """{docstring}"""']
@@ -456,7 +605,7 @@ def _emit_payload_class(
         if not isinstance(field, MetaField):
             continue
         annotation, imports = _resolve_field_type(
-            field, root, nested_emit_queue, emitted_nested_fqns, enum_aliases
+            field, root, nested_emit_queue, emitted_nested_keys, enum_aliases, name_map
         )
         extra_imports.update(imports)
         # Optionality mirrors the cross-port (TS) payload-codegen: a ``@required``
@@ -515,9 +664,18 @@ def render_payload_vo(
     if payload is None:
         return None
 
+    # ADR-0044 pass 1/2 — the collision domain is this module's nested-payload
+    # closure. Seed `seen` with the primary VO's key so the primary (named after
+    # the TEMPLATE, not the VO) stays out of the VO-short-name collision domain.
+    closure: dict[str, MetaObject] = {}
+    _collect_nested_closure(root, payload, closure, {payload.resolution_key()})
+    name_map = _assign_nested_names(closure)
+
     # Per-file dedupe set: scoped to this single render call so each emitted
-    # module is self-contained (no cross-template forward references).
-    emitted_nested_fqns: set[str] = set()
+    # module is self-contained (no cross-template forward references). Keyed by
+    # ``resolution_key()`` (see _resolve_object_field_type) so two same-short-name
+    # VOs from different packages both emit.
+    emitted_nested_keys: set[str] = set()
     class_name = payload_class_name(template.name)
     extra_imports: set[str] = set()
     nested_emit_queue: list[tuple[MetaObject, str]] = []
@@ -541,13 +699,14 @@ def render_payload_vo(
         payload_vo=payload,
         root=root,
         nested_emit_queue=nested_emit_queue,
-        emitted_nested_fqns=emitted_nested_fqns,
+        emitted_nested_keys=emitted_nested_keys,
         extra_imports=extra_imports,
         enum_aliases=enum_aliases,
         docstring=(
             f"GENERATED payload for template ``{template.name}``.\n\n"
             f"    Field shape derived from the ``{payload.name}`` object.value."
         ),
+        name_map=name_map,
     )
     if strict_extras:
         primary_block = _with_strict_extras(primary_block)
@@ -564,12 +723,13 @@ def render_payload_vo(
             payload_vo=target,
             root=root,
             nested_emit_queue=nested_emit_queue,
-            emitted_nested_fqns=emitted_nested_fqns,
+            emitted_nested_keys=emitted_nested_keys,
             extra_imports=extra_imports,
             enum_aliases=enum_aliases,
             docstring=(
                 f"GENERATED nested payload for collection target ``{target.name}``."
             ),
+            name_map=name_map,
         )
         if strict_extras:
             block = _with_strict_extras(block)
@@ -650,10 +810,11 @@ class PayloadVoGenerator:
         payload_vo: MetaObject,
         root: MetaData,
         nested_emit_queue: list[tuple[MetaObject, str]],
-        emitted_nested_fqns: set[str],
+        emitted_nested_keys: set[str],
         extra_imports: set[str],
         enum_aliases: dict[str, str],
         docstring: str,
+        name_map: dict[str, str],
     ) -> list[str]:
         """EXTENSION SEAM — the source lines for one Pydantic ``BaseModel`` subclass
         (primary OR a nested collection target). Defaults to the module-level
@@ -664,10 +825,11 @@ class PayloadVoGenerator:
             payload_vo,
             root,
             nested_emit_queue,
-            emitted_nested_fqns,
+            emitted_nested_keys,
             extra_imports,
             enum_aliases,
             docstring,
+            name_map,
         )
 
     def _render_module(self, template: MetaTemplate, root: MetaData) -> str | None:

{metaobjects-0.19.2 → metaobjects-0.19.4}/src/metaobjects/codegen/generators/router_generator.py

@@ -52,6 +52,7 @@ from metaobjects.codegen.instance_artifacts import emits_instance_artifacts
 from metaobjects.codegen.type_map import PyType, py_type_for
 from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.meta.core.field.meta_field import MetaField
+from metaobjects.meta.persistence.db import db_constants as dbc
 from metaobjects.meta.core.identity.identity_constants import (
     IDENTITY_ATTR_FIELDS,
     IDENTITY_REFERENCE_ATTR_REFERENCES,
@@ -95,7 +96,73 @@ def _required_field_names(entity: MetaObject) -> list[str]:
     _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)]
+    # #203/ADR-0045: an @autoSet field is server-owned — never a caller-facing PATCH field, so
+    # it is not present-null-checked (a caller-sent null is ignored/stamped, not a 400). Mirrors
+    # the Kotlin controller (which excludes @autoSet from its patch-settable set).
+    return [f.name for f in entity.fields() if is_required(f) and not _is_auto_set(f)]
+
+
+# --- #203 / ADR-0045: @autoSet stamping in the generated router (above the repo seam) ----------
+
+_AUTO_SET_TEMPORAL_SUBTYPES = (
+    fc.FIELD_SUBTYPE_DATE,
+    fc.FIELD_SUBTYPE_TIME,
+    fc.FIELD_SUBTYPE_TIMESTAMP,
+)
+
+
+def _is_auto_set(field: MetaField) -> bool:
+    """True iff *field* is a server-owned ``@autoSet`` column (ADR-0039 resolving read)."""
+    return field.get_meta_attr(fc.FIELD_ATTR_AUTO_SET) in (
+        fc.AUTO_SET_ON_CREATE,
+        fc.AUTO_SET_ON_UPDATE,
+    )
+
+
+def _auto_set_split(entity: MetaObject) -> tuple[list[MetaField], list[MetaField]]:
+    """The entity's ``@autoSet`` temporal fields split into ``(onCreate, onUpdate)``.
+
+    Reads the RESOLVING ``@autoSet`` (ADR-0039) so an inherited
+    ``BaseEntity.createdAt/updatedAt`` is honored; a non-temporal field is skipped.
+    Both lists are empty for an entity that declares none, keeping its router
+    byte-identical to the pre-#203 output."""
+    on_create: list[MetaField] = []
+    on_update: list[MetaField] = []
+    for f in entity.fields():
+        if f.sub_type not in _AUTO_SET_TEMPORAL_SUBTYPES:
+            continue
+        mode = f.get_meta_attr(fc.FIELD_ATTR_AUTO_SET)  # ADR-0039 resolving: may be inherited via extends
+        if mode == fc.AUTO_SET_ON_CREATE:
+            on_create.append(f)
+        elif mode == fc.AUTO_SET_ON_UPDATE:
+            on_update.append(f)
+    return on_create, on_update
+
+
+def _auto_set_stamp_expr(field: MetaField, base_var: str) -> str:
+    """The inline now()-expression for an ``@autoSet`` *field*, derived from one shared
+    tz-aware *base_var* datetime so every column stamped in one op is equal (a fresh
+    row's created == updated). Keyed off the COLUMN's temporal type: ``field.date`` →
+    ``.date()``; ``field.time`` → ``.time()``; ``field.timestamp`` → the tz-aware base
+    (``@localTime`` → a naive wall-clock value). Mirrors ObjectManager._auto_set_stamp."""
+    sub = field.sub_type
+    if sub == fc.FIELD_SUBTYPE_DATE:
+        return f"{base_var}.date()"
+    if sub == fc.FIELD_SUBTYPE_TIME:
+        return f"{base_var}.time()"
+    is_tz = field.get_meta_attr(dbc.FIELD_ATTR_LOCAL_TIME) is not True  # ADR-0039 resolving
+    return base_var if is_tz else f"{base_var}.replace(tzinfo=None)"
+
+
+def _auto_set_stamp_lines(fields: list[MetaField], comment: str) -> list[str]:
+    """Router-handler body lines stamping *fields* into ``dto`` from ONE captured base
+    instant (so all same-op columns are equal), led by *comment*. Empty for no fields
+    (so the call site spreads to nothing — a non-@autoSet router stays byte-identical)."""
+    if not fields:
+        return []
+    lines = [f"    # {comment}", "    _asnow = _dt.datetime.now(_dt.timezone.utc)"]
+    lines += [f'    dto["{f.name}"] = {_auto_set_stamp_expr(f, "_asnow")}' for f in fields]
+    return lines
 
 
 def _py_set_literal(names: list[str], *, frozen: bool = False) -> str:
@@ -259,6 +326,8 @@ class RouterGenerator:
         ops_const: str,
         model_name: str,
         patch_model: str,
+        create_autoset: list[str] = (),
+        update_autoset: list[str] = (),
     ) -> list[str]:
         """One CRUD route handler block, dispatched by *name*
         (``list`` / ``get`` / ``create`` / ``update`` / ``delete``). Override to
@@ -318,6 +387,10 @@ class RouterGenerator:
                 f"        {model_name}(**dto)",
                 "    except ValidationError:",
                 '        return JSONResponse(status_code=400, content={"error": "validation"})',
+                # #203/ADR-0045: the generated router (the API surface) stamps @autoSet columns
+                # ABOVE the consumer repo seam — onCreate + onUpdate both stamped from one instant
+                # (a fresh row's createdAt == updatedAt), ignoring any caller-supplied value.
+                *create_autoset,
                 "    return repo.create(dto)",
             ]
         if name == "update":
@@ -341,6 +414,10 @@ class RouterGenerator:
                 f"        {patch_model}(**dto)",
                 "    except ValidationError:",
                 '        return JSONResponse(status_code=400, content={"error": "validation"})',
+                # #203/ADR-0045: bump onUpdate @autoSet columns (server-owned) on EVERY patch,
+                # above the repo seam — a server-inserted present key (compatible with the PATCH
+                # present-key tristate); onCreate columns are never touched here.
+                *update_autoset,
                 f"    saved = repo.update({pk_param}, dto)",
                 "    if saved is None:",
                 '        return JSONResponse(status_code=404, content={"error": "not_found"})',
@@ -417,6 +494,24 @@ class RouterGenerator:
         ops_const = f"{upper}_FILTER_OPS_BY_FIELD"
         allowlist_module = f"{snake}_filter_allowlist"
 
+        # #203/ADR-0045: @autoSet columns live on the BASE entity and are shared by every
+        # subtype (RESOLVING _auto_set_split(entity) picks up an inherited BaseEntity
+        # column too) — computed once here and threaded into each per-subtype handler
+        # below (empty for a non-@autoSet hierarchy → byte-identical output).
+        on_create_auto, on_update_auto = _auto_set_split(entity)
+        has_autoset = bool(on_create_auto or on_update_auto)
+        create_autoset = _auto_set_stamp_lines(
+            on_create_auto + on_update_auto,
+            "#203/ADR-0045: stamp @autoSet columns (server-owned; caller ignored).",
+        )
+        update_autoset = [
+            f'    dto.pop("{f.name}", None)  # onCreate @autoSet is write-once (server-owned)'
+            for f in on_create_auto
+        ] + _auto_set_stamp_lines(
+            on_update_auto,
+            "#203/ADR-0045: bump onUpdate @autoSet column(s) (server-owned).",
+        )
+
         # Sort allowlist = base scalar fields ∪ every subtype's own scalar fields, so a
         # per-subtype list can sort on a subtype-only column too. Stable order.
         sort_fields: list[str] = [f.name for f in _scalar_fields(entity)]
@@ -448,6 +543,10 @@ class RouterGenerator:
         )
         parts.append("from __future__ import annotations")
         parts.append("")
+        if has_autoset:
+            # #203/ADR-0045: the router stamps @autoSet columns inline (no runtime dependency).
+            parts.append("import datetime as _dt")
+            parts.append("")
         for import_line in sorted(pk.imports):
             parts.append(import_line)
         if pk.imports:
@@ -555,6 +654,9 @@ class RouterGenerator:
             parts.append(f"        {sub}Create(**dto)")
             parts.append("    except ValidationError:")
             parts.append('        return JSONResponse(status_code=400, content={"error": "validation"})')
+            # #203/ADR-0045: stamp @autoSet columns ABOVE the repo seam (empty for a
+            # non-@autoSet hierarchy — byte-identical output).
+            parts.extend(create_autoset)
             parts.append(f'    return repo.create("{val}", dto)')
             parts.append("")
             parts.append("")
@@ -585,6 +687,9 @@ class RouterGenerator:
             parts.append(f"        {sub}Patch(**dto)")
             parts.append("    except ValidationError:")
             parts.append('        return JSONResponse(status_code=400, content={"error": "validation"})')
+            # #203/ADR-0045: pop the write-once onCreate column(s), bump onUpdate — ABOVE
+            # the repo seam (empty for a non-@autoSet hierarchy — byte-identical output).
+            parts.extend(update_autoset)
             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"})')
@@ -684,6 +789,27 @@ class RouterGenerator:
         # is a 400 — the update handler guards these before the repo call.
         required_set_body = _py_set_literal(_required_field_names(entity), frozen=True)
 
+        # #203/ADR-0045: @autoSet stamp lines for the create/update handlers (empty for a
+        # non-@autoSet entity → byte-identical output). insert stamps onCreate+onUpdate from one
+        # instant; a patch bumps onUpdate only (createdAt stays immutable).
+        _on_create_auto, _on_update_auto = _auto_set_split(entity)
+        create_autoset = _auto_set_stamp_lines(
+            _on_create_auto + _on_update_auto,
+            "#203/ADR-0045: stamp @autoSet columns (server-owned; caller ignored).",
+        )
+        # #203/ADR-0045 (integrity): onCreate @autoSet columns are write-once — strip any
+        # caller-supplied value on PATCH before the repo call (a caller cannot mutate createdAt via
+        # the deployed API). Mirrors ObjectManager.update (`data.pop(...)`) + the Kotlin controller
+        # (which excludes @autoSet from its patch-settable set).
+        update_autoset = [
+            f'    dto.pop("{f.name}", None)  # onCreate @autoSet is write-once (server-owned)'
+            for f in _on_create_auto
+        ] + _auto_set_stamp_lines(
+            _on_update_auto,
+            "#203/ADR-0045: bump onUpdate @autoSet column(s) (server-owned).",
+        )
+        has_autoset = bool(_on_create_auto or _on_update_auto)
+
         parts: list[str] = []
         parts.append(
             generated_header(short_name, _effective_fqn(entity)).rstrip() + "\n"
@@ -691,6 +817,10 @@ class RouterGenerator:
         )
         parts.append("from __future__ import annotations")
         parts.append("")
+        if has_autoset:
+            # #203/ADR-0045: the router stamps @autoSet columns inline (no runtime dependency).
+            parts.append("import datetime as _dt")
+            parts.append("")
         for import_line in sorted(pk.imports):
             parts.append(import_line)
         if pk.imports:
@@ -762,6 +892,8 @@ class RouterGenerator:
             ops_const=ops_const,
             model_name=f"{short_name}Create",
             patch_model=f"{short_name}Patch",
+            create_autoset=create_autoset,
+            update_autoset=update_autoset,
         )
         for i, hname in enumerate(("list", "get", "create", "update", "delete")):
             if i > 0:

{metaobjects-0.19.2 → metaobjects-0.19.4}/src/metaobjects/errors.py

@@ -133,6 +133,9 @@ class ErrorCode(str, Enum):
     ERR_PARTIAL_UNRESOLVED = "ERR_PARTIAL_UNRESOLVED"
     ERR_REQUIRED_SLOT_UNUSED = "ERR_REQUIRED_SLOT_UNUSED"
     ERR_VAR_NOT_ON_PAYLOAD = "ERR_VAR_NOT_ON_PAYLOAD"
+    # Codegen (ADR-0044): two value-object FQNs in one payload artifact derive the same
+    # emitted record name even after package-qualification. Peer of ERR_VAR_NOT_ON_PAYLOAD.
+    ERR_PAYLOAD_NAME_COLLISION = "ERR_PAYLOAD_NAME_COLLISION"
     ERR_OUTPUT_TAG_MISSING = "ERR_OUTPUT_TAG_MISSING"
     # SP-H Unit9 — @filterable: true on a field subtype with no filter-operator
     # band (e.g. field.object). Would silently generate an empty-ops filter.