python-cqrs 0.0.2__py3-none-any.whl

cqrs/mediator.py

@@ -0,0 +1,103 @@
+import typing
+
+from cqrs import container as di_container
+from cqrs import dispatcher, events, middlewares, requests, response
+
+Req = typing.TypeVar("Req", bound=requests.Request, contravariant=True)
+Resp = typing.TypeVar("Resp", bound=response.Response, covariant=True)
+E = typing.TypeVar("E", bound=events.Event, contravariant=True)
+
+
+class RequestMediator:
+    """
+    The request mediator object.
+
+    Usage::
+
+      message_broker = AMQPMessageBroker(
+        dsn=f"amqp://{LOGIN}:{PASSWORD}@{HOSTNAME}/",
+        queue_name="user_joined_domain",
+        exchange_name="user_joined",
+      )
+      event_map = EventMap()
+      event_map.bind(UserJoinedDomainEvent, UserJoinedDomainEventHandler)
+      request_map = RequestMap()
+      request_map.bind(JoinUserCommand, JoinUserCommandHandler)
+      event_emitter = EventEmitter(event_map, container, message_broker)
+
+      mediator = RequestMediator(
+        request_map=request_map,
+        container=container
+        event_emitter=event_emitter,
+      )
+
+      # Handles command and published events by the command handler.
+      await mediator.send(join_user_command)
+
+    """
+
+    def __init__(
+        self,
+        request_map: requests.RequestMap,
+        container: di_container.Container,
+        event_emitter: events.EventEmitter | None = None,
+        middleware_chain: middlewares.MiddlewareChain | None = None,
+        *,
+        dispatcher_type: typing.Type[dispatcher.RequestDispatcher] = dispatcher.RequestDispatcher,
+    ) -> None:
+        self._event_emitter = event_emitter
+        self._dispatcher = dispatcher_type(
+            request_map=request_map,  # type: ignore
+            container=container,  # type: ignore
+            middleware_chain=middleware_chain,  # type: ignore
+        )
+
+    async def send(self, request: Req) -> Resp | None:
+        dispatch_result = await self._dispatcher.dispatch(request)
+
+        if dispatch_result.events:
+            await self._send_events(dispatch_result.events.copy())
+
+        return dispatch_result.response
+
+    async def _send_events(self, events: typing.List[E]) -> None:
+        if not self._event_emitter:
+            return
+
+        while events:
+            event = events.pop()
+            await self._event_emitter.emit(event)
+
+
+class EventMediator:
+    """
+    The event mediator object.
+
+    Usage::
+      event_map = EventMap()
+      event_map.bind(UserJoinedECSTEvent, UserJoinedECSTEventHandler)
+      mediator = EventMediator(
+        event_map=event_map,
+        container=container
+      )
+
+      # Handles ecst and notification events.
+      await mediator.send(user_joined_event)
+    """
+
+    def __init__(
+        self,
+        event_map: events.EventMap,
+        container: di_container.Container,
+        middleware_chain: middlewares.MiddlewareChain | None = None,
+        *,
+        dispatcher_type: typing.Type[dispatcher.EventDispatcher] = dispatcher.EventDispatcher,
+    ):
+        self._dispatcher = dispatcher_type(
+            event_map=event_map,  # type: ignore
+            container=container,  # type: ignore
+            middleware_chain=middleware_chain,  # type: ignore
+        )
+
+    async def send(self, event: E) -> None:
+        await self._dispatcher.dispatch(event)

cqrs/message_brokers/__init__.py

@@ -0,0 +1,6 @@
+from cqrs.message_brokers.protocol import Message, MessageBroker
+
+__all__ = (
+    "Message",
+    "MessageBroker",
+)

cqrs/message_brokers/amqp.py

