metaobjects 0.19.9__tar.gz → 0.20.11__tar.gz

{metaobjects-0.19.9 → metaobjects-0.20.11}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.19.9"
+version = "0.20.11"
 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.9 → metaobjects-0.20.11}/src/metaobjects/errors.py

@@ -180,6 +180,11 @@ class ErrorCode(str, Enum):
     ERR_SQL_BODY_WITH_UNMANAGED = "ERR_SQL_BODY_WITH_UNMANAGED"
     ERR_SQL_BODY_ON_WRITABLE_KIND = "ERR_SQL_BODY_ON_WRITABLE_KIND"
     ERR_ORIGIN_UNDER_SQL_BODY = "ERR_ORIGIN_UNDER_SQL_BODY"
+    # #246 — a field.enum both extends a shared package-level abstract enum and
+    # declares its own @values. One shared enum type has one member set — the
+    # own @values would be silently dropped in codegen. Remove the own @values
+    # to inherit the shared set, or extend a concrete (non-shared) enum instead.
+    ERR_ENUM_EXTENDS_VALUES_CONFLICT = "ERR_ENUM_EXTENDS_VALUES_CONFLICT"
     ERR_UNKNOWN = "ERR_UNKNOWN"
 
 

{metaobjects-0.19.9 → metaobjects-0.20.11}/src/metaobjects/loader/validation_passes.py

@@ -68,6 +68,7 @@ from ..shared.base_types import (
     TYPE_IDENTITY,
     TYPE_INDEX,
     TYPE_LAYOUT,
+    TYPE_METADATA,
     TYPE_OBJECT,
     TYPE_ORIGIN,
     TYPE_RELATIONSHIP,
@@ -599,6 +600,33 @@ def _validate_enum_values(
                 )
             )
 
