python-event-sourcery 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

event_sourcery/__init__.py

@@ -1,68 +0,0 @@
-__all__ = [
-    "configure_models",
-    "get_event_store",
-    "Event",
-    "EventStore",
-    "get_outbox",
-    "Repository",
-    "Aggregate",
-    "Metadata",
-    "Context",
-    "NO_VERSIONING",
-    "Projector",
-    "Subscription",
-]
-
-from typing import Callable, Type
-
-from sqlalchemy.orm import Session
-
-from event_sourcery.aggregate import Aggregate
-from event_sourcery.dummy_outbox_storage_strategy import DummyOutboxStorageStrategy
-from event_sourcery.event_store import EventStore
-from event_sourcery.interfaces.base_event import Event
-from event_sourcery.interfaces.event import Context, Metadata
-from event_sourcery.interfaces.event import TEvent as EventProtocol
-from event_sourcery.interfaces.outbox_storage_strategy import OutboxStorageStrategy
-from event_sourcery.interfaces.subscriber import Subscriber
-from event_sourcery.outbox import Outbox
-from event_sourcery.projector import Projector
-from event_sourcery.repository import Repository
-from event_sourcery.subscription import Subscription
-from event_sourcery.types.stream_id import StreamName
-from event_sourcery.versioning import NO_VERSIONING
-from event_sourcery_pydantic.serde import PydanticSerde
-from event_sourcery_sqlalchemy.models import configure_models
-from event_sourcery_sqlalchemy.sqlalchemy_event_store import SqlAlchemyStorageStrategy
-from event_sourcery_sqlalchemy.sqlalchemy_outbox import SqlAlchemyOutboxStorageStrategy
-
-
-def get_event_store(
-    session: Session,
-    subscriptions: dict[Type[EventProtocol], list[Subscriber]] | None = None,
-    with_outbox: bool = True,
-) -> EventStore:
-    outbox_storage: OutboxStorageStrategy
-    if with_outbox:
-        outbox_storage = SqlAlchemyOutboxStorageStrategy(session)
-    else:
-        outbox_storage = DummyOutboxStorageStrategy()
-
-    return EventStore(
-        serde=PydanticSerde(),
-        storage_strategy=SqlAlchemyStorageStrategy(session),
-        outbox_storage_strategy=outbox_storage,
-        event_base_class=Event,
-        subscriptions=subscriptions,
-    )
-
-
-def get_outbox(
-    session: Session, publisher: Callable[[Metadata, StreamName | None], None]
-) -> Outbox:
-    return Outbox(
-        serde=PydanticSerde(),
-        storage_strategy=SqlAlchemyOutboxStorageStrategy(session),
-        event_base_class=Event,
-        publisher=publisher,
-    )

event_sourcery/aggregate/__init__.py

@@ -0,0 +1,7 @@
+__all__ = [
+    "Aggregate",
+    "Repository",
+]
+
+from event_sourcery.aggregate.aggregate import Aggregate
+from event_sourcery.aggregate.repository import Repository

event_sourcery/aggregate/aggregate.py

@@ -0,0 +1,23 @@
+from contextlib import contextmanager
+from typing import ClassVar, Iterator
+
+from event_sourcery.event_store import Event
+
+
+class Aggregate:
+    category: ClassVar[str]
+    _changes: list[Event]
+
+    @contextmanager
+    def __persisting_changes__(self) -> Iterator[Iterator[Event]]:
+        yield iter(getattr(self, "_changes", []))
+        self._changes = []
+
+    def __apply__(self, event: Event) -> None:
+        raise NotImplementedError
+
+    def _emit(self, event: Event) -> None:
+        if not hasattr(self, "_changes"):
+            self._changes = []
+        self.__apply__(event)
+        self._changes.append(event)

event_sourcery/{repository.py → aggregate/repository.py}

@@ -2,14 +2,9 @@ from contextlib import contextmanager
 from typing import Generic, Iterator, TypeVar, cast
 
 from event_sourcery.aggregate import Aggregate
-from event_sourcery.event_store import EventStore
-from event_sourcery.interfaces.base_event import Event
-from event_sourcery.interfaces.event import Metadata
-from event_sourcery.types.stream_id import StreamId
+from event_sourcery.event_store import Event, EventStore, Metadata, StreamId, StreamUUID
 
 TAggregate = TypeVar("TAggregate", bound=Aggregate)
