metaobjects 0.23.1__tar.gz → 0.23.2__tar.gz

{metaobjects-0.23.1 → metaobjects-0.23.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: metaobjects
-Version: 0.23.1
+Version: 0.23.2
 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.23.1 → metaobjects-0.23.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "metaobjects"
-version = "0.23.1"
+version = "0.23.2"
 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.23.1 → metaobjects-0.23.2}/src/metaobjects/codegen/generators/filter_allowlist_generator.py

@@ -53,6 +53,11 @@ _OPS_STRING: tuple[str, ...] = ("eq", "ne", "in", "like", "isNull")
 # uuid: identity-comparison only — no `like` (not a substring type), no ordering.
 _OPS_UUID: tuple[str, ...] = ("eq", "ne", "in", "isNull")
 _OPS_NUMERIC: tuple[str, ...] = ("eq", "ne", "gt", "gte", "lt", "lte", "in", "isNull")
+# int-backed enum (@intValueMap, design D5): the enum band minus `like` — the column
+# is an integer, and a substring match against an integer is meaningless. Distinct
+# constant from _OPS_UUID despite the identical members: they narrow for different
+# reasons and would diverge independently.
+_OPS_ENUM_INT_BACKED: tuple[str, ...] = ("eq", "ne", "in", "isNull")
 _OPS_BOOLEAN: tuple[str, ...] = ("eq", "isNull")
 
 
@@ -118,6 +123,36 @@ def ops_for_subtype_ordered(sub_type: str | None) -> tuple[str, ...]:
     return ()
 
 
+def ops_for_field_ordered(field: MetaField) -> tuple[str, ...]:
+    """The operator tuple for a FIELD, in canonical operator order.
+
+    The ordered counterpart of ``validation_passes.ops_for_field``, and the entry
+    point for every consumer that has a field in hand: the codegen allowlist emit
+    and the cross-port ``field.filter-ops`` conformance capability.
+
+    Identical to :func:`ops_for_subtype_ordered` except for ONE case: an int-backed
+    ``field.enum`` (one declaring ``@intValueMap``, design D5) persists as an INTEGER
+    column, so ``like`` -- a substring match -- is dropped. ``eq``/``ne``/``in``
+    survive because the member symbol encodes to its integer before it reaches SQL;
+    ``like`` has no such encoding, and an unencoded ``LIKE 'DRAFT'`` against an integer
+    column is a request-time type error.
+
+    ADR-0039: the ``@intValueMap`` read is RESOLVING (``attrs()``, NOT ``attr()`` --
+    Python inverts the TS naming, ``attr()`` here is own-only). Post-#246 the map lives
+    on a shared root-level abstract declaration and consuming fields INHERIT it, so an
+    own-only read would see it absent on exactly the shape adopters are steered toward
+    and wrongly keep ``like``.
+
+    Cross-port: ``fixtures/conformance/filter-ops-matrix`` pins ``fEnum`` vs
+    ``fEnumInt`` in all five ports.
+    """
+    if field.sub_type == fc.FIELD_SUBTYPE_ENUM and isinstance(
+        field.attrs().get(fc.FIELD_ATTR_INT_VALUE_MAP), dict
+    ):
+        return _OPS_ENUM_INT_BACKED
+    return ops_for_subtype_ordered(field.sub_type)
+
+
 def _is_filterable(field: MetaField) -> bool:
     """True iff ``field`` carries ``@filterable: true`` as a metadata attribute.
 
@@ -166,10 +201,10 @@ class FilterAllowlistGenerator:
     name = "filter-allowlist-generator"
 
     def _ops_for_field(self, field: MetaField) -> tuple[str, ...]:
-        """The operator tuple allowed for ``field`` (FR-009 §5 per-subtype matrix by
-        default). Override to customize the per-field operator vocabulary; returning
-        an empty tuple excludes the field from the allowlist."""
-        return ops_for_subtype_ordered(field.sub_type)
+        """The operator tuple allowed for ``field`` (FR-009 §5 matrix by default).
+        Override to customize the per-field operator vocabulary; returning an empty
+        tuple excludes the field from the allowlist."""
+        return ops_for_field_ordered(field)
 
     def _compute_filterable_ops(
         self, entity: MetaObject, object_index: dict[str, MetaObject] | None = None

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/core_types.py

@@ -9,6 +9,7 @@ from .meta.core.attr.attr_constants import (
     ATTR_SUBTYPE_EXPRESSION,
     ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_STRING,
     ATTR_SUBTYPES,
 )
@@ -19,6 +20,7 @@ from .meta.core.field.field_constants import (
     FIELD_ATTR_AUTO_SET,
     FIELD_ATTR_CURRENCY,
     FIELD_ATTR_DEFAULT,
+    FIELD_ATTR_INT_VALUE_MAP,
     FIELD_ATTR_PROVIDED,
     FIELD_ATTR_MAX_LENGTH,
     FIELD_ATTR_OBJECT_REF,
@@ -472,6 +474,17 @@ core_provider.add(
                 value_type=ATTR_SUBTYPE_BOOLEAN,
                 required=False,
             ),
+            # int-backed-enum-values plan — @intValueMap: optional per-member int
+            # values ({member: int}) switching this enum field's DB persistence
+            # from string+CHECK to integer+CHECK. Keys must exactly match @values;
+            # values must be unique integers (enforced in _validate_enum_values,
+            # Rule 4). Structural (core), like @values / @provided — not a
+            # TS-web-only / prompt-domain overlay.
+            AttrSchema(
+                name=FIELD_ATTR_INT_VALUE_MAP,
+                value_type=ATTR_SUBTYPE_INT_MAP,
+                required=False,
+            ),
             # FR-033 — the field.enum tolerant-extract overlays (@enumAlias / @enumDoc /
             # @coerceDefault / @normalize) are NO LONGER declared here; they are re-homed
             # to the prompt domain provider (`prompt_provider`, metaobjects-prompt) via

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/errors.py

@@ -194,6 +194,12 @@ class ErrorCode(str, Enum):
     # 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"
+    # A field.enum carries @intValueMap together with isArray=true. Int-backing is
+    # a persistence-layer codec and no port implements it element-wise over an
+    # array column, so the combination would silently persist member SYMBOLS into
+    # an integer array. An array-of-enum stays string-backed: drop @intValueMap,
+    # or make the field scalar.
+    ERR_ENUM_INT_VALUE_MAP_ARRAY = "ERR_ENUM_INT_VALUE_MAP_ARRAY"
     ERR_UNKNOWN = "ERR_UNKNOWN"
 
 

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/loader/validation_passes.py

@@ -23,6 +23,7 @@ from ..meta.core.field.field_constants import (
     ENUM_MEMBER_PATTERN,
     FIELD_ATTR_COERCE_DEFAULT,
     FIELD_ATTR_DEFAULT,
+    FIELD_ATTR_INT_VALUE_MAP,
     FIELD_ATTR_OBJECT_REF,
     FIELD_ATTR_REQUIRED,
     FIELD_ATTR_STORAGE,
@@ -60,6 +61,7 @@ from ..meta.persistence.source.source_constants import (
     SOURCE_ROLE_PRIMARY,
 )
 from ..meta.core.attr.attr_constants import (
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_STRINGARRAY,
 )
@@ -281,6 +283,26 @@ def _type_ok(value: object, value_type: str) -> bool:
         # fails here → ERR_BAD_ATTR_VALUE, matching TS + Java (fail-closed); an object
         # @expr then flows to the closed-grammar check in the origin pass.
         return isinstance(value, dict)
+    if value_type == ATTR_SUBTYPE_INT_MAP:
+        # attr.intMap (int-backed-enum-values plan): an object whose every member
+        # value is an integer (e.g. field.enum's @intValueMap). This port has no
+        # per-attr-class validateValue dispatch (that's TS's architecture); the
+        # generic shape check lives here, mirroring C#'s ValueMatchesType
+        # ATTR_SUBTYPE_INT_MAP case. field.enum's own key-set/uniqueness content
+        # rules run separately in _validate_enum_values (Rule 4), which skips
+        # re-reporting a non-integer member already caught here.
+        #
+        # Final-review fix: also bound every value to the 32-bit signed int range
+        # (inclusive) — the eventual DB column for an int-backed enum is a 32-bit
+        # Postgres/SQLite `integer` (design doc D5), matching Java's
+        # IntMapAttribute#setValueAsString bound check exactly. Python ints have
+        # no fixed width, so this is the only place that boundary is enforced.
+        return isinstance(value, dict) and all(
+            isinstance(v, int)
+            and not isinstance(v, bool)
+            and -2147483648 <= v <= 2147483647
+            for v in value.values()
+        )
     # Unknown value types (e.g. "class") — allow anything.
     return True
 
@@ -544,6 +566,32 @@ def _validate_attr_schema(
 _ENUM_MEMBER_RE = re.compile(ENUM_MEMBER_PATTERN)
 
 
+def _shared_enum_super(node: MetaData) -> MetaData | None:
+    """The shared-enum super of ``node``, or ``None`` when it has none.
+
+    "Shared" (FR-019 / #246) means the immediate super is abstract AND declared at
+    metadata-root — its parent is the ``metadata.root`` node, not an object. Such a
+    declaration is materialized ONCE per port as a single named type, so anything a
+    consuming field re-declares that belongs to the shared TYPE's contract (its
+    ``@values`` member set, or the ``@intValueMap`` integer backing of that set) is a
+    conflict. A concrete super, or a non-root abstract super (e.g. one nested inside
+    an object), is legal and not flagged.
+
+    Immediate-super-only, matching codegen's ``resolve_shared_enum_decl``
+    (``codegen/generators/fr019_shared_enum.py``) so the validator and the
+    shared-enum collapse agree on what "shared" means.
+    """
+    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
+    ):
+        return sup
+    return None
+
+
 def _validate_enum_values(
     root: MetaData,
     errors: list[MetaError],
@@ -556,6 +604,21 @@ def _validate_enum_values(
         # @coerceDefault / @default / @normalize while inheriting @values).
         _validate_enum_fr011_attrs(node, errors)
 
+        # Rule 4 (@intValueMap content rules) is independent of whether @values is
+        # own or inherited on THIS node — it must run whenever this node owns
+        # @intValueMap, using the EFFECTIVE @values (own-or-inherited) as the
+        # membership set. Mirrors TS/C#/Java, which all check this unconditionally
+        # (Java's `validateEnumIntValueMap` is a standalone call at the top of
+        # `validateEnumNode`). Deliberately called BEFORE the `own_values is None:
+        # continue` gate below so a concrete field.enum that inherits @values via
+        # `extends` but declares its own @intValueMap is still validated.
+        _validate_enum_int_value_map(node, errors)
+
+        # Design D7, narrowed: int-backing is scalar-only. Separate from the content
+        # rules above because it must fire on the node that combines the two halves,
+        # which is NOT necessarily the node that declares the map.
+        _validate_enum_int_value_map_not_array(node, errors)
+
         # ADR-0039 sanctioned own: validates the AUTHORED @values membership on THIS
         # node (mirrors the TS attr-schema-validate `node.ownAttrs()`); an inherited
         # @values yields None here and is validated on its declaring node.
@@ -607,19 +670,9 @@ 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
-        ):
+        # silently dropped by the shared-enum codegen collapse. Mirrors the TS
+        # reference (attr-schema-validate.ts).
+        if _shared_enum_super(node) is not None:
             errors.append(
                 MetaError(
                     f"{label} declares its own '@{FIELD_ATTR_VALUES}' but extends "
@@ -633,6 +686,113 @@ def _validate_enum_values(
             )
 
 
+def _validate_enum_int_value_map_not_array(node: MetaData, errors: list[MetaError]) -> None:
+    """``@intValueMap`` is scalar-only (design D7, narrowed).
+
+    Int-backing is a persistence-layer CODEC, and no port implements it
+    element-wise over an array column: this port's ``ObjectManager`` would bind the
+    symbol LIST straight into an ``integer[]``, OMDB's ``EnumCodec`` and Kotlin's
+    ``customEnumeration`` are scalar by construction, and TypeScript's sqlite branch
+    serializes an array as JSON text before the enum case is reached. Two ports that
+    happen to compose (TS/Postgres, C#) are not a feature — shipping a claim four
+    ports silently get wrong is the ``field.byte``/``short``/``class`` mistake.
+
+    BOTH halves are read RESOLVING, unlike the content rules: the illegal thing is
+    the EFFECTIVE combination. Post-#246 the map must live on the shared abstract
+    declaration, so the field that inherits it is exactly where ``isArray`` gets
+    declared — an own-only read would see the two halves on different nodes and
+    never fire.
+    """
+    if not isinstance(node.get_meta_attr(FIELD_ATTR_INT_VALUE_MAP), dict):
+        return
+    if not node.resolved_is_array():
+        return
+    errors.append(
+        MetaError(
+            f"{_node_label(node)} declares '@{FIELD_ATTR_INT_VALUE_MAP}' with isArray=true; "
+            f"int-backing is scalar-only — an array-of-enum persists its member symbols. "
+            f"Remove '@{FIELD_ATTR_INT_VALUE_MAP}', or make the field scalar.",
+            ErrorCode.ERR_ENUM_INT_VALUE_MAP_ARRAY,
+            envelope=node.source,
+        )
+    )
+
+
+def _validate_enum_int_value_map(node: MetaData, errors: list[MetaError]) -> None:
+    """``@intValueMap`` content rules (optional), independent of whether ``@values``
+    is own or inherited on this node. Mirrors TS/C#/Java, which all run this check
+    unconditionally against the node's EFFECTIVE ``@values`` — a concrete
+    ``field.enum`` that inherits ``@values`` via ``extends`` but declares its own
+    ``@intValueMap`` locally must still have that map validated.
+
+      a. Key set must exactly match the EFFECTIVE ``@values`` (own or inherited).
+      b. No two members may share the same int (protobuf's stance — no alias
+         opt-in). Every-value-is-an-integer is already enforced by ``_type_ok``'s
+         ATTR_SUBTYPE_INT_MAP case at parse time.
+    """
+    int_value_map = node.attr(FIELD_ATTR_INT_VALUE_MAP)
+    if not isinstance(int_value_map, dict):
+        return
+
+    label = _node_label(node)
+
+    # #246 (int-backed twin): the symbol->int mapping is a property of the enum
+    # VOCABULARY, not of one column that uses it -- it is @values' numeric half. A
+    # shared enum is materialized once as a single type, so a per-field map would
+    # give one logical type N storage encodings (and, where a port emits per-TYPE
+    # codec artifacts, two same-named declarations). Same remedy as the @values
+    # half: declare it on the shared declaration and inherit it.
+    shared_super = _shared_enum_super(node)
+    if shared_super is not None:
+        errors.append(
+            MetaError(
+                f"{label} declares its own '@{FIELD_ATTR_INT_VALUE_MAP}' but extends "
+                f"a shared package-level abstract enum — a shared enum's integer "
+                f"backing is owned by the shared declaration. Move "
+                f"'@{FIELD_ATTR_INT_VALUE_MAP}' onto the shared declaration to "
+                f"inherit it, or extend a concrete (non-shared) enum instead",
+                ErrorCode.ERR_ENUM_EXTENDS_VALUES_CONFLICT,
+                envelope=node.source,
+            )
+        )
+    effective_values = _effective_enum_values(node)
+    member_set = set(effective_values)
+    key_set = set(int_value_map.keys())
+    missing = [m for m in effective_values if m not in key_set]
+    extra = [k for k in int_value_map if k not in member_set]
+    if missing or extra:
+        parts = []
+        if missing:
+            parts.append(f"missing: {', '.join(missing)}")
+        if extra:
+            parts.append(f"unknown: {', '.join(extra)}")
+        errors.append(
+            MetaError(
+                f"{label} attribute '@{FIELD_ATTR_INT_VALUE_MAP}' keys must exactly match "
+                f"'@{FIELD_ATTR_VALUES}' members ({'; '.join(parts)}).",
+                ErrorCode.ERR_BAD_ATTR_VALUE,
+                envelope=node.source,
+            )
+        )
+
+    seen_values: dict[int, str] = {}
+    for member, value in int_value_map.items():
+        if not isinstance(value, int) or isinstance(value, bool):
+            continue  # _type_ok already reported this
+        owner = seen_values.get(value)
+        if owner is not None:
+            errors.append(
+                MetaError(
+                    f"{label} attribute '@{FIELD_ATTR_INT_VALUE_MAP}' members {owner!r} and {member!r} "
+                    f"share the same value {value}; every member must have a unique int.",
+                    ErrorCode.ERR_BAD_ATTR_VALUE,
+                    envelope=node.source,
+                )
+            )
+        else:
+            seen_values[value] = member
+
+
 def _effective_enum_values(node: MetaData) -> list[str]:
     """The effective ``@values`` members of an enum node (own or inherited via
     ``extends:``). Empty list when absent. Mirrors Java ``effectiveEnumValues``."""
@@ -913,6 +1073,45 @@ def ops_for_subtype(field_subtype: str) -> frozenset[str]:
     return frozenset()
 
 
+# The int-backed-enum band: the enum band minus `like`. Named so the narrowing is
+# one constant rather than a set rebuilt at every call.
+_OPS_ENUM_INT_BACKED: frozenset[str] = frozenset({"eq", "ne", "in", "isNull"})
+
+
+def ops_for_field(field: MetaData) -> frozenset[str]:
+    """The filter-operator band for a FIELD.
+
+    The entry point every consumer that has a field in hand must use (loader
+    validation, the codegen filter-allowlist generator, the cross-port
+    ``field.filter-ops`` capability).
+
+    Identical to :func:`ops_for_subtype` except for ONE case: an int-backed
+    ``field.enum`` (one declaring ``@intValueMap``, design D5) persists as an
+    INTEGER column, so ``like`` -- a substring match -- is dropped.
+    ``eq``/``ne``/``in`` survive because the member symbol encodes to its integer
+    before it reaches SQL; ``like`` has no such encoding, and an unencoded
+    ``LIKE 'DRAFT'`` against an integer column is a request-time type error.
+
+    ``ops_for_subtype`` cannot express this -- it only ever sees the subtype
+    ``"enum"`` -- and is deliberately left unchanged for the one caller that
+    genuinely has no field: the expression grammar's declared operand type.
+
+    ADR-0039: the ``@intValueMap`` read is RESOLVING (``attrs()``, NOT ``attr()``
+    -- Python inverts the TS naming, ``attr()`` here is own-only). Post-#246 the
+    map lives on a shared root-level abstract declaration and consuming fields
+    INHERIT it, so an own-only read would see it absent on exactly the shape
+    adopters are steered toward and wrongly keep ``like``.
+
+    Cross-port: ``fixtures/conformance/filter-ops-matrix`` pins ``fEnum`` vs
+    ``fEnumInt`` in all five ports.
+    """
+    if field.sub_type == FIELD_SUBTYPE_ENUM and isinstance(
+        field.attrs().get(FIELD_ATTR_INT_VALUE_MAP), dict
+    ):
+        return _OPS_ENUM_INT_BACKED
+    return ops_for_subtype(field.sub_type)
+
+
 # ---------------------------------------------------------------------------
 # #195 — attr.expression closed grammar (validate + infer)
 # ---------------------------------------------------------------------------
@@ -1095,8 +1294,10 @@ def _validate_datagrid_filter_values(
             continue
 
         # Build filterable map: field_name → allowed ops set
+        # ops_for_field, not ops_for_subtype — an int-backed field.enum
+        # (@intValueMap) stores as an integer, so `like` is not in its band.
         filterable: dict[str, frozenset[str]] = {
-            f.name: ops_for_subtype(f.sub_type)
+            f.name: ops_for_field(f)
             for f in node.fields()
             if f.attrs().get("filterable") is True
         }

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/meta/core/attr/attr_constants.py

@@ -14,6 +14,13 @@ ATTR_SUBTYPE_CLASS = "class"
 # ATTR_SUBTYPE_EXPRESSION / meta-attr-expression.ts.
 ATTR_SUBTYPE_EXPRESSION = "expression"
 
+# attr.intMap (int-backed-enum-values plan) — an object-shaped attribute whose
+# values are all integers (e.g. field.enum's @intValueMap: {memberSymbol: int}).
+# Generic shape check only; field.enum layers its own semantic rules (key-set
+# membership, uniqueness) in its own content-rule validation pass. Mirrors TS
+# ATTR_SUBTYPE_INT_MAP / C# AttrConstants.ATTR_SUBTYPE_INT_MAP.
+ATTR_SUBTYPE_INT_MAP = "intMap"
+
 # The retired "stringarray" array attr subtype. It is NO LONGER a registered
 # (attr, sub_type) (not in ATTR_SUBTYPES) — array-ness is modeled as a "string"
 # attr with the orthogonal AttrSchema.is_array flag (matching Java's
@@ -33,4 +40,5 @@ ATTR_SUBTYPES = (
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_CLASS,
     ATTR_SUBTYPE_EXPRESSION,
+    ATTR_SUBTYPE_INT_MAP,
 )

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/meta/core/attr/meta_attr.py

@@ -12,6 +12,7 @@ from .attr_constants import (
     ATTR_SUBTYPE_EXPRESSION,
     ATTR_SUBTYPE_FILTER,
     ATTR_SUBTYPE_INT,
+    ATTR_SUBTYPE_INT_MAP,
     ATTR_SUBTYPE_LONG,
     ATTR_SUBTYPE_PROPERTIES,
     ATTR_SUBTYPE_STRING,
@@ -134,6 +135,21 @@ class PropertiesAttr(MetaAttr):
         return DataType.OBJECT
 
 
+class IntMapAttr(MetaAttr):
+    """attr.intMap (int-backed-enum-values plan) — an object-shaped attribute
+    whose values are all integers (e.g. field.enum's @intValueMap). Generic
+    shape check only; the deeper "every value is an int" check is enforced by
+    `_type_ok`'s ATTR_SUBTYPE_INT_MAP case in validation_passes.py (this port
+    has no per-attr-class validate_value dispatch — TS's is the one port that
+    does; C# mirrors the same "static type-check function" architecture this
+    port uses). field.enum's own key-set/uniqueness content rules run in a
+    separate pass. Mirrors TS IntMapAttr / C# ATTR_SUBTYPE_INT_MAP shape."""
+
+    @property
+    def data_type(self) -> DataType:
+        return DataType.OBJECT
+
+
 class ClassAttr(MetaAttr):
     @property
     def data_type(self) -> DataType:
@@ -145,4 +161,5 @@ register_attr_class(ATTR_SUBTYPE_STRINGARRAY, StringArrayAttr)
 register_attr_class(ATTR_SUBTYPE_FILTER, FilterAttr)
 register_attr_class(ATTR_SUBTYPE_PROPERTIES, PropertiesAttr)
 register_attr_class(ATTR_SUBTYPE_EXPRESSION, ExpressionAttr)
+register_attr_class(ATTR_SUBTYPE_INT_MAP, IntMapAttr)
 register_attr_class(ATTR_SUBTYPE_CLASS, ClassAttr)

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/meta/core/field/field_constants.py

@@ -150,3 +150,10 @@ SORT_ORDER_VALUES = (SORT_ORDER_ASC, SORT_ORDER_DESC)
 # Regex pattern for enum member symbols — must be identifier-safe.
 # Cross-language contract: every port enforces this pattern.
 ENUM_MEMBER_PATTERN = r"^[A-Za-z_][A-Za-z0-9_]*$"
+
+# int-backed-enum-values plan — @intValueMap (field.enum only): optional
+# per-member int values ({member: int}) switching this enum field's DB
+# persistence from string+CHECK to integer+CHECK. Keys must exactly match
+# @values; values must be unique integers. The generated native type and wire
+# format are unchanged in every language. Mirrors TS FIELD_ATTR_INT_VALUE_MAP.
+FIELD_ATTR_INT_VALUE_MAP = "intValueMap"

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/runtime/object_manager.py

@@ -311,6 +311,8 @@ class ObjectManager:
         }
         row = result.rows[0]
         mapped = {col_to_field.get(k, k): v for k, v in row.items()}
