metaobjects 0.11.0__tar.gz → 0.11.1__tar.gz

{metaobjects-0.11.0 → metaobjects-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: metaobjects
-Version: 0.11.0
+Version: 0.11.1
 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.11.0 → metaobjects-0.11.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.11.0"
+version = "0.11.1"
 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.11.0 → metaobjects-0.11.1}/src/metaobjects/codegen/generators/entity_model.py

@@ -109,7 +109,10 @@ def _field_line(field: MetaField, imports: set[str], config: GenConfig) -> tuple
         pt = py_type_for(field)
         imports.update(pt.imports)
         type_expr = pt.expr
-    if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
+    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.
         ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
         if ref:
             # @objectRef is FQN-expanded at load time; the generated VOs live

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/codegen/type_map.py

@@ -65,6 +65,20 @@ def py_type_for(field: MetaField) -> PyType:
     constrained, Pydantic runtime-validated) rather than bare ``str``; an enum array
     becomes ``list[Literal[...]]``. An enum WITHOUT declared values falls back to
     ``str``."""
+    if field.sub_type == fc.FIELD_SUBTYPE_MAP:
+        # field.map → dict[str, V]. Keys are always strings; V is a value-object
+        # (@objectRef → bare class name) or a scalar (@valueType, defaulting to
+        # str). A map is stored as a single jsonb/object column and is NEVER
+        # wrapped in list[...] (isArray does not apply), so return directly.
+        ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
+        if ref:
+            # @objectRef is expanded to a package-qualified FQN at load time; the
+            # emitted VOs live flat in one generated package, so type by the bare
+            # class name (mirrors the field.object branch below).
+            return PyType(f"dict[str, {str(ref).split('::')[-1]}]")
+        value_type = field.attrs().get(fc.FIELD_ATTR_VALUE_TYPE)
+        value = _SCALAR.get(str(value_type), PyType("str")) if value_type else PyType("str")
+        return PyType(f"dict[str, {value.expr}]", value.imports)
     if field.sub_type == fc.FIELD_SUBTYPE_OBJECT:
         ref = field.attrs().get(fc.FIELD_ATTR_OBJECT_REF)
         # @objectRef is expanded to a package-qualified FQN at load time

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/core_types.py

@@ -26,6 +26,7 @@ from .meta.core.field.field_constants import (
     FIELD_ATTR_SCALE,
     FIELD_ATTR_STORAGE,
     FIELD_ATTR_UNIQUE,
+    FIELD_ATTR_VALUE_TYPE,
     FIELD_ATTR_VALUES,
     FIELD_SUBTYPE_ENUM,
     STORAGE_VALUES,
@@ -335,6 +336,18 @@ for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment
         )
         break
 
+# field.map carries the @valueType attr (scalar value subtype) IN ADDITION to the
+# common field attrs (@objectRef is already common). The bulk loop registered
+# field.map with the common attrs; append @valueType to that definition (mirrors
+# TS, where field.map's attr set = commonFieldAttrs + @valueType + @objectRef).
+# The exactly-one-of @valueType/@objectRef rule is enforced by validation_passes.
+for _def in core_provider._defs:  # noqa: SLF001 (provider build-time enrichment)
+    if _def.type == TYPE_FIELD and _def.sub_type == fc.FIELD_SUBTYPE_MAP:
+        _def.attrs.append(
+            AttrSchema(name=FIELD_ATTR_VALUE_TYPE, value_type=ATTR_SUBTYPE_STRING, required=False)
+        )
+        break
+
 # field.enum — dedicated registration with required @values attr.
 # Inherits every common field attr (column / required / unique / default /
 # maxLength / filterable / sortable / etc.) so the D2 type-coercion guard

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/loader/validation_passes.py

@@ -22,18 +22,23 @@ from ..meta.core.field.field_constants import (
     FIELD_ATTR_DEFAULT,
     FIELD_ATTR_OBJECT_REF,
     FIELD_ATTR_STORAGE,
+    FIELD_ATTR_VALUE_TYPE,
     FIELD_ATTR_VALUES,
     FIELD_SUBTYPE_BOOLEAN,
     FIELD_SUBTYPE_CURRENCY,
+    FIELD_SUBTYPE_DATE,
     FIELD_SUBTYPE_DECIMAL,
     FIELD_SUBTYPE_DOUBLE,
     FIELD_SUBTYPE_ENUM,
     FIELD_SUBTYPE_FLOAT,
     FIELD_SUBTYPE_INT,
     FIELD_SUBTYPE_LONG,
+    FIELD_SUBTYPE_MAP,
     FIELD_SUBTYPE_OBJECT,
     FIELD_SUBTYPE_STRING,
+    FIELD_SUBTYPE_TIME,
     FIELD_SUBTYPE_TIMESTAMP,
+    FIELD_SUBTYPE_UUID,
 )
 from ..meta.persistence.db.db_constants import (
     DB_COLUMN_TYPE_JSONB,
@@ -156,6 +161,9 @@ def run_validations(
     # FR-015 — source.rdb @parameterRef typed-input rules.
     validate_source_parameter_ref(root, errors)
     _validate_field_object_storage(root, errors)
+    # field.map — exactly one of @valueType (scalar) or @objectRef (VO), and
+    # @valueType (when set) must name a known scalar subtype.
+    _validate_field_map(root, errors)
     _validate_templates(root, errors)
     _validate_subtype_rules(root, errors, warnings)
     _validate_max_occurs(root, registry, errors)
@@ -1527,6 +1535,72 @@ def _validate_field_object_storage(root: MetaData, errors: list[MetaError]) -> N
             ))
 
 
+# ---------------------------------------------------------------------------
+# Pass: field.map value-type validation
+#
+# A field.map is an open-keyed map (dict[str, V] / Record<string,V>) stored in a
+# single jsonb column. Keys are always strings. The value type is set by EXACTLY
+# ONE of @valueType (a scalar value subtype) or @objectRef (a value-object). This
+# pass enforces that exactly-one-of rule and that @valueType (when set) names a
+# known scalar subtype. Cross-port parity: TS validateFieldMap, Java
+# validateFieldMap, C# ValidateFieldMap.
+# ---------------------------------------------------------------------------
+
+# Scalar value subtypes legal as a field.map @valueType (mirrors the TS
+# _MAP_SCALAR_VALUE_SUBTYPES set).
+_MAP_SCALAR_VALUE_SUBTYPES = frozenset({
+    FIELD_SUBTYPE_STRING,
+    FIELD_SUBTYPE_INT,
+    FIELD_SUBTYPE_LONG,
+    FIELD_SUBTYPE_DOUBLE,
+    FIELD_SUBTYPE_FLOAT,
+    FIELD_SUBTYPE_DECIMAL,
+    FIELD_SUBTYPE_BOOLEAN,
+    FIELD_SUBTYPE_DATE,
+    FIELD_SUBTYPE_TIME,
+    FIELD_SUBTYPE_TIMESTAMP,
+    FIELD_SUBTYPE_UUID,
+})
+
+
+def _validate_field_map(root: MetaData, errors: list[MetaError]) -> None:
+    for obj in (c for c in root.own_children() if c.type == TYPE_OBJECT):
+        for field in (c for c in obj.own_children() if c.type == TYPE_FIELD):
+            if field.sub_type != FIELD_SUBTYPE_MAP:
+                continue
+
+            value_type = field.attr(FIELD_ATTR_VALUE_TYPE)
+            has_value_type = isinstance(value_type, str) and bool(value_type)
+            object_ref = field.attr(FIELD_ATTR_OBJECT_REF)
+            has_object_ref = isinstance(object_ref, str) and bool(object_ref)
+
+            if has_value_type == has_object_ref:
+                which = "both are set" if has_value_type else "neither is set"
+                errors.append(MetaError(
+                    code=ErrorCode.ERR_BAD_ATTR_VALUE,
+                    message=(
+                        f'field.map "{obj.name}.{field.name}" must set exactly one of '
+                        f"@valueType (a scalar value subtype) or @objectRef (a "
+                        f"value-object); {which}"
+                    ),
+                    envelope=field.source,
+                ))
+                continue
+
+            if has_value_type and value_type not in _MAP_SCALAR_VALUE_SUBTYPES:
+                errors.append(MetaError(
+                    code=ErrorCode.ERR_BAD_ATTR_VALUE,
+                    message=(
+                        f'field.map "{obj.name}.{field.name}" has @valueType '
+                        f'"{value_type}" which is not a scalar value subtype '
+                        f"(string/int/long/double/float/decimal/boolean/date/time/"
+                        f"timestamp/uuid). For a value-object-valued map use @objectRef "
+                        f"instead."
+                    ),
+                    envelope=field.source,
+                ))
+
+
 # ---------------------------------------------------------------------------
 # Pass: template.* validation (FR-004)
 # ---------------------------------------------------------------------------

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/meta/core/field/field_constants.py

@@ -12,6 +12,10 @@ FIELD_SUBTYPE_TIMESTAMP = "timestamp"
 FIELD_SUBTYPE_TIME = "time"
 FIELD_SUBTYPE_DECIMAL = "decimal"
 FIELD_SUBTYPE_OBJECT = "object"
+# An open-keyed map (dict[str, V] / Record<string,V>) stored in a single jsonb
+# column. Keys are always strings; the value type is set by @valueType (a scalar
+# field subtype) or @objectRef (a value-object). Mirrors TS FIELD_SUBTYPE_MAP.
+FIELD_SUBTYPE_MAP = "map"
 FIELD_SUBTYPE_CURRENCY = "currency"
 FIELD_SUBTYPE_ENUM = "enum"
 # R6 Plan 2a — field.uuid is a logical identity scalar (ADR-0013). String-backed
@@ -33,6 +37,7 @@ FIELD_SUBTYPES = (
     FIELD_SUBTYPE_TIME,
     FIELD_SUBTYPE_DECIMAL,
     FIELD_SUBTYPE_OBJECT,
+    FIELD_SUBTYPE_MAP,
     FIELD_SUBTYPE_CURRENCY,
     FIELD_SUBTYPE_UUID,
     # Note: FIELD_SUBTYPE_ENUM is intentionally excluded here; it is registered
@@ -58,6 +63,10 @@ FIELD_ATTR_SORTABLE = "sortable"
 FIELD_ATTR_SORTABLE_DEFAULT_ORDER = "sortableDefaultOrder"
 FIELD_ATTR_AUTO_SET = "autoSet"
 FIELD_ATTR_OBJECT_REF = "objectRef"
+# @valueType — scalar value subtype of a field.map (open-keyed map). Mutually
+# exclusive with @objectRef (which sets a value-object value type); exactly one of
+# the two must be set. Keys are always strings. Mirrors TS FIELD_ATTR_VALUE_TYPE.
+FIELD_ATTR_VALUE_TYPE = "valueType"
 FIELD_ATTR_VALUES = "values"
 # FR-010 field-teaching attrs (any field; drive the output-format prompt fragment).
 # Never carried in comments.

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/meta/core/field/meta_field.py

@@ -17,6 +17,9 @@ _FIELD_DATA_TYPE = {
     fc.FIELD_SUBTYPE_TIME: DataType.DATE,
     fc.FIELD_SUBTYPE_DECIMAL: DataType.DECIMAL,
     fc.FIELD_SUBTYPE_OBJECT: DataType.OBJECT,
+    # field.map is the map analog of field.object — an open-keyed map stored as a
+    # single jsonb/object column. Same logical data type as field.object.
+    fc.FIELD_SUBTYPE_MAP: DataType.OBJECT,
     fc.FIELD_SUBTYPE_CURRENCY: DataType.LONG,
     fc.FIELD_SUBTYPE_ENUM: DataType.STRING,
     # R6 Plan 2a — field.uuid is string-backed on the wire; the native uuid.UUID

{metaobjects-0.11.0 → metaobjects-0.11.1}/src/metaobjects/spec_metamodel/field.json

@@ -105,6 +105,18 @@
         { "type": "attr", "subType": "string", "name": "objectRef", "min": 0, "max": 1, "description": "Name (or FQN) of the target object an object-typed field nests — drives nested-object (de)serialization." }
       ]
     },
+    {
+      "type": "field",
+      "subType": "map",
+      "dataType": "object",
+      "extendsBase": true,
+      "description": "An open-keyed map (Record<string,V> / dict[str,V]) stored in a single jsonb column. Keys are always strings (the JSON object constraint); the value type is set by @valueType (a scalar field subtype) or @objectRef (a value-object).",
+      "rules": "Keys are always strings. Set exactly one of @valueType (a scalar value subtype: string/int/long/double/float/decimal/boolean/date/time/timestamp/uuid) or @objectRef (a value-object name or FQN). Stored as a single jsonb column holding the JSON object — never a native array; isArray does not apply.",
+      "children": [
+        { "type": "attr", "subType": "string", "name": "valueType", "min": 0, "max": 1, "description": "Scalar value subtype for a scalar-valued map (string/int/long/double/float/decimal/boolean/date/time/timestamp/uuid). Mutually exclusive with @objectRef; exactly one of the two must be set." },
+        { "type": "attr", "subType": "string", "name": "objectRef", "min": 0, "max": 1, "description": "Name (or FQN) of the value-object for a value-object-valued map. Mutually exclusive with @valueType; exactly one of the two must be set." }
+      ]
+    },
     {
       "type": "field",
       "subType": "currency",

{metaobjects-0.11.0 → metaobjects-0.11.1}/tests/codegen/test_type_map.py

@@ -5,11 +5,19 @@ from metaobjects.meta.core.field import field_constants as fc
 from metaobjects.shared.base_types import TYPE_FIELD
 
 
-def _field(sub_type: str, *, is_array: bool = False, object_ref: str | None = None) -> MetaField:
+def _field(
+    sub_type: str,
+    *,
+    is_array: bool = False,
+    object_ref: str | None = None,
+    value_type: str | None = None,
+) -> MetaField:
     f = MetaField(TYPE_FIELD, sub_type, "x")
     f.is_array = is_array
     if object_ref is not None:
         f.set_attr(fc.FIELD_ATTR_OBJECT_REF, object_ref)
+    if value_type is not None:
+        f.set_attr(fc.FIELD_ATTR_VALUE_TYPE, value_type)
     return f
 
 
@@ -60,6 +68,32 @@ def test_uuid_binds_native_uuid_with_import() -> None:
     assert "import uuid" in t.imports
 
 
+def test_map_with_scalar_value_type() -> None:
+    # field.map → dict[str, V]; V is the scalar Python type for @valueType.
+    assert py_type_for(_field(fc.FIELD_SUBTYPE_MAP, value_type="string")).expr == "dict[str, str]"
+    assert py_type_for(_field(fc.FIELD_SUBTYPE_MAP, value_type="int")).expr == "dict[str, int]"
+    # A scalar value type that carries an import propagates it to the map type.
+    dec = py_type_for(_field(fc.FIELD_SUBTYPE_MAP, value_type="decimal"))
+    assert dec.expr == "dict[str, Decimal]" and "from decimal import Decimal" in dec.imports
+
+
+def test_map_with_object_ref() -> None:
+    # field.map with @objectRef → dict[str, <VO bare name>] (FQN folded to base).
+    assert py_type_for(_field(fc.FIELD_SUBTYPE_MAP, object_ref="SomeVO")).expr == "dict[str, SomeVO]"
+    assert (
+        py_type_for(_field(fc.FIELD_SUBTYPE_MAP, object_ref="acme::pkg::SomeVO")).expr
+        == "dict[str, SomeVO]"
+    )
+
+
+def test_map_is_never_wrapped_in_list() -> None:
+    # isArray does not apply to a map — it is a single jsonb/object column.
+    assert (
+        py_type_for(_field(fc.FIELD_SUBTYPE_MAP, value_type="string", is_array=True)).expr
+        == "dict[str, str]"
+    )
+
+
 def test_dbcolumntype_uuid_string_stays_str() -> None:
     # R6 Plan 2b — @dbColumnType:uuid only changes the DB column type; the native
     # binding of a field.string is unchanged (stays a Python str).

metaobjects-0.11.1/tests/unit/test_field_map_validation.py

@@ -0,0 +1,92 @@
+"""Unit tests for the field.map value-type validation pass.
+
+A ``field.map`` is an open-keyed map (``dict[str, V]`` / ``Record<string,V>``)
+stored in a single jsonb column. Keys are always strings; the value type is set
+by EXACTLY ONE of ``@valueType`` (a scalar value subtype) or ``@objectRef`` (a
+value-object). This suite exercises the loader's ``_validate_field_map`` pass —
+cross-port parity with the TS ``validateFieldMap``.
+"""
+from __future__ import annotations
+
+import json
+
+from metaobjects import MetaDataLoader
+from metaobjects.errors import ErrorCode
+
+
+def _load(*map_attrs: dict[str, object]):
+    """Load a root with one VO (``Score``) and an entity carrying one field.map
+    per supplied attr dict. Returns the LoadResult."""
+    map_fields = [
+        {"field.map": {"name": f"m{i}", **attrs}} for i, attrs in enumerate(map_attrs)
+    ]
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "object.value": {
+                        "name": "Score",
+                        "children": [{"field.int": {"name": "points"}}],
+                    }
+                },
+                {
+                    "object.entity": {
+                        "name": "Player",
+                        "children": [
+                            {"field.long": {"name": "id"}},
+                            *map_fields,
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+            ],
+        }
+    }
+    return MetaDataLoader.from_string(json.dumps(doc))
+
+
+def _bad_attr_errors(result) -> list[str]:
+    return [e.message for e in result.errors if e.code is ErrorCode.ERR_BAD_ATTR_VALUE]
+
+
+def test_value_type_only_loads_clean() -> None:
+    result = _load({"@valueType": "string"})
+    assert not result.errors, [str(e) for e in result.errors]
+
+
+def test_object_ref_only_loads_clean() -> None:
+    result = _load({"@objectRef": "Score"})
+    assert not result.errors, [str(e) for e in result.errors]
+
+
+def test_neither_value_type_nor_object_ref_is_an_error() -> None:
+    result = _load({})
+    errs = _bad_attr_errors(result)
+    assert errs, "field.map with neither @valueType nor @objectRef must error"
+    assert any("neither is set" in m for m in errs)
+
+
+def test_both_value_type_and_object_ref_is_an_error() -> None:
+    result = _load({"@valueType": "string", "@objectRef": "Score"})
+    errs = _bad_attr_errors(result)
+    assert errs, "field.map with both @valueType and @objectRef must error"
+    assert any("both are set" in m for m in errs)
+
+
+def test_non_scalar_value_type_is_an_error() -> None:
+    # "object" is a field subtype but NOT a scalar value subtype — a VO-valued
+    # map must use @objectRef instead.
+    result = _load({"@valueType": "object"})
+    errs = _bad_attr_errors(result)
+    assert errs, "field.map with a non-scalar @valueType must error"
+    assert any("not a scalar value subtype" in m for m in errs)
+
+
+def test_every_scalar_value_type_loads_clean() -> None:
+    scalars = [
+        "string", "int", "long", "double", "float", "decimal",
+        "boolean", "date", "time", "timestamp", "uuid",
+    ]
+    result = _load(*({"@valueType": s} for s in scalars))
+    assert not result.errors, [str(e) for e in result.errors]