-
-
 TEvent = TypeVar("TEvent", bound=Event)
 
 
@@ -20,9 +15,10 @@ class Repository(Generic[TAggregate]):
     @contextmanager
     def aggregate(
         self,
-        stream_id: StreamId,
+        uuid: StreamUUID,
         aggregate: TAggregate,
     ) -> Iterator[TAggregate]:
+        stream_id = StreamId(uuid=uuid, name=uuid.name, category=aggregate.category)
         old_version = self._load(stream_id, aggregate)
         yield aggregate
         self._save(aggregate, old_version, stream_id)
@@ -42,13 +38,18 @@ class Repository(Generic[TAggregate]):
         old_version: int,
         stream_id: StreamId,
     ) -> None:
-        with aggregate.__persisting_changes__() as events:
+        with aggregate.__persisting_changes__() as pending:
             start_from = old_version + 1
+            events = [
+                Metadata.wrap(event, version)
+                for version, event in enumerate(pending, start=start_from)
+            ]
+
+            if not events:
+                return
+
             self._event_store.publish(
-                *[
-                    Metadata.wrap(event, version)
-                    for version, event in enumerate(events, start=start_from)
-                ],
+                *events,
                 stream_id=stream_id,
                 expected_version=old_version,
             )

event_sourcery/event_store/__init__.py

@@ -0,0 +1,52 @@
+__all__ = [
+    "Backend",
+    "BackendFactory",
+    "Dispatcher",
+    "Entry",
+    "Event",
+    "EventRegistry",
+    "EventStore",
+    "ExplicitVersioning",
+    "InMemoryBackendFactory",
+    "Listener",
+    "Metadata",
+    "NO_VERSIONING",
+    "Position",
+    "RawEvent",
+    "Recorded",
+    "RecordedRaw",
+    "StreamId",
+    "StreamUUID",
+    "TransactionalBackend",
+    "Versioning",
+    "exceptions",
+    "factory",
+    "interfaces",
+    "subscription",
+]
+
+from event_sourcery.event_store import exceptions, factory, interfaces, subscription
+from event_sourcery.event_store.dispatcher import Dispatcher, Listener
+from event_sourcery.event_store.event import (
+    Entry,
+    Event,
+    EventRegistry,
+    Metadata,
+    Position,
+    RawEvent,
+    Recorded,
+    RecordedRaw,
+)
+from event_sourcery.event_store.event_store import EventStore
+from event_sourcery.event_store.factory import (
+    Backend,
+    BackendFactory,
+    TransactionalBackend,
+)
+from event_sourcery.event_store.in_memory import InMemoryBackendFactory
+from event_sourcery.event_store.stream_id import StreamId, StreamUUID
+from event_sourcery.event_store.versioning import (
+    NO_VERSIONING,
+    ExplicitVersioning,
+    Versioning,
+)

event_sourcery/event_store/dispatcher.py

@@ -0,0 +1,35 @@
+from collections import defaultdict
+from typing import Callable, Type
+
+from event_sourcery.event_store.event import (
+    Event,
+    Metadata,
+    Position,
+    RecordedRaw,
+    Serde,
+)
+from event_sourcery.event_store.stream_id import StreamId
+
+Listener = Callable[[Metadata, StreamId, Position | None], None]
+
+
+class Dispatcher:
+    def __init__(self, serde: Serde) -> None:
+        self._listeners: dict[Type[Event], set[Listener]] = defaultdict(set)
+        self._serde = serde
+
+    def dispatch(self, *raws: RecordedRaw) -> None:
+        for raw in raws:
+            record = self._serde.deserialize_record(raw)
+            for event_type, listeners in self._listeners.items():
+                if not isinstance(record.metadata.event, event_type):
+                    continue
+                for listener in listeners:
+                    listener(record.metadata, record.stream_id, record.position)
+
+    def register(self, listener: Listener, to: Type[Event]) -> None:
+        self._listeners[to].add(listener)
+
+    def remove(self, listener: Listener, to: Type[Event]) -> None:
+        if listener in self._listeners[to]:
+            self._listeners[to].remove(listener)

