jararaca 0.3.9__py3-none-any.whl → 0.3.11__py3-none-any.whl

jararaca/persistence/utilities.py

@@ -213,7 +213,7 @@ class CRUDOperations(Generic[IDENTIFIABLE_T]):
 # region PaginatedFilter
 class PaginatedFilter(BaseModel):
     page: Annotated[int, Field(gt=-1)] = 0
-    page_size: int = 10
+    page_size: Annotated[int, Field(gt=0)] = 10
     sort_models: list[SortModel] = []
     filter_models: list[FilterModel] = []
 
@@ -307,51 +307,63 @@ class QueryOperations(Generic[QUERY_FILTER_T, QUERY_ENTITY_T]):
             Callable[[Select[Tuple[QUERY_ENTITY_T]]], Select[Tuple[QUERY_ENTITY_T]]]
         ] = [],
     ) -> "Paginated[QUERY_ENTITY_T]":
+        """
+        Executes a query with the provided filter and interceptors.
+        Args:
+            filter: The filter to apply to the query.
+            interceptors: A list of functions that can modify the query before execution.
+        Returns:
+            Paginated[QUERY_ENTITY_T]: A paginated result containing the items and metadata.
+        """
+
+        tier_one_filtered_query = self.generate_filtered_query(
+            filter, select(self.entity_type)
+        )
 
