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

jararaca/__init__.py

@@ -54,9 +54,13 @@ if TYPE_CHECKING:
     from .messagebus.types import Message, MessageOf
     from .messagebus.worker import MessageBusWorker
     from .microservice import Microservice, use_app_context, use_current_container
-    from .persistence.base import (
-        T_BASEMODEL,
-        BaseEntity,
+    from .persistence.base import T_BASEMODEL, BaseEntity
+    from .persistence.interceptors.aiosqa_interceptor import (
+        AIOSQAConfig,
+        AIOSqlAlchemySessionInterceptor,
+        use_session,
+    )
+    from .persistence.utilities import (
         CriteriaBasedAttributeQueryInjector,
         CRUDOperations,
         DateCriteria,
@@ -71,11 +75,6 @@ if TYPE_CHECKING:
         QueryOperations,
         StringCriteria,
     )
-    from .persistence.interceptors.aiosqa_interceptor import (
-        AIOSQAConfig,
-        AIOSqlAlchemySessionInterceptor,
-        use_session,
-    )
     from .presentation.decorators import (
         Delete,
         Get,
@@ -232,27 +231,31 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "HttpPut": (__SPEC_PARENT__, "rpc.http.decorators", "Put"),
     "HttpDelete": (__SPEC_PARENT__, "rpc.http.decorators", "Delete"),
     "ObservabilityInterceptor": (__SPEC_PARENT__, "observability.interceptor", None),
-    "QueryInjector": (__SPEC_PARENT__, "persistence.base", None),
+    "QueryInjector": (__SPEC_PARENT__, "persistence.utilities", None),
     "HttpMicroservice": (__SPEC_PARENT__, "presentation.http_microservice", None),
     "use_current_container": (__SPEC_PARENT__, "microservice", None),
     "T_BASEMODEL": (__SPEC_PARENT__, "persistence.base", None),
-    "DatedEntity": (__SPEC_PARENT__, "persistence.base", None),
+    "DatedEntity": (__SPEC_PARENT__, "persistence.utilities", None),
     "BaseEntity": (__SPEC_PARENT__, "persistence.base", None),
     "use_ws_manager": (__SPEC_PARENT__, "presentation.websocket.context", None),
     "WebSocketEndpoint": (__SPEC_PARENT__, "presentation.websocket.decorators", None),
-    "CriteriaBasedAttributeQueryInjector": (__SPEC_PARENT__, "persistence.base", None),
-    "Identifiable": (__SPEC_PARENT__, "persistence.base", None),
-    "IdentifiableEntity": (__SPEC_PARENT__, "persistence.base", None),
+    "CriteriaBasedAttributeQueryInjector": (
+        __SPEC_PARENT__,
+        "persistence.utilities",
+        None,
+    ),
+    "Identifiable": (__SPEC_PARENT__, "persistence.utilities", None),
+    "IdentifiableEntity": (__SPEC_PARENT__, "persistence.utilities", None),
     "MessageOf": (__SPEC_PARENT__, "messagebus.types", None),
     "Message": (__SPEC_PARENT__, "messagebus.types", None),
-    "StringCriteria": (__SPEC_PARENT__, "persistence.base", None),
-    "DateCriteria": (__SPEC_PARENT__, "persistence.base", None),
-    "DateOrderedFilter": (__SPEC_PARENT__, "persistence.base", None),
-    "DateOrderedQueryInjector": (__SPEC_PARENT__, "persistence.base", None),
-    "Paginated": (__SPEC_PARENT__, "persistence.base", None),
-    "PaginatedFilter": (__SPEC_PARENT__, "persistence.base", None),
-    "QueryOperations": (__SPEC_PARENT__, "persistence.base", None),
-    "CRUDOperations": (__SPEC_PARENT__, "persistence.base", None),
+    "StringCriteria": (__SPEC_PARENT__, "persistence.utilities", None),
+    "DateCriteria": (__SPEC_PARENT__, "persistence.utilities", None),
+    "DateOrderedFilter": (__SPEC_PARENT__, "persistence.utilities", None),
+    "DateOrderedQueryInjector": (__SPEC_PARENT__, "persistence.utilities", None),
+    "Paginated": (__SPEC_PARENT__, "persistence.utilities", None),
+    "PaginatedFilter": (__SPEC_PARENT__, "persistence.utilities", None),
+    "QueryOperations": (__SPEC_PARENT__, "persistence.utilities", None),
+    "CRUDOperations": (__SPEC_PARENT__, "persistence.utilities", None),
     "RestController": (__SPEC_PARENT__, "presentation.decorators", None),
     "MessageBusController": (__SPEC_PARENT__, "messagebus.decorators", None),
     "MessageHandler": (__SPEC_PARENT__, "messagebus.decorators", None),

jararaca/persistence/base.py

@@ -1,41 +1,9 @@
-import asyncio
-import logging
-from datetime import UTC, date, datetime
-from functools import reduce
-from typing import (
-    Annotated,
-    Any,
-    Awaitable,
-    Callable,
-    Generic,
-    Iterable,
-    Literal,
-    Protocol,
-    Self,
-    Tuple,
-    Type,
-    TypeVar,
-)
-from uuid import UUID, uuid4
+from typing import Any, Self, Type, TypeVar
 
-from pydantic import BaseModel, Field, ValidationError
-from sqlalchemy import DateTime, Result, Select, delete, func, select, update
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
+from pydantic import BaseModel
+from sqlalchemy.orm import DeclarativeBase
 
 IDENTIFIABLE_SCHEMA_T = TypeVar("IDENTIFIABLE_SCHEMA_T")
-logger = logging.getLogger(__name__)
-
-
-class Identifiable(BaseModel, Generic[IDENTIFIABLE_SCHEMA_T]):
-    id: UUID
-    data: IDENTIFIABLE_SCHEMA_T
-
-    @staticmethod
-    def instance(
-        id: UUID, data: IDENTIFIABLE_SCHEMA_T
-    ) -> "Identifiable[IDENTIFIABLE_SCHEMA_T]":
-        return Identifiable[IDENTIFIABLE_SCHEMA_T](id=id, data=data)
 
 
 T_BASEMODEL = TypeVar("T_BASEMODEL", bound=BaseModel)
@@ -63,369 +31,3 @@ class BaseEntity(DeclarativeBase):
 
     def to_basemodel(self, model: Type[T_BASEMODEL]) -> T_BASEMODEL:
         return model.model_validate(recursive_get_dict(self))
-
-
-def nowutc() -> datetime:
-    return datetime.now(UTC)
-
-
-class DatedEntity(BaseEntity):
-    __abstract__ = True
-
-    created_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, default=nowutc
-    )
-    updated_at: Mapped[datetime] = mapped_column(
-        DateTime(timezone=True), nullable=False, default=nowutc
-    )
-
-
-class IdentifiableEntity(BaseEntity):
-    __abstract__ = True
-
-    id: Mapped[UUID] = mapped_column(primary_key=True, default=uuid4)
-
-    @classmethod
-    def from_identifiable(cls, model: Identifiable[T_BASEMODEL]) -> "Self":
-        return cls(**{"id": model.id, **model.data.model_dump()})
-
-    def to_identifiable(self, MODEL: Type[T_BASEMODEL]) -> Identifiable[T_BASEMODEL]:
-        try:
-            return Identifiable[MODEL].model_validate(  # type: ignore[valid-type]
-                {"id": self.id, "data": recursive_get_dict(self)}
-            )
-        except ValidationError:
-            logger.critical(
-                "Error on to_identifiable for identifiable id %s of class %s table '%s'",
-                self.id,
-                self.__class__,
-                self.__tablename__,
-            )
-            raise
-
-
-IDENTIFIABLE_T = TypeVar("IDENTIFIABLE_T", bound=IdentifiableEntity)
-
-
-class CRUDOperations(Generic[IDENTIFIABLE_T]):
-
-    def __init__(
-        self,
-        entity_type: Type[IDENTIFIABLE_T],
-        session_provider: Callable[[], AsyncSession],
-    ) -> None:
-        self.entity_type = entity_type
-        self.session_provider = session_provider
-
-    @property
-    def session(self) -> AsyncSession:
-        return self.session_provider()
-
-    async def create(self, entity: IDENTIFIABLE_T) -> None:
-        self.session.add(entity)
-        await self.session.flush()
-        await self.session.refresh(entity)
-
-    async def get(self, id: UUID) -> IDENTIFIABLE_T:
-        return await self.session.get_one(self.entity_type, id)
-
-    async def get_many(self, ids: Iterable[UUID]) -> Iterable[IDENTIFIABLE_T]:
-        return await self.session.scalars(
-            select(self.entity_type).where(self.entity_type.id.in_(ids))
-        )
-
-    async def update(self, entity: IDENTIFIABLE_T) -> None:
-        await self.session.merge(entity)
-
-    async def delete(self, entity: IDENTIFIABLE_T) -> None:
-        await self.session.delete(entity)
-
-    async def delete_by_id(self, id: UUID) -> None:
-        await self.session.execute(
-            delete(self.entity_type).where(self.entity_type.id == id)
-        )
-
-    async def update_by_id(self, id: UUID, entity: IDENTIFIABLE_T) -> None:
-        await self.session.execute(
-            update(self.entity_type)
-            .where(self.entity_type.id == id)
-            .values(entity.__dict__)
-        )
-
-    async def exists(self, id: UUID) -> bool:
-        return (
-            await self.session.execute(
-                select(
-                    select(self.entity_type).where(self.entity_type.id == id).exists()
-                )
-            )
-        ).scalar_one()
-
-    async def exists_some(self, ids: Iterable[UUID]) -> bool:
-        return (
-            await self.session.execute(
-                select(
-                    select(self.entity_type)
-                    .where(self.entity_type.id.in_(ids))
-                    .exists()
-                )
-            )
-        ).scalar_one()
-
-    async def exists_all(self, ids: set[UUID]) -> bool:
-
-        return (
-            await self.session.execute(
-                select(func.count())
-                .select_from(self.entity_type)
-                .where(self.entity_type.id.in_(ids))
-            )
-        ).scalar_one() >= len(ids)
-
-    async def intersects(self, ids: set[UUID]) -> set[UUID]:
-        return set(
-            (
-                await self.session.execute(
-                    select(self.entity_type.id).where(self.entity_type.id.in_(ids))
-                )
-            ).scalars()
-        )
-
-    async def difference(self, ids: set[UUID]) -> set[UUID]:
-        return ids - set(
-            (
-                await self.session.execute(
-                    select(self.entity_type.id).where(self.entity_type.id.in_(ids))
-                )
-            ).scalars()
-        )
-
-
-# region PaginatedFilter
-class PaginatedFilter(BaseModel):
-    page: Annotated[int, Field(gt=-1)] = 1
-    page_size: int = 10
-
-
-class QueryInjector(Protocol):
-
-    def inject(self, query: Select[Tuple[Any]], filter: Any) -> Select[Tuple[Any]]: ...
-
-
-# endregion
-
-
-QUERY_ENTITY_T = TypeVar("QUERY_ENTITY_T", bound=BaseEntity)
-QUERY_FILTER_T = TypeVar("QUERY_FILTER_T", bound=PaginatedFilter)
-
-
-TRANSFORM_T = TypeVar("TRANSFORM_T")
-PAGINATED_T = TypeVar("PAGINATED_T", bound=Any)
-
-
-class Paginated(BaseModel, Generic[PAGINATED_T]):
-    items: list[PAGINATED_T]
-    total: int
-    unpaginated_total: int
-    total_pages: int
-
-    def transform(
-        self,
-        transform: Callable[[PAGINATED_T], TRANSFORM_T],
-    ) -> "Paginated[TRANSFORM_T]":
-        return Paginated[TRANSFORM_T](
-            items=[transform(item) for item in self.items],
-            total=self.total,
-            unpaginated_total=self.unpaginated_total,
-            total_pages=self.total_pages,
-        )
-
-    async def transform_async(
-        self,
-        transform: Callable[[PAGINATED_T], Awaitable[TRANSFORM_T]],
-        gather: bool = False,
-    ) -> "Paginated[TRANSFORM_T]":
-        """
-        Transform the items of the paginated result asynchronously.
-
-        Args:
-            transform: The transformation function.
-            gather: If the items should be gathered in a single async call.
-            SQL Alchemy async session queries may cannot be gathered. Use this option with caution.
-        """
-
-        items = (
-            await asyncio.gather(*[transform(item) for item in self.items])
-            if gather
-            else [await transform(item) for item in self.items]
-        )
-        return Paginated[TRANSFORM_T](
-            items=items,
-            total=self.total,
-            unpaginated_total=self.unpaginated_total,
-            total_pages=self.total_pages,
-        )
-
-
-class QueryOperations(Generic[QUERY_FILTER_T, QUERY_ENTITY_T]):
-
-    def __init__(
-        self,
-        entity_type: Type[QUERY_ENTITY_T],
-        session_provider: Callable[[], AsyncSession],
-        filters_functions: list[QueryInjector],
-        unique: bool = False,
-    ) -> None:
-        self.entity_type: type[QUERY_ENTITY_T] = entity_type
-        self.session_provider = session_provider
-        self.filters_functions = filters_functions
-        self.unique = unique
-
-    @property
-    def session(self) -> AsyncSession:
-        return self.session_provider()
-
-    async def query(
-        self,
-        filter: QUERY_FILTER_T,
-        interceptors: list[
-            Callable[[Select[Tuple[QUERY_ENTITY_T]]], Select[Tuple[QUERY_ENTITY_T]]]
-        ] = [],
-    ) -> "Paginated[QUERY_ENTITY_T]":
-
-        query = reduce(
-            lambda query, interceptor: interceptor(query),
-            interceptors,
-            select(self.entity_type),
-        )
-
-        unpaginated_total = (
-            await self.session.execute(
-                select(func.count()).select_from(query.subquery())
-            )
-        ).scalar_one()
-
-        filtered_query = self.generate_filtered_query(filter, query)
-
-        paginated_query = filtered_query.limit(filter.page_size).offset(
-            (filter.page) * filter.page_size
-        )
-
-        filtered_total = (
-            await self.session.execute(
-                select(func.count()).select_from(paginated_query.subquery())
-            )
-        ).scalar_one()
-
-        return Paginated(
-            items=[
-                e
-                for e in self.judge_unique(
-                    await self.session.execute(paginated_query)
-                ).scalars()
-            ],
-            total=filtered_total,
-            unpaginated_total=unpaginated_total,
-            total_pages=int(filtered_total / filter.page_size) + 1,
-        )
-
-    def judge_unique(
-        self, result: Result[Tuple[QUERY_ENTITY_T]]
-    ) -> Result[Tuple[QUERY_ENTITY_T]]:
-        if self.unique:
-            return result.unique()
-        return result
-
-    def generate_filtered_query(
-        self, filter: QUERY_FILTER_T, select_query: Select[Tuple[QUERY_ENTITY_T]]
-    ) -> Select[Tuple[QUERY_ENTITY_T]]:
-        return reduce(
-            lambda query, filter_function: filter_function.inject(query, filter),
-            self.filters_functions,
-            select_query,
-        )
-
-
-# DateOrderedFilter
-
-
-class DateOrderedFilter(BaseModel):
-    order_by: Literal["asc", "desc"] = "asc"
-
-
-class DateOrderedQueryInjector(QueryInjector):
-
-    def __init__(self, entity_type: Type[DatedEntity]) -> None:
-        self.entity_type = entity_type
-
-    def inject(
-        self,
-        query: Select[Tuple[DatedEntity]],
-        filter: DateOrderedFilter,
-    ) -> Select[Tuple[DatedEntity]]:
-        return query.order_by(getattr(self.entity_type.created_at, filter.order_by)())
-
-
-# region Criteria
-
-
-# region Criteria
-
-
-class StringCriteria(BaseModel):
-    value: str
-    is_exact: bool
-    case_sensitive: bool
-
-
-class DateCriteria(BaseModel):
-    value: date
-    op: Literal["eq", "gt", "lt", "gte", "lte"]
-
-
-class DatetimeCriteria(BaseModel):
-    value: datetime
-    op: Literal["eq", "gt", "lt", "gte", "lte"]
-
-
-class CriteriaBasedAttributeQueryInjector(QueryInjector):
-
-    def __init__(self, entity_type: Type[BaseEntity]) -> None:
-        self.entity_type = entity_type
-
-    def inject(
-        self, query: Select[Tuple[BaseEntity]], filter: Any
-    ) -> Select[Tuple[BaseEntity]]:
-
-        attrs = filter.__dict__
-
-        for field_name, value in attrs.items():
-
-            if isinstance(value, (DateCriteria, DatetimeCriteria)):
-                value = getattr(filter, field_name)
-
-                entity_field = getattr(self.entity_type, field_name)
-
-                op_mapping = {
-                    "eq": entity_field == value.value,
-                    "gt": entity_field > value.value,
-                    "lt": entity_field < value.value,
-                    "gte": entity_field >= value.value,
-                    "lte": entity_field <= value.value,
-                }
-
-                query = query.filter(op_mapping[value.op])
-            elif isinstance(value, StringCriteria):
-                value = getattr(filter, field_name)
-
-                entity_field = getattr(self.entity_type, field_name)
-
-                if value.is_exact:
-                    query = query.filter(entity_field == value.value)
-                else:
-                    query = query.filter(entity_field.contains(value.value))
-
-        return query
-
-
-# endregion

jararaca/persistence/utilities.py

@@ -0,0 +1,413 @@
+import asyncio
+import logging
+from datetime import UTC, date, datetime
+from functools import reduce
+from typing import (
+    Annotated,
+    Any,
+    Awaitable,
+    Callable,
+    Generic,
+    Iterable,
+    Literal,
+    Protocol,
+    Self,
+    Tuple,
+    Type,
+    TypeVar,
+)
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field, ValidationError
+from sqlalchemy import DateTime, Result, Select, delete, func, select, update
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import Mapped, mapped_column
+
+from jararaca.persistence.base import (
+    IDENTIFIABLE_SCHEMA_T,
+    T_BASEMODEL,
+    BaseEntity,
+    recursive_get_dict,
+)
+from jararaca.persistence.sort_filter import FilterModel, SortModel
+
+logger = logging.getLogger(__name__)
+
+
+class Identifiable(BaseModel, Generic[IDENTIFIABLE_SCHEMA_T]):
+    id: UUID
+    data: IDENTIFIABLE_SCHEMA_T
+
+    @staticmethod
+    def instance(
+        id: UUID, data: IDENTIFIABLE_SCHEMA_T
+    ) -> "Identifiable[IDENTIFIABLE_SCHEMA_T]":
+        return Identifiable[IDENTIFIABLE_SCHEMA_T](id=id, data=data)
+
+
+def nowutc() -> datetime:
+    return datetime.now(UTC)
+
+
+class DatedEntity(BaseEntity):
+    __abstract__ = True
+
+    created_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, default=nowutc
+    )
+    updated_at: Mapped[datetime] = mapped_column(
+        DateTime(timezone=True), nullable=False, default=nowutc
+    )
+
+
+class IdentifiableEntity(BaseEntity):
+    __abstract__ = True
+
+    id: Mapped[UUID] = mapped_column(primary_key=True, default=uuid4)
+
+    @classmethod
+    def from_identifiable(cls, model: Identifiable[T_BASEMODEL]) -> "Self":
+        return cls(**{"id": model.id, **model.data.model_dump()})
+
+    def to_identifiable(self, MODEL: Type[T_BASEMODEL]) -> Identifiable[T_BASEMODEL]:
+        try:
+            return Identifiable[MODEL].model_validate(  # type: ignore[valid-type]
+                {"id": self.id, "data": recursive_get_dict(self)}
+            )
+        except ValidationError:
+            logger.critical(
+                "Error on to_identifiable for identifiable id %s of class %s table '%s'",
+                self.id,
+                self.__class__,
+                self.__tablename__,
+            )
+            raise
+
+
+IDENTIFIABLE_T = TypeVar("IDENTIFIABLE_T", bound=IdentifiableEntity)
+
+
+class CRUDOperations(Generic[IDENTIFIABLE_T]):
+
+    def __init__(
+        self,
+        entity_type: Type[IDENTIFIABLE_T],
+        session_provider: Callable[[], AsyncSession],
+    ) -> None:
+        self.entity_type = entity_type
+        self.session_provider = session_provider
+
+    @property
+    def session(self) -> AsyncSession:
+        return self.session_provider()
+
+    async def create(self, entity: IDENTIFIABLE_T) -> None:
+        self.session.add(entity)
+        await self.session.flush()
+        await self.session.refresh(entity)
+
+    async def get(self, id: UUID) -> IDENTIFIABLE_T:
+        return await self.session.get_one(self.entity_type, id)
+
+    async def get_many(self, ids: Iterable[UUID]) -> Iterable[IDENTIFIABLE_T]:
+        return await self.session.scalars(
+            select(self.entity_type).where(self.entity_type.id.in_(ids))
+        )
+
+    async def update(self, entity: IDENTIFIABLE_T) -> None:
+        await self.session.merge(entity)
+
+    async def delete(self, entity: IDENTIFIABLE_T) -> None:
+        await self.session.delete(entity)
+
+    async def delete_by_id(self, id: UUID) -> None:
+        await self.session.execute(
+            delete(self.entity_type).where(self.entity_type.id == id)
+        )
+
+    async def update_by_id(self, id: UUID, entity: IDENTIFIABLE_T) -> None:
+        await self.session.execute(
+            update(self.entity_type)
+            .where(self.entity_type.id == id)
+            .values(entity.__dict__)
+        )
+
+    async def exists(self, id: UUID) -> bool:
+        return (
+            await self.session.execute(
+                select(
+                    select(self.entity_type).where(self.entity_type.id == id).exists()
+                )
+            )
+        ).scalar_one()
+
+    async def exists_some(self, ids: Iterable[UUID]) -> bool:
+        return (
+            await self.session.execute(
+                select(
+                    select(self.entity_type)
+                    .where(self.entity_type.id.in_(ids))
+                    .exists()
+                )
+            )
+        ).scalar_one()
+
+    async def exists_all(self, ids: set[UUID]) -> bool:
+
+        return (
+            await self.session.execute(
+                select(func.count())
+                .select_from(self.entity_type)
+                .where(self.entity_type.id.in_(ids))
+            )
+        ).scalar_one() >= len(ids)
+
+    async def intersects(self, ids: set[UUID]) -> set[UUID]:
+        return set(
+            (
+                await self.session.execute(
+                    select(self.entity_type.id).where(self.entity_type.id.in_(ids))
+                )
+            ).scalars()
+        )
+
+    async def difference(self, ids: set[UUID]) -> set[UUID]:
+        return ids - set(
+            (
+                await self.session.execute(
+                    select(self.entity_type.id).where(self.entity_type.id.in_(ids))
+                )
+            ).scalars()
+        )
+
+
+# region PaginatedFilter
+class PaginatedFilter(BaseModel):
+    page: Annotated[int, Field(gt=-1)] = 1
+    page_size: int = 10
+    sort_models: list[SortModel] = []
+    filter_model: list[FilterModel] = []
+
+
+class QueryInjector(Protocol):
+
+    def inject(self, query: Select[Tuple[Any]], filter: Any) -> Select[Tuple[Any]]: ...
+
+
+# endregion
+
+
+QUERY_ENTITY_T = TypeVar("QUERY_ENTITY_T", bound=BaseEntity)
+QUERY_FILTER_T = TypeVar("QUERY_FILTER_T", bound=PaginatedFilter)
+
+
+TRANSFORM_T = TypeVar("TRANSFORM_T")
+PAGINATED_T = TypeVar("PAGINATED_T", bound=Any)
+
+
+class Paginated(BaseModel, Generic[PAGINATED_T]):
+    items: list[PAGINATED_T]
+    total: int
+    unpaginated_total: int
+    total_pages: int
+
+    def transform(
+        self,
+        transform: Callable[[PAGINATED_T], TRANSFORM_T],
+    ) -> "Paginated[TRANSFORM_T]":
+        return Paginated[TRANSFORM_T](
+            items=[transform(item) for item in self.items],
+            total=self.total,
+            unpaginated_total=self.unpaginated_total,
+            total_pages=self.total_pages,
+        )
+
+    async def transform_async(
+        self,
+        transform: Callable[[PAGINATED_T], Awaitable[TRANSFORM_T]],
+        gather: bool = False,
+    ) -> "Paginated[TRANSFORM_T]":
+        """
+        Transform the items of the paginated result asynchronously.
+
+        Args:
+            transform: The transformation function.
+            gather: If the items should be gathered in a single async call.
+            SQL Alchemy async session queries may cannot be gathered. Use this option with caution.
+        """
+
+        items = (
+            await asyncio.gather(*[transform(item) for item in self.items])
+            if gather
+            else [await transform(item) for item in self.items]
+        )
+        return Paginated[TRANSFORM_T](
+            items=items,
+            total=self.total,
+            unpaginated_total=self.unpaginated_total,
+            total_pages=self.total_pages,
+        )
+
+
+class QueryOperations(Generic[QUERY_FILTER_T, QUERY_ENTITY_T]):
+
+    def __init__(
+        self,
+        entity_type: Type[QUERY_ENTITY_T],
+        session_provider: Callable[[], AsyncSession],
+        filters_functions: list[QueryInjector],
+        unique: bool = False,
+    ) -> None:
+        self.entity_type: type[QUERY_ENTITY_T] = entity_type
+        self.session_provider = session_provider
+        self.filters_functions = filters_functions
+        self.unique = unique
+
+    @property
+    def session(self) -> AsyncSession:
+        return self.session_provider()
+
+    async def query(
+        self,
+        filter: QUERY_FILTER_T,
+        interceptors: list[
+            Callable[[Select[Tuple[QUERY_ENTITY_T]]], Select[Tuple[QUERY_ENTITY_T]]]
+        ] = [],
+    ) -> "Paginated[QUERY_ENTITY_T]":
+
+        query = reduce(
+            lambda query, interceptor: interceptor(query),
+            interceptors,
+            select(self.entity_type),
+        )
+
+        unpaginated_total = (
+            await self.session.execute(
+                select(func.count()).select_from(query.subquery())
+            )
+        ).scalar_one()
+
+        filtered_query = self.generate_filtered_query(filter, query)
+
+        paginated_query = filtered_query.limit(filter.page_size).offset(
+            (filter.page) * filter.page_size
+        )
+
+        filtered_total = (
+            await self.session.execute(
+                select(func.count()).select_from(paginated_query.subquery())
+            )
+        ).scalar_one()
+
+        return Paginated(
+            items=[
+                e
+                for e in self.judge_unique(
+                    await self.session.execute(paginated_query)
+                ).scalars()
+            ],
+            total=filtered_total,
+            unpaginated_total=unpaginated_total,
+            total_pages=int(filtered_total / filter.page_size) + 1,
+        )
+
+    def judge_unique(
+        self, result: Result[Tuple[QUERY_ENTITY_T]]
+    ) -> Result[Tuple[QUERY_ENTITY_T]]:
+        if self.unique:
+            return result.unique()
+        return result
+
+    def generate_filtered_query(
+        self, filter: QUERY_FILTER_T, select_query: Select[Tuple[QUERY_ENTITY_T]]
+    ) -> Select[Tuple[QUERY_ENTITY_T]]:
+        return reduce(
+            lambda query, filter_function: filter_function.inject(query, filter),
+            self.filters_functions,
+            select_query,
+        )
+
+
+# DateOrderedFilter
+
+
+class DateOrderedFilter(BaseModel):
+    order_by: Literal["asc", "desc"] = "asc"
+
+
+class DateOrderedQueryInjector(QueryInjector):
+
+    def __init__(self, entity_type: Type[DatedEntity]) -> None:
+        self.entity_type = entity_type
+
+    def inject(
+        self,
+        query: Select[Tuple[DatedEntity]],
+        filter: DateOrderedFilter,
+    ) -> Select[Tuple[DatedEntity]]:
+        return query.order_by(getattr(self.entity_type.created_at, filter.order_by)())
+
+
+# region Criteria
+
+
+# region Criteria
+
+
+class StringCriteria(BaseModel):
+    value: str
+    is_exact: bool
+    case_sensitive: bool
+
+
+class DateCriteria(BaseModel):
+    value: date
+    op: Literal["eq", "gt", "lt", "gte", "lte"]
+
+
+class DatetimeCriteria(BaseModel):
+    value: datetime
+    op: Literal["eq", "gt", "lt", "gte", "lte"]
+
+
+class CriteriaBasedAttributeQueryInjector(QueryInjector):
+
+    def __init__(self, entity_type: Type[BaseEntity]) -> None:
+        self.entity_type = entity_type
+
+    def inject(
+        self, query: Select[Tuple[BaseEntity]], filter: Any
+    ) -> Select[Tuple[BaseEntity]]:
+
+        attrs = filter.__dict__
+
+        for field_name, value in attrs.items():
+
+            if isinstance(value, (DateCriteria, DatetimeCriteria)):
+                value = getattr(filter, field_name)
+
+                entity_field = getattr(self.entity_type, field_name)
+
+                op_mapping = {
+                    "eq": entity_field == value.value,
+                    "gt": entity_field > value.value,
+                    "lt": entity_field < value.value,
+                    "gte": entity_field >= value.value,
+                    "lte": entity_field <= value.value,
+                }
+
+                query = query.filter(op_mapping[value.op])
+            elif isinstance(value, StringCriteria):
+                value = getattr(filter, field_name)
+
+                entity_field = getattr(self.entity_type, field_name)
+
+                if value.is_exact:
+                    query = query.filter(entity_field == value.value)
+                else:
+                    query = query.filter(entity_field.contains(value.value))
+
+        return query
+
+
+# endregion

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

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