@@ -0,0 +1,23 @@
+import logging
+
+import aio_pika
+import orjson
+
+from cqrs.adapters import amqp
+from cqrs.message_brokers import protocol
+
+
+class AMQPMessageBroker:
+    def __init__(self, dsn: str, queue_name: str, exchange_name: str, pika_log_level: str = "ERROR"):
+        self.publisher = amqp.AMQPPublisher(url=dsn)
+        self.queue_name = queue_name
+        self.exchange_name = exchange_name
+        logging.getLogger("aiormq").setLevel(pika_log_level)
+        logging.getLogger("aio_pika").setLevel(pika_log_level)
+
+    async def send_message(self, message: protocol.Message) -> None:
+        await self.publisher.publish(
+            message=aio_pika.Message(body=orjson.dumps(message.model_dump(mode="json"))),
+            exchange_name=self.exchange_name,
+            queue_name=self.queue_name,
+        )

cqrs/message_brokers/devnull.py

@@ -0,0 +1,10 @@
+import logging
+
+from cqrs.message_brokers import protocol
+
+logger = logging.getLogger("cqrs")
+
+
+class DevnullMessageBroker:
+    async def send_message(self, message: protocol.Message) -> None:
+        logger.warning(f"Event {message} will be skip")

cqrs/message_brokers/kafka.py

@@ -0,0 +1,14 @@
+import logging
+import typing
+
+from cqrs.adapters import kafka
+from cqrs.message_brokers import protocol
+
+
+class KafkaMessageBroker:
+    def __init__(self, producer: kafka.KafkaProducer, aiokafka_log_level: typing.Text = "ERROR"):
+        self._producer = producer
+        logging.getLogger("aiokafka").setLevel(aiokafka_log_level)
+
+    async def send_message(self, message: protocol.Message) -> None:
+        await self._producer.produce(message)

cqrs/message_brokers/protocol.py

@@ -0,0 +1,22 @@
+import typing
+import uuid
+
+import pydantic
+
+
+class Message(pydantic.BaseModel):
+    message_type: str = pydantic.Field()
+    message_name: str = pydantic.Field()
+    message_id: uuid.UUID = pydantic.Field(default_factory=uuid.uuid4)
+    payload: dict = pydantic.Field()
+
+
+class MessageBroker(typing.Protocol):
+    """
+    The interface over a message broker.
+
+    Used for sending messages to message brokers (currently only redis supported).
+    """
+
+    async def send_message(self, message: Message) -> None:
+        ...

cqrs/middlewares/__init__.py

@@ -0,0 +1,3 @@
+from cqrs.middlewares.base import Middleware, MiddlewareChain
+
+__all__ = ("Middleware", "MiddlewareChain")

cqrs/middlewares/base.py

@@ -0,0 +1,30 @@
+import functools
+import typing
+
+from cqrs import requests, response
+
+Req = typing.TypeVar("Req", bound=requests.Request, contravariant=True)
+Res = typing.TypeVar("Res", response.Response, None, covariant=True)
+HandleType = typing.Callable[[Req], typing.Awaitable[Res]]
+
+
+class Middleware(typing.Protocol):
+    async def __call__(self, request: requests.Request, handle: HandleType) -> Res:
+        ...
+
+
+class MiddlewareChain:
+    def __init__(self) -> None:
+        self._chain: list[Middleware] = []
+
+    def set(self, chain: list[Middleware]) -> None:
+        self._chain = chain
+
+    def add(self, middleware: Middleware) -> None:
+        self._chain.append(middleware)
+
+    def wrap(self, handle: HandleType) -> HandleType:
+        for middleware in reversed(self._chain):
+            handle = functools.partial(middleware.__call__, handle=handle)
+
+        return handle

cqrs/middlewares/logging.py

