jararaca 0.3.12a4__py3-none-any.whl → 0.3.12a6__py3-none-any.whl

jararaca/__init__.py

@@ -102,6 +102,8 @@ if TYPE_CHECKING:
     from .messagebus.publisher import use_publisher
     from .microservice import (
         Microservice,
+        is_shutting_down,
+        request_shutdown,
         use_app_context,
         use_app_transaction_context,
         use_app_tx_ctx_data,
@@ -158,6 +160,7 @@ if TYPE_CHECKING:
     from .presentation.websocket.websocket_interceptor import WebSocketInterceptor
     from .scheduler.decorators import ScheduledAction
     from .tools.app_config.interceptor import AppConfigurationInterceptor
+    from .tools.typescript.decorators import MutationEndpoint, QueryEndpoint
 
     __all__ = [
         "SetMetadata",
@@ -207,6 +210,12 @@ if TYPE_CHECKING:
         "QueryInjector",
         "HttpMicroservice",
         "use_current_container",
+        "use_app_context",
+        "use_app_transaction_context",
+        "use_app_tx_ctx_data",
+        "is_shutting_down",
+        "request_shutdown",
+        "Microservice",
         "T_BASEMODEL",
         "DatedEntity",
         "BaseEntity",
@@ -229,7 +238,6 @@ if TYPE_CHECKING:
         "MessageBusController",
         "MessageHandler",
         "ScheduledAction",
-        "Microservice",
         "ProviderSpec",
         "Token",
         "AIOSqlAlchemySessionInterceptor",
@@ -254,6 +262,8 @@ if TYPE_CHECKING:
         "MessageBusPublisherInterceptor",
         "RedisWebSocketConnectionBackend",
         "AppConfigurationInterceptor",
+        "QueryEndpoint",
+        "MutationEndpoint",
         "UseMiddleware",
         "UseDependency",
         "GlobalHttpErrorHandler",
@@ -284,9 +294,6 @@ if TYPE_CHECKING:
         "RetryConfig",
         # Exception classes
         "TimeoutException",
-        "use_app_context",
-        "use_app_transaction_context",
-        "use_app_tx_ctx_data",
         "AppTransactionContext",
         "AppContext",
         "ControllerMemberReflect",
@@ -469,6 +476,8 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "tools.app_config.interceptor",
         None,
     ),
+    "QueryEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
+    "MutationEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "UseMiddleware": (__SPEC_PARENT__, "presentation.decorators", None),
     "UseDependency": (__SPEC_PARENT__, "presentation.decorators", None),
     "GlobalHttpErrorHandler": (__SPEC_PARENT__, "rpc.http.decorators", None),
@@ -501,6 +510,8 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
     "use_app_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_transaction_context": (__SPEC_PARENT__, "microservice", None),
     "use_app_tx_ctx_data": (__SPEC_PARENT__, "microservice", None),
+    "is_shutting_down": (__SPEC_PARENT__, "microservice", None),
+    "request_shutdown": (__SPEC_PARENT__, "microservice", None),
     "AppContext": (__SPEC_PARENT__, "microservice", None),
     "AppInterceptor": (__SPEC_PARENT__, "microservice", None),
     "AppTransactionContext": (__SPEC_PARENT__, "microservice", None),

jararaca/cli.py

@@ -5,6 +5,7 @@ import multiprocessing
 import os
 import sys
 import time
+import traceback
 from codecs import StreamWriter
 from pathlib import Path
 from typing import Any, Callable
@@ -615,6 +616,7 @@ def generate_interfaces(
         return content
     except Exception as e:
         click.echo(f"Error generating TypeScript interfaces: {e}", file=sys.stderr)
+        traceback.print_exc(file=sys.stderr)
         return ""
 
 

jararaca/messagebus/worker.py

@@ -49,6 +49,8 @@ from jararaca.microservice import (
     MessageBusTransactionData,
     Microservice,
     SchedulerTransactionData,
+    ShutdownState,
+    provide_shutdown_state,
 )
 from jararaca.scheduler.decorators import ScheduledActionData
 from jararaca.utils.rabbitmq_utils import RabbitmqUtils
@@ -129,6 +131,17 @@ class MessageBusConsumer(ABC):
         """Close all resources related to the consumer"""
 
 
+class _WorkerShutdownState(ShutdownState):
+    def __init__(self, shutdown_event: asyncio.Event):
+        self.shutdown_event = shutdown_event
+
+    def request_shutdown(self) -> None:
+        self.shutdown_event.set()
+
+    def is_shutdown_requested(self) -> bool:
+        return self.shutdown_event.is_set()
+
+
 class AioPikaMicroserviceConsumer(MessageBusConsumer):
     def __init__(
         self,
@@ -146,6 +159,7 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         self.incoming_map: dict[str, MessageHandlerData] = {}
         self.uow_context_provider = uow_context_provider
         self.shutdown_event = asyncio.Event()
+        self.shutdown_state = _WorkerShutdownState(self.shutdown_event)
         self.lock = asyncio.Lock()
         self.tasks: set[asyncio.Task[Any]] = set()
         self.connection: aio_pika.abc.AbstractConnection | None = None
@@ -832,18 +846,19 @@ class ScheduledMessageHandlerCallback:
         args: tuple[Any, ...],
         kwargs: dict[str, Any],
     ) -> None:
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=scheduled_action.controller_member,
-                transaction_data=SchedulerTransactionData(
-                    scheduled_to=datetime.now(UTC),
-                    cron_expression=scheduled_action.spec.cron,
-                    triggered_at=datetime.now(UTC),
-                ),
-            )
-        ):
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=scheduled_action.controller_member,
+                    transaction_data=SchedulerTransactionData(
+                        scheduled_to=datetime.now(UTC),
+                        cron_expression=scheduled_action.spec.cron,
+                        triggered_at=datetime.now(UTC),
+                    ),
+                )
+            ):
 
