added join filter

Author: OleksandrZhydyk

.gitignore

@@ -0,0 +1,4 @@
+.idea
+__pychache__/
+.env
+dist

README.md

@@ -12,7 +12,7 @@ Supported operators, datatypes and example of work you can find below.
 pip install fastapi-sa-orm-filter
 ```
 ### Compatibility
-v 0.2.0
+v 0.2.1
  - Python: >= 3.8
  - Fastapi: >= 0.100
  - Pydantic: >= 2.0.0
@@ -57,7 +57,7 @@ async def get_filtered_objects(
     return res.scalars().all()
 ```
 
-### Example of work
+### Examples of usage
 
 ```shell
 
@@ -83,6 +83,47 @@ select(model)
         ).order_by(model.id.desc(), model.category.asc())
 ```
 
+```shell
+# Filter by joined model
+
+# Input query string
+'''vacancies.salary_from__gte=100'''
+
+allowed_filter_fields = {
+    "id": [ops.eq],
+    "title": [ops.startswith, ops.eq, ops.contains],
+    "salary_from": [ops.eq, ops.gt, ops.lte, ops.gte]
+}
+
+company_filter = FilterCore(
+    Company, 
+    allowed_filter_fields, 
+    select(Company).join(Vacancy).options(joinedload(Company.vacancies))
+)
+
+@app.get("/")
+async def get_filtered_company(
+    filter_query: str = "title__eq=MyCompany&vacancies.salary_from__gte=100",
+    db: AsyncSession = Depends(get_session)
+ ) -> List[Company]:
+  
+    query = company_filter.get_query(filter_query)
+    res = await db.execute(query)
+    return res.scalars().all()
+    
+# Returned SQLAlchemy query
+select(Company)
+  .join(Vacancy)
+  .options(joinedload(Company.vacancies))
+  .where(
+    and_(
+      Company.title == "MyCompany", 
+      Vacancy.salary_from >= 100
+    )
+  )
+
+```
+
 ### Supported query string format
 
 * field_name__eq=value
