GeneralManager 0.81.4__tar.gz → 0.82.0__tar.gz

{generalmanager-0.81.4/src/GeneralManager.egg-info → generalmanager-0.82.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.81.4
+Version: 0.82.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.81.4 → generalmanager-0.82.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.81.4"
+version = "0.82.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.81.4 → generalmanager-0.82.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.81.4
+Version: 0.82.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.81.4 → generalmanager-0.82.0}/src/GeneralManager.egg-info/SOURCES.txt

@@ -34,6 +34,7 @@ src/general_manager/api/graphql.py
 src/general_manager/api/graphql_as_of.py
 src/general_manager/api/graphql_errors.py
 src/general_manager/api/graphql_groups.py
+src/general_manager/api/graphql_identifiers.py
 src/general_manager/api/graphql_mutations.py
 src/general_manager/api/graphql_ordering.py
 src/general_manager/api/graphql_output.py

{generalmanager-0.81.4 → generalmanager-0.82.0}/src/general_manager/api/graphql.py

@@ -38,6 +38,7 @@ from django.core.exceptions import ObjectDoesNotExist
 from django.db import DEFAULT_DB_ALIAS, models, transaction
 from django.utils.module_loading import import_string
 
+from general_manager.api.graphql_identifiers import build_identification_arguments
 from general_manager.bucket.base_bucket import Bucket
 from general_manager.bucket.group_bucket import GroupBucket
 from general_manager.cache.dependency_index import (
@@ -1355,7 +1356,8 @@ class GraphQL:
         plus generated relation filter/exclude inputs when available. Explicit
         sibling ``*_groups`` fields provide grouped results. Other types map through the scalar base
         mapper and may use `field_info["graphql_scalar"]` for supported scalar
-        overrides such as `"bigint"`.
+        overrides such as `"bigint"`. Scalar attributes marked ``is_identifier``
+        map to ``ID`` without altering their Python metadata type.
 
         Parameters:
             field_type (type): Python type declared on the interface.
@@ -1410,6 +1412,8 @@ class GraphQL:
                 return graphene.Field(StoredFile)
             if orm_field_kind == "image":
                 return graphene.Field(StoredImage)
+            if field_info and field_info.get("is_identifier"):
+                return graphene.ID()
             scalar_type = cast(type, field_type)
             return GraphQL._map_field_to_graphene_base_type(
                 scalar_type,
@@ -1646,7 +1650,10 @@ class GraphQL:
         """
         Build the GraphQL arguments required to uniquely identify an instance of the given manager class.
 
-        For each input field defined on the manager's Interface: use "<name>_id" for fields that reference another GeneralManager, use "id" when present, and map other fields to their corresponding Graphene base type. Each argument's nullability mirrors `input_field.required`.
+        ORM constructor identifiers and explicit scalar identity metadata use
+        ``ID``. Manager references use ``<name>_id`` with ``ID`` or structured
+        composite input types. Named business inputs retain their native scalars;
+        nullability mirrors ``input_field.required``.
 
         Parameters:
             generalManagerClass: GeneralManager subclass whose Interface.input_fields are used to derive identification arguments.
@@ -1654,29 +1661,7 @@ class GraphQL:
         Returns:
             dict[str, object]: Mapping of argument name to a Graphene Argument suitable for identifying a single manager instance.
         """
-        identification_fields: GraphQLFieldMap = {}
-        for (
-            input_field_name,
-            input_field,
-        ) in generalManagerClass.Interface.input_fields.items():
-            if resolve_general_manager_type(
-                input_field.type,
-                cls.manager_registry,
-            ):
-                key = f"{input_field_name}_id"
-                identification_fields[key] = graphene.Argument(
-                    graphene.ID, required=input_field.required
-                )
-            elif input_field_name == "id":
-                identification_fields[input_field_name] = graphene.Argument(
-                    graphene.ID, required=input_field.required
-                )
-            else:
-                base_type = cls._map_field_to_graphene_base_type(input_field.type)
-                identification_fields[input_field_name] = graphene.Argument(
-                    base_type, required=input_field.required
-                )
-        return identification_fields
+        return build_identification_arguments(generalManagerClass)
 
     @classmethod
     def _add_queries_to_schema(

generalmanager-0.82.0/src/general_manager/api/graphql_identifiers.py

@@ -0,0 +1,79 @@
+"""Share declared constructor arguments between generated GraphQL operations."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import cast
+
+import graphene
+from django.db import models
+
+from general_manager.api.graphql_errors import (
+    GrapheneBaseTypeClass,
+    map_field_to_graphene_base_type,
+)
+from general_manager.api.graphql_relations import (
+    get_graphql_manager_registry,
+    resolve_general_manager_type,
+)
+from general_manager.manager.general_manager import GeneralManager
+
+
+def is_orm_identifier_input(manager_class: type[GeneralManager], name: str) -> bool:
+    """Identify the ORM constructor alias addressing the actual model PK."""
+    model = getattr(manager_class.Interface, "_model", None)
+    return name == "id" and isinstance(model, type) and issubclass(model, models.Model)
+
+
+def map_identification_scalar(
+    manager_class: type[GeneralManager], name: str, input_type: type
+) -> GrapheneBaseTypeClass:
+    """Map actual scalar identities consistently, including nested references."""
+    metadata: Mapping[str, object] = manager_class.Interface.get_attribute_types().get(
+        name, {}
+    )
+    if is_orm_identifier_input(manager_class, name) or metadata.get("is_identifier"):
+        return cast(GrapheneBaseTypeClass, graphene.ID)
+    return map_field_to_graphene_base_type(
+        input_type, cast(str | None, metadata.get("graphql_scalar"))
+    )
+
+
+def build_identification_arguments(
+    manager_class: type[GeneralManager], *, for_mutation: bool = False
+) -> dict[str, object]:
+    """Keep named business inputs and use ID only for scalar identities/references."""
+    interface = manager_class.Interface
+    arguments: dict[str, object] = {}
+    for name, input_field in interface.input_fields.items():
+        # The ORM constructor's id input addresses model._meta.pk. Its public
+        # name is independent of the actual primary-key column name.
+        is_orm_id = is_orm_identifier_input(manager_class, name)
+        required = input_field.required or (for_mutation and is_orm_id)
+        manager_type = resolve_general_manager_type(
+            input_field.type, get_graphql_manager_registry()
+        )
+        if manager_type is not None:
+            # Reuse custom mutation support for structured/composite manager
+            # references. Import lazily after GraphQL startup to avoid a cycle.
+            from general_manager.api.mutation import (
+                _build_manager_argument_field,
+                _uses_single_id_input,
+            )
+
+            arguments[f"{name}_id"] = (
+                graphene.Argument(graphene.ID, required=required)
+                if _uses_single_id_input(manager_type)
+                else _build_manager_argument_field(manager_type, required=required)
+            )
+        else:
+            scalar = map_identification_scalar(manager_class, name, input_field.type)
+            arguments[name] = graphene.Argument(scalar, required=required)
+    return arguments
+
+
+def pop_identification(
+    arguments: dict[str, object], payload: dict[str, object]
+) -> dict[str, object]:
+    """Extract only declared constructor values, preserving omission for defaults."""
+    return {name: payload.pop(name) for name in arguments if name in payload}

{generalmanager-0.81.4 → generalmanager-0.82.0}/src/general_manager/api/graphql_mutations.py

@@ -11,7 +11,7 @@ module can be imported by ``graphql.py`` without creating a circular dependency.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Protocol, cast
+from typing import TYPE_CHECKING, Mapping, Protocol, cast
 
 import graphene
 from graphql import GraphQLError, Undefined
@@ -35,6 +35,11 @@ from general_manager.api.graphql_errors import (
     handle_graph_ql_error,
     map_field_to_graphene_base_type,
 )
+from general_manager.api.graphql_identifiers import (
+    build_identification_arguments,
+    is_orm_identifier_input,
+    pop_identification,
+)
 
 if TYPE_CHECKING:
     from graphene import ResolveInfo as GraphQLResolveInfo
@@ -161,7 +166,9 @@ def _normalize_mutation_kwargs_for_manager(
 
     GraphQL-facing relation inputs may arrive as ``field``/``field_list`` while
     ORM mutation capabilities expect ``field_id``/``field_id_list`` for manager
-    relations. Unknown keys and already-normalized keys are preserved.
+    relations. Structured references pass through their manager constructor so
+    all declared inputs are validated. Scalar reference values stay unchanged.
+    Unknown keys and already-normalized keys are preserved.
     """
     interface_cls = getattr(general_manager_class, "Interface", None)
     if interface_cls is None:
@@ -171,33 +178,59 @@ def _normalize_mutation_kwargs_for_manager(
     normalized = dict(kwargs)
     manager_registry = get_graphql_manager_registry()
 
+    def normalize_reference(
+        manager_type: type[GeneralManager], value: object, relation_name: str
+    ) -> object:
+        if not isinstance(value, Mapping):
+            return value
+        reference = manager_type(**dict(value))
+        model = getattr(interface_cls, "_model", None)
+        if isinstance(model, type) and issubclass(model, models.Model):
+            try:
+                model_field = model._meta.get_field(relation_name)
+            except FieldDoesNotExist:
+                return reference
+            target_field = getattr(model_field, "target_field", None)
+            if isinstance(model_field, models.ManyToManyField):
+                related_model = model_field.remote_field.model
+                target_field = related_model._meta.get_field(
+                    model_field.m2m_reverse_target_field_name()
+                )
+            if target_field is not None and not target_field.primary_key:
+                return cast(object, getattr(reference, target_field.attname))
+        return reference
+
     for key in list(kwargs.keys()):
         if key.endswith("_list") and not key.endswith("_id_list"):
             base_key = key.removesuffix("_list")
             type_info = attribute_types.get(key)
             relation_type = type_info["type"] if type_info is not None else None
-            if (
-                resolve_general_manager_type(
-                    relation_type,
-                    manager_registry,
-                )
-                is not None
-            ):
-                normalized.setdefault(f"{base_key}_id_list", normalized[key])
+            manager_type = resolve_general_manager_type(relation_type, manager_registry)
+            if manager_type is not None:
+                target_key = f"{base_key}_id_list"
+                if target_key not in normalized:
+                    value = normalized[key]
+                    normalized[target_key] = (
+                        [
+                            normalize_reference(manager_type, item, base_key)
+                            for item in value
+                        ]
+                        if isinstance(value, (list, tuple))
+                        else normalize_reference(manager_type, value, base_key)
+                    )
                 normalized.pop(key, None)
                 continue
 
         if not key.endswith("_id"):
             type_info = attribute_types.get(key)
             relation_type = type_info["type"] if type_info is not None else None
-            if (
-                resolve_general_manager_type(
-                    relation_type,
-                    manager_registry,
-                )
-                is not None
-            ):
-                normalized.setdefault(f"{key}_id", normalized[key])
+            manager_type = resolve_general_manager_type(relation_type, manager_registry)
+            if manager_type is not None:
+                target_key = f"{key}_id"
+                if target_key not in normalized:
+                    normalized[target_key] = normalize_reference(
+                        manager_type, normalized[key], key
+                    )
                 normalized.pop(key, None)
 
     return normalized
@@ -291,8 +324,8 @@ def create_write_fields(
     is the ``*_list`` metadata entry whose type is a ``GeneralManager`` subclass.
 
     Non-editable attributes are still returned with ``editable=False``. Create
-    and update builders filter on that flag; delete keeps only constructor input
-    fields plus its explicit metadata arguments. ``_EditableGrapheneField`` is an
+    and update builders filter on that flag; delete uses the shared constructor
+    argument builder plus explicit metadata arguments. ``_EditableGrapheneField`` is an
     internal structural contract used by this module to annotate the dynamic flag
     attached to otherwise untyped Graphene field instances.
 
@@ -302,7 +335,9 @@ def create_write_fields(
     helper produces an ID field or a list of ID fields for names ending with
     ``"_list"``. Later mutation resolvers normalize those canonical inputs to
     ``"owner_id"`` and ``"member_id_list"`` before calling the ORM mutation
-    layer. Always includes an optional ``history_comment`` string field.
+    layer. Scalar identity metadata maps to ``ID`` as well. Sentinel and callable
+    defaults are omitted from the schema; runtime defaults and validation stay
+    with the interface/ORM. Always includes an optional ``history_comment``.
 
     Parameters:
         interface_cls: Interface providing attribute metadata used to build
@@ -337,21 +372,42 @@ def create_write_fields(
         # GraphQL injects argument defaults before the resolver sees the payload.
         # Partial updates must preserve omission, including defaults of None.
         default = info["default"] if require_fields else Undefined
+        if default is NOT_PROVIDED or callable(default):
+            default = Undefined
+        manager_type = resolve_general_manager_type(typ, manager_registry)
 
         fld: object
         if info.get("orm_field_kind") in {"file", "image"}:
             fld = UploadToken(required=req, default_value=default)
-        elif (
-            resolve_general_manager_type(
-                typ,
-                manager_registry,
+        elif info.get("is_identifier"):
+            fld = graphene.ID(required=req, default_value=default)
+        elif manager_type is not None:
+            from general_manager.api.mutation import (
+                _build_manager_argument_field,
+                _get_or_create_manager_input_type,
+                _uses_single_id_input,
             )
-            is not None
-        ):
+
             if name.endswith("_list"):
-                fld = graphene.List(graphene.ID, required=req, default_value=default)
+                reference_type = (
+                    graphene.ID
+                    if _uses_single_id_input(manager_type)
+                    else _get_or_create_manager_input_type(manager_type)
+                )
+                fld = graphene.List(reference_type, required=req, default_value=default)
             else:
+                fld = _build_manager_argument_field(
+                    manager_type, required=req, default_value=default
+                )
+        elif isinstance(typ, type) and issubclass(typ, models.Model):
+            if info.get("relation_kind") == "collection":
+                fld = graphene.List(graphene.ID, required=req, default_value=default)
+            elif info.get("relation_kind") == "direct":
                 fld = graphene.ID(required=req, default_value=default)
+            else:
+                fld = map_field_to_graphene_base_type(typ)(
+                    required=req, default_value=default
+                )
         else:
             base_cls = map_field_to_graphene_base_type(
                 typ,
@@ -399,6 +455,11 @@ def generate_create_mutation_class(
     if not interface_cls:
         return None
     write_fields = create_write_fields(interface_cls)
+    attribute_types: Mapping[str, Mapping[str, object]] = (
+        interface_cls.get_attribute_types()
+    )
+    model = getattr(interface_cls, "_model", None)
+    has_model = isinstance(model, type) and issubclass(model, models.Model)
     file_field_names = tuple(
         name
         for name in _file_token_field_names(interface_cls, write_fields)
@@ -456,8 +517,14 @@ def generate_create_mutation_class(
                 {
                     field_name: field
                     for field_name, field in write_fields.items()
-                    if field_name not in generalManagerClass.Interface.input_fields
-                    and field.editable
+                    if field.editable
+                    and not attribute_types.get(field_name, {}).get(
+                        "is_auto_primary_key"
+                    )
+                    and (
+                        has_model
+                        or field_name not in generalManagerClass.Interface.input_fields
+                    )
                 },
             ),
             "mutate": create_mutation,
@@ -493,6 +560,16 @@ def generate_update_mutation_class(
     if not interface_cls:
         return None
     write_fields = create_write_fields(interface_cls, require_fields=False)
+    attribute_types: Mapping[str, Mapping[str, object]] = (
+        interface_cls.get_attribute_types()
+    )
+    identification_arguments = build_identification_arguments(
+        generalManagerClass, for_mutation=True
+    )
+    requires_id = is_orm_identifier_input(generalManagerClass, "id")
+    if not identification_arguments:
+        identification_arguments = {"id": graphene.Argument(graphene.ID, required=True)}
+        requires_id = True
     file_field_names = _file_token_field_names(interface_cls, write_fields)
 
     def update_mutation(
@@ -500,8 +577,9 @@ def generate_update_mutation_class(
         info: GraphQLResolveInfo,
         **kwargs: object,
     ) -> MutationPayload:
-        manager_id = kwargs.pop("id", None)
-        if manager_id is None:
+        identification = pop_identification(identification_arguments, kwargs)
+        manager_id = identification.get("id")
+        if requires_id and manager_id is None:
             raise handle_graph_ql_error(MissingManagerIdentifierError())
         try:
             kwargs = {
@@ -520,7 +598,7 @@ def generate_update_mutation_class(
             kwargs = _normalize_mutation_kwargs_for_manager(generalManagerClass, kwargs)
             history_comment = _pop_history_comment(kwargs)
             update = cast(
-                _ManagerUpdateMethod, generalManagerClass(id=manager_id).update
+                _ManagerUpdateMethod, generalManagerClass(**identification).update
             )
             update_kwargs = {"creator_id": info.context.user.id, **kwargs}
             if isinstance(history_comment, _UnsetHistoryComment):
@@ -549,12 +627,15 @@ def generate_update_mutation_class(
                 "Arguments",
                 (),
                 {
-                    "id": graphene.ID(required=True),
                     **{
                         field_name: field
                         for field_name, field in write_fields.items()
                         if field.editable
+                        and not attribute_types.get(field_name, {}).get(
+                            "is_primary_key"
+                        )
                     },
+                    **identification_arguments,
                 },
             ),
             "mutate": update_mutation,
@@ -570,10 +651,9 @@ def generate_delete_mutation_class(
     Generate a Graphene Mutation class that deletes instances of the given manager.
 
     The generated mutation is named ``Delete<ManagerName>``. It always requires
-    an ``id`` argument and exposes optional ``history_comment`` metadata for the
-    manager delete call. Additional constructor input fields may appear for
-    backward compatibility, but only ``id`` and ``history_comment`` are consumed
-    by the generated resolver.
+    an ``id: ID!`` argument for ORM managers and exposes optional
+    ``history_comment`` metadata. Non-ORM managers retain their named constructor
+    arguments, all of which are consumed to locate the target instance.
 
     Parameters:
         generalManagerClass: The GeneralManager subclass to expose a delete
@@ -591,18 +671,26 @@ def generate_delete_mutation_class(
     if not interface_cls:
         return None
 
+    identification_arguments = build_identification_arguments(
+        generalManagerClass, for_mutation=True
+    )
+    requires_id = is_orm_identifier_input(generalManagerClass, "id")
+    if not identification_arguments:
+        identification_arguments = {"id": graphene.Argument(graphene.ID, required=True)}
+        requires_id = True
+
     def delete_mutation(
         self: object,
         info: GraphQLResolveInfo,
         **kwargs: object,
     ) -> MutationPayload:
-        manager_id = kwargs.pop("id", None)
-        if manager_id is None:
+        identification = pop_identification(identification_arguments, kwargs)
+        if requires_id and identification.get("id") is None:
             raise handle_graph_ql_error(MissingManagerIdentifierError())
         history_comment = _pop_history_comment(kwargs)
         try:
             delete = cast(
-                _ManagerDeleteMethod, generalManagerClass(id=manager_id).delete
+                _ManagerDeleteMethod, generalManagerClass(**identification).delete
             )
             if isinstance(history_comment, _UnsetHistoryComment):
                 delete(creator_id=info.context.user.id)
@@ -632,16 +720,8 @@ def generate_delete_mutation_class(
                 "Arguments",
                 (),
                 {
-                    # Always include id so the resolver can locate the instance.
-                    "id": graphene.ID(required=True),
                     "history_comment": graphene.String(),
-                    **{
-                        field_name: field
-                        for field_name, field in create_write_fields(
-                            interface_cls
-                        ).items()
-                        if field_name in generalManagerClass.Interface.input_fields
-                    },
+                    **identification_arguments,
                 },
             ),
             "mutate": delete_mutation,

{generalmanager-0.81.4 → generalmanager-0.82.0}/src/general_manager/api/graphql_search.py

@@ -21,6 +21,8 @@ from typing import (
 
 import graphene
 from graphql import GraphQLError
+from django.core.exceptions import FieldDoesNotExist
+from django.db import models
 
 from general_manager.conf import get_setting
 from general_manager.api.graphql_ordering import (
@@ -522,8 +524,10 @@ def get_filter_options(
     Emitted variants are:
     - GeneralManager relations: the base attribute with ``None`` so relation
       filter generation can handle it separately.
-    - ``id``: ``id``, ``id__exact``, ``id__in``, plus range variants
-      ``id__gt/gte/lt/lte`` using the normal mapper.
+    - Scalar identifiers marked in metadata: base, ``exact`` and ``in`` use
+      ``ID``/``[ID]``; range variants retain the native scalar mapper.
+    - Other scalar fields named ``id`` retain their legacy ``exact``, ``in``
+      and range operators, using their native scalar types.
     - ``Measurement``: base attribute plus ``gt/gte/lt/lte`` using
       ``MeasurementScalar``.
     - numeric, date, and datetime types: base attribute plus
@@ -570,23 +574,57 @@ def get_filter_options(
 
     if manager_type is not None:
         yield attribute_name, None
-    elif attribute_name == "id":
-        yield attribute_name, graphene.ID()
-        yield f"{attribute_name}__exact", graphene.ID()
-        yield f"{attribute_name}__in", graphene.List(graphene.ID)
+    elif (attr_info and attr_info.get("is_identifier")) or (
+        attribute_name == "id" and not safe_issubclass(normalized_type, Measurement)
+    ):
+        # The legacy id filter operators also belong to business fields. Only
+        # explicit identity metadata selects ID; the name preserves operators.
+        is_identifier = bool(attr_info and attr_info.get("is_identifier"))
+        native_info = {
+            k: v for k, v in (attr_info or {}).items() if k != "is_identifier"
+        }
+        for option in (attribute_name, f"{attribute_name}__exact"):
+            yield (
+                option,
+                graphene.ID()
+                if is_identifier
+                else map_field_to_graphene_read(
+                    normalized_type, attribute_name, native_info
+                ),
+            )
+        graphql_scalar = native_info.get("graphql_scalar")
+        membership_type = (
+            graphene.ID
+            if is_identifier
+            else map_field_to_graphene_base_type(
+                normalized_type,
+                graphql_scalar if isinstance(graphql_scalar, str) else None,
+            )
+        )
+        yield f"{attribute_name}__in", graphene.List(membership_type)
         for option in ("gt", "gte", "lt", "lte"):
             yield (
                 f"{attribute_name}__{option}",
                 map_field_to_graphene_read(
                     normalized_type,
                     attribute_name,
-                    attr_info,
+                    native_info,
                 ),
             )
+        if safe_issubclass(normalized_type, str):
+            for option in ("icontains", "contains", "startswith", "endswith"):
+                yield (
+                    f"{attribute_name}__{option}",
+                    map_field_to_graphene_read(
+                        normalized_type, attribute_name, native_info
+                    ),
+                )
     elif safe_issubclass(normalized_type, Measurement):
         yield attribute_name, MeasurementScalar()
         for option in number_options:
             yield f"{attribute_name}__{option}", MeasurementScalar()
+        if attribute_name == "id":
+            yield f"{attribute_name}__in", graphene.List(MeasurementScalar)
     else:
         yield (
             attribute_name,
@@ -833,31 +871,55 @@ def normalize_id_filter_value(
     value: object,
 ) -> object:
     """
-    Cast equality-style ID filter values to the manager's identifier type.
+    Convert equality filters marked as scalar identities to their native types.
 
-    Only ``id``, ``id__exact``, and list/tuple-valued ``id__in`` lookups are
-    cast. When the interface does not expose an ``id`` input, or ``id__in`` is
-    not list/tuple-shaped, the original value is returned unchanged. Other
-    iterables are not cast specially.
+    Actual ORM primary keys use the declared constructor input, independent of
+    the model column name. Raw relation references use the target field's
+    ``to_python`` conversion, including ``to_field`` references. Ordered lookups
+    and non-list/tuple ``in`` values pass through unchanged. Conversion preserves
+    existing filter semantics; constructor and write validation remain separate.
 
     Raises:
-        Exceptions from the interface input field's ``cast()`` method propagate
-        unchanged.
+        Exceptions from ``Input.cast()`` or ORM field conversion propagate.
     """
-    if lookup not in {"id", "id__exact", "id__in"}:
+    parts = lookup.split("__")
+    attribute_name = parts[0]
+    operator = parts[1] if len(parts) == 2 else "exact"
+    if len(parts) > 2 or operator not in {"exact", "in"}:
         return value
 
     interface = getattr(field_type, "Interface", None)
+    if interface is None:
+        return value
+    metadata = interface.get_attribute_types().get(attribute_name, {})
+    if not metadata.get("is_identifier"):
+        return value
     input_fields = getattr(interface, "input_fields", {})
-    id_input = input_fields.get("id") if isinstance(input_fields, dict) else None
-    if id_input is None:
+    input_field = input_fields.get(attribute_name)
+    model = getattr(interface, "_model", None)
+    converter: Callable[[object], object] | None = None
+    if isinstance(model, type) and issubclass(model, models.Model):
+        try:
+            model_field = model._meta.get_field(attribute_name)
+        except FieldDoesNotExist:
+            return value
+        if model_field.primary_key:
+            # ORM constructors expose the actual PK under their public id input,
+            # even when the model column has another name.
+            input_field = input_fields.get("id")
+        if input_field is None:
+            target_field = getattr(model_field, "target_field", model_field)
+            converter = target_field.to_python
+    if input_field is not None:
+        converter = input_field.cast
+    if converter is None:
         return value
 
-    if lookup == "id__in":
+    if operator == "in":
         if not isinstance(value, (list, tuple)):
             return value
-        return [id_input.cast(item) for item in value]
-    return id_input.cast(value)
+        return [converter(item) for item in value]
+    return converter(value)
 
 
 def normalize_filter_input(