jararaca 0.2.20__tar.gz → 0.2.22__tar.gz

{jararaca-0.2.20 → jararaca-0.2.22}/PKG-INFO

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

{jararaca-0.2.20 → jararaca-0.2.22}/pyproject.toml

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

{jararaca-0.2.20 → jararaca-0.2.22}/src/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-0.2.22/src/jararaca/persistence/sort_filter.py

@@ -0,0 +1,186 @@
+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]:
+            __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 "isEmpty":
+                    return query.filter(field == None)  # noqa
+                case "isNotEmpty":
+                    return query.filter(field != None)  # noqa
+                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.20 → jararaca-0.2.22}/src/jararaca/tools/typescript/interface_parser.py

@@ -251,11 +251,11 @@ def parse_type_to_typescript_interface(
         )
 
     if hasattr(basemodel_type, "__annotations__"):
-        for field_name in (f for f in dir(basemodel_type) if is_constant(f)):
-            field = getattr(basemodel_type, field_name)
-            if field is None:
-                continue
-            string_builder.write(f"  {field_name}: {parse_literal_value(field)};\n")
+        # for field_name in (f for f in dir(basemodel_type) if is_constant(f)):
+        #     field = getattr(basemodel_type, field_name)
+        #     if field is None:
+        #         continue
+        #     string_builder.write(f"  {field_name}: {parse_literal_value(field)};\n")
         for field_name, field in basemodel_type.__annotations__.items():
             if field_name in cls_consts:
                 continue