jararaca 0.2.29__tar.gz → 0.2.31__tar.gz

{jararaca-0.2.29 → jararaca-0.2.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.2.29
+Version: 0.2.31
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S

{jararaca-0.2.29 → jararaca-0.2.31}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.2.29"
+version = "0.2.31"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"

{jararaca-0.2.29 → jararaca-0.2.31}/src/jararaca/persistence/sort_filter.py

@@ -10,7 +10,7 @@ from sqlalchemy.orm.attributes import InstrumentedAttribute
 from jararaca import BaseEntity
 
 FILTER_SORT_ENTITY_ATTR_MAP = dict[
-    str, InstrumentedAttribute[str | int | datetime | date | UUID]
+    str, InstrumentedAttribute[str | int | datetime | date | UUID | None]
 ]
 
 
@@ -54,14 +54,12 @@ class FilterModel(BaseModel):
 INHERITS_BASE_ENTITY = TypeVar("INHERITS_BASE_ENTITY", bound=BaseEntity)
 
 
-class SortFilterRunner:
+class FilterRuleApplier:
     def __init__(
         self,
         allowed_filters: FILTER_SORT_ENTITY_ATTR_MAP,
-        allowed_sorts: FILTER_SORT_ENTITY_ATTR_MAP,
     ):
         self.allowed_filters = allowed_filters
-        self.allowed_sorts = allowed_sorts
 
     def create_query_for_filter(
         self, query: Select[Tuple[INHERITS_BASE_ENTITY]], filter: FilterModel
@@ -103,6 +101,8 @@ class SortFilterRunner:
             __value = (
                 filter.value[0] if isinstance(filter.value, list) else filter.value
             )
+            if not __value.strip():
+                return query
             if field_type is date:
                 value = datetime.strptime(__value, "%Y-%m-%d").date()
             else:
@@ -166,6 +166,14 @@ class SortFilterRunner:
     ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
         return reduce(lambda q, f: self.create_query_for_filter(q, f), filters, query)
 
+
+class SortRuleApplier:
+    def __init__(
+        self,
+        allowed_sorts: FILTER_SORT_ENTITY_ATTR_MAP,
+    ):
+        self.allowed_sorts = allowed_sorts
+
     def create_query_for_sorting(
         self, query: Select[Tuple[INHERITS_BASE_ENTITY]], sort: SortModel
     ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
@@ -180,6 +188,38 @@ class SortFilterRunner:
         return reduce(lambda q, s: self.create_query_for_sorting(q, s), sorts, query)
 
 
+class SortFilterRunner:
+    def __init__(
+        self,
+        allowed_filters: FILTER_SORT_ENTITY_ATTR_MAP,
+        allowed_sorts: FILTER_SORT_ENTITY_ATTR_MAP,
+    ):
+        self.allowed_filters = allowed_filters
+        self.allowed_sorts = allowed_sorts
+        self.filter_rule_applier = FilterRuleApplier(allowed_filters)
+        self.sort_rule_applier = SortRuleApplier(allowed_sorts)
+
+    def create_query_for_filter(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], filter: FilterModel
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return self.filter_rule_applier.create_query_for_filter(query, filter)
+
+    def create_query_for_filter_list(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], filters: list[FilterModel]
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return self.filter_rule_applier.create_query_for_filter_list(query, filters)
+
+    def create_query_for_sorting(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], sort: SortModel
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return self.sort_rule_applier.create_query_for_sorting(query, sort)
+
+    def create_query_for_sorting_list(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], sorts: list[SortModel]
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return self.sort_rule_applier.create_query_for_sorting_list(query, sorts)
+
+
 __all__ = [
     "SortFilterRunner",
     "FilterModel",

{jararaca-0.2.29 → jararaca-0.2.31}/src/jararaca/persistence/utilities.py

@@ -29,7 +29,12 @@ from jararaca.persistence.base import (
     BaseEntity,
     recursive_get_dict,
 )
-from jararaca.persistence.sort_filter import FilterModel, SortModel
+from jararaca.persistence.sort_filter import (
+    FilterModel,
+    FilterRuleApplier,
+    SortModel,
+    SortRuleApplier,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -257,11 +262,15 @@ class QueryOperations(Generic[QUERY_FILTER_T, QUERY_ENTITY_T]):
         session_provider: Callable[[], AsyncSession],
         filters_functions: list[QueryInjector],
         unique: bool = False,
+        sort_rule_applier: SortRuleApplier | None = None,
+        filter_rule_applier: FilterRuleApplier | None = None,
     ) -> None:
         self.entity_type: type[QUERY_ENTITY_T] = entity_type
         self.session_provider = session_provider
         self.filters_functions = filters_functions
         self.unique = unique
+        self.sort_rule_applier = sort_rule_applier
+        self.filter_rule_applier = filter_rule_applier
 
     @property
     def session(self) -> AsyncSession:
@@ -281,6 +290,16 @@ class QueryOperations(Generic[QUERY_FILTER_T, QUERY_ENTITY_T]):
             select(self.entity_type),
         )
 
+        if self.sort_rule_applier:
+            query = self.sort_rule_applier.create_query_for_sorting_list(
+                query, filter.sort_models
+            )
+
+        if self.filter_rule_applier:
+            query = self.filter_rule_applier.create_query_for_filter_list(
+                query, filter.filter_models
+            )
+
         unpaginated_total = (
             await self.session.execute(
                 select(func.count()).select_from(query.subquery())