hexcore 2.0.6__tar.gz → 2.1.0__tar.gz

{hexcore-2.0.6/hexcore.egg-info → hexcore-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hexcore
-Version: 2.0.6
+Version: 2.1.0
 Summary: Núcleo reutilizable para proyectos Python con arquitectura hexagonal y event handling. Provee abstracciones, utilidades y contratos para DDD, eventos y desacoplamiento de infraestructura.
 Author-email: "David Latosefki (Indroic)" <indroic@outlook.com>
 License-Expression: MIT
@@ -18,6 +18,8 @@ Requires-Dist: redis>=6.4.0
 Requires-Dist: sqlalchemy>=2.0.43
 Requires-Dist: typer>=0.17.3
 Requires-Dist: ruff>=0.12.11
+Provides-Extra: procrastinate
+Requires-Dist: procrastinate>=3.0.0; extra == "procrastinate"
 Dynamic: license-file
 
 # HexCore [![PyPI Downloads](https://static.pepy.tech/personalized-badge/hexcore?period=total&units=INTERNATIONAL_SYSTEM&left_color=BLACK&right_color=GREEN&left_text=downloads)](https://pepy.tech/projects/hexcore)
@@ -264,6 +266,194 @@ Ambos repositorios utilizan `to_entity_from_model_or_document` para convertir mo
 
 ---
 
+---
+
+## Arquitectura CQRS en HexCore
+
+HexCore v2 integra de forma nativa soporte para el patrón **CQRS (Command Query Responsibility Segregation)**, permitiendo separar conceptual y técnicamente las operaciones de escritura (Commands) de las de lectura (Queries). 
+
+### ¿Cómo funciona el CQRS en HexCore?
+
+El sistema se basa en 3 buses principales, configurables e independientes:
+
+1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema y se ejecutan (por defecto) dentro de una transacción de base de datos (Unit of Work).
+2. **`AbstractQueryBus`**: Despacha intenciones de lectura (`Query`) a un único `AbstractQueryHandler`. Retornan un resultado sin mutar el estado.
+3. **`EventBus`**: Distribuye eventos de dominio (`DomainEvent`) a múltiples suscriptores asíncronamente (vía `subscribe`/`publish`).
+
+La configuración de CQRS se activa mediante el `CQRSConfig` en tu `ServerConfig`:
+
+```python
+from hexcore.config import ServerConfig
+from hexcore.application.cqrs.config import CQRSConfig, BusConfig
+
+config = ServerConfig(
+    cqrs=CQRSConfig(
+        command_bus=BusConfig(
+            # Por defecto incluye TransactionMiddleware
+            middlewares=["hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"]
+        ),
+        # Puedes sustituir el backend en memoria por uno distribuido (Ej: Celery, Procrastinate)
+        # backend="mi_app.infrastructure.ProcrastinateCommandBus" 
+    )
+)
+```
+
+---
+
+### Guía de Migración: De Casos de Uso Clásicos a CQRS
+
+Si ya tienes una aplicación escrita con la abstracción `UseCase` de HexCore, puedes migrar progresivamente a CQRS sin reescribir todo tu código, utilizando los adaptadores incluidos.
+
+#### Paso 1: Usar el adaptador `UseCaseCommandHandler`
+
+En lugar de instanciar un UseCase directamente en tu endpoint, envuélvelo en un comando:
+
+```python
+from hexcore.application.cqrs.adapters import UseCaseCommandHandler
+from hexcore.application.cqrs.registry import HandlerRegistry
+
+# 1. Tienes tu UseCase legado
+class CreateUserUseCase(UseCase[CreateUserCommand, UserDTO]):
+    async def execute(self, request: CreateUserCommand) -> UserDTO:
+        # logica legacy
+        pass
+
+# 2. Lo registras en el registry de CQRS utilizando el adaptador
+registry = HandlerRegistry()
+registry.register_command(
+    CreateUserCommand, 
+    UseCaseCommandHandler(CreateUserUseCase())
+)
+```
+
+#### Paso 2: Consumirlo desde el endpoint usando el CommandBus
+
+```python
+@router.post("/users")
+async def create_user(
+    cmd: CreateUserCommand, 
+    # factory inyectado por dependencias
+    bus: AbstractCommandBus = Depends(get_command_bus)
+):
+    # El bus despacha el comando al UseCase legacy de forma transparente
+    result = await bus.dispatch(cmd)
+    return result
+```
+
+#### Paso 3 (Final): Refactor a Handler Puro
+
+Cuando estés listo, convierte tu UseCase directamente en un `AbstractCommandHandler`:
+
+```python
+from hexcore.domain.cqrs import AbstractCommandHandler
+
+class CreateUserHandler(AbstractCommandHandler[CreateUserCommand, UserDTO]):
+    def __init__(self, uow: IUnitOfWork):
+        self.uow = uow
+
+    async def handle(self, command: CreateUserCommand) -> UserDTO:
+        # Lógica refactorizada
+        return dto
+```
+
+---
+
+### Guía: Almacenamiento Híbrido para Queries (Mongo, Redis, SQL)
+
+La mayor ventaja de CQRS es optimizar las lecturas. HexCore permite que tus **Commands** escriban en una base de datos relacional (SQLAlchemy) fuertemente normalizada, mientras que los **Queries** leen de vistas desnormalizadas súper rápidas en MongoDB o Redis.
+
+#### 1. Sincronización a través del EventBus (La Proyección)
+
+Cuando un Command modifica SQL, dispara un Evento de Dominio. Un handler de eventos intercepta este evento y actualiza el "Read Model" en MongoDB o Redis.
+
+```python
+from hexcore.domain.events import EventBus, DomainEvent
+
+class UserCreatedEvent(DomainEvent):
+    user_id: str
+    full_name: str
+    email: str
+
+async def project_user_to_mongodb(event: UserCreatedEvent):
+    """Proyecta el evento en la BD de lectura (MongoDB)"""
+    doc = UserReadDocument(
+        id=event.user_id, 
+        name=event.full_name, 
+        email=event.email
+    )
+    await doc.insert() # usando Beanie (Mongo)
+
+# Registrar la proyección
+event_bus.subscribe(UserCreatedEvent, project_user_to_mongodb)
+```
+
+#### 2. Query Handler leyendo del Read Model
+
+Tu QueryHandler nunca toca SQL, simplemente ataca directamente a Mongo o Redis para máxima velocidad.
+
+```python
+from hexcore.domain.cqrs import AbstractQueryHandler, Query
+
+class GetUserQuery(Query[UserReadDTO]):
+    user_id: str
+
+class GetUserQueryHandler(AbstractQueryHandler[GetUserQuery, UserReadDTO]):
+    async def handle(self, query: GetUserQuery) -> UserReadDTO:
+        # Consulta ultra rápida a la colección de lectura en MongoDB
+        doc = await UserReadDocument.get(query.user_id)
+        
+        # O desde Redis:
+        # data = await redis_client.get(f"user:{query.user_id}")
+        
+        if not doc:
+            raise UserNotFoundException()
+        return UserReadDTO(**doc.dict())
+```
+
+Con este esquema, alcanzas una alta escalabilidad: tus endpoints GET son despachados por el `QueryBus` respondiendo en milisegundos desde Mongo/Redis, y tus operaciones POST/PUT/DELETE van por el `CommandBus` transaccionando con ACID en SQL.
+
+#### 3. Definición de Modelos de Lectura (Proyecciones)
+
+Una pregunta frecuente es: **¿HexCore genera automáticamente estos modelos de lectura?** 
+La respuesta es **No**. El patrón CQRS sugiere que tus modelos de lectura estén diseñados *específicamente* para lo que tus interfaces visuales (UI) o APIs van a consultar. Por lo tanto, debes definir estos modelos manualmente.
+
+**Si usas MongoDB (Beanie) para lecturas:**
+Debes crear un documento manual optimizado. Por ejemplo, en lugar de tener joins, puedes embeber datos:
+```python
+from beanie import Document
+
+# Modelo desnormalizado optimizado para la lectura
+class UserReadDocument(Document):
+    id: str  # ID referenciado de la tabla SQL
+    name: str
+    email: str
+    total_purchases_cache: int = 0  # Dato pre-calculado por eventos
+
+    class Settings:
+        name = "users_read_projections"
+```
+
+**Si usas PostgreSQL/MySQL (SQLAlchemy) para lecturas:**
+Si prefieres mantenerte 100% en SQL pero aislando lecturas, puedes crear tablas específicas para proyecciones (Materialized Views o tablas planas):
+```python
+from sqlalchemy.orm import declarative_base
+from sqlalchemy import Column, String, Integer
+
+Base = declarative_base()
+
+class UserReadProjection(Base):
+    __tablename__ = 'users_read_projection'
+    
+    # Modelo totalmente plano sin relaciones ForeignKey complejas
+    id = Column(String, primary_key=True)
+    full_name = Column(String)
+    email = Column(String)
+    total_purchases_cache = Column(Integer, default=0)
+```
+En ambos casos, es tu **EventBus** (o un consumidor como Procrastinate) el encargado de instanciar estos modelos manuales y persistirlos cada vez que se detecte un cambio en los modelos de escritura.
+
+---
+
 ## Referencias
 
 - [CONTRIBUTING.md](./CONTRIBUTING.md): Pautas de colaboración.

{hexcore-2.0.6 → hexcore-2.1.0}/README.md

@@ -242,6 +242,194 @@ Ambos repositorios utilizan `to_entity_from_model_or_document` para convertir mo
 
 ---
 
+---
+
+## Arquitectura CQRS en HexCore
+
+HexCore v2 integra de forma nativa soporte para el patrón **CQRS (Command Query Responsibility Segregation)**, permitiendo separar conceptual y técnicamente las operaciones de escritura (Commands) de las de lectura (Queries). 
+
+### ¿Cómo funciona el CQRS en HexCore?
+
+El sistema se basa en 3 buses principales, configurables e independientes:
+
+1. **`AbstractCommandBus`**: Despacha inteniones de mutación (`Command`) a un único `AbstractCommandHandler`. Los commands modifican el estado del sistema y se ejecutan (por defecto) dentro de una transacción de base de datos (Unit of Work).
+2. **`AbstractQueryBus`**: Despacha intenciones de lectura (`Query`) a un único `AbstractQueryHandler`. Retornan un resultado sin mutar el estado.
+3. **`EventBus`**: Distribuye eventos de dominio (`DomainEvent`) a múltiples suscriptores asíncronamente (vía `subscribe`/`publish`).
+
+La configuración de CQRS se activa mediante el `CQRSConfig` en tu `ServerConfig`:
+
+```python
+from hexcore.config import ServerConfig
+from hexcore.application.cqrs.config import CQRSConfig, BusConfig
+
+config = ServerConfig(
+    cqrs=CQRSConfig(
+        command_bus=BusConfig(
+            # Por defecto incluye TransactionMiddleware
+            middlewares=["hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"]
+        ),
+        # Puedes sustituir el backend en memoria por uno distribuido (Ej: Celery, Procrastinate)
+        # backend="mi_app.infrastructure.ProcrastinateCommandBus" 
+    )
+)
+```
+
+---
+
+### Guía de Migración: De Casos de Uso Clásicos a CQRS
+
+Si ya tienes una aplicación escrita con la abstracción `UseCase` de HexCore, puedes migrar progresivamente a CQRS sin reescribir todo tu código, utilizando los adaptadores incluidos.
+
+#### Paso 1: Usar el adaptador `UseCaseCommandHandler`
+
+En lugar de instanciar un UseCase directamente en tu endpoint, envuélvelo en un comando:
+
+```python
+from hexcore.application.cqrs.adapters import UseCaseCommandHandler
+from hexcore.application.cqrs.registry import HandlerRegistry
+
+# 1. Tienes tu UseCase legado
+class CreateUserUseCase(UseCase[CreateUserCommand, UserDTO]):
+    async def execute(self, request: CreateUserCommand) -> UserDTO:
+        # logica legacy
+        pass
+
+# 2. Lo registras en el registry de CQRS utilizando el adaptador
+registry = HandlerRegistry()
+registry.register_command(
+    CreateUserCommand, 
+    UseCaseCommandHandler(CreateUserUseCase())
+)
+```
+
+#### Paso 2: Consumirlo desde el endpoint usando el CommandBus
+
+```python
+@router.post("/users")
+async def create_user(
+    cmd: CreateUserCommand, 
+    # factory inyectado por dependencias
+    bus: AbstractCommandBus = Depends(get_command_bus)
+):
+    # El bus despacha el comando al UseCase legacy de forma transparente
+    result = await bus.dispatch(cmd)
+    return result
+```
+
+#### Paso 3 (Final): Refactor a Handler Puro
+
+Cuando estés listo, convierte tu UseCase directamente en un `AbstractCommandHandler`:
+
+```python
+from hexcore.domain.cqrs import AbstractCommandHandler
+
+class CreateUserHandler(AbstractCommandHandler[CreateUserCommand, UserDTO]):
+    def __init__(self, uow: IUnitOfWork):
+        self.uow = uow
+
+    async def handle(self, command: CreateUserCommand) -> UserDTO:
+        # Lógica refactorizada
+        return dto
+```
+
+---
+
+### Guía: Almacenamiento Híbrido para Queries (Mongo, Redis, SQL)
+
+La mayor ventaja de CQRS es optimizar las lecturas. HexCore permite que tus **Commands** escriban en una base de datos relacional (SQLAlchemy) fuertemente normalizada, mientras que los **Queries** leen de vistas desnormalizadas súper rápidas en MongoDB o Redis.
+
+#### 1. Sincronización a través del EventBus (La Proyección)
+
+Cuando un Command modifica SQL, dispara un Evento de Dominio. Un handler de eventos intercepta este evento y actualiza el "Read Model" en MongoDB o Redis.
+
+```python
+from hexcore.domain.events import EventBus, DomainEvent
+
+class UserCreatedEvent(DomainEvent):
+    user_id: str
+    full_name: str
+    email: str
+
+async def project_user_to_mongodb(event: UserCreatedEvent):
+    """Proyecta el evento en la BD de lectura (MongoDB)"""
+    doc = UserReadDocument(
+        id=event.user_id, 
+        name=event.full_name, 
+        email=event.email
+    )
+    await doc.insert() # usando Beanie (Mongo)
+
+# Registrar la proyección
+event_bus.subscribe(UserCreatedEvent, project_user_to_mongodb)
+```
+
+#### 2. Query Handler leyendo del Read Model
+
+Tu QueryHandler nunca toca SQL, simplemente ataca directamente a Mongo o Redis para máxima velocidad.
+
+```python
+from hexcore.domain.cqrs import AbstractQueryHandler, Query
+
+class GetUserQuery(Query[UserReadDTO]):
+    user_id: str
+
+class GetUserQueryHandler(AbstractQueryHandler[GetUserQuery, UserReadDTO]):
+    async def handle(self, query: GetUserQuery) -> UserReadDTO:
+        # Consulta ultra rápida a la colección de lectura en MongoDB
+        doc = await UserReadDocument.get(query.user_id)
+        
+        # O desde Redis:
+        # data = await redis_client.get(f"user:{query.user_id}")
+        
+        if not doc:
+            raise UserNotFoundException()
+        return UserReadDTO(**doc.dict())
+```
+
+Con este esquema, alcanzas una alta escalabilidad: tus endpoints GET son despachados por el `QueryBus` respondiendo en milisegundos desde Mongo/Redis, y tus operaciones POST/PUT/DELETE van por el `CommandBus` transaccionando con ACID en SQL.
+
+#### 3. Definición de Modelos de Lectura (Proyecciones)
+
+Una pregunta frecuente es: **¿HexCore genera automáticamente estos modelos de lectura?** 
+La respuesta es **No**. El patrón CQRS sugiere que tus modelos de lectura estén diseñados *específicamente* para lo que tus interfaces visuales (UI) o APIs van a consultar. Por lo tanto, debes definir estos modelos manualmente.
+
+**Si usas MongoDB (Beanie) para lecturas:**
+Debes crear un documento manual optimizado. Por ejemplo, en lugar de tener joins, puedes embeber datos:
+```python
+from beanie import Document
+
+# Modelo desnormalizado optimizado para la lectura
+class UserReadDocument(Document):
+    id: str  # ID referenciado de la tabla SQL
+    name: str
+    email: str
+    total_purchases_cache: int = 0  # Dato pre-calculado por eventos
+
+    class Settings:
+        name = "users_read_projections"
+```
+
+**Si usas PostgreSQL/MySQL (SQLAlchemy) para lecturas:**
+Si prefieres mantenerte 100% en SQL pero aislando lecturas, puedes crear tablas específicas para proyecciones (Materialized Views o tablas planas):
+```python
+from sqlalchemy.orm import declarative_base
+from sqlalchemy import Column, String, Integer
+
+Base = declarative_base()
+
+class UserReadProjection(Base):
+    __tablename__ = 'users_read_projection'
+    
+    # Modelo totalmente plano sin relaciones ForeignKey complejas
+    id = Column(String, primary_key=True)
+    full_name = Column(String)
+    email = Column(String)
+    total_purchases_cache = Column(Integer, default=0)
+```
+En ambos casos, es tu **EventBus** (o un consumidor como Procrastinate) el encargado de instanciar estos modelos manuales y persistirlos cada vez que se detecte un cambio en los modelos de escritura.
+
+---
+
 ## Referencias
 
 - [CONTRIBUTING.md](./CONTRIBUTING.md): Pautas de colaboración.

hexcore-2.1.0/hexcore/application/cqrs/__init__.py

@@ -0,0 +1,24 @@
+"""
+hexcore.application.cqrs — Capa de aplicación CQRS.
+Registry, Pipeline, Buses In-Memory, Adaptadores y Factory.
+"""
+
+from .registry import HandlerRegistry
+from .config import CQRSConfig, BusConfig, MiddlewareConfig
+from .pipeline import MiddlewarePipeline
+from .in_memory_buses import InMemoryCommandBus, InMemoryQueryBus, InMemoryEventBus
+from .adapters import UseCaseCommandHandler
+from .factory import CQRSFactory
+
+__all__ = [
+    "HandlerRegistry",
+    "CQRSConfig",
+    "BusConfig",
+    "MiddlewareConfig",
+    "MiddlewarePipeline",
+    "InMemoryCommandBus",
+    "InMemoryQueryBus",
+    "InMemoryEventBus",
+    "UseCaseCommandHandler",
+    "CQRSFactory",
+]

hexcore-2.1.0/hexcore/application/cqrs/adapters.py

@@ -0,0 +1,33 @@
+"""
+Adaptadores de compatibilidad entre UseCase existente y el sistema CQRS.
+"""
+from __future__ import annotations
+
+import typing as t
+
+from hexcore.application.use_cases.base import UseCase
+from hexcore.domain.cqrs.handlers import ICommandHandler
+from hexcore.domain.cqrs.commands import Command
+
+
+T = t.TypeVar("T", bound=Command)
+R = t.TypeVar("R")
+
+
+class UseCaseCommandHandler(ICommandHandler[T, R]):
+    """
+    Adaptador que envuelve un UseCase existente como un ICommandHandler.
+    Permite migrar progresivamente sin reescribir use cases.
+
+    Uso::
+
+        existing_use_case = CreateUserUseCase(repository)
+        handler = UseCaseCommandHandler(existing_use_case)
+        registry.register_command_handler(CreateUserCommand, handler)
+    """
+
+    def __init__(self, use_case: UseCase[t.Any, R]) -> None:
+        self._use_case = use_case
+
+    async def handle(self, command: T) -> R:
+        return await self._use_case.execute(command)

hexcore-2.1.0/hexcore/application/cqrs/config.py

@@ -0,0 +1,69 @@
+"""
+Configuración declarativa de CQRS integrada en ServerConfig.
+"""
+from __future__ import annotations
+
+import typing as t
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class MiddlewareConfig(BaseModel):
+    """Configuración de un middleware individual."""
+
+    enabled: bool = True
+    order: int = 0  # Menor = se ejecuta primero
+    options: dict[str, t.Any] = Field(default_factory=dict)
+
+    model_config = ConfigDict(frozen=True)
+
+
+class BusConfig(BaseModel):
+    """Configuración de un bus individual (command, query o event)."""
+
+    # Clase del bus a instanciar (dotted path o referencia directa)
+    # Si es None, usa el bus in-memory por defecto
+    backend: t.Optional[str] = None
+    middlewares: list[str] = Field(default_factory=list)
+    options: dict[str, t.Any] = Field(default_factory=dict)
+
+    model_config = ConfigDict(frozen=True)
+
+
+class CQRSConfig(BaseModel):
+    """
+    Configuración global de CQRS para Hexcore.
+    Se integra como campo opcional en ServerConfig.
+
+    Ejemplo en config.py del proyecto::
+
+        from hexcore.config import ServerConfig
+        from hexcore.application.cqrs.config import CQRSConfig, BusConfig
+
+        config = ServerConfig(
+            cqrs=CQRSConfig(
+                command_bus=BusConfig(
+                    backend="hexcore.infrastructure.cqrs.procrastinate.ProcrastinateCommandBus",
+                    middlewares=[
+                        "hexcore.infrastructure.cqrs.middlewares.LoggingMiddleware",
+                        "hexcore.infrastructure.cqrs.middlewares.RetryMiddleware",
+                    ],
+                    options={"max_retries": 3},
+                ),
+            ),
+        )
+    """
+
+    enabled: bool = True
+    command_bus: BusConfig = Field(
+        default_factory=lambda: BusConfig(
+            middlewares=[
+                "hexcore.infrastructure.cqrs.middlewares.TransactionMiddleware"
+            ]
+        )
+    )
+    query_bus: BusConfig = Field(default_factory=BusConfig)
+    event_bus: BusConfig = Field(default_factory=BusConfig)
+    serializer: t.Optional[str] = None  # None = PydanticSerializer por defecto
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)

