fix filtering by nested entities

Author: Znbiz

examples/api_for_sqlalchemy/api/user.py

@@ -7,6 +7,7 @@
 from fastapi import Depends
 from sqlalchemy import select, desc
 from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql import Select
 from tortoise.exceptions import DoesNotExist
 from tortoise.queryset import QuerySet
 
@@ -76,7 +77,7 @@ async def patch(cls, obj_id, data: UserPatchSchema, query_params: QueryStringMan
 
 class UserList:
     @classmethod
-    async def get(cls, query_params: QueryStringManager, session: AsyncSession = Depends(Connector.get_session)) -> Union[QuerySet, JSONAPIResultListSchema]:
+    async def get(cls, query_params: QueryStringManager, session: AsyncSession = Depends(Connector.get_session)) -> Union[Select, JSONAPIResultListSchema]:
         user_query = select(User).order_by(desc(User.id))
         dl = SqlalchemyEngine(query=user_query, schema=UserSchema, model=User, session=session)
         count, users_db = await dl.get_collection(qs=query_params)

fastapi_rest_jsonapi/api.py

@@ -13,15 +13,15 @@
 from fastapi import APIRouter
 from pydantic import BaseModel, Field
 
-from fastapi_rest_jsonapi.data_layers.data_typing import TypeModel
+from fastapi_rest_jsonapi.data_layers.data_typing import TypeModel, TypeSchema
 from fastapi_rest_jsonapi.data_layers.orm import DBORMType
 from fastapi_rest_jsonapi.exceptions import ExceptionResponseSchema
 from fastapi_rest_jsonapi.methods import (
     delete_detail_jsonapi,
     get_detail_jsonapi,
     get_list_jsonapi,
     patch_detail_jsonapi,
-    post_list_jsonapi,
+    post_list_jsonapi, delete_list_jsonapi,
 )
 from fastapi_rest_jsonapi.schema import BasePatchJSONAPISchema, BasePostJSONAPISchema, JSONAPIObjectSchema, \
     JSONAPIResultDetailSchema
@@ -39,10 +39,10 @@ def __init__(  # noqa: WPS211
         tags: List[str],
         class_detail: Any,
         class_list: Any,
-        schema: Type[BaseModel],
+        schema: Type[TypeSchema],
         type_resource: str,
-        schema_in_patch: Type[BaseModel],
-        schema_in_post: Type[BaseModel],
+        schema_in_patch: Type[TypeSchema],
+        schema_in_post: Type[TypeSchema],
         model: Type[TypeModel],
         engine: DBORMType = DBORMType.sqlalchemy,
     ) -> None:
@@ -166,6 +166,21 @@ def _add_routers(self, path: str):
                 )(self.class_list.post)
             )
 
+        if hasattr(self.class_list, "delete"):
+            self._routers.delete(
+                path,
+                tags=self._tags,
+                summary=f"Delete list objects of type `{self._type}`"
+            )(
+                delete_list_jsonapi(
+                    schema=self._schema,
+                    model=self._model,
+                    engine=self._engine,
+                )(
+                    self.class_list.delete
+                )
+            )
+
         if hasattr(self.class_detail, "get"):
             self._routers.get(
                 path + "/{obj_id}",

fastapi_rest_jsonapi/data_layers/data_typing.py

@@ -1,7 +1,6 @@
 from typing import TypeVar
 
-from pydantic import BaseModel
 
 TypeQuery = TypeVar("TypeQuery")
 TypeModel = TypeVar("TypeModel")
-TypeSchema = TypeVar("TypeSchema", bound=BaseModel)
+TypeSchema = TypeVar("TypeSchema")

fastapi_rest_jsonapi/data_layers/filtering/sqlalchemy.py

@@ -8,7 +8,7 @@
 from sqlalchemy.sql.elements import BinaryExpression
 
 from fastapi_rest_jsonapi.data_layers.shared import create_filters_or_sorts
-from fastapi_rest_jsonapi.exceptions import InvalidFilters
+from fastapi_rest_jsonapi.exceptions import InvalidFilters, InvalidType
 
 from fastapi_rest_jsonapi.data_layers.data_typing import TypeSchema, TypeModel
 from fastapi_rest_jsonapi.schema import get_relationships, get_model_field
@@ -78,8 +78,24 @@ def create_filter(self, schema_field: ModelField, model_column, operator, value)
             )
         # Here we have to deserialize and validate fields, that are used in filtering,
         # so the Enum fields are loaded correctly