+        # #246: own @values AND extends a shared package-level abstract enum —
+        # one shared enum type has one member set, so the own @values would be
+        # silently dropped by the shared-enum codegen collapse. "Shared" means
+        # the resolved super is abstract AND declared at metadata-root (its
+        # parent is the metadata.root node, not nested inside an object) — a
+        # concrete super, or a non-root abstract super (e.g. nested inside an
+        # object), is legal and not flagged. Mirrors the TS reference
+        # (attr-schema-validate.ts).
+        sup = node.super_data
+        if (
+            sup is not None
+            and sup.is_abstract
+            and sup.parent is not None
+            and sup.parent.type == TYPE_METADATA
+        ):
+            errors.append(
+                MetaError(
+                    f"{label} declares its own '@{FIELD_ATTR_VALUES}' but extends "
+                    f"a shared package-level abstract enum — one shared enum type "
+                    f"has one member set. Remove the own '@{FIELD_ATTR_VALUES}' to "
+                    f"inherit the shared set, or extend a concrete (non-shared) "
+                    f"enum instead",
+                    ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT,
+                    envelope=node.source,
+                )
+            )
+
 
 def _effective_enum_values(node: MetaData) -> list[str]:
     """The effective ``@values`` members of an enum node (own or inherited via

metaobjects-0.20.11/tests/loader/test_enum_extends_values_conflict.py

@@ -0,0 +1,167 @@
+"""#246 — field.enum extends-a-shared-enum-AND-declares-own-@values conflict.
+
+Mirrors the TS reference test
+(server/typescript/packages/metadata/test/enum-extends-values-conflict.test.ts):
+a field.enum that both `extends` a shared PACKAGE-LEVEL abstract enum AND
+declares its own `@values` must fail to load with
+ERR_ENUM_EXTENDS_VALUES_CONFLICT — one shared enum type has one member set, so
+the own `@values` would be silently dropped by the shared-enum codegen
+collapse.
+
+Three cases (the third pins the "root-level" clause of the predicate — Task 3's
+review required it: dropping `sup.parent.type == TYPE_METADATA` would let a
+non-root abstract super go unrejected):
+
+  1. CONFLICT — extends a root-level (metadata.root child) abstract enum, and
+     also declares its own @values.
+  2. LEGAL — extends a CONCRETE (non-abstract) enum, and also declares its own
+     @values.
+  3. LEGAL — extends an ABSTRACT but NON-ROOT enum (declared as a child of an
+     object.entity, not the shared package level), and also declares its own
+     @values.
+"""
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+from pathlib import Path
+
+from metaobjects import MetaDataLoader
+from metaobjects.core_types import core_provider
+from metaobjects.errors import ErrorCode
+
+
+def _load_codes(doc: dict) -> list[ErrorCode]:
+    """Load a doc dict via a temp file; return the loader's error codes."""
+    with tempfile.TemporaryDirectory() as tmpdir:
+        path = os.path.join(tmpdir, "meta.test.json")
+        Path(path).write_text(json.dumps(doc))
+        result = MetaDataLoader.from_directory(tmpdir, providers=[core_provider])
+        return [e.code for e in result.errors]
+
+
+def test_conflict_extends_root_level_abstract_enum_with_own_values() -> None:
+    """Extending a root-level (shared, package-level) abstract enum while also
+    declaring own @values must fail with ERR_ENUM_EXTENDS_VALUES_CONFLICT."""
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "field.enum": {
+                        "name": "Status",
+                        "abstract": True,
+                        "@values": ["A", "B"],
+                    }
+                },
+                {
+                    "object.entity": {
+                        "name": "Order",
+                        "children": [
+                            {"field.long": {"name": "id"}},
+                            {
+                                "field.enum": {
+                                    "name": "status",
+                                    "extends": "acme::Status",
+                                    "@values": ["A", "B", "C"],
+                                }
+                            },
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+            ],
+        }
+    }
+    codes = _load_codes(doc)
+    assert codes.count(ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT) == 1, (
+        f"Expected exactly one ERR_ENUM_EXTENDS_VALUES_CONFLICT; got {codes}"
+    )
+
+
+def test_legal_extends_concrete_enum_with_own_values() -> None:
+    """Extending a CONCRETE (non-abstract) enum while also declaring own
+    @values is legal — no ERR_ENUM_EXTENDS_VALUES_CONFLICT."""
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "field.enum": {
+                        "name": "Status",
+                        "@values": ["A", "B"],
+                    }
+                },
+                {
+                    "object.entity": {
+                        "name": "Order",
+                        "children": [
+                            {"field.long": {"name": "id"}},
+                            {
+                                "field.enum": {
+                                    "name": "status",
+                                    "extends": "acme::Status",
+                                    "@values": ["A", "B", "C"],
+                                }
+                            },
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+            ],
+        }
+    }
+    codes = _load_codes(doc)
+    assert ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT not in codes, (
+        f"Did not expect ERR_ENUM_EXTENDS_VALUES_CONFLICT; got {codes}"
+    )
+
+
+def test_legal_extends_non_root_abstract_enum_with_own_values() -> None:
+    """Extending an ABSTRACT but NON-ROOT enum (nested inside an object, not
+    declared at the shared package level) while also declaring own @values is
+    legal — no ERR_ENUM_EXTENDS_VALUES_CONFLICT. Pins the `sup.parent.type ==
+    TYPE_METADATA` clause of the predicate."""
+    doc = {
+        "metadata.root": {
+            "package": "acme",
+            "children": [
+                {
+                    "object.entity": {
+                        "name": "Container",
+                        "abstract": True,
+                        "children": [
+                            {
+                                "field.enum": {
+                                    "name": "kind",
+                                    "abstract": True,
+                                    "@values": ["X", "Y"],
+                                }
+                            }
+                        ],
+                    }
+                },
+                {
+                    "object.entity": {
+                        "name": "Order",
+                        "children": [
+                            {"field.long": {"name": "id"}},
+                            {
+                                "field.enum": {
+                                    "name": "status",
+                                    "extends": "acme::Container.kind",
+                                    "@values": ["X", "Y", "Z"],
+                                }
+                            },
+                            {"identity.primary": {"@fields": "id"}},
+                        ],
+                    }
+                },
+            ],
+        }
+    }
+    codes = _load_codes(doc)
+    assert ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT not in codes, (
+        f"Did not expect ERR_ENUM_EXTENDS_VALUES_CONFLICT; got {codes}"
+    )

{metaobjects-0.19.9 → metaobjects-0.20.11}/uv.lock

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