+        # int-backed enums come back as integers; hand the caller the symbol.
+        mapped = _decode_read_row({f.name: f for f in returning_fields}, mapped)
         # #214: a write-through entity's INSERT RETURNING covers only the table (non-derived)
         # columns; re-read the persisted row through the replica VIEW by PK so the returned row
         # carries the derived origin.* fields (read-your-writes). find_by_id routes to the view.
@@ -423,6 +425,8 @@ class ObjectManager:
         }
         row = result.rows[0]
         mapped = {col_to_field.get(k, k): v for k, v in row.items()}
+        # int-backed enums come back as integers; hand the caller the symbol.
+        mapped = _decode_read_row({f.name: f for f in returning_fields}, mapped)
         # #214: re-read the updated row through the replica VIEW by PK so the returned row
         # carries the derived origin.* fields (write targeted the table, which lacks them).
         if entity.is_write_through():
@@ -509,8 +513,11 @@ class ObjectManager:
         self.last_column_oids = {
             col_to_field.get(c, c): oid for c, oid in result.column_oids.items()
         }
+        # int-backed enums come back as integers; hand the caller the symbol.
+        fields_by_name = {f.name: f for f in entity.fields()}
         return [
-            {col_to_field.get(k, k): v for k, v in row.items()} for row in result.rows
+            _decode_read_row(fields_by_name, {col_to_field.get(k, k): v for k, v in row.items()})
+            for row in result.rows
         ]
 
     def count(self, entity_name: str, filter: Filter | None = None) -> int:
