added test case for nested query filter and fix

Author: CosmoV

docs/filtering.rst

@@ -81,31 +81,29 @@ You can also use boolean combination of operations:
         "val":"%admin%"
       },
       {
-        "or": {
-          [
-            {
-              "not": {
+        "or": [
+          {
+            "not": {
+              "name": "first_name",
+              "op": "eq",
+              "val": "John"
+            }
+          },
+          {
+            "and": [
+              {
                 "name": "first_name",
-                "op": "eq",
-                "val":"John"
+                "op": "like",
+                "val": "%Jim%"
+              },
+              {
+                "name": "date_create",
+                "op": "gt",
+                "val": "1990-01-01"
               }
-            },
-            {
-              "and": [
-                {
-                  "name": "first_name",
-                  "op": "like",
-                  "val": "%Jim%"
-                },
-                {
-                  "name": "date_create",
-                  "op": "gt",
-                  "val": "1990-01-01"
-                }
-              ]
-            }
-          ]
-        }
+            ]
+          }
+        ]
       }
     ] HTTP/1.1
     Accept: application/vnd.api+json

fastapi_jsonapi/data_layers/sqla_orm.py

@@ -140,7 +140,7 @@ async def apply_relationships(self, obj: TypeModel, data_create: BaseJSONAPIItem
             relationship_info: RelationshipInfo = field.field_info.extra["relationship"]
 
             # ...
-            related_model = get_related_model_cls(obj, relation_name)
+            related_model = get_related_model_cls(type(obj), relation_name)
 
             if relationship_info.many:
                 assert isinstance(relationship_in, BaseJSONAPIRelationshipDataToManySchema)

fastapi_jsonapi/querystring.py

@@ -149,6 +149,15 @@ def filters(self) -> List[dict]:
         filters = self.qs.get("filter")
         if filters is not None:
             try:
+                loaded_filters = json.loads(filters)
+
+                if not isinstance(loaded_filters, list):
+                    msg = (
+                        "Incorrect filters format, expected list of "
+                        f"conditions but got {type(loaded_filters).__name__}"
+                    )
+                    raise InvalidFilters(msg)
+
                 results.extend(json.loads(filters))
             except (ValueError, TypeError):
                 msg = "Parse error"

fastapi_jsonapi/utils/sqla.py

@@ -1,9 +1,9 @@
 from typing import Type
 
-from fastapi_jsonapi.data_typing import TypeModel
+from fastapi_jsonapi.data_typing import TypeModel, TypeSchema
 
 
-def get_related_model_cls(obj: TypeModel, relation_name: str) -> Type[TypeModel]:
+def get_related_model_cls(cls: TypeSchema, relation_name: str) -> Type[TypeModel]:
     """
 
     SQLA Get related model class
@@ -18,8 +18,8 @@ class Computer(sqla_base):
     class ComputerSchema(pydantic_base):
         owner = Field(alias="user", relationship=...)
 
-    :param obj:
+    :param cls:
     :param relation_name:
     :return:
     """
-    return getattr(obj.__class__, relation_name).property.mapper.class_
+    return getattr(cls, relation_name).property.mapper.class_

tests/test_api/test_api_sqla_with_includes.py

@@ -7,11 +7,12 @@
 from fastapi import APIRouter, FastAPI, status
 from httpx import AsyncClient
 from pytest import mark, param  # noqa PT013
+from sqlalchemy.ext.asyncio import AsyncSession
 
 from fastapi_jsonapi import RoutersJSONAPI
 from fastapi_jsonapi.views.view_base import ViewBase
 from tests.fixtures.app import build_app_plain
-from tests.fixtures.entities import create_user
+from tests.fixtures.entities import build_workplace, create_user
 from tests.fixtures.views import DetailViewBaseGeneric, ListViewBaseGeneric
 from tests.misc.utils import fake
 from tests.models import (
@@ -1799,6 +1800,90 @@ async def test_composite_filter_with_mutually_exclusive_conditions(
             "meta": {"count": 0, "totalPages": 1},
         }
 
+    async def test_filter_with_nested_conditions(
+        self,
+        app: FastAPI,
+        async_session: AsyncSession,
+        client: AsyncClient,
+    ):
+        workplace_name = "Common workplace name"
+
+        workplace_1, workplace_2, workplace_3, workplace_4 = (
+            await build_workplace(async_session, name=workplace_name),
+            await build_workplace(async_session, name=workplace_name),
+            await build_workplace(async_session, name=workplace_name),
+            await build_workplace(async_session, name=workplace_name),
+        )
+
+        user_1, user_2, _, user_4 = (
+            await create_user(async_session, name="John Doe", age=20, workplace=workplace_1),
+            await create_user(async_session, name="Jane Doe", age=25, workplace=workplace_2),
+            await create_user(async_session, name="Jonny Doe", age=30, workplace=workplace_3),
+            await create_user(async_session, name="Mary Jane", age=21, workplace=workplace_4),
+        )
+
+        params = {
+            "filter": dumps(
+                [
+                    {
+                        "name": "workplace.name",
+                        "op": "eq",
+                        "val": workplace_name,
+                    },
+                    {
+                        "or": [
+                            {
+                                "not": {
+                                    "name": "name",
+                                    "op": "ne",
+                                    "val": "Mary Jane",
+                                },
+                            },
+                            {
+                                "and": [
+                                    {
+                                        "name": "name",
+                                        "op": "like",
+                                        "val": "%Doe%",
+                                    },
+                                    {
+                                        "name": "age",
+                                        "op": "lt",
+                                        "val": 30,
+                                    },
+                                ],
+                            },
+                        ],
+                    },
+                ],
+            ),
+        }
+
+        url = app.url_path_for("get_user_list")
+        res = await client.get(url, params=params)
+        assert res.status_code == status.HTTP_200_OK, res.text
+        assert res.json() == {
+            "data": [
+                {
+                    "attributes": UserAttributesBaseSchema.from_orm(user_1),
+                    "id": str(user_1.id),
+                    "type": "user",
+                },
+                {
+                    "attributes": UserAttributesBaseSchema.from_orm(user_2),
+                    "id": str(user_2.id),
+                    "type": "user",
+                },
+                {
+                    "attributes": UserAttributesBaseSchema.from_orm(user_4),
+                    "id": str(user_4.id),
+                    "type": "user",
+                },
+            ],
+            "jsonapi": {"version": "1.0"},
+            "meta": {"count": 3, "totalPages": 1},
+        }
+
 
 ASCENDING = ""
 DESCENDING = "-"
@@ -1819,7 +1904,7 @@ async def test_sort(
         self,
         app: FastAPI,
         client: AsyncClient,
-        async_session,
+        async_session: AsyncSession,
         order: str,
     ):
         user_1, _, user_3 = (