-        query = reduce(
+        tier_two_filtered_query = reduce(
             lambda query, interceptor: interceptor(query),
             interceptors,
-            select(self.entity_type),
+            tier_one_filtered_query,
         )
 
         if self.sort_rule_applier:
-            query = self.sort_rule_applier.create_query_for_sorting_list(
-                query, filter.sort_models
+            tier_two_filtered_query = (
+                self.sort_rule_applier.create_query_for_sorting_list(
+                    tier_two_filtered_query, filter.sort_models
+                )
             )
 
         if self.filter_rule_applier:
-            query = self.filter_rule_applier.create_query_for_filter_list(
-                query, filter.filter_models
+            tier_two_filtered_query = (
+                self.filter_rule_applier.create_query_for_filter_list(
+                    tier_two_filtered_query, filter.filter_models
+                )
             )
 
         unpaginated_total = (
             await self.session.execute(
-                select(func.count()).select_from(query.subquery())
+                select(func.count()).select_from(tier_two_filtered_query.subquery())
             )
         ).scalar_one()
 
-        filtered_query = self.generate_filtered_query(filter, query)
-
-        paginated_query = filtered_query.limit(filter.page_size).offset(
+        paginated_query = tier_two_filtered_query.limit(filter.page_size).offset(
             (filter.page) * filter.page_size
         )
 
-        filtered_total = (
+        paginated_total = (
             await self.session.execute(
                 select(func.count()).select_from(paginated_query.subquery())
             )
         ).scalar_one()
 
+        result = await self.session.execute(paginated_query)
+        result_scalars = list(self.judge_unique(result).scalars().all())
+
         return Paginated(
-            items=[
-                e
-                for e in self.judge_unique(
-                    await self.session.execute(paginated_query)
-                ).scalars()
-            ],
-            total=filtered_total,
+            items=result_scalars,
+            total=paginated_total,
             unpaginated_total=unpaginated_total,
-            total_pages=int(filtered_total / filter.page_size) + 1,
+            total_pages=int(unpaginated_total / filter.page_size) + 1,
         )
 
     def judge_unique(

jararaca/presentation/decorators.py

@@ -1,5 +1,7 @@
-import inspect
-from typing import Any, Callable, Literal, Protocol, TypeVar, cast
+from contextlib import contextmanager
+from contextvars import ContextVar
+from functools import wraps
+from typing import Any, Awaitable, Callable, Literal, Protocol, TypeVar, cast
 
 from fastapi import APIRouter
 from fastapi import Depends as DependsF
@@ -9,6 +11,10 @@ from fastapi.params import Depends
 from jararaca.lifecycle import AppLifecycle
 from jararaca.presentation.http_microservice import HttpMiddleware
 from jararaca.presentation.websocket.decorators import WebSocketEndpoint
+from jararaca.reflect.controller_inspect import (
+    ControllerMemberReflect,
+    inspect_controller,
+)
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
 DECORATED_CLASS = TypeVar("DECORATED_CLASS", bound=Any)
@@ -73,15 +79,15 @@ class RestController:
                 **(self.options or {}),
             )
 
-            members = inspect.getmembers(cls, predicate=inspect.isfunction)
+            controller, members = inspect_controller(cls)
 
             router_members = [
-                (name, mapping)
-                for name, member in members
+                (name, mapping, member)
+                for name, member in members.items()
                 if (
                     mapping := (
-                        HttpMapping.get_http_mapping(member)
-                        or WebSocketEndpoint.get(member)
+                        HttpMapping.get_http_mapping(member.member_function)
+                        or WebSocketEndpoint.get(member.member_function)
                     )
                 )
                 is not None
@@ -89,7 +95,7 @@ class RestController:
 
             router_members.sort(key=lambda x: x[1].order)
 
-            for name, mapping in router_members:
+            for name, mapping, member in router_members:
                 route_dependencies: list[Depends] = []
                 for middlewares_by_hook in UseMiddleware.get_middlewares(
                     getattr(instance, name)
@@ -104,12 +110,18 @@ class RestController:
                 ):
                     route_dependencies.append(DependsF(dependency.dependency))
 
+                instance_method = getattr(instance, name)
+                instance_method = wraps_with_attributes(
+                    instance_method,
+                    controller_member_reflect=member,
+                )
+
                 if isinstance(mapping, HttpMapping):
                     try:
                         router.add_api_route(
                             methods=[mapping.method],
                             path=mapping.path,
-                            endpoint=getattr(instance, name),
+                            endpoint=instance_method,
                             dependencies=route_dependencies,
                             **(mapping.options or {}),
                         )
@@ -120,7 +132,7 @@ class RestController:
                 else:
                     router.add_api_websocket_route(
                         path=mapping.path,
-                        endpoint=getattr(instance, name),
+                        endpoint=instance_method,
                         dependencies=route_dependencies,
                         **(mapping.options or {}),
                     )
@@ -299,3 +311,77 @@ class UseDependency:
     @staticmethod
     def get_dependencies(subject: DECORATED_FUNC) -> list["UseDependency"]:
         return getattr(subject, UseDependency.__DEPENDENCY_ATTR__, [])
+
+
+def wraps_with_member_data(
+    controller_member: ControllerMemberReflect, func: Callable[..., Awaitable[Any]]
+) -> Callable[..., Any]:
+    """
+    A decorator that wraps a function and preserves its metadata.
+    This is useful for preserving metadata when using decorators.
+    """
+
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+
+        with providing_controller_member(
+            controller_member=controller_member,
+        ):
+
+            return await func(*args, **kwargs)
+
+    # Copy metadata from the original function to the wrapper
+    # for attr in dir(func):
+    #     if not attr.startswith("__"):
+    #         setattr(wrapper, attr, getattr(func, attr))
+
+    return wrapper
+
+
+controller_member_ctxvar = ContextVar[ControllerMemberReflect](
+    "controller_member_ctxvar"
+)
+
+
+@contextmanager
+def providing_controller_member(
+    controller_member: ControllerMemberReflect,
+) -> Any:
+    """
+    Context manager to provide the controller member metadata.
+    This is used to preserve the metadata of the controller member
+    when using decorators.
+    """
+    token = controller_member_ctxvar.set(controller_member)
+    try:
+        yield
+    finally:
+        controller_member_ctxvar.reset(token)
+
+
+def use_controller_member() -> ControllerMemberReflect:
+    """
+    Get the current controller member metadata.
+    This is used to access the metadata of the controller member
+    when using decorators.
+    """
+    return controller_member_ctxvar.get()
+
+
+def wraps_with_attributes(
+    func: Callable[..., Awaitable[Any]], **attributes: Any
+) -> Callable[..., Awaitable[Any]]:
+    """
+    A decorator that wraps a function and preserves its attributes.
+    This is useful for preserving attributes when using decorators.
+    """
+
+    @wraps(func)
+    async def wrapper(*args: Any, **kwargs: Any) -> Any:
+        return await func(*args, **kwargs)
+
+    # Copy attributes from the original function to the wrapper
+    for key, value in attributes.items():
+        setattr(wrapper, key, value)
+
+    return wrapper

jararaca/presentation/server.py

@@ -7,9 +7,14 @@ from starlette.types import ASGIApp
 from jararaca.core.uow import UnitOfWorkContextProvider
 from jararaca.di import Container
 from jararaca.lifecycle import AppLifecycle
-from jararaca.microservice import HttpAppContext, WebSocketAppContext
+from jararaca.microservice import (
+    AppTransactionContext,
+    HttpTransactionData,
+    WebSocketTransactionData,
+)
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
+from jararaca.reflect.controller_inspect import ControllerMemberReflect
 
 
 class HttpAppLifecycle:
@@ -79,10 +84,32 @@ class HttpUowContextProviderDependency:
     async def __call__(
         self, websocket: WebSocket = None, request: Request = None  # type: ignore
     ) -> AsyncGenerator[None, None]:
+        if request:
+            endpoint = request.scope["endpoint"]
+        elif websocket:
+            endpoint = websocket.scope["endpoint"]
+        else:
+            raise ValueError("Either request or websocket must be provided.")
+
+        member = getattr(endpoint, "controller_member_reflect", None)
+
+        if member is None:
+            raise ValueError("The endpoint does not have a controller member reflect.")
+
+        assert isinstance(member, ControllerMemberReflect), (
+            "Expected endpoint.controller_member_reflect to be of type "
+            "ControllerMemberReflect, but got: {}".format(type(member))
+        )
+
         async with self.uow_provider(
-            HttpAppContext(request=request)
-            if request
-            else WebSocketAppContext(websocket=websocket)
+            AppTransactionContext(
+                controller_member_reflect=member,
+                transaction_data=(
+                    HttpTransactionData(request=request)
+                    if request
+                    else WebSocketTransactionData(websocket=websocket)
+                ),
+            )
         ):
             yield
 

jararaca/presentation/websocket/context.py

@@ -16,12 +16,12 @@ class WebSocketConnectionManager(Protocol):
     async def remove_websocket(self, websocket: WebSocket) -> None: ...
 
 
-_ws_manage_ctx = ContextVar[WebSocketConnectionManager]("ws_manage_ctx")
+_ws_conn_manager_ctx = ContextVar[WebSocketConnectionManager]("ws_manage_ctx")
 
 
 def use_ws_manager() -> WebSocketConnectionManager:
     try:
-        return _ws_manage_ctx.get()
+        return _ws_conn_manager_ctx.get()
     except LookupError:
         raise RuntimeError("No WebSocketConnectionManager found")
 
@@ -30,9 +30,35 @@ def use_ws_manager() -> WebSocketConnectionManager:
 def provide_ws_manager(
     ws_manager: WebSocketConnectionManager,
 ) -> Generator[None, None, None]:
-    token = _ws_manage_ctx.set(ws_manager)
+    token = _ws_conn_manager_ctx.set(ws_manager)
     try:
         yield
     finally:
         with suppress(ValueError):
-            _ws_manage_ctx.reset(token)
+            _ws_conn_manager_ctx.reset(token)
+
+
+class WebSocketMessageSender(Protocol):
+    async def send(self, rooms: list[str], message: WebSocketMessageBase) -> None: ...
+
+
+_ws_msg_sender_ctx = ContextVar[WebSocketMessageSender]("ws_msg_sender_ctx")
+
+
+def use_ws_message_sender() -> WebSocketMessageSender:
+    try:
+        return _ws_msg_sender_ctx.get()
+    except LookupError:
+        raise RuntimeError("No WebSocketMessageSender found")
+
+
+@contextmanager
+def provide_ws_message_sender(
+    ws_message_sender: WebSocketMessageSender,
+) -> Generator[None, None, None]:
+    token = _ws_msg_sender_ctx.set(ws_message_sender)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            _ws_msg_sender_ctx.reset(token)

jararaca/presentation/websocket/types.py

@@ -1,8 +1,8 @@
 from jararaca.presentation.websocket.base_types import WebSocketMessageBase
-from jararaca.presentation.websocket.context import use_ws_manager
+from jararaca.presentation.websocket.context import use_ws_message_sender
 
 
 class WebSocketMessage(WebSocketMessageBase):
 
     async def send(self, *rooms: str) -> None:
-        await use_ws_manager().send(list(rooms), self)
+        await use_ws_message_sender().send(list(rooms), self)

jararaca/presentation/websocket/websocket_interceptor.py

@@ -13,9 +13,9 @@ from pydantic import BaseModel
 from jararaca.core.uow import UnitOfWorkContextProvider
 from jararaca.di import Container
 from jararaca.microservice import (
-    AppContext,
     AppInterceptor,
     AppInterceptorWithLifecycle,
+    AppTransactionContext,
     Microservice,
 )
 from jararaca.presentation.decorators import (
@@ -25,7 +25,9 @@ from jararaca.presentation.decorators import (
 )
 from jararaca.presentation.websocket.context import (
     WebSocketConnectionManager,
+    WebSocketMessageSender,
     provide_ws_manager,
+    provide_ws_message_sender,
 )
 from jararaca.presentation.websocket.decorators import (
     INHERITS_WS_MESSAGE,
@@ -127,9 +129,23 @@ class WebSocketConnectionManagerImpl(WebSocketConnectionManager):
     # async def setup_consumer(self, websocket: WebSocket) -> None: ...
 
 
+class StagingWebSocketMessageSender(WebSocketMessageSender):
+
+    def __init__(self, connection: WebSocketConnectionManager) -> None:
+        self.connection = connection
+        self.staged_messages: list[tuple[list[str], WebSocketMessageBase]] = []
+
+    async def send(self, rooms: list[str], message: WebSocketMessageBase) -> None:
+        self.staged_messages.append((rooms, message))
+
+    async def flush(self) -> None:
+        for rooms, message in self.staged_messages:
+            await self.connection.send(rooms, message)
+        self.staged_messages.clear()
+
+
 class WebSocketInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
     """
-    @Deprecated
     WebSocketInterceptor is responsible for managing WebSocket connections and
     intercepting WebSocket requests within the application. It integrates with
     the application's lifecycle and provides a router for WebSocket endpoints.
@@ -169,10 +185,18 @@ class WebSocketInterceptor(AppInterceptor, AppInterceptorWithLifecycle):
         self.shutdown_event.set()
 
     @asynccontextmanager
-    async def intercept(self, app_context: AppContext) -> AsyncGenerator[None, None]:
+    async def intercept(
+        self, app_context: AppTransactionContext
+    ) -> AsyncGenerator[None, None]:
 
-        with provide_ws_manager(self.connection_manager):
+        staging_ws_messages_sender = StagingWebSocketMessageSender(
+            self.connection_manager
+        )
+        with provide_ws_manager(self.connection_manager), provide_ws_message_sender(
+            staging_ws_messages_sender
+        ):
             yield
+            await staging_ws_messages_sender.flush()
 
     # def __wrap_with_uow_context_provider(
     #     self, uow: UnitOfWorkContextProvider, func: Callable[..., Any]

jararaca/reflect/controller_inspect.py

@@ -0,0 +1,75 @@
+import inspect
+from dataclasses import dataclass
+from typing import Any, Callable, Mapping, Tuple, Type
+
+from frozendict import frozendict
+
+from jararaca.reflect.metadata import ControllerInstanceMetadata, SetMetadata
+
+
+@dataclass(frozen=True)
+class ControllerReflect:
+
+    controller_class: Type[Any]
+    metadata: Mapping[str, ControllerInstanceMetadata]
+
+
+@dataclass(frozen=True)
+class ControllerMemberReflect:
+    controller_reflect: ControllerReflect
+    member_function: Callable[..., Any]
+    metadata: Mapping[str, ControllerInstanceMetadata]
+
+
+def inspect_controller(
+    controller: Type[Any],
+) -> Tuple[ControllerReflect, Mapping[str, ControllerMemberReflect]]:
+    """
+    Inspect a controller class to extract its metadata and member functions.
+
+    Args:
+        controller (Type[Any]): The controller class to inspect.
+
+    Returns:
+        Tuple[ControllerReflect, list[ControllerMemberReflect]]: A tuple containing the controller reflect and a list of member reflects.
+    """
+    controller_metadata_list = SetMetadata.get(controller)
+
+    controller_metadata_map = frozendict(
+        {
+            metadata.key: ControllerInstanceMetadata(
+                value=metadata.value, inherited=False
+            )
+            for metadata in controller_metadata_list
+        }
+    )
+
+    controller_reflect = ControllerReflect(
+        controller_class=controller, metadata=controller_metadata_map
+    )
+
+    members = {
+        name: ControllerMemberReflect(
+            controller_reflect=controller_reflect,
+            member_function=member,
+            metadata=frozendict(
+                {
+                    **{
+                        key: ControllerInstanceMetadata(
+                            value=value.value, inherited=True
+                        )
+                        for key, value in controller_metadata_map.items()
+                    },
+                    **{
+                        metadata.key: ControllerInstanceMetadata(
+                            value=metadata.value, inherited=False
+                        )
+                        for metadata in SetMetadata.get(member)
+                    },
+                }
+            ),
+        )
+        for name, member in inspect.getmembers(controller, predicate=inspect.isfunction)
+    }
+
+    return controller_reflect, members

jararaca/{tools → reflect}/metadata.py

@@ -1,19 +1,39 @@
 from contextlib import contextmanager, suppress
 from contextvars import ContextVar
-from typing import Any, Awaitable, Callable, TypeVar, Union, cast
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Mapping, TypeVar, Union, cast
 
 DECORATED = TypeVar("DECORATED", bound=Union[Callable[..., Awaitable[Any]], type])
 
 
-metadata_context: ContextVar[dict[str, Any]] = ContextVar("metadata_context")
+@dataclass
+class ControllerInstanceMetadata:
+    value: Any
+    inherited: bool
 
 
-def get_metadata(key: str) -> Any | None:
+metadata_context: ContextVar[Mapping[str, ControllerInstanceMetadata]] = ContextVar(
+    "metadata_context"
+)
+
+
+def get_metadata(key: str) -> ControllerInstanceMetadata | None:
     return metadata_context.get({}).get(key)
 
 
+def get_metadata_value(key: str, default: Any | None = None) -> Any:
+    metadata = get_metadata(key)
+    if metadata is None:
+        return default
+    return metadata.value
+
+
+def get_all_metadata() -> Mapping[str, ControllerInstanceMetadata]:
+    return metadata_context.get({})
+
+
 @contextmanager
-def provide_metadata(metadata: dict[str, Any]) -> Any:
+def provide_metadata(metadata: Mapping[str, ControllerInstanceMetadata]) -> Any:
 
     current_metadata = metadata_context.get({})
 
@@ -39,7 +59,7 @@ class SetMetadata:
         setattr(cls, SetMetadata.METATADA_LIST, metadata_list)
 
     @staticmethod
-    def get(cls: type) -> "list[SetMetadata]":
+    def get(cls: DECORATED) -> "list[SetMetadata]":
         return cast(list[SetMetadata], getattr(cls, SetMetadata.METATADA_LIST, []))
 
     def __call__(self, cls: DECORATED) -> DECORATED: