jararaca 0.3.15__tar.gz → 0.3.17__tar.gz

{jararaca-0.3.15 → jararaca-0.3.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: jararaca
-Version: 0.3.15
+Version: 0.3.17
 Summary: A simple and fast API framework for Python
 Home-page: https://github.com/LuscasLeo/jararaca
 Author: Lucas S
@@ -74,6 +74,7 @@ Jararaca is an async-first microservice framework designed to simplify the devel
 - Command-line tool for generating TypeScript types
 - Support for REST endpoints, WebSocket events, and message bus payloads
 - Type-safe frontend-backend communication
+- **`@ExposeType` decorator** - Explicitly expose types for TypeScript generation without needing them in endpoints
 
 ### Hexagonal Architecture
 - Clear separation of concerns

{jararaca-0.3.15 → jararaca-0.3.17}/README.md

@@ -37,6 +37,7 @@ Jararaca is an async-first microservice framework designed to simplify the devel
 - Command-line tool for generating TypeScript types
 - Support for REST endpoints, WebSocket events, and message bus payloads
 - Type-safe frontend-backend communication
+- **`@ExposeType` decorator** - Explicitly expose types for TypeScript generation without needing them in endpoints
 
 ### Hexagonal Architecture
 - Clear separation of concerns

jararaca-0.3.17/docs/expose-type.md

@@ -0,0 +1,221 @@
+# Exposing Types for TypeScript Generation
+
+The `@ExposeType` decorator allows you to explicitly expose types for TypeScript interface generation without requiring them to be directly referenced in REST endpoints, WebSocket messages, or as indirect dependencies.
+
+## Use Cases
+
+The `@ExposeType` decorator is useful when you have types that:
+
+1. **Are used only on the frontend** - Types that exist for frontend state management, validation, or business logic
+2. **Are part of a shared schema** - Common types that multiple parts of your application use but aren't directly in API contracts
+3. **Need to be pre-generated** - Types that you want available immediately even if they're not yet used in any endpoints
+4. **Are utility types** - Helper types, enums, or constants that the frontend needs to know about
+
+## Basic Usage
+
+Simply decorate any Pydantic model with `@ExposeType()`:
+
+```python
+from pydantic import BaseModel
+
+from jararaca import ExposeType
+
+
+@ExposeType()
+class UserPermission(BaseModel):
+    id: str
+    name: str
+    description: str
+    resource: str
+    action: str
+```
+
+This type will now be included in the generated TypeScript output when you run:
+
+```bash
+jararaca gen-tsi app:app output.ts
+```
+
+## Example: Frontend-Only Types
+
+```python
+from pydantic import BaseModel
+
+from jararaca import ExposeType
+
+
+@ExposeType()
+class FilterState(BaseModel):
+    """Frontend state for table filtering."""
+    search_query: str
+    sort_column: str
+    sort_direction: str
+    page: int
+    page_size: int
+
+@ExposeType()
+class UITheme(BaseModel):
+    """Frontend theme configuration."""
+    primary_color: str
+    secondary_color: str
+    dark_mode: bool
+```
+
+## Example: Error Codes and Constants
+
+```python
+from enum import Enum
+
+from pydantic import BaseModel
+
+from jararaca import ExposeType
+
+
+@ExposeType()
+class ErrorCode(str, Enum):
+    """Standard error codes."""
+    UNAUTHORIZED = "UNAUTHORIZED"
+    NOT_FOUND = "NOT_FOUND"
+    VALIDATION_ERROR = "VALIDATION_ERROR"
+    INTERNAL_ERROR = "INTERNAL_ERROR"
+
+@ExposeType()
+class ApiErrorDetail(BaseModel):
+    """Detailed error information."""
+    code: ErrorCode
+    message: str
+    field: str | None = None
+    details: dict[str, str] | None = None
+```
+
+## Example: Complex Nested Types
+
+```python
+from pydantic import BaseModel
+
+from jararaca import ExposeType
+
+
+@ExposeType()
+class Address(BaseModel):
+    street: str
+    city: str
+    country: str
+    postal_code: str
+
+@ExposeType()
+class ContactInfo(BaseModel):
+    email: str
+    phone: str | None = None
+    address: Address
+
+@ExposeType()
+class Organization(BaseModel):
+    """Complete organization structure."""
+    id: str
+    name: str
+    contacts: list[ContactInfo]
+    settings: dict[str, str]
+```
+
+When you expose a type with nested structures, the decorator ensures that all related types are also included in the TypeScript generation.
+
+## Comparison: With vs Without @ExposeType
+
+### Without @ExposeType
+
+```python
+class UserRole(BaseModel):
+    """Only generated if used in an endpoint or as a dependency."""
+    id: str
+    name: str
+
+@RestController("/api/users")
+class UserController:
+    @Get("/{user_id}")
+    async def get_user(self, user_id: str) -> UserResponse:
+        # UserRole is only generated if UserResponse references it
+        return UserResponse(...)
+```
+
+### With @ExposeType
+
+```python
+@ExposeType()
+class UserRole(BaseModel):
+    """Always generated, available immediately."""
+    id: str
+    name: str
+
+@RestController("/api/users")
+class UserController:
+    @Get("/{user_id}")
+    async def get_user(self, user_id: str) -> UserResponse:
+        # UserRole is available in TypeScript even if not used yet
+        return UserResponse(...)
+```
+
+## Integration with Other Decorators
+
+The `@ExposeType` decorator works seamlessly with other TypeScript generation decorators:
+
+```python
+from jararaca import ExposeType, SplitInputOutput
+
+
+@ExposeType()
+@SplitInputOutput()
+class UserProfile(BaseModel):
+    """Generates UserProfileInput and UserProfileOutput interfaces."""
+    id: str
+    username: str
+    email: str
+    created_at: str
+    updated_at: str
+```
+
+This creates both `UserProfileInput` and `UserProfileOutput` TypeScript interfaces.
+
+## Best Practices
+
+1. **Use for shared types**: Apply `@ExposeType` to types that are used across multiple parts of your application
+2. **Document the purpose**: Add clear docstrings explaining why a type is exposed
+3. **Avoid overuse**: Only expose types that the frontend actually needs - don't expose internal implementation details
+4. **Combine with other decorators**: Use alongside `@SplitInputOutput` when appropriate
+5. **Group related types**: Keep exposed types in dedicated modules (e.g., `shared_types.py`)
+
+## Viewing Exposed Types
+
+All types decorated with `@ExposeType` are tracked globally. You can check which types are exposed:
+
+```python
+from jararaca.tools.typescript.decorators import ExposeType
+
+# Get all exposed types
+exposed = ExposeType.get_all_exposed_types()
+print(f"Exposed {len(exposed)} types: {[t.__name__ for t in exposed]}")
+```
+
+## Generated TypeScript
+
+Given this Python code:
+
+```python
+@ExposeType()
+class NotificationPreference(BaseModel):
+    email_enabled: bool
+    push_enabled: bool
+    frequency: str
+```
+
+The generated TypeScript will be:
+
+```typescript
+export interface NotificationPreference {
+  emailEnabled: boolean;
+  pushEnabled: boolean;
+  frequency: string;
+}
+```
+
+The type is available in your TypeScript code even if no REST endpoint uses it yet.

{jararaca-0.3.15 → jararaca-0.3.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "jararaca"
-version = "0.3.15"
+version = "0.3.17"
 description = "A simple and fast API framework for Python"
 authors = ["Lucas S <me@luscasleo.dev>"]
 readme = "README.md"
@@ -62,6 +62,10 @@ mkdocs-mermaid2-plugin = "^1.2.1"
 [tool.poetry.group.dev.dependencies]
 httptools = "^0.6.1"
 httpx = "^0.27.2"
+pytest = "^8.0.0"
+pytest-asyncio = "^0.23.0"
+pytest-cov = "^4.1.0"
+pytest-mock = "^3.12.0"
 
 [build-system]
 requires = ["poetry-core"]
@@ -84,3 +88,39 @@ jararaca = "jararaca.cli:cli"
 [[tool.mypy.overrides]]
 module = "mako.*"
 ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+asyncio_mode = "auto"
+addopts = [
+    "--strict-markers",
+    "--strict-config",
+    "--showlocals",
+]
+markers = [
+    "unit: Unit tests",
+    "integration: Integration tests",
+    "slow: Slow tests",
+]
+
+[tool.coverage.run]
+source = ["src/jararaca"]
+omit = [
+    "*/tests/*",
+    "*/__pycache__/*",
+    "*/.venv/*",
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "pragma: no cover",
+    "def __repr__",
+    "raise AssertionError",
+    "raise NotImplementedError",
+    "if __name__ == .__main__.:",
+    "if TYPE_CHECKING:",
+    "@abstractmethod",
+]

{jararaca-0.3.15 → jararaca-0.3.17}/src/jararaca/__init__.py

@@ -171,6 +171,7 @@ if TYPE_CHECKING:
     from .scheduler.decorators import ScheduledAction
     from .tools.app_config.interceptor import AppConfigurationInterceptor
     from .tools.typescript.decorators import (
+        ExposeType,
         MutationEndpoint,
         QueryEndpoint,
         SplitInputOutput,
@@ -279,6 +280,7 @@ if TYPE_CHECKING:
         "MessageBusPublisherInterceptor",
         "RedisWebSocketConnectionBackend",
         "AppConfigurationInterceptor",
+        "ExposeType",
         "QueryEndpoint",
         "MutationEndpoint",
         "SplitInputOutput",
@@ -510,6 +512,7 @@ _dynamic_imports: "dict[str, tuple[str, str, str | None]]" = {
         "tools.app_config.interceptor",
         None,
     ),
+    "ExposeType": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "QueryEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "MutationEndpoint": (__SPEC_PARENT__, "tools.typescript.decorators", None),
     "SplitInputOutput": (__SPEC_PARENT__, "tools.typescript.decorators", None),

{jararaca-0.3.15 → jararaca-0.3.17}/src/jararaca/messagebus/decorators.py

@@ -11,6 +11,8 @@ from jararaca.scheduler.decorators import ScheduledAction, ScheduledActionData
 
 DECORATED_FUNC = TypeVar("DECORATED_FUNC", bound=Callable[..., Any])
 DECORATED_T = TypeVar("DECORATED_T", bound=Any)
+INSTANCE_T = TypeVar("INSTANCE_T", bound=Any)
+RETURN_T = TypeVar("RETURN_T", bound=Any)
 
 
 class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
@@ -35,8 +37,9 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
         self.name = name
 
     def __call__(
-        self, func: Callable[[Any, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]]
-    ) -> Callable[[Any, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]]:
+        self,
+        func: Callable[[INSTANCE_T, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]],
+    ) -> Callable[[INSTANCE_T, MessageOf[INHERITS_MESSAGE_CO]], Awaitable[None]]:
 
         MessageHandler[Any].register(func, self)
 
@@ -52,7 +55,7 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
 
     @staticmethod
     def get_message_incoming(
-        func: Callable[[MessageOf[Any]], Awaitable[Any]],
+        func: Callable[[Any, MessageOf[Any]], Awaitable[None]],
     ) -> "MessageHandler[Message] | None":
         if not hasattr(func, MessageHandler.MESSAGE_INCOMING_ATTR):
             return None
@@ -66,7 +69,7 @@ class MessageHandler(Generic[INHERITS_MESSAGE_CO]):
 class MessageHandlerData:
     message_type: type[Any]
     spec: MessageHandler[Message]
-    instance_callable: Callable[[MessageOf[Any]], Awaitable[None]]
+    instance_callable: Callable[..., Awaitable[None]]
     controller_member: ControllerMemberReflect
 
 

{jararaca-0.3.15 → jararaca-0.3.17}/src/jararaca/messagebus/worker.py

@@ -188,11 +188,8 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         # Connection resilience attributes
         self.connection_healthy = False
         self.connection_lock = asyncio.Lock()
-        self.reconnection_event = asyncio.Event()
-        self.reconnection_in_progress = False
         self.consumer_tags: dict[str, str] = {}  # Track consumer tags for cleanup
         self.health_check_task: asyncio.Task[Any] | None = None
-        self.reconnection_task: asyncio.Task[Any] | None = None
 
     async def _verify_infrastructure(self) -> bool:
         """
@@ -229,10 +226,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         routing_key = f"{handler.message_type.MESSAGE_TOPIC}.#"
 
         async def setup_consumer() -> None:
-            # Wait for connection to be healthy if reconnection is in progress
-            if self.reconnection_in_progress:
-                await self.reconnection_event.wait()
-
             # Create a channel using the context manager
             async with self.create_channel(queue_name) as channel:
                 queue = await RabbitmqUtils.get_queue(
@@ -289,10 +282,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         routing_key = queue_name
 
         async def setup_consumer() -> None:
-            # Wait for connection to be healthy if reconnection is in progress
-            if self.reconnection_in_progress:
-                await self.reconnection_event.wait()
-
             # Create a channel using the context manager
             async with self.create_channel(queue_name) as channel:
                 queue = await RabbitmqUtils.get_queue(
@@ -341,106 +330,107 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         Main consume method that sets up all message handlers and scheduled actions with retry mechanisms.
         """
         # Establish initial connection
-        async with self.connect() as connection:
-            self.connection_healthy = True
-
-            # Start connection health monitoring
-            self.health_check_task = asyncio.create_task(
-                self._monitor_connection_health()
-            )
+        try:
+            async with self.connect() as connection:
+                self.connection_healthy = True
 
-            # Verify infrastructure with retry
-            infra_check_success = await retry_with_backoff(
-                self._verify_infrastructure,
-                retry_config=self.config.connection_retry_config,
-                retry_exceptions=(Exception,),
-            )
+                # Start connection health monitoring
+                self.health_check_task = asyncio.create_task(
+                    self._monitor_connection_health()
+                )
 
-            if not infra_check_success:
-                logger.critical(
-                    "Failed to verify RabbitMQ infrastructure. Shutting down."
+                # Verify infrastructure with retry
+                infra_check_success = await retry_with_backoff(
+                    self._verify_infrastructure,
+                    retry_config=self.config.connection_retry_config,
+                    retry_exceptions=(Exception,),
                 )
-                self.shutdown_event.set()
-                return
 
-            async def wait_for(
-                type: str, name: str, coroutine: Awaitable[bool]
-            ) -> tuple[str, str, bool]:
-                return type, name, await coroutine
+                if not infra_check_success:
+                    logger.critical(
+                        "Failed to verify RabbitMQ infrastructure. Shutting down."
+                    )
+                    self.shutdown_event.set()
+                    return
 
-            tasks: set[asyncio.Task[tuple[str, str, bool]]] = set()
+                async def wait_for(
+                    type: str, name: str, coroutine: Awaitable[bool]
+                ) -> tuple[str, str, bool]:
+                    return type, name, await coroutine
 
-            # Setup message handlers
-            for handler in self.message_handler_set:
-                queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
-                self.incoming_map[queue_name] = handler
+                tasks: set[asyncio.Task[tuple[str, str, bool]]] = set()
 
-                tasks.add(
-                    task := asyncio.create_task(
-                        wait_for(
-                            "message_handler",
-                            queue_name,
-                            self._setup_message_handler_consumer(handler),
-                        )
-                    )
-                )
+                # Setup message handlers
+                for handler in self.message_handler_set:
+                    queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
+                    self.incoming_map[queue_name] = handler
 
-            # Setup scheduled actions
-            for scheduled_action in self.scheduled_actions:
-                queue_name = f"{scheduled_action.callable.__module__}.{scheduled_action.callable.__qualname__}"
-                tasks.add(
-                    task := asyncio.create_task(
-                        wait_for(
-                            "scheduled_action",
-                            queue_name,
-                            self._setup_scheduled_action_consumer(scheduled_action),
+                    tasks.add(
+                        task := asyncio.create_task(
+                            wait_for(
+                                "message_handler",
+                                queue_name,
+                                self._setup_message_handler_consumer(handler),
+                            )
                         )
                     )
-                )
 
-            async def handle_task_results() -> None:
-                for task in asyncio.as_completed(tasks):
-                    type, name, success = await task
-                    if success:
-                        logger.info(f"Successfully set up {type} consumer for {name}")
-                    else:
-                        logger.warning(
-                            f"Failed to set up {type} consumer for {name}, will not process messages from this queue"
+                # Setup scheduled actions
+                for scheduled_action in self.scheduled_actions:
+                    queue_name = f"{scheduled_action.callable.__module__}.{scheduled_action.callable.__qualname__}"
+                    tasks.add(
+                        task := asyncio.create_task(
+                            wait_for(
+                                "scheduled_action",
+                                queue_name,
+                                self._setup_scheduled_action_consumer(scheduled_action),
+                            )
                         )
+                    )
 
-            handle_task_results_task = asyncio.create_task(handle_task_results())
-
-            # Wait for shutdown signal
-            await self.shutdown_event.wait()
-            logger.info("Shutdown event received, stopping consumers")
+                async def handle_task_results() -> None:
+                    for task in asyncio.as_completed(tasks):
+                        type, name, success = await task
+                        if success:
+                            logger.info(
+                                f"Successfully set up {type} consumer for {name}"
+                            )
+                        else:
+                            logger.warning(
+                                f"Failed to set up {type} consumer for {name}, will not process messages from this queue"
+                            )
 
-            # Cancel health monitoring
-            if self.health_check_task:
-                self.health_check_task.cancel()
-                with suppress(asyncio.CancelledError):
-                    await self.health_check_task
+                handle_task_results_task = asyncio.create_task(handle_task_results())
 
-            # Cancel reconnection task if running
-            if self.reconnection_task:
-                self.reconnection_task.cancel()
-                with suppress(asyncio.CancelledError):
-                    await self.reconnection_task
+                # Wait for shutdown signal
+                await self.shutdown_event.wait()
+                logger.info("Shutdown event received, stopping consumers")
 
-            handle_task_results_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await handle_task_results_task
-            for task in tasks:
-                if not task.done():
-                    task.cancel()
+                # Cancel health monitoring
+                if self.health_check_task:
+                    self.health_check_task.cancel()
                     with suppress(asyncio.CancelledError):
-                        await task
-            logger.info("Worker shutting down")
+                        await self.health_check_task
 
-            # Wait for all tasks to complete
-            await self.wait_all_tasks_done()
-
-            # Close all channels and the connection
-            await self.close_channels_and_connection()
+                handle_task_results_task.cancel()
+                with suppress(asyncio.CancelledError):
+                    await handle_task_results_task
+                for task in tasks:
+                    if not task.done():
+                        task.cancel()
+                        with suppress(asyncio.CancelledError):
+                            await task
+                logger.info("Worker shutting down")
+
+                # Wait for all tasks to complete
+                await self.wait_all_tasks_done()
+
+                # Close all channels and the connection
+                await self.close_channels_and_connection()
+        except Exception as e:
+            logger.critical(f"Failed to establish initial connection to RabbitMQ: {e}")
+            # Re-raise the exception so it can be caught by the caller
+            raise
 
     async def wait_all_tasks_done(self) -> None:
         if not self.tasks:
@@ -478,12 +468,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
             with suppress(asyncio.CancelledError):
                 await self.health_check_task
 
-        # Cancel reconnection task if running
-        if self.reconnection_task:
-            self.reconnection_task.cancel()
-            with suppress(asyncio.CancelledError):
-                await self.reconnection_task
-
         await self.wait_all_tasks_done()
         await self.close_channels_and_connection()
 
@@ -492,16 +476,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         Get the channel for a specific queue, or None if not found.
         This helps with error handling when a channel might have been closed.
         """
-        # If reconnection is in progress, wait for it to complete
-        if self.reconnection_in_progress:
-            try:
-                await asyncio.wait_for(self.reconnection_event.wait(), timeout=30.0)
-            except asyncio.TimeoutError:
-                logger.warning(
-                    f"Timeout waiting for reconnection when getting channel for {queue_name}"
-                )
-                return None
-
         if queue_name not in self.channels:
             logger.warning(f"No channel found for queue {queue_name}")
             return None
@@ -530,17 +504,17 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
                         logger.error(
                             f"Failed to recreate channel for {queue_name}: {e}"
                         )
-                        # Trigger reconnection if channel creation fails
+                        # Trigger shutdown if channel creation fails
                         self._trigger_reconnection()
                         return None
                 else:
-                    # Connection is not healthy, trigger reconnection
+                    # Connection is not healthy, trigger shutdown
                     self._trigger_reconnection()
                     return None
             return channel
         except Exception as e:
             logger.error(f"Error accessing channel for queue {queue_name}: {e}")
-            # Trigger reconnection on any channel access error
+            # Trigger shutdown on any channel access error
             self._trigger_reconnection()
             return None
 
@@ -691,33 +665,14 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
                         yield new_channel
                         return
                 else:
-                    # Connection is not healthy, wait for reconnection
-                    if self.reconnection_in_progress:
-                        try:
-                            await asyncio.wait_for(
-                                self.reconnection_event.wait(), timeout=30.0
-                            )
-                            # Retry after reconnection
-                            continue
-                        except asyncio.TimeoutError:
-                            logger.warning(
-                                f"Timeout waiting for reconnection for queue {queue_name}"
-                            )
-
-                    # Still no connection, trigger reconnection
-                    if not self.reconnection_in_progress:
-                        self._trigger_reconnection()
-
-                    if attempt < max_retries - 1:
-                        logger.info(
-                            f"Retrying channel access for {queue_name} in {retry_delay}s"
-                        )
-                        await asyncio.sleep(retry_delay)
-                        retry_delay *= 2
-                    else:
-                        raise RuntimeError(
-                            f"Cannot get channel for queue {queue_name}: no connection available after {max_retries} attempts"
-                        )
+                    # Connection is not healthy, trigger shutdown
+                    logger.error(
+                        f"Connection not healthy while getting channel for {queue_name}, triggering shutdown"
+                    )
+                    self._trigger_reconnection()
+                    raise RuntimeError(
+                        f"Cannot get channel for queue {queue_name}: connection is not healthy"
+                    )
 
             except Exception as e:
                 if attempt < max_retries - 1:
@@ -734,7 +689,7 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
     async def _monitor_connection_health(self) -> None:
         """
-        Monitor connection health and trigger reconnection if needed.
+        Monitor connection health and trigger shutdown if connection is lost.
         This runs as a background task.
         """
         while not self.shutdown_event.is_set():
@@ -746,11 +701,11 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
                 # Check connection health
                 if not await self._is_connection_healthy():
-                    logger.warning(
-                        "Connection health check failed, triggering reconnection"
+                    logger.error(
+                        "Connection health check failed, initiating worker shutdown"
                     )
-                    if not self.reconnection_in_progress:
-                        self._trigger_reconnection()
+                    self.shutdown()
+                    break
 
             except asyncio.CancelledError:
                 logger.info("Connection health monitoring cancelled")
@@ -778,74 +733,12 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
 
     def _trigger_reconnection(self) -> None:
         """
-        Trigger reconnection process.
+        Trigger worker shutdown due to connection loss.
         """
-        if not self.reconnection_in_progress and not self.shutdown_event.is_set():
-            self.reconnection_in_progress = True
+        if not self.shutdown_event.is_set():
+            logger.error("Connection lost, initiating worker shutdown")
             self.connection_healthy = False
-            self.reconnection_event.clear()
-
-            # Start reconnection task
-            self.reconnection_task = asyncio.create_task(self._handle_reconnection())
-            self.reconnection_task.add_done_callback(self._on_reconnection_done)
-
-    def _on_reconnection_done(self, task: asyncio.Task[Any]) -> None:
-        """
-        Handle completion of reconnection task.
-        """
-        self.reconnection_in_progress = False
-        if task.exception():
-            logger.error(f"Reconnection task failed: {task.exception()}")
-        else:
-            logger.info("Reconnection completed successfully")
-
-    async def _handle_reconnection(self) -> None:
-        """
-        Handle the reconnection process with exponential backoff.
-        """
-        logger.info("Starting reconnection process")
-
-        # Close existing connection and channels
-        await self._cleanup_connection()
-
-        reconnection_config = self.config.reconnection_backoff_config
-        attempt = 0
-
-        while not self.shutdown_event.is_set():
-            try:
-                attempt += 1
-                logger.info(f"Reconnection attempt {attempt}")
-
-                # Establish new connection
-                self.connection = await self._establish_connection()
-                self.connection_healthy = True
-
-                # Re-establish all consumers
-                await self._reestablish_consumers()
-
-                logger.info("Reconnection successful")
-                self.reconnection_event.set()
-                return
-
-            except Exception as e:
-                logger.error(f"Reconnection attempt {attempt} failed: {e}")
-
-                if self.shutdown_event.is_set():
-                    break
-
-                # Calculate backoff delay
-                delay = reconnection_config.initial_delay * (
-                    reconnection_config.backoff_factor ** (attempt - 1)
-                )
-                if reconnection_config.jitter:
-                    jitter_amount = delay * 0.25
-                    delay = delay + random.uniform(-jitter_amount, jitter_amount)
-                    delay = max(delay, 0.1)
-
-                delay = min(delay, reconnection_config.max_delay)
-
-                logger.info(f"Retrying reconnection in {delay:.2f} seconds")
-                await asyncio.sleep(delay)
+            self.shutdown()
 
     async def _cleanup_connection(self) -> None:
         """
@@ -889,32 +782,6 @@ class AioPikaMicroserviceConsumer(MessageBusConsumer):
         self.connection = None
         self.connection_healthy = False
 
-    async def _reestablish_consumers(self) -> None:
-        """
-        Re-establish all consumers after reconnection.
-        """
-        logger.info("Re-establishing consumers after reconnection")
-
-        # Re-establish message handlers
-        for handler in self.message_handler_set:
-            queue_name = f"{handler.message_type.MESSAGE_TOPIC}.{handler.instance_callable.__module__}.{handler.instance_callable.__qualname__}"
-            try:
-                await self._setup_message_handler_consumer(handler)
-                logger.info(f"Re-established consumer for {queue_name}")
-            except Exception as e:
-                logger.error(f"Failed to re-establish consumer for {queue_name}: {e}")
-
-        # Re-establish scheduled actions
-        for scheduled_action in self.scheduled_actions:
-            queue_name = f"{scheduled_action.callable.__module__}.{scheduled_action.callable.__qualname__}"
-            try:
-                await self._setup_scheduled_action_consumer(scheduled_action)
-                logger.info(f"Re-established scheduler consumer for {queue_name}")
-            except Exception as e:
-                logger.error(
-                    f"Failed to re-establish scheduler consumer for {queue_name}: {e}"
-                )
-
 
 def create_message_bus(
     broker_url: str,
@@ -1798,7 +1665,14 @@ class MessageBusWorker:
             loop.add_signal_handler(signal.SIGINT, on_shutdown, loop)
             # Add graceful shutdown handler for SIGTERM as well
             loop.add_signal_handler(signal.SIGTERM, on_shutdown, loop)
-            runner.run(self.start_async())
+            try:
+                runner.run(self.start_async())
+            except Exception as e:
+                logger.critical(f"Worker failed to start due to connection error: {e}")
+                # Exit with error code 1 to indicate startup failure
+                import sys
+
+                sys.exit(1)
 
     async def _graceful_shutdown(self) -> None:
         """Handles graceful shutdown process"""

{jararaca-0.3.15 → jararaca-0.3.17}/src/jararaca/tools/typescript/decorators.py

@@ -93,3 +93,49 @@ class SplitInputOutput:
         Check if the Pydantic model is marked for split interface generation.
         """
         return getattr(cls, SplitInputOutput.METADATA_KEY, False)
+
+
+class ExposeType:
+    """
+    Decorator to explicitly expose types for TypeScript interface generation.
+
+    Use this decorator to include types in the generated TypeScript output without
+    needing them as request/response bodies or indirect dependencies.
+
+    Example:
+        @ExposeType()
+        class UserRole(BaseModel):
+            id: str
+            name: str
+
+        # This ensures UserRole interface is generated even if it's not
+        # directly referenced in any REST endpoint
+    """
+
+    METADATA_KEY = "__jararaca_expose_type__"
+    _exposed_types: set[type] = set()
+
+    def __init__(self) -> None:
+        pass
+
+    def __call__(self, cls: type[BASEMODEL_T]) -> type[BASEMODEL_T]:
+        """
+        Decorate the type to mark it for explicit TypeScript generation.
+        """
+        setattr(cls, self.METADATA_KEY, True)
+        ExposeType._exposed_types.add(cls)
+        return cls
+
+    @staticmethod
+    def is_exposed_type(cls: type) -> bool:
+        """
+        Check if the type is marked for explicit exposure.
+        """
+        return getattr(cls, ExposeType.METADATA_KEY, False)
+
+    @staticmethod
+    def get_all_exposed_types() -> set[type]:
+        """
+        Get all types that have been marked for explicit exposure.
+        """
+        return ExposeType._exposed_types.copy()

{jararaca-0.3.15 → jararaca-0.3.17}/src/jararaca/tools/typescript/interface_parser.py

@@ -36,6 +36,7 @@ from jararaca.presentation.websocket.websocket_interceptor import (
     WebSocketMessageWrapper,
 )
 from jararaca.tools.typescript.decorators import (
+    ExposeType,
     MutationEndpoint,
     QueryEndpoint,
     SplitInputOutput,
@@ -661,6 +662,9 @@ def write_microservice_to_typescript_interface(
     websocket_registries: set[RegisterWebSocketMessage] = set()
     mapped_types_set.add(WebSocketMessageWrapper)
 
+    # Add all explicitly exposed types
+    mapped_types_set.update(ExposeType.get_all_exposed_types())
+
     for controller in microservice.controllers:
         rest_controller = RestController.get_controller(controller)