metaobjects 1.0.9rc6__tar.gz → 1.0.10__tar.gz

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

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "1.0.9rc6"
+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.9rc6 → 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.9rc6 → 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.9rc6 → 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.9rc6 → 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_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.9rc6 → 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()) == 45
+    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)
 

metaobjects-1.0.10/tests/conformance/test_extract_object_array_bounds.py

@@ -0,0 +1,58 @@
+"""validator.array (@min/@max) on an array field reaches the extract engine.
+
+A reply with too many elements keeps the first @max; one with too few is MALFORMED and
+counted in malformed_required, so the strict gate fails. Mirrors the TypeScript
+extract-object-array-bounds test and the Java MetaObjectExtractorArrayBoundsTest.
+"""
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from metaobjects import ExtractError, extract_object, extract_schema_for, load_string, or_throw
+from metaobjects.meta.core.object.meta_object import MetaObject
+from metaobjects.render.extract import FieldExtraction, Format
+
+META = {
+    "metadata.root": {
+        "package": "app",
+        "children": [
+            {"object.value": {"name": "Suggestion", "children": [
+                {"field.string": {"name": "tags", "@required": True, "isArray": True, "children": [
+                    {"validator.array": {"name": "threeTags", "@min": 3, "@max": 3}},
+                ]}},
+            ]}},
+        ],
+    }
+}
+
+
+def _suggestion() -> MetaObject:
+    result = load_string(json.dumps(META))
+    assert result.errors == [], f"load errors: {result.errors}"
+    mo = next(c for c in result.root.children() if isinstance(c, MetaObject) and c.name == "Suggestion")
+    return mo
+
+
+def test_schema_carries_the_bounds() -> None:
+    tags = extract_schema_for(_suggestion()).fields[0]
+    assert tags.min_items == 3
+    assert tags.max_items == 3
+
+
+def test_too_many_keeps_the_first_max() -> None:
+    mo = _suggestion()
+    result = extract_object(mo, '{"tags":["a","b","c","d","e"]}', Format.JSON)
+    assert result.report.states()["tags"] == FieldExtraction.EXTRACTED
+    field = mo.get_meta_field("tags")
+    assert field is not None
+    assert field.get_value(or_throw(result)) == ["a", "b", "c"]
+
+
+def test_too_few_is_malformed_required() -> None:
+    result = extract_object(_suggestion(), '{"tags":["a","b"]}', Format.JSON)
+    assert result.report.states()["tags"] == FieldExtraction.MALFORMED
+    assert list(result.report.malformed_required()) == ["tags"]
+    with pytest.raises(ExtractError):
+        or_throw(result)

{metaobjects-1.0.9rc6 → metaobjects-1.0.10}/uv.lock

@@ -250,7 +250,7 @@ wheels = [
 
 [[package]]
 name = "metaobjects"
-version = "1.0.8"
+version = "1.0.10"
 source = { editable = "." }
 dependencies = [
     { name = "pyyaml" },

metaobjects-1.0.9rc6/src/metaobjects/codegen/instance_artifacts.py

@@ -1,18 +0,0 @@
-"""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)