metaobjects 1.0.9rc5__tar.gz → 1.0.10__tar.gz

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/PKG-INFO

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

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

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/cli.py

@@ -57,7 +57,7 @@ from pathlib import Path
 from typing import Callable
 
 from metaobjects import MetaDataLoader
-from metaobjects.errors import ParseError
+from metaobjects.errors import ErrorCode, MetaError, ParseError
 from metaobjects.config.dependencies import (
     Collection,
     imported_from,
@@ -276,9 +276,14 @@ def _load_root(
     strict: bool = False,
     providers: list[object] | None = None,
     libraries: list[str] | None = None,
+    unknown_attr_out: list[str] | None = None,
 ) -> tuple[MetaData | None, list[str]]:
     """Load metadata; return ``(root, error_messages)``. ``root`` is None on error.
 
+    ``unknown_attr_out`` — when given on a LENIENT load, a second strict load of the
+    same metadata is run and its ``ERR_UNKNOWN_ATTR`` findings are appended, formatted,
+    so ``gen`` can warn about what ``verify`` would reject instead of staying silent.
+
     ``strict`` (ADR-0023, #96) — when True, an undeclared own ``@attr`` →
     ``ERR_UNKNOWN_ATTR``. Defaults False so ``gen`` / ``docs`` keep the legacy
     open-attr load; only ``verify`` opts in (strict-by-default with a ``--lax``
@@ -312,20 +317,24 @@ def _load_root(
         return None, [f"{exc.code}: {exc}"]
     all_libraries = _merge_libraries(neutral.libraries if neutral is not None else None, libraries)
 
-    try:
+    def load(strict_load: bool) -> LoadResult:
         if providers:
             from metaobjects.core_types import core_providers
 
-            result = MetaDataLoader.from_directory(
+            return MetaDataLoader.from_directory(
                 metadata_dir,
                 providers=[*core_providers, *providers],
-                strict=strict,
+                strict=strict_load,
                 libraries=all_libraries,
             )
-        else:
-            result = MetaDataLoader.from_directory(
-                metadata_dir, strict=strict, libraries=all_libraries
-            )
+        return MetaDataLoader.from_directory(
+            metadata_dir, strict=strict_load, libraries=all_libraries
+        )
+
+    try:
+        result = load(strict)
+        if unknown_attr_out is not None and not strict and not result.errors:
+            unknown_attr_out.extend(_unknown_attr_findings(load(True)))
     except OSError as e:
         # `DirectorySource.expand()` walks via `iterdir()` (not `rglob()`, so it
         # can follow a symlinked subdirectory — the I1 fix) and raises a plain
@@ -416,6 +425,7 @@ def _load_root_from_collection(
     strict: bool = False,
     providers: list[object] | None = None,
     libraries: list[str] | None = None,
+    unknown_attr_out: list[str] | None = None,
 ) -> tuple[MetaData | None, list[str]]:
     """Load a resolved `Collection` — the source-resolution ladder's
     ``.metaobjects/config.json`` rung (:func:`resolve_metadata_location`), which
@@ -432,9 +442,58 @@ def _load_root_from_collection(
     if result.errors:
         msgs = [f"{e.code}: {e.message}" for e in result.errors]
         return None, msgs
+    if unknown_attr_out is not None and not strict:
+        # See `_load_root`: what a strict load (`verify`) would reject, for `gen` to warn.
+        try:
+            strict_result = _load_collection_result(
+                collection, strict=True, providers=providers, libraries=libraries
+            )
+        except ParseError:
+            strict_result = None
+        if strict_result is not None:
+            unknown_attr_out.extend(_unknown_attr_findings(strict_result))
     return result.root, []
 
 
+#: Trailing advice after ``gen``'s unknown-attribute warnings. ``gen`` has no strict
+#: flag of its own; ``verify`` is the strict door (ADR-0023), so that is what it names.
+UNKNOWN_ATTR_GEN_ADVICE = (
+    "metaobjects gen loads leniently and generated anyway, but `metaobjects verify` "
+    "rejects this metadata (ADR-0023): fix or remove the attribute - a typo'd one "
+    "(`isAbstrakt`, `requird`) silently changes what is generated."
+)
+
+
+def _format_unknown_attr(err: MetaError) -> str:
+    """One ``gen`` warning: code + message (naming attribute and node), then the file."""
+    env = getattr(err, "envelope", None)
+    files = [f for f in (getattr(env, "files", None) or ()) if f]
+    json_path = getattr(env, "json_path", None)
+    where = " ".join(
+        p for p in (", ".join(files) if files else None, f"at {json_path}" if json_path else None) if p
+    )
+    head = f"{err.code.value if hasattr(err.code, 'value') else err.code}: {err.message}"
+    return f"{head}\n  in {where}" if where else head
+
+
+def _unknown_attr_findings(result: LoadResult) -> list[str]:
+    """The ERR_UNKNOWN_ATTR findings of a STRICT load, formatted for ``gen``."""
+    return [
+        _format_unknown_attr(e) for e in result.errors
+        if (e.code.value if hasattr(e.code, "value") else e.code) == ErrorCode.ERR_UNKNOWN_ATTR.value
+    ]
+
+
+def _print_unknown_attr_warnings(findings: list[str]) -> None:
+    """``gen`` loads leniently; an unknown attribute ``verify`` would reject is named here
+    as a warning (attribute, node, file). Advisory only: the exit code is unchanged."""
+    if not findings:
+        return
+    for f in findings:
+        print(f"warning: {f}", file=sys.stderr)
+    print(f"warning: {UNKNOWN_ATTR_GEN_ADVICE}", file=sys.stderr)
+
+
 def _strict_load_hint() -> str:
     """Actionable next-steps when strict verify rejects an undeclared @attr."""
     return (
@@ -1099,12 +1158,16 @@ def _cmd_gen(args: argparse.Namespace) -> int:
         return 1
     # Load the metadata ONCE; both the default suite and the (optional)
     # --template-spec pass run against this single loaded root.
-    root, load_errors = _load_root(args.metadata_dir, providers=providers)
+    unknown_attrs: list[str] = []
+    root, load_errors = _load_root(
+        args.metadata_dir, providers=providers, unknown_attr_out=unknown_attrs
+    )
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in load_errors:
             print(f"  {msg}", file=sys.stderr)
         return 1
+    _print_unknown_attr_warnings(unknown_attrs)
     gen_state = gen_state_dir_for(args.metadata_dir)
     # Same anchor the manifest itself uses. Both passes below key against it, so a
     # `--template-spec` artifact and a default-suite artifact land in one key space.
@@ -1368,14 +1431,17 @@ def _cmd_gen_config(args: argparse.Namespace) -> int:
     if collection is None:
         return 1
 
+    unknown_attrs: list[str] = []
     root, load_errors = _load_root_from_collection(
-        collection, providers=providers, libraries=config.libraries
+        collection, providers=providers, libraries=config.libraries,
+        unknown_attr_out=unknown_attrs,
     )
     if root is None:
         print("error: failed to load metadata:", file=sys.stderr)
         for msg in load_errors:
             print(f"  {msg}", file=sys.stderr)
         return 1
+    _print_unknown_attr_warnings(unknown_attrs)
 
     for t in targets:
         imported_refusal = _refuse_imported_entities(t.entities, root, collection)

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/codegen/generators/filter_allowlist_generator.py

@@ -39,6 +39,7 @@ from metaobjects.codegen.generator import EmittedFile, GenContext, Generator, pe
 from metaobjects.codegen.generators.m2m_codegen import build_object_index
 from metaobjects.codegen.generators.router_generator import emits_router
 from metaobjects.codegen.generators.tph_plan import tph_plan_for
+from metaobjects.codegen.instance_artifacts import is_sourceless_entity
 from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.meta.core.field.meta_field import MetaField
 from metaobjects.meta.core.object.meta_object import MetaObject
@@ -179,7 +180,9 @@ class FilterAllowlistGenerator:
 
     Skips entities without a ``source.rdb`` child and read-only kinds
     (view / materializedView / storedProc / tableFunction) — same gate as
-    ``RouterGenerator``, so the two generators emit in lock-step.
+    ``RouterGenerator``, so the two generators emit in lock-step. The exception is a
+    sourceless entity (``is_sourceless_entity``): no router, but an allowlist for the
+    adopter's own endpoint.
     """
 
     name = "filter-allowlist-generator"
@@ -271,7 +274,12 @@ class FilterAllowlistGenerator:
         # again at F22 when the router learned to serve view-only projections and
         # this module did not — the emitted router imported an allowlist nothing
         # had generated.
-        if not emits_router(entity):
+        #
+        # The one addition: a sourceless entity (identity, no source — a record in a store
+        # MetaObjects does not manage) gets no router but does get the allowlist, for the
+        # list endpoint its adopter writes. Nothing generated imports it, so the lock-step
+        # rule above is not at stake.
+        if not emits_router(entity) and not is_sourceless_entity(entity):
             return None
 
         short_name = entity.name

metaobjects-1.0.10/src/metaobjects/codegen/instance_artifacts.py

@@ -0,0 +1,43 @@
+"""Guard for the abstract concept (mirrors the TS instance-artifacts module).
+
+An abstract entity must never produce instance/write artifacts (routers, filter
+allowlists, CREATE TABLE DDL). The Pydantic base *model* is a separate concern: this
+port ALWAYS emits it (concretes subclass it). It was described here as "a configurable
+shape concern (emit_abstract_shapes, default on) handled in entity_model" — that config
+field was read by nothing and entity_model never consulted it, so `GenConfig` now
+refuses to accept a value it cannot honour.
+"""
+from metaobjects.meta.core.object.meta_object import MetaObject
+
+
+def is_abstract(entity: MetaObject) -> bool:
+    return entity.is_abstract is True
+
+
+def emits_instance_artifacts(entity: MetaObject) -> bool:
+    return not is_abstract(entity)
+
+
+def is_sourceless_entity(entity: MetaObject) -> bool:
+    """A record whose store MetaObjects does not manage: a concrete object with a primary
+    identity and no ``source.*`` at all, declared or inherited (a MongoDB collection, a
+    Cassandra table, a Neo4j node, a remote API). #248 gives it no router, table or
+    migration; the adopter owns the data access.
+
+    It still has a wire contract, because the identity makes it addressable: a client can
+    create, fetch and PATCH it. So it gets the filter allowlist its own list endpoint needs
+    (the Create/Patch models come from the entity generator already).
+
+    Keyed on the identity, not the object subtype (#248): ADR-0028 forbids a value object
+    any identity. The projection exclusion is ADR-0028's own rule — a projection is
+    read-only because of its subtype. Mirrors the TypeScript ``isSourcelessEntity``.
+    """
+    from metaobjects.meta.core.object.object_constants import OBJECT_SUBTYPE_PROJECTION
+    from metaobjects.meta.persistence.source.meta_source import MetaSource
+
+    if is_abstract(entity) or entity.sub_type == OBJECT_SUBTYPE_PROJECTION:
+        return False
+    if entity.primary_identity() is None:
+        return False
+    # ADR-0039: children() resolves — an inherited source makes the object persistable.
+    return not any(isinstance(c, MetaSource) for c in entity.children())

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/meta/core/object/object_extract.py

@@ -158,6 +158,31 @@ def _field_spec_for(
     format: Format,
     visited: set[int],
     depth: int,
+) -> FieldSpec:
+    spec = _field_shape_for(field, owner, format, visited, depth)
+    if not _is_array(field):
+        return spec
+    # Element-count bounds: the field's array validator (@min/@max) is the single source of
+    # truth, as the numeric validator is for a scalar's range.
+    for c in field.children():
+        if c.type == TYPE_VALIDATOR and c.sub_type == vc.VALIDATOR_SUBTYPE_ARRAY:
+            # ADR-0039 sanctioned own: a validator's @min/@max are its own declared bounds,
+            # read exactly as _numeric_bound reads the numeric validator's.
+            lo = c.attr(vc.VALIDATOR_ATTR_MIN)
+            hi = c.attr(vc.VALIDATOR_ATTR_MAX)
+            return spec.with_item_bounds(
+                lo if isinstance(lo, int) and not isinstance(lo, bool) else None,
+                hi if isinstance(hi, int) and not isinstance(hi, bool) else None,
+            )
+    return spec
+
+
+def _field_shape_for(
+    field: MetaField,
+    owner: MetaObject,
+    format: Format,
+    visited: set[int],
+    depth: int,
 ) -> FieldSpec:
     name = field.name
     required = _is_required(field)

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/render/extract/extract.py

@@ -143,8 +143,22 @@ def _extract(
             # Cross-port contract: a MALFORMED array still places its successfully-coerced
             # elements into data (partial extraction), UNLIKE a MALFORMED scalar which is
             # absent from data.
+            # validator.array bounds. Too many: NORMAL/LOOSE keep the first max_items (a
+            # "truncate" coercion, like a numeric clamp); STRICT rejects. Too few: nothing can
+            # repair it, so it is MALFORMED under every tolerance.
+            out_of_bounds = False
+            if not any_malformed and f.max_items is not None and len(out) > f.max_items:
+                if o.tolerance == Tolerance.STRICT:
+                    out_of_bounds = True
+                else:
+                    report.add_coercion(
+                        Coercion(path, str(len(out)), str(f.max_items), "truncate")
+                    )
+                    out = out[: f.max_items]
+            if not any_malformed and f.min_items is not None and len(out) < f.min_items:
+                out_of_bounds = True
             data[f.name] = out
-            if any_malformed:
+            if any_malformed or out_of_bounds:
                 _mark_malformed(report, path, f)
             else:
                 report.set(path, FieldExtraction.EXTRACTED)

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/render/extract/json_forgiving_reader.py

@@ -179,7 +179,16 @@ class JsonForgivingReader:
 
     def _read_bare_scalar(self) -> object | None:
         start = self._i
-        while self._i < len(self._s) and self._s[self._i] not in ",}]":
+        # A comment after an unquoted value (`7 // good`) ends it; `http://x` does not.
+        while (
+            self._i < len(self._s)
+            and self._s[self._i] not in ",}]"
+            and not (
+                self._i > start
+                and self._s[self._i - 1].isspace()
+                and comment_opens_at(self._s, self._i)
+            )
+        ):
             self._i += 1
         result = self._s[start : self._i].strip()
         if not result:
@@ -189,8 +198,35 @@ class JsonForgivingReader:
         return result
 
     def _ws(self) -> None:
-        while self._i < len(self._s) and self._s[self._i].isspace():
-            self._i += 1
+        """Skip whitespace AND ``//`` / ``/* */`` comments. Only ever called between tokens,
+        so a comment marker inside a string literal is never reached here."""
+        while True:
+            while self._i < len(self._s) and self._s[self._i].isspace():
+                self._i += 1
+            end = comment_end(self._s, self._i)
+            if end < 0:
+                return
+            self._i = end
+
+
+def comment_opens_at(s: str, i: int) -> bool:
+    """True when a ``//`` or ``/*`` comment opens at ``i``."""
+    return i + 1 < len(s) and s[i] == "/" and s[i + 1] in "/*"
+
+
+def comment_end(s: str, i: int) -> int:
+    """Models write JSONC: ``{"score": 7, // good`` drops every field after it in a strict
+    reader. When a comment opens at ``i``, the index just past it (a line comment runs to the
+    end of its line, a block comment to its ``*/`` or the end of the text); otherwise -1."""
+    if not comment_opens_at(s, i):
+        return -1
+    if s[i + 1] == "/":
+        j = i + 2
+        while j < len(s) and s[j] not in "\n\r":
+            j += 1
+        return j
+    close = s.find("*/", i + 2)
+    return len(s) if close < 0 else close + 2
 
 
 def _unescape(c: str) -> str:

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/render/extract/locate.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 
 import re
 
+from metaobjects.render.extract.json_forgiving_reader import comment_end
+
 
 def json(text: str | None) -> str | None:
     """First balanced ``{...}``; if none closes, first ``{`` to end; ``None`` if no ``{``."""
@@ -46,11 +48,16 @@ def json_candidates(text: str | None) -> list[str]:
 
 
 def _scan_balanced(s: str, open_idx: int) -> int:
-    """Return index of the matching ``}``, or -1 if unterminated. String-aware."""
+    """Return index of the matching ``}``, or -1 if unterminated. String-aware, and
+    comment-aware: a ``//`` / ``/* */`` comment opening after whitespace or a separator is
+    skipped, so a brace or quote inside it cannot close the object early (``http://x`` is
+    not a comment)."""
     depth = 0
     in_str = False
     esc = False
-    for i in range(open_idx, len(s)):
+    i = open_idx - 1
+    while i + 1 < len(s):
+        i += 1
         c = s[i]
         if in_str:
             if esc:
@@ -60,6 +67,11 @@ def _scan_balanced(s: str, open_idx: int) -> int:
             elif c == '"':
                 in_str = False
             continue
+        if i > open_idx and (s[i - 1].isspace() or s[i - 1] in ",{["):
+            end = comment_end(s, i)
+            if end >= 0:
+                i = end - 1
+                continue
         if c == '"':
             in_str = True
         elif c == "{":

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/src/metaobjects/render/extract/types.py

@@ -11,6 +11,8 @@ runner maps the schema-json tokens onto these enums.
 """
 from __future__ import annotations
 
+import dataclasses
+
 from dataclasses import dataclass, field
 from enum import Enum
 from typing import Callable, Generic, TypeVar
@@ -115,6 +117,17 @@ class FieldSpec:
     # reads it from the ``#text`` sentinel the lenient XML reader carries when an element has
     # both attributes and a text body, instead of a same-named child. False for normal/JSON.
     text_content: bool = False
+    # Element-count bounds for an ARRAY field, from its ``validator.array`` (``@min``/``@max``).
+    # None = unbounded. Under NORMAL/LOOSE tolerance a list longer than ``max_items`` keeps its
+    # first ``max_items`` elements (a "truncate" coercion, the array analogue of a numeric
+    # clamp); under STRICT it is MALFORMED. A list shorter than ``min_items`` is MALFORMED under
+    # every tolerance: there is nothing to repair it with.
+    min_items: int | None = None
+    max_items: int | None = None
+
+    def with_item_bounds(self, min_items: int | None, max_items: int | None) -> "FieldSpec":
+        """This field with ``validator.array`` element-count bounds (None = unbounded)."""
+        return dataclasses.replace(self, min_items=min_items, max_items=max_items)
 
     @staticmethod
     def scalar(

metaobjects-1.0.10/tests/codegen/test_cli_gen_unknown_attr.py

@@ -0,0 +1,70 @@
+"""`metaobjects gen` loads leniently, `verify` strictly (ADR-0023).
+
+An unknown attribute — `isAbstrakt: true` meant as `abstract`, a misspelt `required` —
+used to pass `gen` without a word while `verify` rejected the same file with
+ERR_UNKNOWN_ATTR, and the typo changed the output (the "abstract" base got a model
+file). `gen` now names each finding (attribute, node, file) as a warning on stderr and
+keeps its exit code.
+"""
+from __future__ import annotations
+
+from pathlib import Path
+
+from metaobjects.cli import main
+
+TYPO_YAML = """
+metadata:
+  package: app
+  children:
+    - object.entity:
+        name: BaseThing
+        isAbstrakt: true
+        children:
+          - field.long: { name: id }
+    - object.entity:
+        name: Talk
+        extends: BaseThing
+        children:
+          - source.rdb: { table: talks }
+          - field.string: { name: title, requird: true }
+          - identity.primary: { name: pk, fields: [id] }
+"""
+
+CLEAN_YAML = TYPO_YAML.replace("isAbstrakt: true", "abstract: true").replace("requird", "required")
+
+
+def _meta(tmp_path: Path, text: str) -> str:
+    d = tmp_path / "metaobjects"
+    d.mkdir()
+    (d / "meta.app.yaml").write_text(text)
+    return str(d)
+
+
+def test_gen_warns_on_each_unknown_attribute_and_keeps_exit_code(tmp_path: Path, capsys) -> None:
+    meta_dir = _meta(tmp_path, TYPO_YAML)
+    rc = main(["gen", "--generators", "entity", meta_dir, "--out", str(tmp_path / "out")])
+    assert rc == 0
+    err = capsys.readouterr().err
+    assert "ERR_UNKNOWN_ATTR" in err
+    assert "isAbstrakt" in err and "BaseThing" in err
+    assert "requird" in err and "title" in err
+    assert "meta.app.yaml" in err
+    assert "metaobjects verify" in err
+
+
+def test_gen_config_mode_warns_too(tmp_path: Path, capsys) -> None:
+    _meta(tmp_path, TYPO_YAML)
+    cfg = tmp_path / "metaobjects.config.yaml"
+    cfg.write_text("targets:\n  models:\n    outDir: gen/models\n    generators: [entity]\n")
+    rc = main(["gen", "--config", str(cfg)])
+    assert rc == 0
+    err = capsys.readouterr().err
+    assert "ERR_UNKNOWN_ATTR" in err
+    assert "requird" in err
+
+
+def test_gen_clean_model_prints_no_unknown_attr_warning(tmp_path: Path, capsys) -> None:
+    meta_dir = _meta(tmp_path, CLEAN_YAML)
+    rc = main(["gen", "--generators", "entity", meta_dir, "--out", str(tmp_path / "out")])
+    assert rc == 0
+    assert "ERR_UNKNOWN_ATTR" not in capsys.readouterr().err

metaobjects-1.0.10/tests/codegen/test_sourceless_entity_surface.py

@@ -0,0 +1,74 @@
+"""A SOURCELESS entity — ``object.entity`` with an ``identity.primary`` and no ``source.*`` —
+is a record in a store MetaObjects does not manage (a MongoDB collection, a Cassandra table, a
+Neo4j node, a remote API). It gets no router and no table (#248); the adopter owns the data
+access. What it still needs is the wire contract: the ``<E>Create`` / ``<E>Patch`` models (the
+entity generator already emits them for every entity) and the filter allowlist its own list
+endpoint validates a query against. Value objects are unchanged: ADR-0028 forbids them an
+identity.
+
+Mirror of the TypeScript ``sourceless-entity-surface.test.ts``.
+"""
+import json
+
+from metaobjects import InMemoryStringSource, MetaDataFormat, MetaDataLoader
+from metaobjects.codegen.generators.entity_model import EntityModelGenerator
+from metaobjects.codegen.generators.filter_allowlist_generator import render_filter_allowlist
+from metaobjects.codegen.generators.router_generator import render_router
+from metaobjects.codegen.generator import GenContext
+from metaobjects.codegen.config import GenConfig
+from metaobjects.codegen.instance_artifacts import is_sourceless_entity
+from metaobjects.meta.core.object.meta_object import MetaObject
+
+MODEL = {"metadata.root": {"package": "shop", "children": [
+    {"object.value": {"name": "LineItem", "children": [
+        {"field.string": {"name": "sku", "@required": True}},
+    ]}},
+    {"object.entity": {"name": "Order", "children": [
+        {"field.string": {"name": "id"}},
+        {"field.string": {"name": "customerEmail", "@required": True, "@filterable": True}},
+        {"field.enum": {"name": "status", "@values": ["NEW", "SHIPPED"], "@filterable": True}},
+        {"identity.primary": {"name": "id", "@fields": "id"}},
+    ]}},
+    {"object.entity": {"name": "Note", "children": [
+        {"field.string": {"name": "text"}},
+    ]}},
+]}}
+
+
+def _objects() -> dict[str, MetaObject]:
+    result = MetaDataLoader().load(
+        [InMemoryStringSource(json.dumps(MODEL), id="m.json", format=MetaDataFormat.JSON)]
+    )
+    assert not result.errors, result.errors
+    return {o.name: o for o in result.root.own_children() if isinstance(o, MetaObject)}
+
+
+def test_is_sourceless_entity_needs_an_identity_and_no_source() -> None:
+    objs = _objects()
+    assert is_sourceless_entity(objs["Order"]) is True
+    assert is_sourceless_entity(objs["LineItem"]) is False  # a value: no identity, ever
+    assert is_sourceless_entity(objs["Note"]) is False  # no identity: nothing to address
+
+
+def test_sourceless_entity_gets_a_filter_allowlist_but_no_router() -> None:
+    order = _objects()["Order"]
+    assert render_router(order) is None
+    out = render_filter_allowlist(order)
+    assert out is not None
+    assert '"customerEmail"' in out
+    assert '"status"' in out
+
+
+def test_value_object_gets_no_filter_allowlist() -> None:
+    assert render_filter_allowlist(_objects()["LineItem"]) is None
+
+
+def test_sourceless_entity_gets_create_and_patch_models() -> None:
+    objs = _objects()
+    root_objs = list(objs.values())
+    ctx = GenContext(entities=root_objs, loaded_root=root_objs[0].parent, matches=lambda _e: True,
+                     config=GenConfig(out_dir=""), warn=lambda _m: None)
+    files = {f.path: f.content for f in EntityModelGenerator().generate(ctx)}
+    order = next(c for p, c in files.items() if p.endswith("Order.py"))
+    assert "class OrderCreate(BaseModel)" in order
+    assert "class OrderPatch(BaseModel)" in order

{metaobjects-1.0.9rc5 → metaobjects-1.0.10}/tests/conformance/test_extract_conformance.py

@@ -23,6 +23,7 @@ from metaobjects.render.extract import (
     FieldSpec,
     Format,
     ExtractSchema,
+    Tolerance,
     extract,
 )
 
@@ -60,7 +61,7 @@ def _cases() -> list[str]:
 def test_discovers_all_extract_conformance_cases() -> None:
     """FR-011: lock the corpus size so a deleted fixture fails CI rather than
     silently reducing coverage. Mirrors the TS / Java / C# count guards."""
-    assert len(_cases()) == 42
+    assert len(_cases()) == 48
 
 
 _NORMALIZE_MODES = {"none", "collapse", "strip"}
@@ -76,6 +77,13 @@ def _parse_normalize(s: object) -> str:
 
 
 def _parse_field(f: dict[str, object]) -> FieldSpec:
+    # validator.array element-count bounds (array fields only).
+    min_items = int(f["minItems"]) if "minItems" in f else None  # type: ignore[arg-type]
+    max_items = int(f["maxItems"]) if "maxItems" in f else None  # type: ignore[arg-type]
+    return _parse_field_shape(f).with_item_bounds(min_items, max_items)
+
+
+def _parse_field_shape(f: dict[str, object]) -> FieldSpec:
     name = str(f["name"])
     kind = _KINDS[str(f["kind"])]
     required = bool(f.get("required", False))
@@ -116,6 +124,10 @@ def _parse_field(f: dict[str, object]) -> FieldSpec:
         max_v = float(f["max"]) if "max" in f else None  # type: ignore[arg-type]
         return FieldSpec.range_(name, kind, required, min_v, max_v)
 
+    # A scalar array (`tags: ["a", "b"]`): each element coerced to kind.
+    if bool(f.get("array", False)):
+        return FieldSpec.scalar_array(name, kind, required)
+
     # @xmlText: a scalar field that receives its element's text content (the #text sentinel).
     if bool(f.get("textContent", False)):
         return FieldSpec.text_content_field(name, kind, required)
@@ -165,6 +177,9 @@ def test_classification_and_canonical_value_match(case_name: str) -> None:
     opts = ExtractOptions.defaults()
     if bool(schema_node.get("rootless", False)):
         opts = opts.with_rootless(True)
+    # Optional per-fixture tolerance (default NORMAL).
+    if "tolerance" in schema_node:
+        opts = opts.with_tolerance(Tolerance[str(schema_node["tolerance"])])
 
     outcome = extract(text, schema, opts)