python-hexagonal 0.1.0__py3-none-any.whl

hexagonal/adapters/drivens/mappers.py

@@ -0,0 +1,127 @@
+from dataclasses import dataclass
+from typing import Any, Hashable, cast
+from uuid import UUID
+
+import orjson
+from eventsourcing.domain import DomainEventProtocol
+from eventsourcing.persistence import (
+    Mapper,
+    MapperDeserialisationError,
+    StoredEvent,
+    Transcoder,
+    find_id_convertor,
+)
+from eventsourcing.utils import get_topic, resolve_topic
+
+from hexagonal.domain import (
+    CloudMessage,
+    Command,
+    DomainEvent,
+    IntegrationEvent,
+)
+from hexagonal.domain.aggregate import AggregateSnapshot
+from hexagonal.domain.base import Inmutable
+
+
+@dataclass
+class StoredMessage:
+    topic: str
+    state: bytes
+
+
+TMessage = Command | DomainEvent | IntegrationEvent | CloudMessage[Any]
+
+
+class MessageMapper(Mapper[UUID]):
+    def to_stored_event(self, domain_event: DomainEventProtocol[UUID]) -> StoredEvent:
+        """Converts the given domain event to a :class:`StoredEvent` object."""
+        topic = get_topic(domain_event.__class__)
+        event_state = (
+            domain_event.model_dump(mode="json")
+            if isinstance(domain_event, Inmutable)
+            else domain_event.__dict__.copy()
+        )
+        originator_id = event_state.pop("originator_id")
+        originator_version = event_state.pop("originator_version")
+        class_version = getattr(type(domain_event), "class_version", 1)
+        if class_version > 1:
+            event_state["class_version"] = class_version
+        stored_state = self.transcoder.encode(event_state)
+        if self.compressor:
+            stored_state = self.compressor.compress(stored_state)
+        if self.cipher:
+            stored_state = self.cipher.encrypt(stored_state)
+        return StoredEvent(
+            originator_id=originator_id,
+            originator_version=originator_version,
+            topic=topic,
+            state=stored_state,
+        )
+
+    def to_domain_event(self, stored_event: StoredEvent) -> DomainEventProtocol[UUID]:
+        """Converts the given :class:`StoredEvent` to a domain event object."""
+        cls = resolve_topic(stored_event.topic)
+
+        stored_state = stored_event.state
+        try:
+            if self.cipher:
+                stored_state = self.cipher.decrypt(stored_state)
+            if self.compressor:
+                stored_state = self.compressor.decompress(stored_state)
+            event_state: dict[str, Any] = self.transcoder.decode(stored_state)
+        except Exception as e:
+            msg = (
+                f"Failed to deserialise state of stored event with "
+                f"topic '{stored_event.topic}', "
+                f"originator_id '{stored_event.originator_id}' and "
+                f"originator_version {stored_event.originator_version}: {e}"
+            )
+            raise MapperDeserialisationError(msg) from e
+
+        id_convertor = find_id_convertor(
+            cls, cast(Hashable, type(stored_event.originator_id))
+        )
+        # print("ID of convertor:", id(convertor))
+        event_state["originator_id"] = id_convertor(stored_event.originator_id)
+        event_state["originator_version"] = stored_event.originator_version
+        class_version = getattr(cls, "class_version", 1)
+        from_version = event_state.pop("class_version", 1)
+        while from_version < class_version:
+            getattr(cls, f"upcast_v{from_version}_v{from_version + 1}")(event_state)
+            from_version += 1
+        if issubclass(cls, AggregateSnapshot):
+            return cls.model_validate(event_state)  # type: ignore[return-value]
+        domain_event = object.__new__(cls)
+        domain_event.__dict__.update(event_state)
+        return domain_event
+
+    def to_stored_message(self, message: TMessage) -> StoredMessage:
+        topic = get_topic(message.__class__)
+        event_state = message.model_dump(mode="json")
+        stored_state = self.transcoder.encode(event_state)
+        if self.compressor:
+            stored_state = self.compressor.compress(stored_state)
+        if self.cipher:
+            stored_state = self.cipher.encrypt(stored_state)
+        return StoredMessage(
+            topic=topic,
+            state=stored_state,
+        )
+
+    def to_message(self, stored_message: StoredMessage) -> TMessage:
+        stored_state = stored_message.state
+        if self.cipher:
+            stored_state = self.cipher.decrypt(stored_state)
+        if self.compressor:
+            stored_state = self.compressor.decompress(stored_state)
+        event_state: dict[str, Any] = self.transcoder.decode(stored_state)
+        cls = cast(TMessage, resolve_topic(stored_message.topic))
+        return cls.model_validate(event_state)
+
+
+class OrjsonTranscoder(Transcoder):
+    def encode(self, obj: Any) -> bytes:
+        return orjson.dumps(obj)
+
+    def decode(self, data: bytes) -> Any:
+        return orjson.loads(data)

