jararaca 0.2.30__tar.gz → 0.2.32__tar.gz

{jararaca-0.2.30 → jararaca-0.2.32}/PKG-INFO

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

{jararaca-0.2.30 → jararaca-0.2.32}/pyproject.toml

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

{jararaca-0.2.30 → jararaca-0.2.32}/src/jararaca/persistence/sort_filter.py

@@ -1,3 +1,4 @@
+import re
 from datetime import date, datetime
 from functools import reduce
 from typing import Literal, Tuple, TypeVar
@@ -10,7 +11,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 +55,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
@@ -139,25 +138,41 @@ class SortFilterRunner:
                 case _:
                     raise ValueError(f"Unsupported bool operator: {filter.operator}")
         elif field_type is int:
+            __value = (
+                filter.value[0] if isinstance(filter.value, list) else filter.value
+            )
+            if not re.match(r"^-?\d+$", __value):
+                raise ValueError(
+                    f"Unsupported value type for int field: {type(__value)}"
+                )
+            number_value = int(__value)
             match filter.operator:
                 case "=":
-                    return query.filter(field == filter.value)
+                    return query.filter(field == number_value)
                 case "!=":
-                    return query.filter(field != filter.value)
+                    return query.filter(field != number_value)
                 case ">":
-                    return query.filter(field > filter.value)
+                    return query.filter(field > number_value)
                 case "<":
-                    return query.filter(field < filter.value)
+                    return query.filter(field < number_value)
                 case ">=":
-                    return query.filter(field >= filter.value)
+                    return query.filter(field >= number_value)
                 case "<=":
-                    return query.filter(field <= filter.value)
+                    return query.filter(field <= number_value)
                 case "isEmpty":
                     return query.filter(field == None)  # noqa
                 case "isNotEmpty":
                     return query.filter(field != None)  # noqa
                 case "isAnyOf":
-                    return query.filter(field.in_(filter.value))
+                    if not isinstance(filter.value, list):
+                        raise ValueError(
+                            f"Unsupported value type for isAnyOf operator: {type(filter.value)}"
+                        )
+
+                    number_values = [
+                        int(v) for v in filter.value if re.match(r"^-?\d+$", v)
+                    ]
+                    return query.filter(field.in_(number_values))
                 case _:
                     raise ValueError(f"Unsupported int operator: {filter.operator}")
 
@@ -168,6 +183,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]]:
@@ -182,6 +205,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.30 → jararaca-0.2.32}/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())