updated type cast logic in filters

Author: CosmoV

fastapi_jsonapi/data_layers/filtering/sqlalchemy.py

@@ -1,8 +1,18 @@
 """Helper to create sqlalchemy filters according to filter querystring parameter"""
-from typing import Any, List, Tuple, Type, Union
-
-from pydantic import BaseModel
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    Union,
+)
+
+from pydantic import BaseConfig, BaseModel
 from pydantic.fields import ModelField
+from pydantic.validators import _VALIDATORS, find_validators
 from sqlalchemy import and_, not_, or_
 from sqlalchemy.orm import InstrumentedAttribute, aliased
 from sqlalchemy.sql.elements import BinaryExpression
@@ -22,6 +32,9 @@
     List[Join],
 ]
 
+# The mapping with validators using by to cast raw value to instance of target type
+REGISTERED_PYDANTIC_TYPES: Dict[Type, List[Callable]] = dict(_VALIDATORS)
+
 
 def create_filters(model: Type[TypeModel], filter_info: Union[list, dict], schema: Type[TypeSchema]):
     """
@@ -78,20 +91,83 @@ def create_filter(self, schema_field: ModelField, model_column, operator, value)
         types = [i.type_ for i in fields]
         clear_value = None
         errors: List[str] = []
-        for i_type in types:
-            try:
-                if isinstance(value, list):  # noqa: SIM108
-                    clear_value = [i_type(item) for item in value]
-                else:
-                    # pass
-                    clear_value = i_type(value)
-            except (TypeError, ValueError) as ex:
-                errors.append(str(ex))
+
+        pydantic_types, userspace_types = self._separate_types(types)
+
+        if pydantic_types:
+            if isinstance(value, list):
+                clear_value, errors = self._cast_iterable_with_pydantic(pydantic_types, value)
+            else:
+                clear_value, errors = self._cast_value_with_pydantic(pydantic_types, value)
+
+        if clear_value is None and userspace_types:
+            for i_type in types:
+                try:
+                    if isinstance(value, list):  # noqa: SIM108
+                        clear_value = [i_type(item) for item in value]
+                    else:
+                        clear_value = i_type(value)
+                except (TypeError, ValueError) as ex:
+                    errors.append(str(ex))
+
         # Если None, при этом поле обязательное (среди типов в аннотации нет None, то кидаем ошибку)
         if clear_value is None and not any(not i_f.required for i_f in fields):
             raise InvalidType(detail=", ".join(errors))
         return getattr(model_column, self.operator)(clear_value)
 
+    def _separate_types(self, types: List[Type]) -> Tuple[List[Type], List[Type]]:
+        """
+        Separates the types into two kinds. The first are those for which
+        there are already validators defined by pydantic - str, int, datetime
+        and some other built-in types. The second are all other types for which
+        the `arbitrary_types_allowed` config is applied when defining the pydantic model
+        """
+        pydantic_types = filter(lambda type_: type_ in REGISTERED_PYDANTIC_TYPES, types)
+        userspace_types_types = filter(lambda type_: type_ not in REGISTERED_PYDANTIC_TYPES, types)
+        return list(pydantic_types), list(userspace_types_types)
+
+    def _cast_value_with_pydantic(
+        self,
+        types: List[Type],
+        value: Any,
+    ) -> Tuple[Optional[Any], List[str]]:
+        result_value, errors = None, []
+
+        for type_to_cast in types:
+            for validator in find_validators(type_to_cast, BaseConfig):
+                try:
+                    result_value = validator(value)
+                    return result_value, errors
+                except Exception as ex:
+                    errors.append(str(ex))
+
+        return None, errors
+
+    def _cast_iterable_with_pydantic(self, types: List[Type], values: List) -> Tuple[List, List[str]]:
+        type_cast_failed = False
+        failed_values = []
+
+        result_values: List[Any] = []
+        errors: List[str] = []
+
+        for value in values:
+            casted_value, cast_errors = self._cast_value_with_pydantic(types, value)
+            errors.extend(cast_errors)
+
+            if casted_value is None:
+                type_cast_failed = True
+                failed_values.append(value)
+
+                continue
+
+            result_values.append(casted_value)
+
+        if type_cast_failed:
+            msg = f"Can't parse items {failed_values} of value {values}"
+            raise InvalidFilters(msg)
+
+        return result_values, errors
+
     def resolve(self) -> FilterAndJoins:  # noqa: PLR0911
         """Create filter for a particular node of the filter tree"""
         if "or" in self.filter_:

tests/test_api/test_api_sqla_with_includes.py

@@ -1262,7 +1262,7 @@ class ContainsTimestampAttrsSchema(BaseModel):
             stms = select(ContainsTimestamp).where(ContainsTimestamp.id == int(entity_id))
             entity_model: Optional[ContainsTimestamp] = (await async_session.execute(stms)).scalar_one_or_none()
             assert entity_model
-            assert entity_model.timestamp == create_timestamp
+            assert entity_model.timestamp.isoformat() == create_timestamp.replace(tzinfo=None).isoformat()
 
             params = {
                 "filter": json.dumps(
@@ -1285,21 +1285,23 @@ class ContainsTimestampAttrsSchema(BaseModel):
                 "data": [
                     {
                         "type": "contains_timestamp_model",
-                        "attributes": {"timestamp": create_timestamp.isoformat()},
+                        "attributes": {"timestamp": create_timestamp.replace(tzinfo=None).isoformat()},
                         "id": entity_id,
                     },
                 ],
             }
 
             # check filter really work
             params = {
-                "filter": [
-                    {
-                        "name": "timestamp",
-                        "op": "eq",
-                        "val": datetime.now(tz=timezone.utc).isoformat(),
-                    },
-                ],
+                "filter": json.dumps(
+                    [
+                        {
+                            "name": "timestamp",
+                            "op": "eq",
+                            "val": datetime.now(tz=timezone.utc).isoformat(),
+                        },
+                    ],
+                ),
             }
             res = await client.get(url, params=params)
             assert res.status_code == status.HTTP_200_OK, res.text