python-hexagonal 0.1.0__py3-none-any.whl

hexagonal/adapters/drivens/repository/sqlite/unit_of_work.py

@@ -0,0 +1,25 @@
+from typing import Optional
+
+from hexagonal.adapters.drivens.repository.base import BaseUnitOfWork
+from hexagonal.ports.drivens.repository import IBaseRepository
+
+from .datastore import SQLiteConnectionContextManager
+
+
+class SQLiteUnitOfWork(BaseUnitOfWork[SQLiteConnectionContextManager]):
+    def __init__(
+        self,
+        *repositories: IBaseRepository[SQLiteConnectionContextManager],
+        connection_manager: Optional[SQLiteConnectionContextManager] = None,
+    ):
+        if connection_manager is None:
+            connection_manager = SQLiteConnectionContextManager()
+        super().__init__(*repositories, connection_manager=connection_manager)
+
+    def commit(self) -> None:
+        self.verify()
+        return self.connection_manager.current_connection.commit()
+
+    def rollback(self) -> None:
+        self.verify()
+        return self.connection_manager.current_connection.rollback()

hexagonal/adapters/drivers/__init__.py

@@ -0,0 +1,5 @@
+from .app import ApplicationProxyAdapter
+
+__all__ = [
+    "ApplicationProxyAdapter",
+]

hexagonal/adapters/drivers/app.py

@@ -0,0 +1,38 @@
+from hexagonal.domain import CloudMessage, TCommand, TEvent
+from hexagonal.ports.drivens import TManager
+from hexagonal.ports.drivers import IBaseApplication, IBusApp
+
+
+class ApplicationProxyAdapter(IBaseApplication[TManager]):
+    def __init__(self, application: IBaseApplication[TManager]):
+        self._application = application
+
+    @property
+    def bus_app(self):
+        return self._application.bus_app
+
+    @property
+    def bus_infrastructure(self):
+        return self._application.bus_infrastructure
+
+    @property
+    def command_bus(self):
+        return self._application.command_bus
+
+    @property
+    def query_bus(self):
+        return self._application.query_bus
+
+    @property
+    def event_bus(self):
+        return self._application.event_bus
+
+    def bootstrap(self, bus_app: IBusApp[TManager]) -> None:
+        self._application.bootstrap(bus_app)
+
+    def dispatch_and_wait_events(
+        self,
+        command: CloudMessage[TCommand],
+        *event_types: type[TEvent],
+    ) -> dict[type[TEvent], TEvent | None]:
+        return self._application.dispatch_and_wait_events(command, *event_types)

hexagonal/application/__init__.py

@@ -0,0 +1,29 @@
+from .api import BaseAPI, GetEvent
+from .app import Application
+from .bus_app import BusAppGroup, ComposableBusApp
+from .handlers import CommandHandler, EventHandler, MessageHandler, QueryHandler
+from .infrastructure import (
+    ComposableInfrastructure,
+    Infrastructure,
+    InfrastructureGroup,
+)
+from .query import AggregateView, GetById, GetByIdHandler, SearchAggregateRepository
+
+__all__ = [
+    "BaseAPI",
+    "GetEvent",
+    "Application",
+    "ComposableBusApp",
+    "BusAppGroup",
+    "CommandHandler",
+    "EventHandler",
+    "MessageHandler",
+    "QueryHandler",
+    "ComposableInfrastructure",
+    "Infrastructure",
+    "InfrastructureGroup",
+    "GetById",
+    "SearchAggregateRepository",
+    "AggregateView",
+    "GetByIdHandler",
+]

hexagonal/application/api.py

