python-cqrs 4.14.0__tar.gz → 4.15.0__tar.gz

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-cqrs
-Version: 4.14.0
+Version: 4.15.0
 Summary: Event-Driven Architecture Framework for Distributed Systems
 Author-email: Vadim Kozyrevskiy <vadikko2@mail.ru>, Dmitry Kutlubaev <kutlubaev00@mail.ru>
 Maintainer-email: Vadim Kozyrevskiy <vadikko2@mail.ru>
@@ -49,6 +49,7 @@ Requires-Dist: asyncpg>=0.29.0; extra == "dev"
 Requires-Dist: redis>=5.0.0; extra == "dev"
 Requires-Dist: aiobreaker>=0.3.0; extra == "dev"
 Requires-Dist: dishka>=1.0; extra == "dev"
+Requires-Dist: protobuf>=4.25.8; extra == "dev"
 Provides-Extra: examples
 Requires-Dist: fastapi==0.109.*; extra == "examples"
 Requires-Dist: faststream[kafka]==0.5.28; extra == "examples"
@@ -61,6 +62,8 @@ Requires-Dist: dishka>=1.0; extra == "examples"
 Provides-Extra: kafka
 Requires-Dist: aiokafka==0.10.0; extra == "kafka"
 Requires-Dist: retry-async==0.1.*; extra == "kafka"
+Provides-Extra: protobuf
+Requires-Dist: protobuf>=4.25.8; extra == "protobuf"
 Provides-Extra: rabbit
 Requires-Dist: aio-pika==9.3.0; extra == "rabbit"
 Provides-Extra: sqlalchemy
