jararaca 0.2.21__py3-none-any.whl → 0.2.23__py3-none-any.whl

jararaca/__init__.py

@@ -2,10 +2,15 @@ from importlib import import_module
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-
     from jararaca.microservice import AppContext, AppInterceptor
     from jararaca.observability.interceptor import ObservabilityInterceptor
     from jararaca.observability.providers.otel import OtelObservabilityProvider
+    from jararaca.persistence.sort_filter import (
+        FILTER_SORT_ENTITY_ATTR_MAP,
+        FilterModel,
+        SortFilterRunner,
+        SortModel,
+    )
     from jararaca.presentation.hooks import (
         raises_200_on,
         raises_400_on,
@@ -99,6 +104,10 @@ if TYPE_CHECKING:
     from .tools.app_config.interceptor import AppConfigurationInterceptor
 
     __all__ = [
+        "FILTER_SORT_ENTITY_ATTR_MAP",
+        "FilterModel",
+        "SortFilterRunner",
+        "SortModel",
         "RegisterWebSocketMessage",
         "TracedRequestMiddleware",
         "raises_http_exception_on",
@@ -186,6 +195,10 @@ if TYPE_CHECKING:
 __SPEC_PARENT__: str = __spec__.parent  # type: ignore
 # A mapping of {<member name>: (package, <module name>)} defining dynamic imports
 _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
+    "FILTER_SORT_ENTITY_ATTR_MAP": (__SPEC_PARENT__, "persistence.sort_filter", None),
+    "FilterModel": (__SPEC_PARENT__, "persistence.sort_filter", None),
+    "SortFilterRunner": (__SPEC_PARENT__, "persistence.sort_filter", None),
+    "SortModel": (__SPEC_PARENT__, "persistence.sort_filter", None),
     "RegisterWebSocketMessage": (
         __SPEC_PARENT__,
         "presentation.websocket.decorators",

jararaca/persistence/sort_filter.py

@@ -0,0 +1,189 @@
+from datetime import date, datetime
+from functools import reduce
+from typing import Literal, Tuple, TypeVar
+from uuid import UUID
+
+from pydantic import BaseModel
+from sqlalchemy import Select
+from sqlalchemy.orm.attributes import InstrumentedAttribute
+
+from jararaca import BaseEntity
+
+FILTER_SORT_ENTITY_ATTR_MAP = dict[
+    str, InstrumentedAttribute[str | int | datetime | date | UUID]
+]
+
+
+STRING_OPERATORS = Literal[
+    "contains",
+    "doesNotContain",
+    "equals",
+    "doesNotEqual",
+    "startsWith",
+    "endsWith",
+    "isEmpty",
+    "isNotEmpty",
+    "isAnyOf",
+]
+
+
+DATE_DATETIME_OPERATORS = Literal[
+    "is", "not", "after", "onOrAfter", "before", "onOrBefore", "isEmpty", "isNotEmpty"
+]
+
+BOOLEAN_OPERATORS = Literal["is"]
+
+NUMBER_OPERATORS = Literal[
+    "=", "!=", ">", "<", ">=", "<=", "isEmpty", "isNotEmpty", "isAnyOf"
+]
+
+
+class SortModel(BaseModel):
+    field: str
+    direction: Literal["asc", "desc"]
+
+
+class FilterModel(BaseModel):
+    field: str
+    operator: Literal[
+        STRING_OPERATORS, DATE_DATETIME_OPERATORS, BOOLEAN_OPERATORS, NUMBER_OPERATORS
+    ]
+    value: str | list[str] = ""
+
+
+INHERITS_BASE_ENTITY = TypeVar("INHERITS_BASE_ENTITY", bound=BaseEntity)
+
+
+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
+
+    def create_query_for_filter(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], filter: FilterModel
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        field = self.allowed_filters.get(filter.field)
+        if field is None:
+            raise ValueError(f"Unsupported field: {filter.field}")
+        field_type = field.property.columns[0].type.python_type
+
+        if field_type is str:
+            match filter.operator:
+                case "contains":
+                    return query.filter(field.contains(filter.value))
+                case "doesNotContain":
+                    return query.filter(~field.contains(filter.value))
+                case "equals":
+                    return query.filter(field == filter.value)
+                case "doesNotEqual":
+                    return query.filter(field != filter.value)
+                case "startsWith":
+                    return query.filter(field.startswith(filter.value))
+                case "endsWith":
+                    return query.filter(field.endswith(filter.value))
+                case "isEmpty":
+                    return query.filter(field == "")
+                case "isNotEmpty":
+                    return query.filter(field != "")
+                case "isAnyOf":
+                    return query.filter(field.in_(filter.value))
+                case _:
+                    raise ValueError(f"Unsupported string operator: {filter.operator}")
+        elif field_type in [date, datetime]:
+            match filter.operator:
+                case "isEmpty":
+                    return query.filter(field == None)  # noqa
+                case "isNotEmpty":
+                    return query.filter(field != None)  # noqa
+
+            __value = (
+                filter.value[0] if isinstance(filter.value, list) else filter.value
+            )
+            if field_type is date:
+                value = datetime.strptime(__value, "%Y-%m-%d").date()
+            else:
+                value = datetime.strptime(__value, "%Y-%m-%dT%H:%M:%S.%fZ")
+            match filter.operator:
+                case "is":
+                    return query.filter(field == value)
+                case "not":
+                    return query.filter(field != value)
+                case "after":
+                    return query.filter(field > value)
+                case "onOrAfter":
+                    return query.filter(field >= value)
+                case "before":
+                    return query.filter(field < value)
+                case "onOrBefore":
+                    return query.filter(field <= value)
+
+                case _:
+                    raise ValueError(
+                        f"Unsupported data/datetime operator: {filter.operator}"
+                    )
+        elif field_type is bool:
+            __value = (
+                filter.value[0] if isinstance(filter.value, list) else filter.value
+            )
+            match filter.operator:
+                case "is":
+                    if __value == "":
+                        return query.filter(field.is_not(None))
+                    return query.filter(field == (__value == "true"))
+                case _:
+                    raise ValueError(f"Unsupported bool operator: {filter.operator}")
+        elif field_type is int:
+            match filter.operator:
+                case "=":
+                    return query.filter(field == filter.value)
+                case "!=":
+                    return query.filter(field != filter.value)
+                case ">":
+                    return query.filter(field > filter.value)
+                case "<":
+                    return query.filter(field < filter.value)
+                case ">=":
+                    return query.filter(field >= filter.value)
+                case "<=":
+                    return query.filter(field <= filter.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))
+                case _:
+                    raise ValueError(f"Unsupported int operator: {filter.operator}")
+
+        raise ValueError(f"Unsupported field type: {field_type}")
+
+    def create_query_for_filter_list(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], filters: list[FilterModel]
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return reduce(lambda q, f: self.create_query_for_filter(q, f), filters, query)
+
+    def create_query_for_sorting(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], sort: SortModel
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        field = self.allowed_sorts.get(sort.field)
+        if field is None:
+            raise ValueError(f"Unsupported field: {sort.field}")
+        return query.order_by(field.asc() if sort.direction == "asc" else field.desc())
+
+    def create_query_for_sorting_list(
+        self, query: Select[Tuple[INHERITS_BASE_ENTITY]], sorts: list[SortModel]
+    ) -> Select[Tuple[INHERITS_BASE_ENTITY]]:
+        return reduce(lambda q, s: self.create_query_for_sorting(q, s), sorts, query)
+
+
+__all__ = [
+    "SortFilterRunner",
+    "FilterModel",
+    "SortModel",
+    "FILTER_SORT_ENTITY_ATTR_MAP",
+    "INHERITS_BASE_ENTITY",
+]

{jararaca-0.2.21.dist-info → jararaca-0.2.23.dist-info}/METADATA

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

{jararaca-0.2.21.dist-info → jararaca-0.2.23.dist-info}/RECORD

@@ -1,7 +1,7 @@
 LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 README.md,sha256=mte30I-ZEJJp-Oax-OganNgl6G9GaCZPL6JVFAvZGz4,7034
-pyproject.toml,sha256=FjHyojTsOg-6l0EqxPv_DAblh7-fQXgGfgOqSZ0hUoI,1837
-jararaca/__init__.py,sha256=Dt5phB59JV6w9UaOAO7HxIqINazMJega8hVhFaerjr8,13184
+pyproject.toml,sha256=DwBGMHMjD9OcQxeANd4lZh4-u8dMCPL0E273cqbQym4,1837
+jararaca/__init__.py,sha256=fBLWY_hpImDrzD-81avNasZxAbZ8IImAkS3kl83_3Kc,13757
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
 jararaca/cli.py,sha256=fh7lp7rf5xbV5VaoSYWWehktel6BPcOXMjW7cw4wKms,5693
 jararaca/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,6 +28,7 @@ jararaca/persistence/exports.py,sha256=Ghx4yoFaB4QVTb9WxrFYgmcSATXMNvrOvT8ybPNKX
 jararaca/persistence/interceptors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/persistence/interceptors/aiosqa_interceptor.py,sha256=H6ZjOdosYGCZUzKjugiXQwJkAbnsL4HnkZLOEQhULEc,1986
 jararaca/persistence/session.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jararaca/persistence/sort_filter.py,sha256=bUxUkFZ_W1Vuc0TyDzhA41P7Zjb-USWzcTD9kAimRq4,6806
 jararaca/presentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/presentation/decorators.py,sha256=eL2YCgMSr19m4YCri5PQU46NRxf0QxsqDnz6MqKu0YQ,8389
 jararaca/presentation/hooks.py,sha256=WBbU5DG3-MAm2Ro2YraQyYG_HENfizYfyShL2ktHi6k,1980
@@ -56,8 +57,8 @@ jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaN
 jararaca/tools/app_config/interceptor.py,sha256=nfFZiS80hrbnL7-XEYrwmp2rwaVYBqxvqu3Y-6o_ov4,2575
 jararaca/tools/metadata.py,sha256=7nlCDYgItNybentPSSCc2MLqN7IpBd0VyQzfjfQycVI,1402
 jararaca/tools/typescript/interface_parser.py,sha256=rvTlSGDffyxSwqoHDLxdXApwXDw0v8Tq6nOWPO033nQ,28382
-jararaca-0.2.21.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.2.21.dist-info/METADATA,sha256=DJnA44AKrVVw9DMR9lxY5hlmP0PQYVQFB6lIuj4ii0U,8552
-jararaca-0.2.21.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-jararaca-0.2.21.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.2.21.dist-info/RECORD,,
+jararaca-0.2.23.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.2.23.dist-info/METADATA,sha256=eSuPU4Xv26Ri6bpmkGeiuK932KFPnjJp10z6bNSW8O4,8552
+jararaca-0.2.23.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+jararaca-0.2.23.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.2.23.dist-info/RECORD,,

pyproject.toml

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