-            await scheduled_action.callable(*args, **kwargs)
+                await scheduled_action.callable(*args, **kwargs)
 
 
 class MessageHandlerCallback:
@@ -1133,83 +1148,86 @@ class MessageHandlerCallback:
         incoming_message_spec = MessageHandler.get_message_incoming(handler)
         assert incoming_message_spec is not None
 
-        async with self.consumer.uow_context_provider(
-            AppTransactionContext(
-                controller_member_reflect=handler_data.controller_member,
-                transaction_data=MessageBusTransactionData(
-                    message=builded_message,
-                    topic=routing_key,
-                ),
-            )
-        ):
-            ctx: AsyncContextManager[Any]
-            if incoming_message_spec.timeout is not None:
-                ctx = asyncio.timeout(incoming_message_spec.timeout)
-            else:
-                ctx = none_context()
-            async with ctx:
-                try:
-                    with provide_bus_message_controller(
-                        AioPikaMessageBusController(aio_pika_message)
-                    ):
-                        await handler(builded_message)
-                    if not incoming_message_spec.auto_ack:
-                        with suppress(aio_pika.MessageProcessError):
-                            # Use channel context for acknowledgement
-                            async with self.consumer.get_channel_ctx(self.queue_name):
-                                await aio_pika_message.ack()
-                except BaseException as base_exc:
-                    # Get message id for logging
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-
-                    # Extract retry count from headers if available
-                    headers = aio_pika_message.headers or {}
-                    retry_count = int(str(headers.get("x-retry-count", 0)))
-
-                    # Process exception handler if configured
-                    if incoming_message_spec.exception_handler is not None:
-                        try:
-                            incoming_message_spec.exception_handler(base_exc)
-                        except Exception as nested_exc:
+        with provide_shutdown_state(self.consumer.shutdown_state):
+            async with self.consumer.uow_context_provider(
+                AppTransactionContext(
+                    controller_member_reflect=handler_data.controller_member,
+                    transaction_data=MessageBusTransactionData(
+                        message=builded_message,
+                        topic=routing_key,
+                    ),
+                )
+            ):
+                ctx: AsyncContextManager[Any]
+                if incoming_message_spec.timeout is not None:
+                    ctx = asyncio.timeout(incoming_message_spec.timeout)
+                else:
+                    ctx = none_context()
+                async with ctx:
+                    try:
+                        with provide_bus_message_controller(
+                            AioPikaMessageBusController(aio_pika_message)
+                        ):
+                            await handler(builded_message)
+                        if not incoming_message_spec.auto_ack:
+                            with suppress(aio_pika.MessageProcessError):
+                                # Use channel context for acknowledgement
+                                async with self.consumer.get_channel_ctx(
+                                    self.queue_name
+                                ):
+                                    await aio_pika_message.ack()
+                    except BaseException as base_exc:
+                        # Get message id for logging
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+
+                        # Extract retry count from headers if available
+                        headers = aio_pika_message.headers or {}
+                        retry_count = int(str(headers.get("x-retry-count", 0)))
+
+                        # Process exception handler if configured
+                        if incoming_message_spec.exception_handler is not None:
+                            try:
+                                incoming_message_spec.exception_handler(base_exc)
+                            except Exception as nested_exc:
+                                logger.exception(
+                                    f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                )
+                        else:
                             logger.exception(
-                                f"Error processing exception handler for message {message_id}: {base_exc} | {nested_exc}"
+                                f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
                             )