@@ -0,0 +1,61 @@
+# mypy: disable-error-code="misc"
+from typing import Any, Dict, Generic, List, Optional, Tuple, Type, TypeVar
+from uuid import UUID
+
+from hexagonal.domain import CloudMessage, Query, TCommand, TEvento
+from hexagonal.ports.drivens import TAggregate
+from hexagonal.ports.drivers import IBaseApplication
+
+from .app import GetEvent
+from .query import AggregateView
+
+TBaseApp = TypeVar("TBaseApp", bound=IBaseApplication[Any])
+
+
+class BaseAPI(Generic[TBaseApp]):
+    def __init__(self, app: TBaseApp):
+        self._app = app
+
+    @property
+    def app(self) -> TBaseApp:
+        return self._app
+
+    def _dispatch_command(
+        self,
+        command: TCommand,
+        *,
+        events: Optional[List[Type[TEvento]]] = None,
+        default_events: Optional[List[Type[TEvento]]] = None,
+        to_outbox: bool = False,
+        **kwargs: Any,
+    ) -> Tuple[CloudMessage[TCommand], Dict[Type[TEvento], TEvento | None]]:
+        """Dispatch a command and optionally await events before returning."""
+        cloud_message = CloudMessage[type(command)].new(command, **kwargs)
+        if to_outbox:
+            self.app.command_bus.dispatch(cloud_message, to_outbox=to_outbox)
+            return cloud_message, {}
+        tracked_events: set[Type[TEvento]] = set()
+        if events is not None:
+            for e in events:
+                tracked_events.add(e)
+        if default_events is not None:
+            for e in default_events:
+                tracked_events.add(e)
+        awaited: Dict[Type[TEvento], GetEvent[TEvento]] = {}
+        for e in tracked_events:
+            handler = GetEvent[e]()  # type: ignore
+            self.app.event_bus.wait_for_publish(e, handler)
+            awaited[e] = handler
+        self.app.command_bus.dispatch(cloud_message)
+        return cloud_message, {
+            event: wrapper.event for event, wrapper in awaited.items()
+        }
+
+    def _get_aggregate(
+        self,
+        id: UUID,
+        query_type: Type[Query[AggregateView[TAggregate]]],
+        **kwargs: Any,
+    ) -> TAggregate:
+        query = query_type.new(id, **kwargs)
+        return self.app.query_bus.get(query, one=True).item.value

hexagonal/application/app.py

@@ -0,0 +1,76 @@
+from typing import Dict, Generic, Type
+
+from hexagonal.domain import CloudMessage, TCommand, TEvent
+from hexagonal.ports.drivens import (
+    IBusInfrastructure,
+    ICommandBus,
+    IEventBus,
+    IQueryBus,
+    TManager,
+)
+from hexagonal.ports.drivers import IBaseApplication, IBusApp
+
+
+class GetEvent(Generic[TEvent]):
+    event: TEvent | None = None
+
+    def __init__(self):
+        self.event = None
+
+    def __call__(self, event: TEvent):
+        self.event = event
+
+
+class Application(IBaseApplication[TManager]):
+    def __init__(
+        self,
+        bus_app: IBusApp[TManager],
+        bus_infrastructure: IBusInfrastructure[TManager],
+    ):
+        bus_infrastructure.verify()
+        self._bus_infrastructure = bus_infrastructure
+        self._bus_app = bus_app
+        self._bus_app.uow.attach_repo(self.event_bus.inbox_repository)
+        self._bus_app.uow.attach_repo(self.event_bus.outbox_repository)
+        self._bus_app.uow.attach_repo(self.command_bus.inbox_repository)
+        self._bus_app.uow.attach_repo(self.command_bus.outbox_repository)
+        self.bootstrap(self._bus_app)
+
+    @property
+    def bus_app(self) -> IBusApp[TManager]:
+        return self._bus_app
+
+    @property
+    def bus_infrastructure(self) -> IBusInfrastructure[TManager]:
+        return self._bus_infrastructure
+
+    @property
+    def command_bus(self) -> ICommandBus[TManager]:
+        return self._bus_infrastructure.command_bus
+
+    @property
+    def query_bus(self) -> IQueryBus[TManager]:
+        return self._bus_infrastructure.query_bus
+
+    @property
+    def event_bus(self) -> IEventBus[TManager]:
+        return self._bus_infrastructure.event_bus
+
+    def bootstrap(self, bus_app: IBusApp[TManager]) -> None:
+        bus_app.bootstrap(
+            command_bus=self.command_bus,
+            query_bus=self.query_bus,
+            event_bus=self.event_bus,
+        )
+
+    def dispatch_and_wait_events(
+        self,
+        command: CloudMessage[TCommand],
+        *event_types: Type[TEvent],
+    ) -> Dict[Type[TEvent], TEvent | None]:
+        handlers = [(event_type, GetEvent[event_type]()) for event_type in event_types]  # type: ignore
+        # type: ignore
+        for event_type, handler in handlers:
+            self.event_bus.wait_for_publish(event_type, handler)
+        self.command_bus.dispatch(command)
+        return {event_type: handler.event for event_type, handler in handlers}