event_sourcery/event_store/event/__init__.py

@@ -0,0 +1,26 @@
+__all__ = [
+    "Context",
+    "Entry",
+    "Event",
+    "EventRegistry",
+    "Metadata",
+    "Position",
+    "RawEvent",
+    "Recorded",
+    "RecordedRaw",
+    "Serde",
+]
+
+
+from event_sourcery.event_store.event.dto import (
+    Context,
+    Entry,
+    Event,
+    Metadata,
+    Position,
+    RawEvent,
+    Recorded,
+    RecordedRaw,
+)
+from event_sourcery.event_store.event.registry import EventRegistry
+from event_sourcery.event_store.event.serde import Serde

event_sourcery/event_store/event/dto.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+from typing import Any, ClassVar, Generic, Optional, TypeAlias, TypeVar
+from uuid import UUID, uuid4
+
+from pydantic import BaseModel, Field
+
+from event_sourcery.event_store.event.registry import EventRegistry
+from event_sourcery.event_store.stream_id import StreamId
+
+
+class RawEvent(BaseModel):
+    uuid: UUID
+    stream_id: StreamId
+    created_at: datetime
+    version: int | None = None
+    name: str
+    data: dict
+    context: dict
+
+
+Position: TypeAlias = int
+
+
+class RecordedRaw(BaseModel):
+    entry: RawEvent
+    position: Position
+
+
+class Event(BaseModel, extra="forbid"):
+    __registry__: ClassVar = EventRegistry()
+
+    def __init_subclass__(cls, **kwargs: Any) -> None:
+        cls.__registry__.add(cls)
+
+
+TEvent = TypeVar("TEvent", bound=Event)
+
+
+class Context(BaseModel, extra="allow"):
+    correlation_id: UUID | None = None
+    causation_id: UUID | None = None
+
+
+class Metadata(BaseModel, Generic[TEvent], extra="forbid"):
+    event: TEvent
+    version: Optional[int]
+    uuid: UUID = Field(default_factory=uuid4)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    context: Context = Field(default_factory=Context)
+
+    @classmethod
+    def wrap(cls, event: TEvent, version: int | None) -> "Metadata[TEvent]":
+        return Metadata[TEvent](event=event, version=version)
+
+
+class Entry(BaseModel):
+    metadata: Metadata
+    stream_id: StreamId
+
+
+class Recorded(Entry):
+    position: Position

event_sourcery/{event_registry.py → event_store/event/registry.py}

@@ -1,17 +1,18 @@
 import inspect
 from typing import TYPE_CHECKING, Type
 
-if TYPE_CHECKING:
-    from event_sourcery.interfaces.base_event import Event
-
+from event_sourcery.event_store.exceptions import (
+    ClassModuleUnavailable,
+    DuplicatedEvent,
+)
 
-class ClassModuleUnavailable(Exception):
-    pass
+if TYPE_CHECKING:
+    from event_sourcery.event_store.event.dto import Event
 
 
 def event_name(cls: Type) -> str:
     event_module = inspect.getmodule(cls)
-    if event_module is None:
+    if event_module is None:  # pragma: no cover
         raise ClassModuleUnavailable
     return f"{event_module.__name__}.{cls.__qualname__}"
 
@@ -23,11 +24,11 @@ class EventRegistry:
 
     def add(self, event: Type["Event"]) -> Type["Event"]:
         if event in self._types_to_names:
-            raise Exception(f"Duplicated Event detected! {event}")
+            raise DuplicatedEvent(f"Duplicated Event detected! {event}")
 
         name = event_name(event)
         if name in self._names_to_types:
-            raise Exception(f"Duplicated Event name detected! {name}")
+            raise DuplicatedEvent(f"Duplicated Event name detected! {name}")
 
         self._types_to_names[event] = name
         self._names_to_types[name] = event

event_sourcery/event_store/event/serde.py