-                    else:
-                        logger.exception(
-                            f"Error processing message {message_id} on topic {routing_key}: {str(base_exc)}"
-                        )
 
-                    # Handle rejection with retry logic
-                    if incoming_message_spec.requeue_on_exception:
-                        # Use our retry with backoff mechanism
-                        await self.handle_reject_message(
-                            aio_pika_message,
-                            requeue=False,  # Don't requeue directly, use our backoff mechanism
-                            retry_count=retry_count,
-                            exception=base_exc,
-                        )
-                    else:
-                        # Message shouldn't be retried, reject it
-                        await self.handle_reject_message(
-                            aio_pika_message, requeue=False, exception=base_exc
-                        )
-                else:
-                    # Message processed successfully, log and clean up any retry state
-                    message_id = aio_pika_message.message_id or str(uuid.uuid4())
-                    if message_id in self.retry_state:
-                        del self.retry_state[message_id]
-
-                    # Log success with retry information if applicable
-                    headers = aio_pika_message.headers or {}
-                    if "x-retry-count" in headers:
-                        retry_count = int(str(headers.get("x-retry-count", 0)))
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
-                        )
+                        # Handle rejection with retry logic
+                        if incoming_message_spec.requeue_on_exception:
+                            # Use our retry with backoff mechanism
+                            await self.handle_reject_message(
+                                aio_pika_message,
+                                requeue=False,  # Don't requeue directly, use our backoff mechanism
+                                retry_count=retry_count,
+                                exception=base_exc,
+                            )
+                        else:
+                            # Message shouldn't be retried, reject it
+                            await self.handle_reject_message(
+                                aio_pika_message, requeue=False, exception=base_exc
+                            )
                     else:
-                        logger.info(
-                            f"Message {message_id}#{self.queue_name} processed successfully"
-                        )
+                        # Message processed successfully, log and clean up any retry state
+                        message_id = aio_pika_message.message_id or str(uuid.uuid4())
+                        if message_id in self.retry_state:
+                            del self.retry_state[message_id]
+
+                        # Log success with retry information if applicable
+                        headers = aio_pika_message.headers or {}
+                        if "x-retry-count" in headers:
+                            retry_count = int(str(headers.get("x-retry-count", 0)))
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully after {retry_count} retries"
+                            )
+                        else:
+                            logger.info(
+                                f"Message {message_id}#{self.queue_name} processed successfully"
+                            )
 
 
 @asynccontextmanager

jararaca/microservice.py

@@ -325,6 +325,48 @@ def provide_container(container: Container) -> Generator[None, None, None]:
             current_container_ctx.reset(token)
 
 