-        value = schema_field.type_(value)
-        return getattr(model_column, self.operator)(value)
+
+        if schema_field.sub_fields:
+            # Для случаев когда в схеме тип Union
+            fields = [i for i in schema_field.sub_fields]
+        else:
+            fields = [schema_field]
+        types = [i.type_ for i in fields]
+        clear_value = None
+        errors: List[str] = []
+        for i_type in types:
+            try:
+                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 resolve(self) -> FilterAndJoins:
         """Create filter for a particular node of the filter tree"""
@@ -105,13 +121,22 @@ def resolve(self) -> FilterAndJoins:
                 return self._relationship_filtering(value)
 
             schema_field: ModelField = self.schema.__fields__[self.name]
-            if issubclass(schema_field.type_, BaseModel):
-                value = {
-                    'name': self.name,
-                    'op': self.filter_['op'],
-                    'val': value,
-                }
-                return self._relationship_filtering(value)
+            if schema_field.sub_fields:
+                # Для случаев когда в схеме тип Union
+                types = [i.type_ for i in schema_field.sub_fields]
+            else:
+                types = [schema_field.type_]
+            for i_type in types:
+                try:
+                    if issubclass(i_type, BaseModel):
+                        value = {
+                            'name': self.name,
+                            'op': self.filter_['op'],
+                            'val': value,
+                        }
+                        return self._relationship_filtering(value)
+                except (TypeError, ValueError):
+                    pass
 
             return self.create_filter(
                 schema_field=schema_field,

fastapi_rest_jsonapi/data_layers/sqlalchemy_engine.py

@@ -339,7 +339,7 @@ def paginate_query(self, query: Select, paginate_info: PaginationQueryStringMana
         :params paginate_info: pagination information.
         :return: the paginated query
         """
-        if paginate_info.size == 0:
+        if paginate_info.size == 0 or paginate_info.size is None:
             return query
 
         query = query.limit(paginate_info.size)

fastapi_rest_jsonapi/methods.py

@@ -47,6 +47,7 @@ async def wrapper(request: Request, obj_id: int, **kwargs):
 
             params_function = OrderedDict(signature(func).parameters)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             data_schema: Any = await func(**data_dict)
             return schema_resp(
                 data={
@@ -91,6 +92,7 @@ async def wrapper(request: Request, obj_id: int, data: schema_in, **kwargs):  #
 
             params_function = OrderedDict(signature(func).parameters)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             data_schema: Any = await func(**data_dict)
             return schema_resp(
                 data={
@@ -126,6 +128,7 @@ async def wrapper(request: Request, obj_id: int, **kwargs):  # type: ignore
 
             params_function = OrderedDict(signature(func).parameters)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             await func(**data_dict)
             return Response(status_code=status.HTTP_204_NO_CONTENT)
 
@@ -139,6 +142,48 @@ async def wrapper(request: Request, obj_id: int, **kwargs):  # type: ignore
     return inner
 
 
+def delete_list_jsonapi(
+    schema: Type[BaseModel],
+    model: Type[TypeModel],
+    engine: DBORMType,
+) -> Callable:
+    """DELETE method router (Decorator for JSON API)."""
+
+    def inner(func: Callable) -> Callable:
+        async def wrapper(
+            request: Request,
+            filters_list: Optional[str] = Query(
+                None,
+                alias="filter",
+                description="[Filtering docs](https://flask-combo-jsonapi.readthedocs.io/en/latest/filtering.html)"
+                            "\nExamples:\n* filter for timestamp interval: "
+                            '`[{"name": "timestamp", "op": "ge", "val": "2020-07-16T11:35:33.383"},'
+                            '{"name": "timestamp", "op": "le", "val": "2020-07-21T11:35:33.383"}]`',
+            ),
+            **kwargs,
+        ):
+            query_params = QueryStringManager(request=request, schema=schema)
+            data_dict: dict = dict(query_params=query_params)
+            if is_necessary_request(func):
+                data_dict["request"] = request
+
+            params_function = OrderedDict(signature(func).parameters)
+            data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
+            await func(**data_dict)
+            return Response(status_code=status.HTTP_204_NO_CONTENT)
+
+        # mypy ругается что нет метода __signature__, как это обойти красиво- не знаю
+        wrapper.__signature__ = update_signature(  # type: ignore
+            sig=signature(wrapper),
+            schema=schema,
+            other=OrderedDict(signature(func).parameters),
+        )
+        return wrapper
+
+    return inner
+
+
 async def _get_single_response(
     query,
     query_params: QueryStringManager,
@@ -203,6 +248,7 @@ async def wrapper(
 
             params_function = OrderedDict(signature(func).parameters)
             data.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data = {i_k: i_v for i_k, i_v in data.items() if i_k in params_function}
             query = await func(**data)
 
             if engine is DBORMType.sqlalchemy:
@@ -263,6 +309,7 @@ async def wrapper(request: Request, data: schema_in, **kwargs):  # type: ignore
 
             params_function = OrderedDict(signature(func).parameters)
             data_dict.update({i_k: i_v for i_k, i_v in kwargs.items() if i_k in params_function})
+            data_dict = {i_k: i_v for i_k, i_v in data_dict.items() if i_k in params_function}
             data_pydantic: Any = await func(**data_dict)
             return schema_resp(
                 data={

fastapi_rest_jsonapi/schema.py

@@ -1,10 +1,11 @@
 """Helpers to deal with marshmallow schemas. Base JSON:API schemas."""
+import uuid
 from typing import (
     Dict,
     Type,
     List,
     Optional,
-    Sequence, TYPE_CHECKING,
+    Sequence, TYPE_CHECKING, Union,
 )
 
 from fastapi import FastAPI
@@ -33,7 +34,7 @@ class BasePostJSONAPISchema(BaseJSONAPIItemSchema):
 class BaseJSONAPIObjectSchema(BaseJSONAPIItemSchema):
     """Base JSON:API object schema."""
 
-    id: int = Field(description="ID объекта")
+    id: Union[uuid.UUID, int] = Field(description="ID объекта")
 
 
 class BasePatchJSONAPISchema(BaseJSONAPIObjectSchema):
@@ -179,7 +180,13 @@ def get_relationships(schema: Type["TypeSchema"], model_field: bool = False) ->
     :param schema: a pydantic schema
     :param model_field: list of relationship fields of a schema
     """
-    relationships = [i_name for i_name, i_type in schema.__fields__.items() if issubclass(i_type.type_, BaseModel)]
+    relationships: List[str] = []
+    for i_name, i_type in schema.__fields__.items():
+        try:
+            if issubclass(i_type.type_, BaseModel):
+                relationships.append(i_name)
+        except TypeError:
+            pass
 
     if model_field is True:
         relationships = [get_model_field(schema, key) for key in relationships]

fastapi_rest_jsonapi/signature.py

@@ -45,8 +45,8 @@ def update_signature(
     params_dict.pop("cls", None)
     params_no_default = [
         i_param
-        for i_param in other.values()
-        if isinstance(i_param.default, type) and other["query_params"].annotation is not QueryStringManager
+        for i_name, i_param in other.items()
+        if isinstance(i_param.default, type) and other[i_name].annotation is not QueryStringManager
     ]
     params_default = [
         i_param
@@ -56,7 +56,10 @@ def update_signature(
     params: list = list(params_dict.values())
     for name, field in (schema and schema.__fields__ or {}).items():
         try:
-            if issubclass(field.type_, (dict, BaseModel)):
+            if field.sub_fields:
+                default = Query(None, alias="filter[{alias}]".format(alias=field.alias))
+                type_field = field.type_
+            elif issubclass(field.type_, (dict, BaseModel)):
                 continue
             elif issubclass(field.type_, Enum):
                 default = Query(None, alias="filter[{alias}]".format(alias=field.alias), enum=field.type_.values())
@@ -75,9 +78,10 @@ def update_signature(
         except Exception as ex:
             pass
 
-    params: list = params_no_default + params + params_default
+    params: list = params + params_no_default + params_default
     # Убираем дубликаты
     params_dict: dict = {i_p.name: i_p for i_p in params}
     params: list = list(params_dict.values())
+    params.sort(key=lambda x: not isinstance(x.default, type))
 
     return sig.replace(parameters=params)