hexagonal/application/bus_app.py

@@ -0,0 +1,70 @@
+import logging
+
+from hexagonal.ports.drivens import (
+    ICommandBus,
+    IEventBus,
+    IQueryBus,
+    IUnitOfWork,
+    TManager,
+)
+from hexagonal.ports.drivers import IBusApp
+
+logger = logging.getLogger(__name__)
+
+
+class ComposableBusApp(IBusApp[TManager]):
+    def __init__(self, bus_app: IBusApp[TManager]):
+        super().__init__()
+        self._bus_app = bus_app
+
+    def bootstrap(
+        self,
+        command_bus: ICommandBus[TManager],
+        query_bus: IQueryBus[TManager],
+        event_bus: IEventBus[TManager],
+    ) -> None:
+        self._bus_app.bootstrap(command_bus, query_bus, event_bus)
+
+    @property
+    def uow(self) -> IUnitOfWork[TManager]:
+        return self._bus_app.uow
+
+    def __or__(self, other: IBusApp[TManager]) -> "ComposableBusApp[TManager]":
+        other_is_root = other.bus_apps if isinstance(other, BusAppGroup) else [other]
+
+        self_is_root = self.bus_apps if isinstance(self, BusAppGroup) else [self]
+        return BusAppGroup(self.uow, *self_is_root, *other_is_root)
+
+    def __add__(self, other: IBusApp[TManager]) -> "ComposableBusApp[TManager]":
+        return self.__or__(other)
+
+    def __and__(self, other: IBusApp[TManager]) -> "ComposableBusApp[TManager]":
+        return BusAppGroup(self.uow, self, other)
+
+
+class BusAppGroup(ComposableBusApp[TManager]):
+    def __init__(
+        self,
+        uow: IUnitOfWork[TManager],
+        bus_app: IBusApp[TManager],
+        *bus_apps: IBusApp[TManager],
+    ):
+        self._bus_apps = [bus_app, *bus_apps]
+        self._uow = uow
+
+    @property
+    def uow(self) -> IUnitOfWork[TManager]:
+        return self._uow
+
+    @property
+    def bus_apps(self) -> list[IBusApp[TManager]]:
+        return self._bus_apps
+
+    def bootstrap(
+        self,
+        command_bus: ICommandBus[TManager],
+        query_bus: IQueryBus[TManager],
+        event_bus: IEventBus[TManager],
+    ) -> None:
+        for bus_app in self._bus_apps:
+            bus_app.bootstrap(command_bus, query_bus, event_bus)

hexagonal/application/handlers.py