hexagonal/adapters/drivens/repository/base/__init__.py

@@ -0,0 +1,13 @@
+from .repository import (
+    BaseAggregateRepositoryAdapter,
+    BaseRepositoryAdapter,
+    TAggregate,
+)
+from .unit_of_work import BaseUnitOfWork
+
+__all__ = [
+    "BaseRepositoryAdapter",
+    "BaseAggregateRepositoryAdapter",
+    "BaseUnitOfWork",
+    "TAggregate",
+]

hexagonal/adapters/drivens/repository/base/repository.py

@@ -0,0 +1,85 @@
+# pyright: reportMissingTypeStubs=false, reportUnknownArgumentType=false, reportMissingParameterType=none, reportGeneralTypeIssues=none
+
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    Mapping,
+    Type,
+    TypeVar,
+    get_args,
+    get_origin,
+)
+from uuid import UUID
+
+from eventsourcing.persistence import Mapper
+from eventsourcing.utils import Environment
+
+from hexagonal.application import Infrastructure
+from hexagonal.domain import AggregateRoot, TIdEntity
+from hexagonal.ports.drivens import (
+    IAggregateRepository,
+    IBaseRepository,
+    IUnitOfWork,
+    TManager,
+)
+
+TAggregate = TypeVar("TAggregate", bound=AggregateRoot[Any, Any])
+
+
+class BaseRepositoryAdapter(IBaseRepository[TManager], Infrastructure):
+    ENV: ClassVar[Dict[str, str]] = {}
+    NAME: ClassVar[str | None] = None
+
+    def __init__(self, connection_manager: TManager):
+        super().__init__()
+        self._connection_manager = connection_manager
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        env2 = self.ENV.copy()
+        name = self.NAME or self.__class__.__name__.upper()
+        env2.update(env)
+        self.env = Environment(name, env2)
+        self._attached_to_uow = False
+        self._manager_at_uow: TManager | None = None
+        super().initialize(self.env)
+
+    def attach_to_unit_of_work(self, uow: IUnitOfWork[TManager]) -> None:
+        self._attached_to_uow = True
+        self._manager_at_uow = uow.connection_manager
+
+    def detach_from_unit_of_work(self) -> None:
+        self._attached_to_uow = False
+        self._manager_at_uow = None
+
+    @property
+    def connection_manager(self) -> TManager:
+        if self._attached_to_uow and self._manager_at_uow is not None:
+            return self._manager_at_uow
+        return self._connection_manager
+
+
+class BaseAggregateRepositoryAdapter(
+    BaseRepositoryAdapter[TManager],
+    IAggregateRepository[TManager, TAggregate, TIdEntity],
+):
+    _type_of_aggregate: Type[TAggregate]
+
+    def __init_subclass__(cls) -> None:
+        super().__init_subclass__()
+        # Inspect generic base to find the concrete type argument
+        for base in getattr(cls, "__orig_bases__", []):
+            origin = get_origin(base)
+            if origin and issubclass(origin, BaseAggregateRepositoryAdapter):
+                args = get_args(base)
+                if args:
+                    cls._type_of_aggregate = args[0]
+                    cls.NAME = cls._type_of_aggregate.__name__.upper()
+
+    def __init__(self, mapper: Mapper[UUID], connection_manager: TManager):
+        super().__init__(connection_manager)
+        self._mapper = mapper
+
+    @property
+    def aggregate_name(self) -> str:
+        return self._type_of_aggregate.__name__

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

@@ -0,0 +1,75 @@
+from typing import Mapping
+
+from eventsourcing.utils import get_topic
+
+from hexagonal.application import InfrastructureGroup
+from hexagonal.ports.drivens import IBaseRepository, IUnitOfWork, TManager
+
+
+class BaseUnitOfWork(IUnitOfWork[TManager], InfrastructureGroup):
+    def __init__(
+        self,
+        *repositories: IBaseRepository[TManager],
+        connection_manager: TManager,
+    ):
+        self._repositories = {get_topic(repo.__class__): repo for repo in repositories}
+        self._initialized = False
+        self._manager = connection_manager
+        super().__init__(self._manager, *repositories)
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        self._initialized = True
+        self._active = False
+        return super().initialize(env)
+
+    @property
+    def initialized(self) -> bool:
+        return self._initialized and super().initialized
+
+    def attach_repo(self, repo: IBaseRepository[TManager]):
+        topic = get_topic(repo.__class__)
+        if topic in self._repositories:
+            return
+
+        self._repositories[topic] = repo
+        if self.initialized and self._active:
+            repo.attach_to_unit_of_work(self)
+
+    def detach_repo(self, repo: IBaseRepository[TManager]) -> None:
+        topic = get_topic(repo.__class__)
+        if topic not in self._repositories:
+            return
+
+        if self.initialized and self._active:
+            repo.detach_from_unit_of_work()
+        del self._repositories[topic]
+
+    @property
+    def connection_manager(self):
+        return self._manager
+
+    def __enter__(self):
+        self.verify()
+        if self._active:
+            return self
+        # get connection from manager, the connection is entered yet
+        self._ctx = self._manager.start_connection()
+        for repo in self._repositories.values():
+            repo.attach_to_unit_of_work(self)
+        self._active = True
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):  # type: ignore
+        self._active = False
+        try:
+            if exc_type is None:
+                self.commit()
+            else:
+                self.rollback()
+        except Exception as e:
+            # Log or handle commit/rollback errors
+            raise RuntimeError(f"Failed to finalize transaction: {e}") from e
+        finally:
+            for repo in self._repositories.values():
+                repo.detach_from_unit_of_work()
+            self._ctx.__exit__(exc_type, exc_val, exc_tb)  # type: ignore

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