@@ -0,0 +1,37 @@
+import logging
+import typing
+
+from cqrs import requests, response
+
+Req = typing.TypeVar("Req", bound=requests.Request, contravariant=True)
+Res = typing.TypeVar("Res", response.Response, None, covariant=True)
+HandleType = typing.Callable[[Req], typing.Awaitable[Res]]
+
+
+class LoggingMiddleware:
+    def __init__(
+        self,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        self._logger = logger or logging.getLogger("cqrs")
+
+    async def __call__(self, request: Req, handle: HandleType) -> Res:
+        self._logger.debug(
+            "Handle %s request",
+            type(request).__name__,
+            extra={
+                "request_json_fields": {"request": request.model_dump(mode="json")},
+                "to_mask": True,
+            },
+        )
+        resp = await handle(request)
+        self._logger.debug(
+            "Request %s handled",
+            type(request).__name__,
+            extra={
+                "request_json_fields": {"response": resp.model_dump(mode="json") if resp else {}},
+                "to_mask": True,
+            },
+        )
+
+        return resp

cqrs/outbox/producer.py

@@ -0,0 +1,65 @@
+import asyncio
+import logging
+import typing
+import uuid
+
+from sqlalchemy.ext.asyncio import session as sql_session
+
+import cqrs
+from cqrs.message_brokers import protocol as broker_protocol
+from cqrs.outbox import repository as repository_protocol
+
+logger = logging.getLogger("cqrs")
+logger.setLevel(logging.DEBUG)
+
+SessionFactory: typing.TypeAlias = typing.Callable[[], sql_session.AsyncSession]
+Serializer: typing.TypeAlias = typing.Callable[[repository_protocol.Event], typing.Awaitable[typing.Dict]]
+
+
+class EventProducer:
+    def __init__(
+        self,
+        message_broker: broker_protocol.MessageBroker,
+        repository: repository_protocol.OutboxedEventRepository,
+        serializer: Serializer | None = None,
+    ):
+        self.message_broker = message_broker
+        self.repository = repository
+        self.serializer = serializer
+
+    async def periodically_task(self, batch_size: int = 100, wait_ms: int = 500) -> None:
+        """Calls produce periodically with specified delay"""
+        while True:
+            await asyncio.sleep(float(wait_ms) / 1000.0)
+            await self.produce_batch(batch_size)
+
+    async def send_message(self, session: repository_protocol.Session, event: cqrs.ECSTEvent | cqrs.NotificationEvent):
+        try:
+            serialized = (await self.serializer(event)) if self.serializer else event.model_dump(mode="json")
+            await self.message_broker.send_message(
+                broker_protocol.Message(
+                    message_type=event.event_type,
+                    message_name=event.event_name,
+                    message_id=event.event_id,
+                    payload=serialized,
+                ),
+            )
+        except Exception as e:
+            logger.error(f"Error while producing event {event.event_id} to kafka broker: {e}")
+            await self.repository.update_status(session, event.event_id, repository_protocol.EventStatus.NOT_PRODUCED)
+        else:
+            await self.repository.update_status(session, event.event_id, repository_protocol.EventStatus.PRODUCED)
+
+    async def produce_one(self, event_id: uuid.UUID) -> None:
+        async with self.repository as session:
+            event = await self.repository.get_one(session, event_id)
+            if event:
+                await self.send_message(session, event)
+            await self.repository.commit(session)
+
+    async def produce_batch(self, batch_size: int = 100) -> None:
+        async with self.repository as session:
+            events = await self.repository.get_many(session, batch_size)
+            for event in events:
+                await self.send_message(session, event)
+            await self.repository.commit(session)

cqrs/outbox/protocol.py

@@ -0,0 +1,44 @@
+import abc
+import asyncio
+import typing
+import uuid
+
+from cqrs.events import event as ev
+
+Event: typing.TypeAlias = ev.NotificationEvent | ev.ECSTEvent
+
+
+class Outbox(typing.Protocol):
+    def add(self, event: Event):
+        """Adds event to outbox"""
+
+    async def save(self):
+        """Commits events to the storage"""
+
+    async def get_events(self, batch_size: int = 100) -> typing.List[Event]:
+        """Returns not produced events"""
+
+    async def get_event(self, event_id: uuid.UUID) -> Event | None:
+        """Returns event by id"""
+
+    async def mark_as_produced(self, event_id: uuid.UUID) -> None:
+        """Marks event as produced"""
+
+    async def mark_as_failure(self, event_id: uuid.UUID) -> None:
+        """Marks event as not produced with failure"""
+
+
+class EventProducer(abc.ABC):
+    @abc.abstractmethod
+    async def produce_one(self, event_id: uuid.UUID) -> None:
+        """Produces event to broker"""
+
+    @abc.abstractmethod
+    async def produce_batch(self, batch_size: int = 100) -> None:
+        """Produces events to broker"""
+
+    async def periodically_task(self, batch_size: int = 100, wait_ms: int = 500) -> None:
+        """Calls produce periodically with specified delay"""
+        while True:
+            await asyncio.sleep(float(wait_ms) / 1000.0)
+            await self.produce_batch(batch_size)

cqrs/outbox/repository.py

@@ -0,0 +1,54 @@
+import abc
+import enum
+import typing
+import uuid
+
+import cqrs
+from cqrs.events import event as ev
+
+Event: typing.TypeAlias = ev.NotificationEvent | ev.ECSTEvent
+Session = typing.TypeVar("Session")
+
+
+class EventStatus(enum.StrEnum):
+    NEW = "new"
+    PRODUCED = "produced"
+    NOT_PRODUCED = "not_produced"
+
+
+class OutboxedEventRepository(abc.ABC, typing.Generic[Session]):
+    def __init__(self, session_factory: typing.Callable[[], Session], compressor: cqrs.Compressor | None = None):
+        self._session_factory = session_factory
+        self._compressor = compressor
+
+    @abc.abstractmethod
+    async def __aenter__(self) -> Session:
+        """start transaction"""
+
+    @abc.abstractmethod
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """end transaction"""
+
+    @abc.abstractmethod
+    def add(self, session: Session, event: Event) -> None:
+        """Add an event to the repository."""
+
+    @abc.abstractmethod
+    async def get_one(self, session: Session, event_id: uuid.UUID) -> Event | None:
+        """Get one event from the repository."""
+
+    @abc.abstractmethod
+    async def get_many(self, session: Session, batch_size: int = 100) -> typing.List[Event]:
+        """Get many events from the repository."""
+
+    @abc.abstractmethod
+    async def update_status(self, session: Session, event_id: uuid.UUID, new_status: EventStatus):
+        """Update the event status"""
+
+    @abc.abstractmethod
+    async def commit(self, session: Session):
+        """Commit the changes to the repository."""
+
+    @abc.abstractmethod
+    async def rollback(self, session: Session):
+        """Rollback the changes to the repository."""

cqrs/outbox/sqlalchemy.py

@@ -0,0 +1,223 @@
+import asyncio
+import enum
+import logging
+import typing
+import uuid
+
+import orjson
+import sqlalchemy
+from sqlalchemy import func
+from sqlalchemy.dialects import mysql
+from sqlalchemy.ext.asyncio import session as sql_session
+from sqlalchemy.orm import registry
+
+from cqrs.events import event as ev
+from cqrs.outbox import repository
+
+mapper_registry = registry()
+Base = mapper_registry.generate_base()
+
+logger = logging.getLogger(__name__)
+
+
+class EventType(enum.StrEnum):
+    ECST_EVENT = "ecst_event"
+    NOTIFICATION_EVENT = "notification_event"
+
+
+MAX_FLUSH_COUNTER_VALUE = 5
+
+
+class OutboxModel(Base):
+    __tablename__ = "outbox"
+
+    __table_args__ = (
+        sqlalchemy.UniqueConstraint(
+            "event_id_bin",
+            "event_name",
+            name="event_id_unique_index",
+        ),
+    )
+    id = sqlalchemy.Column(
+        sqlalchemy.BigInteger(),
+        sqlalchemy.Identity(),
+        primary_key=True,
+        nullable=False,
+        autoincrement=True,
+        comment="Identity",
+    )
+    event_id = sqlalchemy.Column(sqlalchemy.Uuid, nullable=False, comment="Event idempotency id")
+    event_id_bin = sqlalchemy.Column(
+        sqlalchemy.BINARY(16),
+        nullable=False,
+        comment="Event idempotency id in 16 bit presentation",
+    )
+    event_type = sqlalchemy.Column(sqlalchemy.Enum(EventType), nullable=False, comment="Event type")
+    event_status = sqlalchemy.Column(
+        sqlalchemy.Enum(repository.EventStatus),
+        nullable=False,
+        default=repository.EventStatus.NEW,
+        comment="Event producing status",
+    )
+    flush_counter = sqlalchemy.Column(
+        sqlalchemy.SmallInteger(),
+        nullable=False,
+        default=0,
+        comment="Event producing flush counter",
+    )
+    event_name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False, comment="Event name")
+
+    created_at = sqlalchemy.Column(
+        sqlalchemy.DateTime,
+        nullable=False,
+        server_default=func.now(),
+        comment="Event creation timestamp",
+    )
+    payload = sqlalchemy.Column(mysql.BLOB, nullable=False, default={}, comment="Event payload")
+
+    def row_to_dict(self) -> typing.Dict[typing.Text, typing.Any]:
+        return {column.name: getattr(self, column.name) for column in self.__table__.columns}
+
+    @classmethod
+    def get_batch_query(cls, size: int) -> sqlalchemy.Select:
+        return (
+            sqlalchemy.select(cls)
+            .select_from(cls)
+            .where(
+                sqlalchemy.and_(
+                    cls.event_status.in_([repository.EventStatus.NEW, repository.EventStatus.NOT_PRODUCED]),
+                    cls.flush_counter < MAX_FLUSH_COUNTER_VALUE,
+                ),
+            )
+            .order_by(cls.status_sorting_case().asc())
+            .order_by(cls.id.asc())
+            .limit(size)
+            .with_for_update()
+        )
+
+    @classmethod
+    def get_event_query(cls, event_id: uuid.UUID) -> sqlalchemy.Select:
+        return (
+            sqlalchemy.select(cls)
+            .select_from(cls)
+            .where(
+                sqlalchemy.and_(
+                    cls.event_id_bin == func.UUID_TO_BIN(event_id),
+                    cls.event_status.in_([repository.EventStatus.NEW, repository.EventStatus.NOT_PRODUCED]),
+                    cls.flush_counter < MAX_FLUSH_COUNTER_VALUE,
+                ),
+            )
+            .order_by(cls.status_sorting_case().asc())
+            .order_by(cls.id.asc())
+            .with_for_update()
+        )
+
+    @classmethod
+    def update_status_query(
+        cls,
+        event_id: uuid.UUID,
+        status: typing.Literal[
+            repository.EventStatus.PRODUCED,
+            repository.EventStatus.NOT_PRODUCED,
+        ],
+    ) -> sqlalchemy.Update:
+        values = {"event_status": status}
+        if status == repository.EventStatus.NOT_PRODUCED:
+            values["flush_counter"] = cls.flush_counter + 1
+
+        return sqlalchemy.update(cls).where(cls.event_id_bin == func.UUID_TO_BIN(event_id)).values(**values)
+
+    @classmethod
+    def status_sorting_case(cls) -> sqlalchemy.case:
+        return sqlalchemy.case(
+            {
+                repository.EventStatus.NEW: 1,
+                repository.EventStatus.NOT_PRODUCED: 2,
+                repository.EventStatus.PRODUCED: 3,
+            },
+            value=cls.event_status,
+            else_=4,
+        )
+
+
+class SqlAlchemyOutboxedEventRepository(repository.OutboxedEventRepository[sql_session.AsyncSession]):
+    EVENT_CLASS_MAPPING: typing.ClassVar[typing.Dict[EventType, typing.Type[repository.Event]]] = {
+        EventType.NOTIFICATION_EVENT: ev.NotificationEvent,
+        EventType.ECST_EVENT: ev.ECSTEvent,
+    }
+
+    def add(self, session: sql_session.AsyncSession, event: repository.Event) -> None:
+        bytes_payload = orjson.dumps(event.payload)
+        if self._compressor:
+            bytes_payload = self._compressor.compress(bytes_payload)
+        session.add(
+            OutboxModel(
+                event_id=event.event_id,
+                event_id_bin=func.UUID_TO_BIN(event.event_id),
+                event_type=EventType(event.event_type),
+                event_name=event.event_name,
+                created_at=event.event_timestamp,
+                payload=bytes_payload,
+            ),
+        )
+
+    def _process_events(self, model: OutboxModel) -> repository.Event:
+        event_dict = model.row_to_dict()
+        event_dict["payload"] = orjson.loads(
+            self._compressor.decompress(event_dict["payload"]) if self._compressor else event_dict["payload"],
+        )
+        return self.EVENT_CLASS_MAPPING[event_dict["event_type"]].model_validate(event_dict)
+
+    async def get_many(self, session: sql_session.AsyncSession, batch_size: int = 100) -> typing.List[repository.Event]:
+        events: typing.Sequence[OutboxModel] = (
+            (await session.execute(OutboxModel.get_batch_query(batch_size))).scalars().all()
+        )
+
+        tasks = []
+        for event in events:
+            if not self.EVENT_CLASS_MAPPING.get(event.event_type):
+                logger.warning(f"Unknown event type for {event}")
+                continue
+            tasks.append(asyncio.to_thread(self._process_events, event))
+
+        return await asyncio.gather(*tasks)  # noqa
+
+    async def get_one(self, session: sql_session.AsyncSession, event_id: uuid.UUID) -> repository.Event | None:
+        event: OutboxModel | None = (await session.execute(OutboxModel.get_event_query(event_id))).scalar()
+
+        if event is None:
+            return
+
+        if not self.EVENT_CLASS_MAPPING.get(event.event_type):
+            logger.warning(f"Unknown event type for {event}")
+            return
+
+        event_dict = event.row_to_dict()
+        event_dict["payload"] = orjson.loads(
+            self._compressor.decompress(event_dict["payload"]) if self._compressor else event_dict["payload"],
+        )
+
+        return self.EVENT_CLASS_MAPPING[event.event_type].model_validate(event_dict)
+
+    async def update_status(
+        self,
+        session: sql_session.AsyncSession,
+        event_id: uuid.UUID,
+        new_status: repository.EventStatus,
+    ) -> None:
+        await session.execute(OutboxModel.update_status_query(event_id, new_status))
+
+    async def commit(self, session: sql_session.AsyncSession):
+        await session.commit()
+
+    async def rollback(self, session: sql_session.AsyncSession):
+        await session.rollback()
+
+    async def __aenter__(self):
+        self.session = self._session_factory()
+        return self.session
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.session.rollback()
+        await self.session.close()
+        self.session = None

cqrs/registry.py

@@ -0,0 +1,29 @@
+import typing
+from collections import abc
+
+_VT = typing.TypeVar("_VT")
+_KT = typing.TypeVar("_KT")
+
+
+class InMemoryRegistry(abc.MutableMapping[_KT, _VT]):
+    _registry: typing.Dict[_KT, _VT]
+
+    def __init__(self):
+        self._registry = dict()
+
+    def __setitem__(self, __key: _KT, __value: _VT) -> None:
+        if __key in self._registry:
+            raise KeyError(f"{__key} already exists in registry")
+        self._registry[__key] = __value
+
+    def __delitem__(self, __key):
+        raise TypeError(f"{self.__class__.__name__} has no delete method")
+
+    def __getitem__(self, __key: _KT) -> _VT:
+        return self._registry[__key]
+
+    def __len__(self):
+        return len(self._registry.keys())
+
+    def __iter__(self):
+        return iter(self._registry.keys())

cqrs/requests/__init__.py

@@ -0,0 +1,9 @@
+from cqrs.requests.map import RequestMap
+from cqrs.requests.request import Request
+from cqrs.requests.request_handler import RequestHandler
+
+__all__ = (
+    "RequestMap",
+    "Request",
+    "RequestHandler",
+)