@@ -0,0 +1,51 @@
+from dataclasses import dataclass
+from typing import Mapping, cast
+
+from event_sourcery.event_store.event.dto import (
+    Event,
+    Metadata,
+    RawEvent,
+    Recorded,
+    RecordedRaw,
+)
+from event_sourcery.event_store.event.registry import EventRegistry
+from event_sourcery.event_store.stream_id import StreamId
+
+
+@dataclass(repr=False, frozen=True)
+class Serde:
+    registry: EventRegistry
+
+    def deserialize(self, event: RawEvent) -> Metadata:
+        event_as_dict = dict(event)
+        del event_as_dict["stream_id"]
+        del event_as_dict["name"]
+        data = cast(Mapping, event_as_dict.pop("data"))
+        event_type = self.registry.type_for_name(event.name)
+        return Metadata[event_type](  # type: ignore
+            **event_as_dict,
+            event=event_type(**data),
+        )
+
+    def deserialize_record(self, record: RecordedRaw) -> Recorded:
+        return Recorded(
+            metadata=self.deserialize(record.entry),
+            stream_id=record.entry.stream_id,
+            position=record.position,
+        )
+
+    def serialize(
+        self,
+        event: Metadata,
+        stream_id: StreamId,
+    ) -> RawEvent:
+        model = cast(Event, event.event)
+        return RawEvent(
+            uuid=event.uuid,
+            stream_id=stream_id,
+            created_at=event.created_at,
+            version=event.version,
+            name=self.registry.name_for_type(type(event.event)),
+            data=model.model_dump(mode="json"),
+            context=event.context.model_dump(mode="json"),
+        )

event_sourcery/event_store/event_store.py

@@ -0,0 +1,128 @@
+from functools import singledispatchmethod
+from typing import Sequence, cast
+
+from event_sourcery.event_store.event import Event, Metadata, Position, RawEvent, Serde
+from event_sourcery.event_store.interfaces import StorageStrategy
+from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.versioning import (
+    NO_VERSIONING,
+    ExplicitVersioning,
+    Versioning,
+)
+
+
+class EventStore:
+    def __init__(self, storage_strategy: StorageStrategy, serde: Serde) -> None:
+        self._storage_strategy = storage_strategy
+        self._serde = serde
+
+    def load_stream(
+        self,
+        stream_id: StreamId,
+        start: int | None = None,
+        stop: int | None = None,
+    ) -> Sequence[Metadata]:
+        events = self._storage_strategy.fetch_events(stream_id, start=start, stop=stop)
+        return self._deserialize_events(events)
+
+    @singledispatchmethod
+    def append(
+        self,
+        first: Metadata,
+        *events: Metadata,
+        stream_id: StreamId,
+        expected_version: int | Versioning = 0,
+    ) -> None:
+        self._append(
+            stream_id=stream_id,
+            events=(first,) + events,
+            expected_version=expected_version,
+        )
+
+    @append.register
+    def _append_events(
+        self,
+        *events: Event,
+        stream_id: StreamId,
+        expected_version: int | Versioning = 0,
+    ) -> None:
+        wrapped_events = self._wrap_events(expected_version, events)
+        self.append(
+            *wrapped_events,
+            stream_id=stream_id,
+            expected_version=expected_version,
+        )
+
+    @singledispatchmethod
+    def _wrap_events(
+        self,
+        expected_version: int,
+        events: Sequence[Event],
+    ) -> Sequence[Metadata]:
+        return [
+            Metadata.wrap(event=event, version=version)
+            for version, event in enumerate(events, start=expected_version + 1)
+        ]
+
+    @_wrap_events.register
+    def _wrap_events_versioning(
+        self, expected_version: Versioning, events: Sequence[Event]
+    ) -> Sequence[Metadata]:
+        return [Metadata.wrap(event=event, version=None) for event in events]
+
+    @singledispatchmethod
+    def publish(
+        self,
+        first: Metadata,
+        *events: Metadata,
+        stream_id: StreamId,
+        expected_version: int | Versioning = 0,
+    ) -> None:
+        self._append(
+            stream_id=stream_id,
+            events=(first,) + events,
+            expected_version=expected_version,
+        )
+
+    def _append(
+        self,
+        stream_id: StreamId,
+        events: Sequence[Metadata],
+        expected_version: int | Versioning,
+    ) -> None:
+        new_version = events[-1].version
+        versioning: Versioning
+        if expected_version is not NO_VERSIONING:
+            versioning = ExplicitVersioning(
+                expected_version=cast(int, expected_version),
+                initial_version=cast(int, new_version),
+            )
+        else:
+            versioning = NO_VERSIONING
+
+        self._storage_strategy.insert_events(
+            stream_id=stream_id,
+            versioning=versioning,
+            events=self._serialize_events(events, stream_id),
+        )
+
+    def delete_stream(self, stream_id: StreamId) -> None:
+        self._storage_strategy.delete_stream(stream_id)
+
+    def save_snapshot(self, stream_id: StreamId, snapshot: Metadata) -> None:
+        serialized = self._serde.serialize(event=snapshot, stream_id=stream_id)
+        self._storage_strategy.save_snapshot(serialized)
+
+    def _deserialize_events(self, events: list[RawEvent]) -> list[Metadata]:
+        return [self._serde.deserialize(e) for e in events]
+
+    def _serialize_events(
+        self,
+        events: Sequence[Metadata],
+        stream_id: StreamId,
+    ) -> list[RawEvent]:
+        return [self._serde.serialize(event=e, stream_id=stream_id) for e in events]
+
+    @property
+    def position(self) -> Position | None:
+        return self._storage_strategy.current_position