@@ -0,0 +1,107 @@
+import logging
+from typing import Any, Iterable
+
+from hexagonal.domain import (
+    CloudMessage,
+    QueryResults,
+    TCommand,
+    TEvent,
+    TEvento,
+    TMessagePayloadType,
+    TQuery,
+    TView,
+)
+from hexagonal.ports.drivens import (
+    IBaseRepository,
+    IEventBus,
+    IMessageHandler,
+    IQueryHandler,
+    ISearchRepository,
+    IUnitOfWork,
+    IUseCase,
+    TManager,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class MessageHandler(IMessageHandler[TMessagePayloadType]):
+    event_bus: IEventBus[Any]
+    uow: IUnitOfWork[Any]
+
+    def __init__(
+        self,
+        event_bus: IEventBus[TManager],
+        uow: IUnitOfWork[TManager],
+        *repositories: IBaseRepository[TManager],
+    ) -> None:
+        self.event_bus = event_bus
+        self.uow = uow
+        for repository in repositories:
+            self.uow.attach_repo(repository)
+
+    def handle_message(self, message: CloudMessage[TMessagePayloadType]) -> None:
+        use_case = self.get_use_case(message.payload)
+        with self.uow:
+            events = use_case.execute()
+            if not events:
+                return
+            messages = [message.derive(event, **message.metadata) for event in events]
+            self.event_bus.outbox_repository.save(*messages)
+        return self.event_bus.publish_from_outbox()
+
+
+class EventHandler(MessageHandler[TEvent]):
+    class UseCaseImpl(IUseCase):
+        def __init__(
+            self, event_handler: "EventHandler[TEvent]", event: TEvent
+        ) -> None:
+            self.event_handler = event_handler
+            self.event = event
+
+        def execute(self):
+            evento = self.event_handler.handle(self.event)
+            return evento
+
+    def handle(self, event: TEvent) -> Iterable[TEvento]:
+        return []
+
+    def get_use_case(self, message: TEvent) -> IUseCase:
+        return self.UseCaseImpl(self, message)
+
+
+class CommandHandler(MessageHandler[TCommand]):
+    def execute(self, command: TCommand) -> Iterable[TEvento]:
+        return []
+
+    class UseCaseImpl(IUseCase):
+        def __init__(
+            self, event_handler: "CommandHandler[TCommand]", event: TCommand
+        ) -> None:
+            self.event_handler = event_handler
+            self.event = event
+
+        def execute(self):
+            evento = self.event_handler.execute(self.event)
+            return evento
+
+    def get_use_case(self, message: TCommand) -> IUseCase:
+        return self.UseCaseImpl(self, message)
+
+
+class QueryHandler(IQueryHandler[TManager, TQuery, TView]):
+    def __init__(
+        self,
+        repository: ISearchRepository[TManager, TQuery, TView],
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        self._repository = repository
+
+    @property
+    def repository(self) -> ISearchRepository[TManager, TQuery, TView]:
+        return self._repository
+
+    def get(self, query: TQuery) -> QueryResults[TView]:
+        results = self.repository.search(query)
+        return QueryResults[TView].new(items=results, limit=len(results))

hexagonal/application/infrastructure.py

@@ -0,0 +1,64 @@
+from logging import getLogger
+from typing import Mapping
+
+from hexagonal.ports.drivens import IBaseInfrastructure
+
+logger = getLogger(__name__)
+
+
+class ComposableInfrastructure(IBaseInfrastructure):
+    def __init__(self, infrastructure: IBaseInfrastructure):
+        self.infrastructure = infrastructure
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self.infrastructure.initialize(env)
+
+    @property
+    def initialized(self) -> bool:
+        return self.infrastructure.initialized
+
+    def __or__(self, other: IBaseInfrastructure) -> "ComposableInfrastructure":
+        other_is_root = (
+            other.infrastructures if isinstance(other, InfrastructureGroup) else [other]
+        )
+
+        self_is_root = (
+            self.infrastructures if isinstance(self, InfrastructureGroup) else [self]
+        )
+        return InfrastructureGroup(*self_is_root, *other_is_root)
+
+    def __add__(self, other: IBaseInfrastructure) -> "ComposableInfrastructure":
+        return self.__or__(other)
+
+    def __and__(self, other: IBaseInfrastructure) -> "ComposableInfrastructure":
+        return InfrastructureGroup(self, other)
+
+
+class InfrastructureGroup(ComposableInfrastructure):
+    def __init__(self, *infrastructures: IBaseInfrastructure):
+        self.infrastructures = list(infrastructures)
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        for infrastructure in self.infrastructures:
+            if infrastructure.initialized:
+                continue
+            infrastructure.initialize(env)
+
+    @property
+    def initialized(self) -> bool:
+        return all(
+            infrastructure.initialized for infrastructure in self.infrastructures
+        )
+
+
+class Infrastructure(ComposableInfrastructure):
+    def __init__(self):
+        self._initialized = False
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        logger.debug(f"Initializing {self.__class__.__name__}")
+        self._initialized = True
+
+    @property
+    def initialized(self) -> bool:
+        return self._initialized

hexagonal/application/query.py

@@ -0,0 +1,71 @@
+from typing import Any, Generic, List, Mapping, Type
+
+from hexagonal.application.handlers import QueryHandler
+from hexagonal.domain import Query, TIdEntity, ValueObject
+from hexagonal.ports.drivens import (
+    IAggregateRepository,
+    ISearchRepository,
+    TAggregate,
+    TManager,
+)
+from hexagonal.ports.drivens.repository import IUnitOfWork
+
+
+class AggregateView(ValueObject[TAggregate]): ...
+
+
+class GetById(Query[AggregateView[TAggregate]], Generic[TAggregate, TIdEntity]):
+    id: TIdEntity
+
+    @classmethod
+    def new(cls, id: TIdEntity, agg_type: Type[TAggregate], *_: Any, **__: Any):
+        return cls(id=id, view=AggregateView[agg_type])  # type: ignore
+
+
+class SearchAggregateRepository(
+    ISearchRepository[
+        TManager,
+        GetById[TAggregate, TIdEntity],
+        AggregateView[TAggregate],
+    ],
+    Generic[TManager, TAggregate, TIdEntity],
+):
+    def __init__(self, repo: IAggregateRepository[TManager, TAggregate, TIdEntity]):
+        self._repo = repo
+
+    def search(
+        self, query: GetById[TAggregate, TIdEntity]
+    ) -> List[AggregateView[TAggregate]]:
+        aggregate = self._repo.get(query.id)
+        return [AggregateView[TAggregate].new(aggregate)]
+
+    ## decorate methods from IAggregateRepository to pass through initialization ##
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self._repo.initialize(env)
+
+    @property
+    def initialized(self):
+        return self._repo.initialized
+
+    @property
+    def connection_manager(self) -> TManager:
+        return self._repo.connection_manager
+
+    def attach_to_unit_of_work(self, uow: IUnitOfWork[TManager]) -> None:
+        self._repo.attach_to_unit_of_work(uow)
+
+    def detach_from_unit_of_work(self) -> None:
+        self._repo.detach_from_unit_of_work()
+
+
+class GetByIdHandler(
+    QueryHandler[
+        TManager,
+        GetById[TAggregate, TIdEntity],
+        AggregateView[TAggregate],
+    ],
+    Generic[TManager, TAggregate, TIdEntity],
+):
+    def __init__(self, agg_repo: IAggregateRepository[TManager, TAggregate, TIdEntity]):
+        search = SearchAggregateRepository(agg_repo)
+        super().__init__(search)

hexagonal/domain/__init__.py

@@ -0,0 +1,77 @@
+from .aggregate import (
+    AggregateRoot,
+    AggregateSnapshot,
+    IdValueObject,
+    SnapshotState,
+    TIdEntity,
+    command,
+)
+from .base import (
+    CloudMessage,
+    Command,
+    DomainEvent,
+    FactoryMethod,
+    HasTopic,
+    Inmutable,
+    IntegrationEvent,
+    Message,
+    Query,
+    QueryResult,
+    QueryResults,
+    TCommand,
+    TEvent,
+    TEvento,
+    TMessage,
+    TMessagePayload,
+    TMessagePayloadType,
+    TQuery,
+    TView,
+    ValueObject,
+)
+from .exceptions import (
+    AggregateNotFound,
+    AggregateVersionMismatch,
+    DomainException,
+    DomainValueError,
+    HandlerAlreadyRegistered,
+    HandlerNotFound,
+    HandlerNotRegistered,
+    InfrastructureNotInitialized,
+)
+
+__all__ = [
+    "AggregateRoot",
+    "AggregateSnapshot",
+    "IdValueObject",
+    "command",
+    "TIdEntity",
+    "CloudMessage",
+    "Command",
+    "DomainEvent",
+    "Message",
+    "FactoryMethod",
+    "HasTopic",
+    "IntegrationEvent",
+    "Inmutable",
+    "ValueObject",
+    "TCommand",
+    "TEvent",
+    "TEvento",
+    "TView",
+    "TMessage",
+    "TMessagePayload",
+    "TMessagePayloadType",
+    "Query",
+    "QueryResult",
+    "QueryResults",
+    "TQuery",
+    "DomainException",
+    "DomainValueError",
+    "AggregateNotFound",
+    "AggregateVersionMismatch",
+    "HandlerAlreadyRegistered",
+    "HandlerNotFound",
+    "InfrastructureNotInitialized",
+    "HandlerNotRegistered",
+    "SnapshotState",
+]