{jararaca-0.2.23.dist-info → jararaca-0.2.25.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=DwBGMHMjD9OcQxeANd4lZh4-u8dMCPL0E273cqbQym4,1837
-jararaca/__init__.py,sha256=fBLWY_hpImDrzD-81avNasZxAbZ8IImAkS3kl83_3Kc,13757
+pyproject.toml,sha256=3xtKWnGmMTaIitU2R8vmQrS48cCtJ4ci0T5rqb07ymE,1837
+jararaca/__init__.py,sha256=h1lYQMmB8TATPG0GXjIzLZWHbWFhvkAFu-yBjm2W18g,13875
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
 jararaca/cli.py,sha256=fh7lp7rf5xbV5VaoSYWWehktel6BPcOXMjW7cw4wKms,5693
 jararaca/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -23,12 +23,13 @@ jararaca/observability/decorators.py,sha256=XffBinFXdiNkY6eo8_1nkr_GapM0RUGBg0ai
 jararaca/observability/interceptor.py,sha256=GHkuGKFWftN7MDjvYeGFGEPnuJETNhtxRK6yuPrCrpU,1462
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/observability/providers/otel.py,sha256=LgfoITdoQTCxKebfLcEfwMiG992wlWY_0AUTd2fo8hY,6065
-jararaca/persistence/base.py,sha256=dfZWM-ztN-JEzw8-or7g13XyJ4LwmfbF2d53YFT4dyg,12446
+jararaca/persistence/base.py,sha256=Xfnpvj3yeLdpVBifH5W6AwPCLwL2ot0dpLzbPg1zwkQ,966
 jararaca/persistence/exports.py,sha256=Ghx4yoFaB4QVTb9WxrFYgmcSATXMNvrOvT8ybPNKXCA,62
 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/persistence/utilities.py,sha256=nZA_CKk_qyZ0GhwHrRmTGyN07z0cyU8wrPTyphDtfSM,11857
 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
@@ -57,8 +58,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.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,,
+jararaca-0.2.25.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.2.25.dist-info/METADATA,sha256=psi20F1fXMEO4ATevCDQt8dPS2tuVjTSR4PRN0vO8SA,8552
+jararaca-0.2.25.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+jararaca-0.2.25.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.2.25.dist-info/RECORD,,

pyproject.toml

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