+class ShutdownState(Protocol):
+
+    def request_shutdown(self) -> None: ...
+
+    def is_shutdown_requested(self) -> bool: ...
+
+
+shutdown_state_ctx = ContextVar[ShutdownState]("shutdown_state")
+
+
+def is_shutting_down() -> bool:
+    """
+    Check if the application is in the process of shutting down.
+    """
+    return shutdown_state_ctx.get().is_shutdown_requested()
+
+
+def request_shutdown() -> None:
+    """
+    Request the application to shut down.
+    This will set the shutdown event, allowing the application to gracefully shut down.
+    """
+    shutdown_state_ctx.get().request_shutdown()
+
+
+@contextmanager
+def provide_shutdown_state(
+    state: ShutdownState,
+) -> Generator[None, None, None]:
+    """
+    Context manager to provide the shutdown state.
+    This is used to manage the shutdown event for the application.
+    """
+
+    token = shutdown_state_ctx.set(state)
+    try:
+        yield
+    finally:
+        with suppress(ValueError):
+            shutdown_state_ctx.reset(token)
+
+
 __all__ = [
     "AppTransactionContext",
     "AppInterceptor",

jararaca/presentation/server.py

@@ -1,4 +1,8 @@
+import os
+import signal
+import threading
 from contextlib import asynccontextmanager
+from signal import SIGINT, SIGTERM
 from typing import Any, AsyncGenerator
 
 from fastapi import Depends, FastAPI, Request, WebSocket
@@ -10,7 +14,9 @@ from jararaca.lifecycle import AppLifecycle
 from jararaca.microservice import (
     AppTransactionContext,
     HttpTransactionData,
+    ShutdownState,
     WebSocketTransactionData,
+    provide_shutdown_state,
 )
 from jararaca.presentation.decorators import RestController
 from jararaca.presentation.http_microservice import HttpMicroservice
@@ -76,10 +82,49 @@ class HttpAppLifecycle:
             yield
 
 
+class HttpShutdownState(ShutdownState):
+    def __init__(self) -> None:
+        self._requested = False
+        self.old_signal_handlers = {
+            SIGINT: signal.getsignal(SIGINT),
+            SIGTERM: signal.getsignal(SIGTERM),
+        }
+        self.thread_lock = threading.Lock()
+
+    def request_shutdown(self) -> None:
+        if not self._requested:
+            self._requested = True
+            os.kill(os.getpid(), SIGINT)
+
+    def is_shutdown_requested(self) -> bool:
+        return self._requested
+
+    def handle_signal(self, signum: int, frame: Any) -> None:
+        print(f"Received signal {signum}, initiating shutdown...")
+        if self._requested:
+            print("Shutdown already requested, ignoring signal.")
+            return
+        print("Requesting shutdown...")
+        self._requested = True
+
+        # remove the signal handler to prevent recursion
+        for sig in (SIGINT, SIGTERM):
+            if self.old_signal_handlers[sig] is not None:
+                signal.signal(sig, self.old_signal_handlers[sig])
+
+        signal.raise_signal(signum)
+
+    def setup_signal_handlers(self) -> None:
+        signal.signal(SIGINT, self.handle_signal)
+        signal.signal(SIGTERM, self.handle_signal)
+
+
 class HttpUowContextProviderDependency:
 
     def __init__(self, uow_provider: UnitOfWorkContextProvider) -> None:
         self.uow_provider = uow_provider
+        self.shutdown_state = HttpShutdownState()
+        self.shutdown_state.setup_signal_handlers()
 
     async def __call__(
         self, websocket: WebSocket = None, request: Request = None  # type: ignore
@@ -101,17 +146,18 @@ class HttpUowContextProviderDependency:
             "ControllerMemberReflect, but got: {}".format(type(member))
         )
 
-        async with self.uow_provider(
-            AppTransactionContext(
-                controller_member_reflect=member,
-                transaction_data=(
-                    HttpTransactionData(request=request)
-                    if request
-                    else WebSocketTransactionData(websocket=websocket)
-                ),
-            )
-        ):
-            yield
+        with provide_shutdown_state(self.shutdown_state):
+            async with self.uow_provider(
+                AppTransactionContext(
+                    controller_member_reflect=member,
+                    transaction_data=(
+                        HttpTransactionData(request=request)
+                        if request
+                        else WebSocketTransactionData(websocket=websocket)
+                    ),
+                )
+            ):
+                yield
 
 
 def create_http_server(

jararaca/tools/typescript/decorators.py

@@ -0,0 +1,51 @@
+from typing import Any, Callable, TypeVar
+
+DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
+
+
+class QueryEndpoint:
+    """
+    Decorator to mark a endpoint function as a query endpoint for Typescript generation.
+    """
+
+    METADATA_KEY = "__jararaca_query_endpoint__"
+
+    def __init__(self) -> None: ...
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        """
+        Decorate the function to mark it as a query endpoint.
+        """
+        setattr(func, self.METADATA_KEY, True)
+        return func
+
+    @staticmethod
+    def is_query(func: Any) -> bool:
+        """
+        Check if the function is marked as a query endpoint.
+        """
+        return getattr(func, QueryEndpoint.METADATA_KEY, False)
+
+
+class MutationEndpoint:
+    """
+    Decorator to mark a endpoint function as a mutation endpoint for Typescript generation.
+    """
+
+    METADATA_KEY = "__jararaca_mutation_endpoint__"
+
+    def __init__(self) -> None: ...
+
+    def __call__(self, func: DECORATED_FUNC) -> DECORATED_FUNC:
+        """
+        Decorate the function to mark it as a mutation endpoint.
+        """
+        setattr(func, self.METADATA_KEY, True)
+        return func
+
+    @staticmethod
+    def is_mutation(func: Any) -> bool:
+        """
+        Check if the function is marked as a mutation endpoint.
+        """
+        return getattr(func, MutationEndpoint.METADATA_KEY, False)

jararaca/tools/typescript/interface_parser.py

@@ -8,7 +8,7 @@ from datetime import date, datetime, time
 from decimal import Decimal
 from enum import Enum
 from io import StringIO
-from types import NoneType, UnionType
+from types import FunctionType, NoneType, UnionType
 from typing import (
     IO,
     Annotated,
@@ -35,6 +35,7 @@ from jararaca.presentation.websocket.decorators import RegisterWebSocketMessage
 from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketMessageWrapper,
 )
+from jararaca.tools.typescript.decorators import MutationEndpoint, QueryEndpoint
 
 CONSTANT_PATTERN = re.compile(r"^[A-Z_]+$")
 
@@ -67,6 +68,13 @@ def snake_to_camel(snake_str: str) -> str:
     return components[0] + "".join(x.title() for x in components[1:])
 
 
+def pascal_to_camel(pascal_str: str) -> str:
+    """Convert a PascalCase string to camelCase."""
+    if not pascal_str:
+        return pascal_str
+    return pascal_str[0].lower() + pascal_str[1:]
+
+
 def parse_literal_value(value: Any) -> str:
     if value is None:
         return "null"
@@ -354,12 +362,17 @@ def write_microservice_to_typescript_interface(
         if rest_controller is None:
             continue
 
-        controller_class_str, types = write_rest_controller_to_typescript_interface(
-            rest_controller, controller
+        controller_class_strio, types, hooks_strio = (
+            write_rest_controller_to_typescript_interface(
+                rest_controller,
+                controller,
+            )
         )
 
         mapped_types_set.update(types)
-        rest_controller_buffer.write(controller_class_str)
+        rest_controller_buffer.write(controller_class_strio.getvalue())
+        if hooks_strio is not None:
+            rest_controller_buffer.write(hooks_strio.getvalue())
 
         registered = RegisterWebSocketMessage.get(controller)
 
@@ -376,6 +389,7 @@ def write_microservice_to_typescript_interface(
 
     final_buffer.write(
         """
+import { createClassQueryHooks , createClassMutationHooks, createClassInfiniteQueryHooks } from "@jararaca/core";
 export type WebSocketMessageMap = {
 %s
 }
@@ -494,11 +508,16 @@ def is_primitive(field_type: Any) -> bool:
 
 def write_rest_controller_to_typescript_interface(
     rest_controller: RestController, controller: type
-) -> tuple[str, set[Any]]:
+) -> tuple[StringIO, set[Any], StringIO | None]:
+
+    class_name = controller.__name__
+
+    decorated_queries: list[tuple[str, FunctionType]] = []
+    decorated_mutations: list[tuple[str, FunctionType]] = []
 
     class_buffer = StringIO()
 
-    class_buffer.write(f"export class {controller.__name__} extends HttpService {{\n")
+    class_buffer.write(f"export class {class_name} extends HttpService {{\n")
 
     mapped_types: set[Any] = set()
 
@@ -514,6 +533,11 @@ def write_rest_controller_to_typescript_interface(
             if return_type is None:
                 return_type = NoneType
 
+            if QueryEndpoint.is_query(member):
+                decorated_queries.append((name, member))
+            if MutationEndpoint.is_mutation(member):
+                decorated_mutations.append((name, member))
+
             mapped_types.update(extract_all_envolved_types(return_type))
 
             return_value_repr = get_field_type_for_ts(return_type)
@@ -588,7 +612,31 @@ def write_rest_controller_to_typescript_interface(
 
     class_buffer.write("}\n")
 
-    return class_buffer.getvalue(), mapped_types
+    controller_hooks_builder: StringIO | None = None
+
+    if decorated_queries or decorated_mutations:
+        controller_hooks_builder = StringIO()
+        controller_hooks_builder.write(
+            f"export const {pascal_to_camel(class_name)} = {{\n"
+        )
+
+        if decorated_queries:
+            controller_hooks_builder.write(
+                f"\t...createClassQueryHooks({class_name},\n"
+            )
+            for name, member in decorated_queries:
+                controller_hooks_builder.write(f'\t\t"{snake_to_camel(name)}",\n')
+            controller_hooks_builder.write("\t),\n")
+        if decorated_mutations:
+            controller_hooks_builder.write(
+                f"\t...createClassMutationHooks({class_name},\n"
+            )
+            for name, member in decorated_mutations:
+                controller_hooks_builder.write(f'\t\t"{snake_to_camel(name)}",\n')
+            controller_hooks_builder.write("\t),\n")
+        controller_hooks_builder.write("};\n")
+
+    return class_buffer, mapped_types, controller_hooks_builder
 
 
 EXCLUDED_REQUESTS_TYPES = [Request, Response]

{jararaca-0.3.12a4.dist-info → jararaca-0.3.12a6.dist-info}/METADATA

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

{jararaca-0.3.12a4.dist-info → jararaca-0.3.12a6.dist-info}/RECORD

@@ -1,12 +1,12 @@
 LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
 README.md,sha256=2qMM__t_MoLKZr4IY9tXjo-Jn6LKjuHMb1qbyXpgL08,3401
-pyproject.toml,sha256=52W7n20RKPz82FFphOmYyMWBVaYSyaAsIDUYwh9YACQ,2040
-jararaca/__init__.py,sha256=Jszgq9WCKnriBezBtvhj35aSsJWnTUXm9-UfThkDT3s,20701
+pyproject.toml,sha256=3e1dOSeKg1pARRUHFxJ0d5wOPiGtoe4YiAqf3VngI6o,2040
+jararaca/__init__.py,sha256=jN3paW2ujI97485DNZTcRe_8ORwO-OQbJUG5mmSI9LI,21226
 jararaca/__main__.py,sha256=-O3vsB5lHdqNFjUtoELDF81IYFtR-DSiiFMzRaiSsv4,67
 jararaca/broker_backend/__init__.py,sha256=GzEIuHR1xzgCJD4FE3harNjoaYzxHMHoEL0_clUaC-k,3528
 jararaca/broker_backend/mapper.py,sha256=vTsi7sWpNvlga1PWPFg0rCJ5joJ0cdzykkIc2Tuvenc,696
 jararaca/broker_backend/redis_broker_backend.py,sha256=a7DHchy3NAiD71Ix8SwmQOUnniu7uup-Woa4ON_4J7I,5786
-jararaca/cli.py,sha256=uLwLwM7OSjx2OoIczOqjq7fDBwsoq5vdGzdvXQobs5Q,31943
+jararaca/cli.py,sha256=n3fTOVSNFNICmbZrLCJNGctpbqLWp39xTSkqlIB6Rds,32005
 jararaca/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/core/providers.py,sha256=wktH84FK7c1s2wNq-fudf1uMfi3CQBR0neU2czJ_L0U,434
@@ -23,8 +23,8 @@ jararaca/messagebus/interceptors/aiopika_publisher_interceptor.py,sha256=_DEHwIH
 jararaca/messagebus/interceptors/publisher_interceptor.py,sha256=ojy1bRhqMgrkQljcGGS8cd8-8pUjL8ZHjIUkdmaAnNM,1325
 jararaca/messagebus/message.py,sha256=U6cyd2XknX8mtm0333slz5fanky2PFLWCmokAO56vvU,819
 jararaca/messagebus/publisher.py,sha256=JTkxdKbvxvDWT8nK8PVEyyX061vYYbKQMxRHXrZtcEY,2173
-jararaca/messagebus/worker.py,sha256=CrSIejWMGII4_JK0aH4jxdj0oBJX4hSXY0SmVa6KURA,54187
-jararaca/microservice.py,sha256=rRIimfeP2-wf289PKoUbk9wrSdA0ga_qWz5JNgQ5IE0,9667
+jararaca/messagebus/worker.py,sha256=736rl6mBVxo-w5Y-jJe1w1ORPgVk16jlmTyVJueeAKs,55156
+jararaca/microservice.py,sha256=4uQWPH1Ytxl2tg4IK-M_6T-28X89ku4ObJXJyg9CDr4,10663
 jararaca/observability/decorators.py,sha256=MOIr2PttPYYvRwEdfQZEwD5RxKHOTv8UEy9n1YQVoKw,2281
 jararaca/observability/interceptor.py,sha256=U4ZLM0f8j6Q7gMUKKnA85bnvD-Qa0ii79Qa_X8KsXAQ,1498
 jararaca/observability/providers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,7 +40,7 @@ jararaca/presentation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 jararaca/presentation/decorators.py,sha256=dNcK1xYWhdHVBeWDa8dhqh4z8yQcPkJZTQkfgLXz6RI,11655
 jararaca/presentation/hooks.py,sha256=WBbU5DG3-MAm2Ro2YraQyYG_HENfizYfyShL2ktHi6k,1980
 jararaca/presentation/http_microservice.py,sha256=g771JosV6jTY3hQtG-HkLOo-T0e-r3b3rp1ddt99Qf0,533
-jararaca/presentation/server.py,sha256=5joE17nnSiwR497Nerr-vcthKL4NRBzyf1KWM8DFgwQ,4682
+jararaca/presentation/server.py,sha256=Im-tei9EynKm1DO-63UIGeTJK5ZvxIhpAxbsYGn7ZW0,6244
 jararaca/presentation/websocket/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/presentation/websocket/base_types.py,sha256=AvUeeZ1TFhSiRMcYqZU1HaQNqSrcgTkC5R0ArP5dGmA,146
 jararaca/presentation/websocket/context.py,sha256=A6K5W3kqo9Hgeh1m6JiI7Cdz5SfbXcaICSVX7u1ARZo,1903
@@ -66,12 +66,14 @@ jararaca/scheduler/types.py,sha256=4HEQOmVIDp-BYLSzqmqSFIio1bd51WFmgFPIzPpVu04,1
 jararaca/tools/app_config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/tools/app_config/decorators.py,sha256=-ckkMZ1dswOmECdo1rFrZ15UAku--txaNXMp8fd1Ndk,941
 jararaca/tools/app_config/interceptor.py,sha256=HV8h4AxqUc_ACs5do4BSVlyxlRXzx7HqJtoVO9tfRnQ,2611
-jararaca/tools/typescript/interface_parser.py,sha256=foZ_A_lkyacmAq9TU6hUFv5ZnZcPZbbxcjtzFUu1A_o,31479
+jararaca/tools/typescript/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jararaca/tools/typescript/decorators.py,sha256=F-4de0OKN4VrXCwtfsts1XaycGkXqSGuDKW6ElryMsY,1409
+jararaca/tools/typescript/interface_parser.py,sha256=dc-h74yaySqXklqIDXuIQUN9wwqEE7q4uGWQ4nByI84,33462
 jararaca/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 jararaca/utils/rabbitmq_utils.py,sha256=ytdAFUyv-OBkaVnxezuJaJoLrmN7giZgtKeet_IsMBs,10918
 jararaca/utils/retry.py,sha256=DzPX_fXUvTqej6BQ8Mt2dvLo9nNlTBm7Kx2pFZ26P2Q,4668
-jararaca-0.3.12a4.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-jararaca-0.3.12a4.dist-info/METADATA,sha256=ZhivHS3NMe_L-0vt0uS_jilL4cSNkPGUtGLhX4ygD7U,4995
-jararaca-0.3.12a4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-jararaca-0.3.12a4.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
-jararaca-0.3.12a4.dist-info/RECORD,,
+jararaca-0.3.12a6.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+jararaca-0.3.12a6.dist-info/METADATA,sha256=XPCPH0zrpKaicneY3XJSnwbgVvLlDlS4kfSWblCorWE,4995
+jararaca-0.3.12a6.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+jararaca-0.3.12a6.dist-info/entry_points.txt,sha256=WIh3aIvz8LwUJZIDfs4EeH3VoFyCGEk7cWJurW38q0I,45
+jararaca-0.3.12a6.dist-info/RECORD,,

pyproject.toml

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