@@ -711,12 +718,13 @@ def _compile_filter(f: Filter | None, entity: MetaObject) -> tuple[str, list[Any
         mf = entity.find_field(field_name)
         col = _column_of(mf) if mf is not None else field_name
         if not isinstance(ops, dict):
-            # Shortcut: {field: value} → equality
+            # Shortcut: {field: value} → equality. Encoded like any other bound
+            # value (see _op_clause) so an int-backed enum reaches SQL as its int.
             parts.append(f"{_q(col)} = %s")
-            params.append(ops)
+            params.append(_coerce_write_value(mf, ops) if mf is not None else ops)
             continue
         for op, value in ops.items():
-            sql, p = _op_clause(col, op, value)
+            sql, p = _op_clause(col, op, value, mf)
             parts.append(sql)
             params.extend(p)
     if not parts:
@@ -724,9 +732,21 @@ def _compile_filter(f: Filter | None, entity: MetaObject) -> tuple[str, list[Any
     return " AND ".join(parts), params
 
 
-def _op_clause(col: str, op: str, value: Any) -> tuple[str, list[Any]]:
-    """Translate one operator → SQL + params. Mirrors TS/C#/Java semantics."""
+def _op_clause(col: str, op: str, value: Any, field: MetaField | None = None) -> tuple[str, list[Any]]:
+    """Translate one operator → SQL + params. Mirrors TS/C#/Java semantics.
+
+    Bound values go through the WRITE codec, exactly as an INSERT's do: the four
+    sibling ports all encode on this path (TS through the Drizzle customType, Java
+    through GenericSQLDriver.setStatementValue → EnumCodec.write, Kotlin through
+    Exposed's toDb, C# through the EF converter). Without it an int-backed enum's
+    filter binds the member SYMBOL against an INTEGER column — the filter band
+    keeps eq/ne/in for int-backed enums precisely BECAUSE the symbol is supposed
+    to encode to its integer before reaching SQL.
+    """
     qc = _q(col)
+    if field is not None and op != "isNull":
+        value = ([_coerce_write_value(field, v) for v in value]
+                 if op == "in" and value else _coerce_write_value(field, value))
     if op == "eq":     return f"{qc} = %s", [value]
     if op == "ne":     return f"{qc} <> %s", [value]
     if op == "gt":     return f"{qc} > %s", [value]
@@ -823,11 +843,79 @@ def _coerce_write_value(field: MetaField, value: Any) -> Any:
         storage = field.get_meta_attr(fc.FIELD_ATTR_STORAGE)  # ADR-0039 resolving
         if storage != "flattened":  # None / "jsonb" / "subdocument" → single jsonb column
             return _json.dumps(value)
+    # field.enum carrying @intValueMap: the column is an INTEGER while the native
+    # and wire contract stays the member SYMBOL (int-backing is a persistence-layer
+    # concern, invisible above this codec), so encode symbol -> declared int here.
+    #
+    # An unmapped symbol is passed through untouched: membership is the column's
+    # CHECK constraint to enforce, and inventing a value here would hide the drift.
+    if sub == fc.FIELD_SUBTYPE_ENUM:
+        int_map = _int_value_map(field)
+        if int_map is not None and value in int_map:
+            return int_map[value]
+
     # Everything else (string / int / long / double / float / boolean / enum)
     # is already the native type pg8000 binds directly.
     return value
 
 
+def _int_value_map(field: MetaField) -> dict[Any, Any] | None:
+    """The declared ``@intValueMap`` (symbol → int), or ``None`` when the enum is
+    string-backed.
+
+    ADR-0039 resolving: the map is ``@values``' numeric half — a logical property
+    of the enum vocabulary that inherits through ``extends`` — so it is read with
+    ``get_meta_attr``, NOT the own-only accessor (contrast ``@dbColumnType`` in
+    :func:`_coerce_write_value`, the one field attribute that is deliberately
+    own-only). Shared by the write and read halves of the enum codec, mirroring
+    the dedicated int-map helper each sibling port's codec keeps (Java
+    ``EnumCodec.intValueMap``, Kotlin ``readIntValueMap``, C# ``IntValueMapOf``).
+    """
+    m = field.get_meta_attr(fc.FIELD_ATTR_INT_VALUE_MAP)
+    return m if isinstance(m, dict) else None
+
+
+def _decode_read_value(field: MetaField, value: Any) -> Any:
+    """Decode a stored value back to its authoring form on read.
+
+    The inverse of :func:`_coerce_write_value`'s int-backed-enum branch, and
+    today its only case: the column holds the member's integer, callers expect
+    the member SYMBOL. Every other field subtype is returned verbatim, keeping
+    ADR-0019's "runtime returns native in-process types" contract intact.
+
+    An int with no member RAISES. The database then holds a value the model says
+    is impossible — a hand-written INSERT, or a member removed without a
+    migration — and neither alternative is honest: returning the raw int hands
+    the caller a "member" that is not one (C#, Kotlin and TypeScript type this
+    property as a CLOSED enum, where ``7`` is not even representable), and
+    returning ``None`` hides the corruption behind a nullable column. Every port
+    throws here.
+    """
+    if value is None:
+        return None
+    if field.sub_type != fc.FIELD_SUBTYPE_ENUM:
+        return value
+    int_map = _int_value_map(field)
+    if int_map is None or not isinstance(value, int) or isinstance(value, bool):
+        return value
+    for symbol, stored in int_map.items():
+        if stored == value:
+            return symbol
+    raise ValueError(
+        f"field.enum '{field.name}' read stored value {value} with no member in "
+        f"@{fc.FIELD_ATTR_INT_VALUE_MAP} (declared: {int_map}) — the database holds "
+        f"a value the model does not describe."
+    )
+
+
+def _decode_read_row(fields_by_name: dict[str, MetaField], row: dict[str, Any]) -> dict[str, Any]:
+    """Apply :func:`_decode_read_value` to every field-keyed value in a mapped row."""
+    return {
+        k: (_decode_read_value(fields_by_name[k], v) if k in fields_by_name else v)
+        for k, v in row.items()
+    }
+
+
 # ----------------------------------------------------------------------------
 # #203 — @autoSet CRUD stamping. A ``field.timestamp`` (or any temporal field)
 # marked ``@autoSet: onCreate|onUpdate`` declares "the runtime owns this

{metaobjects-0.23.1 → metaobjects-0.23.2}/src/metaobjects/spec_metamodel/attr.json

@@ -19,6 +19,12 @@
       "dataType": "int",
       "description": "A 32-bit-integer-valued metadata attribute. Coerces to and validates as a number."
     },
+    {
+      "type": "attr",
+      "subType": "intMap",
+      "dataType": "object",
+      "description": "An object-shaped attribute whose values are all integers (e.g. field.enum's @intValueMap: {memberSymbol: int}). Generic shape check only; a consumer field type layers its own semantic rules (key-set membership, uniqueness) in its own content-rule validation."
+    },
     {
       "type": "attr",
       "subType": "long",