hexcore-2.1.0/hexcore/application/cqrs/factory.py

@@ -0,0 +1,131 @@
+"""
+Factory para construir buses CQRS a partir de la configuración.
+Resuelve backends, serializers y middlewares por dotted path.
+"""
+from __future__ import annotations
+
+import importlib
+import typing as t
+
+from hexcore.domain.cqrs.buses import ICommandBus, IQueryBus, IEventBus
+from hexcore.domain.cqrs.middleware import IMiddleware
+from hexcore.domain.cqrs.serializer import ISerializer
+
+from .config import CQRSConfig, BusConfig
+from .registry import HandlerRegistry
+from .pipeline import MiddlewarePipeline
+from .in_memory_buses import InMemoryCommandBus, InMemoryQueryBus, InMemoryEventBus
+
+
+def _import_class(dotted_path: str) -> type:
+    """Importa una clase a partir de su dotted path."""
+    module_path, class_name = dotted_path.rsplit(".", 1)
+    module = importlib.import_module(module_path)
+    return getattr(module, class_name)
+
+
+def _build_middlewares(dotted_paths: list[str]) -> list[IMiddleware]:
+    """Instancia middlewares a partir de sus dotted paths."""
+    middlewares: list[IMiddleware] = []
+    for path in dotted_paths:
+        cls = _import_class(path)
+        middlewares.append(cls())
+    return middlewares
+
+
+def _build_pipeline(bus_config: BusConfig) -> MiddlewarePipeline:
+    """Construye un MiddlewarePipeline desde la configuración de un bus."""
+    middlewares = _build_middlewares(bus_config.middlewares)
+    return MiddlewarePipeline(middlewares)
+
+
+class CQRSFactory:
+    """
+    Factory que construye las instancias de buses CQRS.
+
+    Usa CQRSConfig para determinar qué implementación de bus instanciar,
+    qué middlewares configurar y qué serializer utilizar.
+
+    Uso::
+
+        config = CQRSConfig(...)
+        registry = HandlerRegistry()
+        # ...registrar handlers...
+
+        factory = CQRSFactory(config, registry)
+        command_bus = factory.create_command_bus()
+        query_bus = factory.create_query_bus()
+    """
+
+    def __init__(
+        self,
+        config: CQRSConfig,
+        registry: HandlerRegistry,
+    ) -> None:
+        self._config = config
+        self._registry = registry
+
+    def create_serializer(self) -> ISerializer:
+        """Crea el serializer configurado (PydanticSerializer por defecto)."""
+        if self._config.serializer:
+            cls = _import_class(self._config.serializer)
+            return cls()
+        from hexcore.infrastructure.cqrs.pydantic_serializer import PydanticSerializer
+
+        return PydanticSerializer()
+
+    def create_command_bus(self, **extra_kwargs: t.Any) -> ICommandBus:
+        """
+        Crea el CommandBus configurado.
+        Si no hay backend explícito, retorna InMemoryCommandBus.
+        """
+        bus_config = self._config.command_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            return InMemoryCommandBus(
+                registry=self._registry,
+                pipeline=pipeline,
+            )
+
+        # Backend personalizado (ej. ProcrastinateCommandBus)
+        cls = _import_class(bus_config.backend)
+        return cls(
+            registry=self._registry,
+            serializer=self.create_serializer(),
+            pipeline=pipeline,
+            **bus_config.options,
+            **extra_kwargs,
+        )
+
+    def create_query_bus(self) -> IQueryBus:
+        """
+        Crea el QueryBus configurado.
+        Nota: Las queries siempre son síncronas en CQRS puro.
+        """
+        bus_config = self._config.query_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            return InMemoryQueryBus(
+                registry=self._registry,
+                pipeline=pipeline,
+            )
+
+        cls = _import_class(bus_config.backend)
+        return cls(
+            registry=self._registry,
+            pipeline=pipeline,
+            **bus_config.options,
+        )
+
+    def create_event_bus(self) -> IEventBus:
+        """Crea el EventBus configurado."""
+        bus_config = self._config.event_bus
+        pipeline = _build_pipeline(bus_config)
+
+        if bus_config.backend is None:
+            return InMemoryEventBus(pipeline=pipeline)
+
+        cls = _import_class(bus_config.backend)
+        return cls(pipeline=pipeline, **bus_config.options)