@@ -93,7 +134,7 @@ select(model)
 ### Modify query for custom selection
 ```shell
 # Create a class inherited from FilterCore and rewrite 'get_unordered_query' method.
-# 0.2.0 Version
+# ^0.2.0 Version
 
 class CustomFilter(FilterCore):
 

fastapi_sa_orm_filter/__init__.py

@@ -1,3 +1,3 @@
 """FastAPI-SQLAlchemy filter, transform request query string to SQLAlchemy orm query"""
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"

fastapi_sa_orm_filter/exceptions.py

@@ -0,0 +1,2 @@
+class SAFilterOrmException(Exception):
+    pass

fastapi_sa_orm_filter/main.py

@@ -1,18 +1,20 @@
 import json
-from typing import Any, Dict, List, Type
+
+from typing import Any, Type
 
 import pydantic
 from fastapi import HTTPException
 from pydantic import create_model
 from pydantic._internal._model_construction import ModelMetaclass
 from sqlalchemy_to_pydantic import sqlalchemy_to_pydantic
-from sqlalchemy import select
+from sqlalchemy import select, inspect
 from sqlalchemy.orm import InstrumentedAttribute, DeclarativeMeta
 from sqlalchemy.sql.elements import BinaryExpression, UnaryExpression
 from sqlalchemy.sql.expression import and_, or_
 from starlette import status
 from sqlalchemy.sql import Select
 
+from fastapi_sa_orm_filter.exceptions import SAFilterOrmException
 from fastapi_sa_orm_filter.operators import Operators as ops
 from fastapi_sa_orm_filter.parsers import _FilterQueryParser, _OrderByQueryParser
 
@@ -24,7 +26,10 @@ class FilterCore:
     """
 
     def __init__(
-        self, model: Type[DeclarativeMeta], allowed_filters: Dict[str, List[ops]]
+        self,
+        model: Type[DeclarativeMeta],
+        allowed_filters: dict[str, list[ops]],
+        select_query_part: Select[Any] = None
     ) -> None:
         """
         Produce a class:`FilterCore` object against a function
@@ -38,8 +43,10 @@ def __init__(
                 }
         """
         self.model = model
+        self.relationships = inspect(self.model).relationships.items()
         self._allowed_filters = allowed_filters
-        self._model_serializer = self._create_pydantic_serializer()
+        self._model_serializers = self._create_pydantic_serializers()
+        self.select_query_part = select_query_part
 
     def get_query(self, custom_filter: str) -> Select[Any]:
         """
@@ -63,58 +70,60 @@ def get_query(self, custom_filter: str) -> Select[Any]:
                     ).order_by(model.id.desc())
         """
         split_query = self.split_by_order_by(custom_filter)
-        if len(split_query) == 1:
-            complete_query = self.get_complete_query(split_query[0])
-            return complete_query
-        filter_query_str, order_by_query_str = split_query
-        complete_query = self.get_complete_query(filter_query_str, order_by_query_str)
+        try:
+            complete_query = self.get_complete_query(*split_query)
+        except SAFilterOrmException as e:
+            raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=e.args[0])
         return complete_query
 
     def get_complete_query(self, filter_query_str: str, order_by_query_str: str | None = None) -> Select[Any]:
         select_query_part = self.get_select_query_part()
         filter_query_part = self.get_filter_query_part(filter_query_str)
         complete_query = select_query_part.filter(*filter_query_part)
         group_query_part = self.get_group_by_query_part()
-        if group_query_part != []:
+        if group_query_part:
             complete_query = complete_query.group_by(*group_query_part)
         if order_by_query_str is not None:
             order_by_query = self.get_order_by_query_part(order_by_query_str)
             complete_query = complete_query.order_by(*order_by_query)
         return complete_query
 
     def get_select_query_part(self) -> Select[Any]:
+        if self.select_query_part:
+            return self.select_query_part
         return select(self.model)
 
-    def get_filter_query_part(self, filter_query_str: str) -> List[Any]:
+    def get_filter_query_part(self, filter_query_str: str) -> list[Any]:
         conditions = self._get_filter_query(filter_query_str)
-        if conditions == []:
+        if len(conditions) == 0:
             return conditions
         return [or_(*conditions)]
 
-    def get_group_by_query_part(self):
+    def get_group_by_query_part(self) -> list:
         return []
 
-    def get_order_by_query_part(self, order_by_query_str: str) -> List[UnaryExpression]:
+    def get_order_by_query_part(self, order_by_query_str: str) -> list[UnaryExpression]:
         order_by_parser = _OrderByQueryParser(self.model)
         return order_by_parser.get_order_by_query(order_by_query_str)
 
-    def _get_filter_query(self, custom_filter: str) -> List[BinaryExpression]:
+    def _get_filter_query(self, custom_filter: str) -> list[BinaryExpression]:
         filter_conditions = []
-        if custom_filter == '':
+        if custom_filter == "":
             return filter_conditions
         query_parser = _FilterQueryParser(custom_filter, self.model, self._allowed_filters)
+
         for and_expressions in query_parser.get_parsed_query():
             and_condition = []
             for expression in and_expressions:
-                column, operator, value = expression
-                serialized_dict = self._format_expression(column, operator, value)
+                table, column, operator, value = expression
+                serialized_dict = self._format_expression(table, column, operator, value)
                 value = serialized_dict[column.name]
                 param = self._get_orm_for_field(column, operator, value)
                 and_condition.append(param)
             filter_conditions.append(and_(*and_condition))
         return filter_conditions
 
-    def _create_pydantic_serializer(self) -> Dict[str, ModelMetaclass]:
+    def _create_pydantic_serializers(self) -> dict[str, ModelMetaclass]:
         """
         Create two pydantic models (optional and list field types)
         for value: str serialization
@@ -128,10 +137,23 @@ class model.__name__(BaseModel):
                     field: Optional[List[type]]
         }
         """
-        pydantic_serializer = sqlalchemy_to_pydantic(self.model)
-        optional_model = self._get_optional_pydantic_model(pydantic_serializer)
-        optional_list_model = self._get_optional_pydantic_model(pydantic_serializer, is_list=True)
-        return {"optional_model": optional_model, "optional_list_model": optional_list_model}
+
+        models = [self.model]
+        models.extend(self.get_relations())
+
+        serializers = {}
+
+        for model in models:
+            pydantic_serializer = sqlalchemy_to_pydantic(model)
+            optional_model = self._get_optional_pydantic_model(model, pydantic_serializer)
+            optional_list_model = self._get_optional_pydantic_model(model, pydantic_serializer, is_list=True)
+
+            serializers[model.__tablename__] = {"optional_model": optional_model, "optional_list_model":optional_list_model}
+
+        return serializers
+
+    def get_relations(self) -> list:
+        return [relation[1].mapper.class_ for relation in self.relationships]
 
     def _get_orm_for_field(
         self, column: InstrumentedAttribute, operator: str, value: Any
@@ -146,7 +168,7 @@ def _get_orm_for_field(
         return param
 
     def _format_expression(
-        self, column: InstrumentedAttribute, operator: str, value: str
+        self, table: str, column: InstrumentedAttribute, operator: str, value: str
     ) -> dict[str, Any]:
         """
         Serialize expression value from string to python type value,
@@ -158,41 +180,29 @@ def _format_expression(
         try:
             if operator not in [ops.between, ops.in_]:
                 value = value[0]
-                serialized_dict = self._model_serializer["optional_model"](
-                    **{column.name: value}
-                ).model_dump(exclude_none=True)
-                return serialized_dict
-            serialized_dict = self._model_serializer["optional_list_model"](
-                **{column.name: value}
-            ).model_dump(exclude_none=True)
-            return serialized_dict
+                model_serializer = self._model_serializers[table]["optional_model"]
+            else:
+                model_serializer = self._model_serializers[table]["optional_list_model"]
+            return model_serializer(**{column.name: value}).model_dump(exclude_none=True)
         except pydantic.ValidationError as e:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST, detail=json.loads(e.json())
-            )
+            raise SAFilterOrmException(json.loads(e.json()))
         except ValueError:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail=f"Incorrect filter value '{value}'",
-            )
+            raise SAFilterOrmException(f"Incorrect filter value '{value}'")
 
     @staticmethod
-    def split_by_order_by(query):
+    def split_by_order_by(query) -> list:
         split_query = [query_part.strip("&") for query_part in query.split("order_by=")]
         if len(split_query) > 2:
-            raise HTTPException(
-                status_code=status.HTTP_400_BAD_REQUEST,
-                detail="Use only one order_by directive",
-            )
+            raise SAFilterOrmException("Use only one order_by directive")
         return split_query
 
-    def _get_optional_pydantic_model(self, pydantic_serializer, is_list: bool = False):
+    def _get_optional_pydantic_model(self, model, pydantic_serializer, is_list: bool = False):
         fields = {}
         for k, v in pydantic_serializer.model_fields.items():
             origin_annotation = getattr(v, 'annotation')
             if is_list:
-                fields[k] = (List[origin_annotation], None)
+                fields[k] = (list[origin_annotation], None)
             else:
                 fields[k] = (origin_annotation, None)
-        pydantic_model = create_model(self.model.__name__, **fields)
+        pydantic_model = create_model(model.__name__, **fields)
         return pydantic_model