@@ -0,0 +1,18 @@
+"""SQLite adapters for the repository pattern."""
+
+from .datastore import SQLiteConnectionContextManager, SQLiteDatastore
+from .infrastructure import SQLiteInfrastructure
+from .outbox import SQLiteInboxRepository, SQLiteOutboxRepository, SQLitePairInboxOutbox
+from .repository import SQLiteRepositoryAdapter
+from .unit_of_work import SQLiteUnitOfWork
+
+__all__ = [
+    "SQLiteConnectionContextManager",
+    "SQLiteDatastore",
+    "SQLiteRepositoryAdapter",
+    "SQLiteUnitOfWork",
+    "SQLiteOutboxRepository",
+    "SQLiteInboxRepository",
+    "SQLiteInfrastructure",
+    "SQLitePairInboxOutbox",
+]

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

@@ -0,0 +1,197 @@
+"""SQLite datastore implementation for the repository pattern."""
+
+import sqlite3
+from contextlib import contextmanager
+from typing import Callable, Iterator, Literal, Mapping, Optional, TypeVar
+
+from eventsourcing.utils import strtobool
+
+from hexagonal.application import Infrastructure
+from hexagonal.ports.drivens import IConnectionManager
+
+from .env_vars import SQLITE_CHECK_SAME_THREAD, SQLITE_DB_PATH
+
+# Type variable for the connection type
+T = TypeVar("T", bound=sqlite3.Connection)
+
+# Type alias for SQLite isolation levels
+
+
+class SQLiteDatastore(Infrastructure):
+    """SQLite datastore adapter that provides connection and transaction management."""
+
+    def __init__(
+        self,
+        database: str,
+        *,
+        timeout: float = 5.0,
+        detect_types: int = 0,
+        isolation_level: Optional[Literal["DEFERRED", "IMMEDIATE", "EXCLUSIVE"]] = None,
+        check_same_thread: bool = True,
+        factory: Optional[Callable[..., sqlite3.Connection]] = None,
+        cached_statements: int = 128,
+        uri: bool = False,
+        autocommit: bool = False,
+    ):
+        """Initialize SQLite datastore.
+
+        Args:
+            database: Path to the SQLite database file
+            timeout: How many seconds the connection should wait
+            before raising an exception
+            detect_types: Control the type detection
+            isolation_level: See sqlite3.Connection.isolation_level
+            check_same_thread: If True, only the creating thread may use the connection
+            factory: Custom connection factory
+            (must be a callable that returns a Connection)
+            cached_statements: Number of statements to cache
+            uri: If True, database is interpreted as a URI
+            autocommit: If True, the connection will be in autocommit mode
+        """
+        self.database = database
+        self.timeout = timeout
+        self.detect_types = detect_types
+        self.isolation_level = isolation_level
+        self.check_same_thread = check_same_thread
+        self.factory = factory
+        self.cached_statements = cached_statements
+        self.uri = uri
+        self.autocommit = autocommit
+        self._connection: Optional[sqlite3.Connection] = None
+
+    @contextmanager
+    def get_connection(self) -> Iterator[sqlite3.Connection]:
+        """Get a database connection from the pool.
+
+        Yields:
+            A database connection that will be automatically
+            closed when the context exits
+
+        Example:
+            with datastore.get_connection() as conn:
+                cursor = conn.cursor()
+                cursor.execute('SELECT 1')
+                result = cursor.fetchone()
+        """
+        conn = sqlite3.connect(
+            database=self.database,
+            timeout=self.timeout,
+            detect_types=self.detect_types,
+            check_same_thread=self.check_same_thread,
+            cached_statements=self.cached_statements,
+            uri=self.uri,
+        )
+        try:
+            # Enable foreign key constraints
+            conn.execute("PRAGMA foreign_keys = ON")
+            yield conn
+        except sqlite3.DatabaseError as e:
+            raise Exception(f"SQLite DatabaseError: {e}") from e
+        except sqlite3.InterfaceError as e:
+            raise Exception(f"SQLite InterfaceError: {e}") from e
+        # except Exception as e:
+        #     raise Exception(f"SQLite Unknown error: {e}") from e
+        finally:
+            conn.close()
+
+    @contextmanager
+    def transaction(self, commit: bool = False) -> Iterator[sqlite3.Cursor]:
+        """Execute a transaction on the database.
+
+        Args:
+            commit: If True, commit the transaction after the block completes.
+                   If False, rollback the transaction if an exception occurs.
+
+        Yields:
+            A database cursor for executing SQL statements.
+
+        Example:
+            with datastore.transaction(commit=True) as cursor:
+                cursor.execute('INSERT INTO table VALUES (?)', (value,))
+        """
+        with self.get_connection() as conn:
+            cursor = conn.cursor()
+            try:
+                yield cursor
+                if commit:
+                    conn.commit()
+            except Exception as exc:
+                conn.rollback()
+                raise RuntimeError("Transaction failed") from exc
+            finally:
+                cursor.close()
+
+    def close(self) -> None:
+        """Close any open connection."""
+        if self._connection:
+            self._connection.close()
+            self._connection = None
+
+    def __enter__(self):
+        self._connection = self.get_connection().__enter__()
+        self._connection.row_factory = sqlite3.Row
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):  # type: ignore
+        self.close()
+
+    def __del__(self):
+        self.close()
+
+
+def dict_factory(cursor: sqlite3.Cursor, row: sqlite3.Row):
+    fields = [column[0] for column in cursor.description]
+    return {key: value for key, value in zip(fields, row, strict=False)}
+
+
+class SQLiteConnectionContextManager(IConnectionManager, Infrastructure):
+    def __init__(self, datastore: SQLiteDatastore | None = None):
+        self._current_connection: sqlite3.Connection | None = None
+        self._setted_datastore: bool = datastore is not None
+        if datastore is not None:
+            self._datastore = datastore
+        super().__init__()
+
+    def initialize(self, env: Mapping[str, str]) -> None:
+        if self._setted_datastore:
+            return super().initialize(env)
+        db_path = env.get(SQLITE_DB_PATH, ":memory:")
+        check_same_thread = strtobool(env.get(SQLITE_CHECK_SAME_THREAD, "True"))
+        self._datastore = SQLiteDatastore(
+            database=db_path,
+            check_same_thread=check_same_thread,
+        )
+        super().initialize(env)
+
+    @property
+    def datastore(self) -> SQLiteDatastore:
+        self.verify()
+        return self._datastore
+
+    def start_connection(self):
+        self._ctx_con = self.datastore.get_connection()
+        self._current_connection = self._ctx_con.__enter__()
+        return self._ctx_con
+
+    @property
+    def current_connection(self) -> sqlite3.Connection:
+        if self._current_connection is None:
+            self._ctx_con = self.datastore.get_connection()
+            self._current_connection = self._ctx_con.__enter__()
+        return self._current_connection
+
+    @current_connection.setter
+    def current_connection(self, connection: sqlite3.Connection) -> None:
+        if getattr(self, "_ctx_con", None):
+            self._ctx_con.__exit__(None, None, None)
+        self._current_connection = connection
+
+    @contextmanager
+    def cursor(self) -> Iterator[sqlite3.Cursor]:
+        try:
+            cursor = self.current_connection.cursor()
+        except sqlite3.ProgrammingError:
+            self._current_connection = None
+            cursor = self.current_connection.cursor()
+        yield cursor
+        cursor.close()

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

@@ -0,0 +1,2 @@
+SQLITE_DB_PATH = "SQLITE_DB_PATH"
+SQLITE_CHECK_SAME_THREAD = "SQLITE_CHECK_SAME_THREAD"

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

@@ -0,0 +1,20 @@
+from hexagonal.adapters.drivens.mappers import MessageMapper
+from hexagonal.application import ComposableInfrastructure
+
+from .datastore import SQLiteConnectionContextManager, SQLiteDatastore
+
+
+class SQLiteInfrastructure(ComposableInfrastructure):
+    def __init__(self, mapper: MessageMapper, datastore: SQLiteDatastore | None = None):
+        self._datastore = datastore
+        self._mapper = mapper
+        self._connection_manager = SQLiteConnectionContextManager(datastore)
+        super().__init__(self._connection_manager)
+
+    @property
+    def connection_manager(self) -> SQLiteConnectionContextManager:
+        return self._connection_manager
+
+    @property
+    def mapper(self) -> MessageMapper:
+        return self._mapper