@@ -923,12 +926,9 @@ A runnable FastAPI flow (route → command → transactional outbox → publishe
 > [Database Support](https://mkdocs.python-cqrs.dev/outbox/databases/) docs for the DDL, the Alembic recipe and
 > how to register a native type for your own database.
 > [!TIP]
-> For Protobuf events, implement `proto()` / `from_proto()` on the notification
-> event (see [Protobuf messaging](#protobuf-messaging) and the schema assets in
-> [examples/proto/](https://github.com/vadikko2/python-cqrs/tree/master/examples/proto)).
-> Outbox persistence is unchanged — use
-> [save_events_into_outbox.py](https://github.com/vadikko2/python-cqrs/blob/master/examples/outbox/save_events_into_outbox.py);
-> Protobuf applies when producing to the broker. Full guide:
+> For Protobuf events, implement `proto()` / `from_proto()` and register a
+> `ProtobufEventSerializer` on an `OutboxedEventMap`. JSON stays the default —
+> see [Protobuf messaging](#protobuf-messaging) and the full guide:
 > [Protobuf Integration](https://mkdocs.python-cqrs.dev/protobuf/).
 
 ## Producing Events from Outbox to Kafka
@@ -1231,6 +1231,14 @@ class UserJoinedNotificationEvent(cqrs.NotificationEvent[UserJoinedPayload]):
         )
 ```
 
+JSON remains the default. Opt-in Protobuf wiring (`ProtobufEventSerializer` on an
+`OutboxedEventMap`, `Message.payload_bytes`, consume via `ProtobufDeserializer`) is
+documented in the full guide:
+[Protobuf Integration](https://mkdocs.python-cqrs.dev/protobuf/).
+Runnable example:
+[protobuf_outbox.py](https://github.com/vadikko2/python-cqrs/blob/master/examples/outbox/protobuf_outbox.py)
+(`pip install "python-cqrs[protobuf]"`).
+
 ## Contributing
 
 Contributions are welcome. To develop locally:

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/README.md

@@ -852,12 +852,9 @@ A runnable FastAPI flow (route → command → transactional outbox → publishe
 > [Database Support](https://mkdocs.python-cqrs.dev/outbox/databases/) docs for the DDL, the Alembic recipe and
 > how to register a native type for your own database.
 > [!TIP]
-> For Protobuf events, implement `proto()` / `from_proto()` on the notification
-> event (see [Protobuf messaging](#protobuf-messaging) and the schema assets in
-> [examples/proto/](https://github.com/vadikko2/python-cqrs/tree/master/examples/proto)).
-> Outbox persistence is unchanged — use
-> [save_events_into_outbox.py](https://github.com/vadikko2/python-cqrs/blob/master/examples/outbox/save_events_into_outbox.py);
-> Protobuf applies when producing to the broker. Full guide:
+> For Protobuf events, implement `proto()` / `from_proto()` and register a
+> `ProtobufEventSerializer` on an `OutboxedEventMap`. JSON stays the default —
+> see [Protobuf messaging](#protobuf-messaging) and the full guide:
 > [Protobuf Integration](https://mkdocs.python-cqrs.dev/protobuf/).
 
 ## Producing Events from Outbox to Kafka
@@ -1160,6 +1157,14 @@ class UserJoinedNotificationEvent(cqrs.NotificationEvent[UserJoinedPayload]):
         )
 ```
 
+JSON remains the default. Opt-in Protobuf wiring (`ProtobufEventSerializer` on an
+`OutboxedEventMap`, `Message.payload_bytes`, consume via `ProtobufDeserializer`) is
+documented in the full guide:
+[Protobuf Integration](https://mkdocs.python-cqrs.dev/protobuf/).
+Runnable example:
+[protobuf_outbox.py](https://github.com/vadikko2/python-cqrs/blob/master/examples/outbox/protobuf_outbox.py)
+(`pip install "python-cqrs[protobuf]"`).
+
 ## Contributing
 
 Contributions are welcome. To develop locally:

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/pyproject.toml

@@ -31,7 +31,7 @@ maintainers = [{ name = "Vadim Kozyrevskiy", email = "vadikko2@mail.ru" }]
 name = "python-cqrs"
 readme = "README.md"
 requires-python = ">=3.10"
-version = "4.14.0"
+version = "4.15.0"
 
 [project.optional-dependencies]
 aiobreaker = ["aiobreaker>=0.3.0"]
@@ -60,6 +60,7 @@ dev = [
   # Circuit breaker for tests
   "aiobreaker>=0.3.0", # from aiobreaker
   "dishka>=1.0",  # scoped-deps dishka adapter tests / examples
+  "protobuf>=4.25.8",  # protobuf codec / deserializer unit tests
 ]
 examples = [
   "fastapi==0.109.*",
@@ -72,6 +73,7 @@ examples = [
   "dishka>=1.0",
 ]
 kafka = ["aiokafka==0.10.0", "retry-async==0.1.*"]
+protobuf = ["protobuf>=4.25.8"]
 rabbit = ["aio-pika==9.3.0"]
 sqlalchemy = ["sqlalchemy[asyncio]==2.0.*"]
 dishka = ["dishka>=1.0"]

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/__init__.py

@@ -44,6 +44,13 @@ from cqrs.outbox.sqlalchemy import (
     SqlAlchemyOutboxedEventRepository,
 )
 from cqrs.producer import EventProducer
+from cqrs.deserializers import DeserializeProtobufError, ProtobufDeserializer
+from cqrs.serializers import (
+    EventCodec,
+    EventSerializer,
+    JsonEventSerializer,
+    ProtobufEventSerializer,
+)
 from cqrs.requests.fallback import RequestHandlerFallback
 from cqrs.requests.map import RequestMap, SagaMap
 from cqrs.requests.mermaid import CoRMermaid
@@ -111,6 +118,12 @@ __all__ = (
     "OutboxedEventRepository",
     "SqlAlchemyOutboxedEventRepository",
     "EventProducer",
+    "EventSerializer",
+    "EventCodec",
+    "JsonEventSerializer",
+    "ProtobufEventSerializer",
+    "ProtobufDeserializer",
+    "DeserializeProtobufError",
     "Container",
     "SupportsScope",
     "DIContainer",

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/adapters/kafka.py

@@ -5,7 +5,7 @@ import ssl
 import typing
 
 from cqrs.adapters import protocol
-from cqrs.serializers import default
+from cqrs.serializers.default import passthrough_value_serializer
 
 import aiokafka
 import retry_async
@@ -53,22 +53,41 @@ class KafkaProducer(protocol.KafkaProducer):
         producer: aiokafka.AIOKafkaProducer,
         retry_count: int = 3,
         retry_delay: int = 1,
+        legacy_value_serializer: bool = False,
     ):
         self._producer = producer
         self._retry_count = retry_count
         self._retry_delay = retry_delay
+        # True when kafka_producer_factory got an explicit value_serializer so
+        # KafkaMessageBroker can pass message.payload (dict) on the non-codec path.
+        self.legacy_value_serializer = legacy_value_serializer
 
     async def _check_connection(self):
         node_id = self._producer.client.get_random_node()
         if not await self._producer.client.ready(node_id=node_id):
             await self._producer.start()
 
-    async def _produce(self, topic: typing.Text, message: typing.Any):
+    async def _produce(
+        self,
+        topic: typing.Text,
+        message: typing.Any,
+        headers: dict[str, str] | None = None,
+    ):
         await self._check_connection()
         logger.debug(f"produce message {message} to topic {topic}")
-        await self._producer.send_and_wait(topic, value=message)
-
-    async def produce(self, topic: typing.Text, message: typing.Any):
+        produce_kwargs: dict[str, typing.Any] = {"value": message}
+        if headers is not None:
+            produce_kwargs["headers"] = [
+                (key, value.encode("utf-8") if isinstance(value, str) else value) for key, value in headers.items()
+            ]
+        await self._producer.send_and_wait(topic, **produce_kwargs)
+
+    async def produce(
+        self,
+        topic: typing.Text,
+        message: typing.Any,
+        headers: dict[str, str] | None = None,
+    ):
         """
         Produces event to kafka broker.
         Tries to reconnect if connect has been lost or has not been opened.
@@ -76,6 +95,7 @@ class KafkaProducer(protocol.KafkaProducer):
         await _retry(tries=self._retry_count, delay=self._retry_delay)(self._produce)(
             topic,
             message,
+            headers,
         )
 
 
@@ -95,7 +115,7 @@ def kafka_producer_factory(
 
     producer = aiokafka.AIOKafkaProducer(
         bootstrap_servers=dsn,
-        value_serializer=value_serializer or default.default_serializer,
+        value_serializer=passthrough_value_serializer(value_serializer),
         security_protocol=security_protocol,
         sasl_mechanism=sasl_mechanism,
         sasl_plain_username=user,
@@ -107,4 +127,5 @@ def kafka_producer_factory(
         producer=producer,
         retry_count=retry_count,
         retry_delay=retry_delay,
+        legacy_value_serializer=value_serializer is not None,
     )

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/adapters/protocol.py

@@ -5,10 +5,17 @@ if typing.TYPE_CHECKING:
 
 
 class KafkaProducer(typing.Protocol):
+    """
+    ``legacy_value_serializer`` (optional attribute, default False) is set by
+    ``kafka_producer_factory`` when an explicit ``value_serializer`` is passed.
+    ``KafkaMessageBroker`` uses it to decide whether to forward ``message.payload``.
+    """
+
     async def produce(
         self,
         topic: typing.Text,
         message: typing.Any,
+        headers: dict[str, str] | None = None,
     ) -> None: ...
 
 

python_cqrs-4.15.0/src/cqrs/deserializers/__init__.py

@@ -0,0 +1,11 @@
+from cqrs.deserializers.exceptions import DeserializeJsonError, DeserializeProtobufError
+from cqrs.deserializers.json import Deserializable, JsonDeserializer
+from cqrs.deserializers.protobuf import ProtobufDeserializer
+
+__all__ = (
+    "Deserializable",
+    "JsonDeserializer",
+    "DeserializeJsonError",
+    "ProtobufDeserializer",
+    "DeserializeProtobufError",
+)

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/deserializers/exceptions.py

@@ -2,6 +2,22 @@ import dataclasses
 import typing
 
 
+@dataclasses.dataclass(frozen=True)
+class DeserializeProtobufError:
+    """
+    Error that occurred during protobuf deserialization.
+
+    Args:
+        error_message: Human-readable error message
+        error_type: Type of the exception that occurred
+        message_data: The original message data that failed to deserialize
+    """
+
+    error_message: str
+    error_type: typing.Type[Exception]
+    message_data: str | bytes | None
+
+
 @dataclasses.dataclass(frozen=True)
 class DeserializeJsonError:
     """

python_cqrs-4.15.0/src/cqrs/deserializers/protobuf.py

@@ -0,0 +1,51 @@
+import logging
+import typing
+import sys
+
+from cqrs.deserializers.exceptions import DeserializeProtobufError
+
+if sys.version_info >= (3, 11):
+    from typing import Self  # novm
+else:
+    from typing_extensions import Self
+
+logger = logging.getLogger("cqrs")
+
+
+class ProtoDeserializable(typing.Protocol):
+    """Objects that can be constructed from a protobuf message via ``from_proto``."""
+
+    @classmethod
+    def from_proto(cls, proto: typing.Any) -> Self: ...
+
+
+_T = typing.TypeVar("_T", bound=ProtoDeserializable)
+
+
+class ProtobufDeserializer(typing.Generic[_T]):
+    """
+    Deserializer for protobuf messages.
+
+    Converts protobuf wire bytes into Python objects using the ``from_proto``
+    classmethod of the target model. Duck-typed: this module does not import
+    ``google.protobuf``.
+    """
+
+    def __init__(self, model: type[_T], proto_type: typing.Any) -> None:
+        self._model = model
+        self._proto_type = proto_type
+
+    def __call__(self, data: bytes | None) -> _T | None | DeserializeProtobufError:
+        if data is None:
+            return None
+        try:
+            return self._model.from_proto(self._proto_type.FromString(data))
+        except Exception as e:
+            logger.error(
+                f"Error while deserializing protobuf message: {e}",
+            )
+            return DeserializeProtobufError(
+                error_message=str(e),
+                error_type=type(e),
+                message_data=data,
+            )

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/events/event_emitter.py

@@ -15,6 +15,9 @@ from cqrs.container.scope import (
 from cqrs.events.event import IDomainEvent, IEvent, INotificationEvent
 from cqrs.events import event_handler, map
 from cqrs.events.fallback import EventHandlerFallback
+from cqrs.serializers.default import headers_for_content_type
+from cqrs.serializers.json import JsonEventSerializer
+from cqrs.serializers.protocol import EventSerializer
 
 logger = logging.getLogger("cqrs")
 
@@ -38,6 +41,8 @@ class EventEmitter:
         container: di_container.Container,
         message_broker: message_brokers.MessageBroker | None = None,
         scope_strategy: ScopeStrategy = ScopeStrategy.NONE,
+        *,
+        serializer: EventSerializer | None = None,
     ) -> None:
         """
         Initialize the event emitter.
@@ -48,6 +53,7 @@ class EventEmitter:
             message_broker: Optional broker for notification events; required
                 when emitting :class:`~cqrs.events.event.INotificationEvent`.
             scope_strategy: DI scope boundary; HANDLER opens a scope per handler.
+            serializer: Codec used to fill ``Message.payload_bytes``. Defaults to JSON.
 
         Example::
 
@@ -64,6 +70,7 @@ class EventEmitter:
         self._container = wrap_container(container)
         self._message_broker = message_broker
         self._scope_strategy = scope_strategy
+        self._serializer = serializer or JsonEventSerializer()
 
     @functools.singledispatchmethod
     async def emit(self, event: IEvent) -> typing.Sequence[IEvent]:
@@ -108,11 +115,20 @@ class EventEmitter:
                 f"To send event {event}, message broker must be specified.",
             )
 
+        # payload (dict) and payload_bytes are both intentional: stub brokers /
+        # Message.to_dict() need the structured dict; transport uses wire bytes.
+        content_type, headers = headers_for_content_type(
+            self._serializer.content_type_for(event),
+            event,
+        )
         message = message_brokers.Message(
             message_name=type(event).__name__,
             message_id=event.event_id,
             topic=event.topic,
             payload=event.to_dict(),
+            payload_bytes=self._serializer.serialize(event),
+            content_type=content_type,
+            headers=headers,
         )
 
         logger.debug(

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/message_brokers/amqp.py

@@ -1,10 +1,10 @@
 import logging
 
 import aio_pika
-import orjson
 
 from cqrs.adapters import protocol as adapters_protocol
 from cqrs.message_brokers import protocol
+from cqrs.serializers.default import message_wire_bytes
 
 
 class AMQPMessageBroker(protocol.MessageBroker):
@@ -20,8 +20,16 @@ class AMQPMessageBroker(protocol.MessageBroker):
         logging.getLogger("aio_pika").setLevel(pika_log_level)
 
     async def send_message(self, message: protocol.Message) -> None:
+        kwargs: dict = {}
+        if message.content_type is not None:
+            kwargs["content_type"] = message.content_type
+        if message.headers is not None:
+            kwargs["headers"] = message.headers
         await self.publisher.publish(
-            message=aio_pika.Message(body=orjson.dumps(message.payload)),
+            message=aio_pika.Message(
+                body=message_wire_bytes(message),
+                **kwargs,
+            ),
             queue_name=message.topic,
             exchange_name=self.exchange_name,
         )

python_cqrs-4.15.0/src/cqrs/message_brokers/kafka.py

@@ -0,0 +1,45 @@
+import logging
+import typing
+
+from cqrs.adapters import protocol as adapters_protocol
+from cqrs.message_brokers import protocol
+from cqrs.serializers.default import message_wire_bytes
+
+
+class KafkaMessageBroker(protocol.MessageBroker):
+    def __init__(
+        self,
+        producer: adapters_protocol.KafkaProducer,
+        aiokafka_log_level: typing.Text = "ERROR",
+    ):
+        self._producer = producer
+        logging.getLogger("aiokafka").setLevel(aiokafka_log_level)
+
+    def _produce_value(self, message: protocol.Message) -> typing.Any:
+        """
+        Choose the value passed to ``KafkaProducer.produce``.
+
+        When a legacy ``value_serializer`` was configured on the producer and the
+        message has no codec wire bytes, forward ``message.payload`` so that
+        serializer can run. Otherwise prefer ``payload_bytes`` / encoded payload
+        so Outbox and EventSerializer bytes are not discarded.
+        """
+        legacy_value_serializer = getattr(
+            self._producer,
+            "legacy_value_serializer",
+            False,
+        )
+        if legacy_value_serializer and message.payload_bytes is None and message.content_type is None:
+            return message.payload
+        return message_wire_bytes(message)
+
+    async def send_message(self, message: protocol.Message) -> None:
+        payload = self._produce_value(message)
+        if message.headers is None:
+            await self._producer.produce(message.topic, payload)
+        else:
+            await self._producer.produce(
+                message.topic,
+                payload,
+                headers=message.headers,
+            )

python_cqrs-4.15.0/src/cqrs/message_brokers/protocol.py

@@ -0,0 +1,74 @@
+import abc
+import base64
+import dataclasses
+import typing
+import uuid
+from dataclass_wizard import asdict
+
+
+@dataclasses.dataclass
+class Message:
+    """
+    Internal message structure for message broker communication.
+
+    Args:
+        message_name: Name of the message type
+        message_id: Unique identifier for the message (auto-generated if not provided)
+        topic: Message broker topic where the message should be sent
+        payload: Structured message payload (typically ``event.to_dict()``)
+        payload_bytes: Optional codec wire-bytes for the transport
+        content_type: Optional MIME type (set only by typed codecs such as Protobuf)
+        headers: Optional broker headers (set only when ``content_type`` is set)
+    """
+
+    message_name: typing.Text
+    topic: typing.Text
+    payload: typing.Any
+    message_id: uuid.UUID = dataclasses.field(default_factory=uuid.uuid4)
+    payload_bytes: bytes | None = None
+    content_type: str | None = None
+    headers: dict[str, str] | None = None
+
+    def to_dict(self) -> dict[str, typing.Any]:
+        """
+        Convert the message instance to a dictionary representation.
+
+        Core fields use ``dataclass_wizard.asdict`` camelCase (``messageName``,
+        ``messageId``, …) for JSON-path ``GET /published`` stability. Codec
+        extras (``content_type`` / ``payload_bytes`` / ``headers``) are added
+        only when ``content_type`` is set, in snake_case.
+        """
+        # Rebuild with only the original fields so asdict matches the historical
+        # JSON-path shape (camelCase messageName/messageId). Extra codec fields
+        # still appear as None camelCase keys from defaults — drop them.
+        data = asdict(
+            Message(
+                message_name=self.message_name,
+                topic=self.topic,
+                payload=self.payload,
+                message_id=self.message_id,
+            ),
+        )
+        data.pop("payloadBytes", None)
+        data.pop("contentType", None)
+        data.pop("headers", None)
+        if self.content_type is not None:
+            data["content_type"] = self.content_type
+            if self.payload_bytes is not None:
+                data["payload_bytes"] = base64.b64encode(self.payload_bytes).decode("ascii")
+                data["payload_bytes_encoding"] = "base64"
+            if self.headers is not None:
+                data["headers"] = self.headers
+        return data
+
+
+class MessageBroker(abc.ABC):
+    """
+    The interface over a message broker.
+
+    Used for sending messages to message brokers (currently only redis supported).
+    """
+
+    @abc.abstractmethod
+    async def send_message(self, message: Message) -> None:
+        raise NotImplementedError

python_cqrs-4.15.0/src/cqrs/outbox/map.py

@@ -0,0 +1,103 @@
+import functools
+import typing
+
+from cqrs.events.event import INotificationEvent
+from cqrs.serializers.json import JsonEventSerializer
+from cqrs.serializers.protocol import EventCodec, EventSerializer
+
+
+class _bind_self_or_singleton:
+    """
+    Descriptor for dual class/instance API.
+
+    Class access binds to the process-global singleton; instance access binds to
+    that map instance.
+    """
+
+    def __init__(self, func: typing.Callable) -> None:
+        self.func = func
+
+    def __get__(
+        self,
+        obj: typing.Any,
+        objtype: type | None = None,
+    ) -> typing.Callable:
+        target = obj if obj is not None else objtype._singleton()  # type: ignore[union-attr]
+        return functools.partial(self.func, target)
+
+
+class OutboxedEventMap:
+    """
+    Registry of outbox event names to types and optional codecs.
+
+    Class-level ``register`` / ``get`` use a process-global singleton (existing
+    behaviour). ``OutboxedEventMap()`` creates an isolated registry.
+
+    Warning: class-level methods mutate the process singleton; prefer an
+    instance map when tests or apps need isolation.
+    """
+
+    _instance: typing.ClassVar["OutboxedEventMap | None"] = None
+
+    def __init__(self) -> None:
+        self._entries: typing.Dict[
+            typing.Text,
+            typing.Tuple[typing.Type[INotificationEvent], EventCodec | None],
+        ] = {}
+
+    @classmethod
+    def _singleton(cls) -> "OutboxedEventMap":
+        if cls._instance is None:
+            cls._instance = cls()
+        return cls._instance
+
+    @_bind_self_or_singleton
+    def register(
+        self,
+        event_name: typing.Text,
+        event_type: typing.Type[INotificationEvent],
+        serializer: EventCodec | None = None,
+    ) -> None:
+        if event_name in self._entries:
+            raise KeyError(f"Event with {event_name} already registered")
+        self._entries[event_name] = (event_type, serializer)
+
+    @_bind_self_or_singleton
+    def get(
+        self,
+        event_name: typing.Text,
+    ) -> typing.Type[INotificationEvent] | None:
+        entry = self._entries.get(event_name)
+        if entry is None:
+            return None
+        return entry[0]
+
+    @_bind_self_or_singleton
+    def get_serializer(
+        self,
+        event_name: typing.Text,
+    ) -> EventCodec | None:
+        entry = self._entries.get(event_name)
+        if entry is None:
+            return None
+        return entry[1]
+
+    @_bind_self_or_singleton
+    def as_serializer(
+        self,
+        default: EventSerializer | None = None,
+    ) -> EventSerializer:
+        fallback = default or JsonEventSerializer()
+        event_map = self
+
+        class _Dispatcher:
+            def resolve_codec(self, event: INotificationEvent) -> EventSerializer:
+                return event_map.get_serializer(event.event_name) or fallback
+
+            def serialize(self, event: INotificationEvent) -> bytes:
+                return self.resolve_codec(event).serialize(event)
+
+            def content_type_for(self, event: INotificationEvent) -> str | None:
+                return self.resolve_codec(event).content_type_for(event)
+
+        return _Dispatcher()

{python_cqrs-4.14.0 → python_cqrs-4.15.0}/src/cqrs/outbox/mock.py

@@ -1,14 +1,24 @@
 import typing
 
 import cqrs
-from cqrs.outbox import repository
+from cqrs.outbox import map, repository
+from cqrs.serializers.json import JsonEventSerializer
+from cqrs.serializers.protocol import EventCodec
 
 
 class MockOutboxedEventRepository(repository.OutboxedEventRepository):
     COUNTER: typing.ClassVar = 0
 
-    def __init__(self, session_factory: typing.Callable[[], typing.Dict]):
+    def __init__(
+        self,
+        session_factory: typing.Callable[[], typing.Dict],
+        *,
+        serializer: EventCodec | None = None,
+        event_map: map.OutboxedEventMap | None = None,
+    ):
         self.session = session_factory()
+        self._serializer = serializer or JsonEventSerializer()
+        self._event_map = event_map if event_map is not None else map.OutboxedEventMap
 
     async def __aenter__(self) -> typing.Dict:
         return self.session
@@ -16,13 +26,19 @@ class MockOutboxedEventRepository(repository.OutboxedEventRepository):
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         pass
 
+    def _resolve_codec(self, event_name: str) -> EventCodec:
+        return self._event_map.get_serializer(event_name) or self._serializer
+
     def add(self, event: cqrs.INotificationEvent) -> None:
         MockOutboxedEventRepository.COUNTER += 1
+        codec = self._resolve_codec(event.event_name)
         self.session[MockOutboxedEventRepository.COUNTER] = repository.OutboxedEvent(
             id=MockOutboxedEventRepository.COUNTER,
             event=event,
             topic=event.topic,
             status=repository.EventStatus.NEW,
+            payload_bytes=codec.serialize(event),
+            content_type=codec.content_type_for(event),
         )
 
     async def get_many(