event_sourcery/{exceptions.py → event_store/exceptions.py}

@@ -1,16 +1,20 @@
+from dataclasses import dataclass
+from uuid import UUID
+
+
 class EventStoreException(Exception):
     pass
 
 
-class NoEventsToAppend(EventStoreException):
+class ConcurrentStreamWriteError(EventStoreException):
     pass
 
 
-class ConcurrentStreamWriteError(EventStoreException):
+class AnotherStreamWithThisNameButOtherIdExists(EventStoreException):
     pass
 
 
-class Misconfiguration(EventStoreException):
+class IllegalCategoryName(EventStoreException):
     pass
 
 
@@ -18,17 +22,24 @@ class VersioningMismatch(EventStoreException):
     pass
 
 
-class EitherStreamIdOrStreamNameIsRequired(EventStoreException):
+class ExpectedVersionUsedOnVersionlessStream(VersioningMismatch):
     pass
 
 
-class AnotherStreamWithThisNameButOtherIdExists(EventStoreException):
+class NoExpectedVersionGivenOnVersionedStream(VersioningMismatch):
     pass
 
 
-class ExpectedVersionUsedOnVersionlessStream(VersioningMismatch):
+@dataclass
+class IncompatibleUuidAndName(EventStoreException):
+    received: UUID
+    expected: UUID
+    name: str
+
+
+class ClassModuleUnavailable(Exception):
     pass
 
 
-class NoExpectedVersionGivenOnVersionedStream(VersioningMismatch):
+class DuplicatedEvent(Exception):
     pass

event_sourcery/event_store/factory.py

@@ -0,0 +1,52 @@
+import abc
+from typing import ContextManager, Iterator
+
+from typing_extensions import Self
+
+from event_sourcery.event_store import subscription
+from event_sourcery.event_store.dispatcher import Dispatcher
+from event_sourcery.event_store.event import EventRegistry, RawEvent, RecordedRaw, Serde
+from event_sourcery.event_store.event_store import EventStore
+from event_sourcery.event_store.interfaces import (
+    OutboxFiltererStrategy,
+    OutboxStorageStrategy,
+)
+from event_sourcery.event_store.outbox import Outbox
+
+
+def no_filter(entry: RawEvent) -> bool:
+    return True
+
+
+class NoOutboxStorageStrategy(OutboxStorageStrategy):
+    def outbox_entries(self, limit: int) -> Iterator[ContextManager[RecordedRaw]]:
+        return iter([])
+
+
+class Backend:
+    serde: Serde
+    event_store: EventStore
+    outbox: Outbox
+    subscriber: subscription.PositionPhase
+
+
+class TransactionalBackend(Backend):
+    in_transaction: Dispatcher
+
+
+class BackendFactory(abc.ABC):
+    @abc.abstractmethod
+    def build(self) -> Backend:
+        pass
+
+    @abc.abstractmethod
+    def with_event_registry(self, event_registry: EventRegistry) -> Self:
+        pass
+
+    @abc.abstractmethod
+    def with_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
+        pass
+
+    @abc.abstractmethod
+    def without_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
+        pass