python-event-sourcery 0.4.0a9__tar.gz → 0.4.0a10__tar.gz

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: python-event-sourcery
-Version: 0.4.0a9
+Version: 0.4.0a10
 Summary: 
 License: MIT
 Author: Your Name

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/__init__.py

@@ -23,6 +23,7 @@ __all__ = [
     "factory",
     "interfaces",
     "subscription",
+    "TenantId",
 ]
 
 from event_sourcery.event_store import exceptions, factory, interfaces, subscription
@@ -45,6 +46,7 @@ from event_sourcery.event_store.factory import (
 )
 from event_sourcery.event_store.in_memory import InMemoryBackendFactory
 from event_sourcery.event_store.stream_id import StreamId, StreamUUID
+from event_sourcery.event_store.tenant_id import TenantId
 from event_sourcery.event_store.versioning import (
     NO_VERSIONING,
     ExplicitVersioning,

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/dispatcher.py

@@ -9,8 +9,9 @@ from event_sourcery.event_store.event import (
     WrappedEvent,
 )
 from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.tenant_id import TenantId
 
-Listener = Callable[[WrappedEvent, StreamId, Position | None], None]
+Listener = Callable[[WrappedEvent, StreamId, TenantId, Position | None], None]
 
 
 class Dispatcher:
@@ -25,7 +26,12 @@ class Dispatcher:
                 if not isinstance(record.wrapped_event.event, event_type):
                     continue
                 for listener in listeners:
-                    listener(record.wrapped_event, record.stream_id, record.position)
+                    listener(
+                        record.wrapped_event,
+                        record.stream_id,
+                        record.tenant_id,
+                        record.position,
+                    )
 
     def register(self, listener: Listener, to: type[Event]) -> None:
         self._listeners[to].add(listener)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/event/dto.py

@@ -6,6 +6,7 @@ from pydantic import BaseModel, Field
 
 from event_sourcery.event_store.event.registry import EventRegistry
 from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 
 
 class RawEvent(BaseModel):
@@ -24,6 +25,7 @@ Position: TypeAlias = int
 class RecordedRaw(BaseModel):
     entry: RawEvent
     position: Position
+    tenant_id: TenantId = DEFAULT_TENANT
 
 
 class Event(BaseModel, extra="forbid"):
@@ -83,3 +85,4 @@ class Entry(BaseModel):
 
 class Recorded(Entry):
     position: Position
+    tenant_id: TenantId = DEFAULT_TENANT

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/event/serde.py

@@ -36,6 +36,7 @@ class Serde:
             wrapped_event=self.deserialize(record.entry),
             stream_id=record.entry.stream_id,
             position=record.position,
+            tenant_id=record.tenant_id,
         )
 
     def serialize(

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/event_store.py

@@ -10,6 +10,7 @@ from event_sourcery.event_store.event import (
 )
 from event_sourcery.event_store.interfaces import StorageStrategy
 from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery.event_store.versioning import (
     NO_VERSIONING,
     ExplicitVersioning,
@@ -189,3 +190,21 @@ class EventStore:
 
         """
         return self._storage_strategy.current_position
+
+    def scoped_for_tenant(self, tenant_id: TenantId = DEFAULT_TENANT) -> "EventStore":
+        """Factory method to create a new event store instance scoped to a tenant.
+
+        Examples:
+            >>> event_store.scoped_for_tenant("tenant_1")
+            <EventStore ...>
+
+        Args:
+            tenant_id: The tenant identifier to work with.
+
+        Returns:
+            An event store instance scoped to the tenant.
+        """
+        return EventStore(
+            storage_strategy=self._storage_strategy.scoped_for_tenant(tenant_id),
+            serde=self._serde,
+        )

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/exceptions.py

@@ -18,6 +18,10 @@ class IllegalCategoryName(EventStoreException):
     pass
 
 
+class IllegalTenantId(EventStoreException):
+    pass
+
+
 class VersioningMismatch(EventStoreException):
     pass
 

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/in_memory.py

@@ -32,18 +32,19 @@ from event_sourcery.event_store.interfaces import (
 )
 from event_sourcery.event_store.outbox import Outbox
 from event_sourcery.event_store.stream_id import StreamId
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery.event_store.versioning import NO_VERSIONING, Versioning
 
 
 @dataclass
 class Storage:
-    events: list[RawEvent] = field(default_factory=list, init=False)
-    _data: dict[StreamId, list[RawEvent]] = field(default_factory=dict, init=False)
+    records: list[RecordedRaw] = field(default_factory=list, init=False)
+    _data: dict[StreamId, list[RecordedRaw]] = field(default_factory=dict, init=False)
     _versions: dict[StreamId, int | None] = field(default_factory=dict, init=False)
 
     @property
-    def current_position(self) -> int:
-        return len(self.events)
+    def current_position(self) -> int | None:
+        return self.records[-1].position if self.records else None
 
     def __contains__(self, stream_id: object) -> bool:
         return stream_id in self._data
@@ -55,19 +56,19 @@ class Storage:
         else:
             self._versions[stream_id] = 0
 
-    def append(self, events: list[RawEvent]) -> None:
-        self.events.extend(events)
-        for event in events:
-            stream_id = event.stream_id
-            self._data[stream_id].append(event)
-            self._versions[stream_id] = event.version
+    def append(self, records: list[RecordedRaw]) -> None:
+        self.records.extend(records)
+        for record in records:
+            stream_id = record.entry.stream_id
+            self._data[stream_id].append(record)
+            self._versions[stream_id] = record.entry.version
 
-    def replace(self, with_snapshot: RawEvent) -> None:
-        stream_id = with_snapshot.stream_id
+    def replace(self, with_snapshot: RecordedRaw) -> None:
+        stream_id = with_snapshot.entry.stream_id
         self._data[stream_id] = [with_snapshot]
-        self._versions[stream_id] = with_snapshot.version
+        self._versions[stream_id] = with_snapshot.entry.version
 
-    def read(self, stream_id: StreamId) -> list[RawEvent]:
+    def read(self, stream_id: StreamId) -> list[RecordedRaw]:
         return copy(self._data[stream_id])
 
     def delete(self, stream_id: StreamId) -> None:
@@ -84,15 +85,15 @@ class InMemorySubscription(Iterator[list[RecordedRaw]]):
     _batch_size: int
     _timelimit: timedelta
 
-    def _pop_record(self) -> tuple[RawEvent, Position] | None:
-        if len(self._storage.events) <= self._current_position:
+    def _pop_record(self) -> RecordedRaw | None:
+        if (self._storage.current_position or 0) <= self._current_position:
             return None
-        record = self._storage.events[self._current_position]
+        record = self._storage.records[self._current_position]
         self._current_position += 1
-        return record, self._current_position - 1
+        return record
 
     def __next__(self) -> list[RecordedRaw]:
-        batch: list[tuple[RawEvent, Position]] = []
+        batch: list[RecordedRaw] = []
 
         start = time.monotonic()
         while len(batch) < self._batch_size:
@@ -103,23 +104,19 @@ class InMemorySubscription(Iterator[list[RecordedRaw]]):
             if time.monotonic() - start > self._timelimit.total_seconds():
                 break
 
-        return [
-            RecordedRaw(entry=copy(record), position=position)
-            for record, position in batch
-        ]
+        return batch
 
 
 @dataclass
 class InMemoryToCategorySubscription(InMemorySubscription):
     _category: str
 
-    def _pop_record(self) -> tuple[RawEvent, Position] | None:
+    def _pop_record(self) -> RecordedRaw | None:
         while True:
             record = super()._pop_record()
             if record is None:
                 return None
-            raw, position = record
-            if raw.stream_id.category != self._category:
+            if record.entry.stream_id.category != self._category:
                 continue
             return record
 
@@ -128,13 +125,12 @@ class InMemoryToCategorySubscription(InMemorySubscription):
 class InMemoryToEventTypesSubscription(InMemorySubscription):
     _types: list[str]
 
-    def _pop_record(self) -> tuple[RawEvent, Position] | None:
+    def _pop_record(self) -> RecordedRaw | None:
         while True:
             record = super()._pop_record()
             if record is None:
                 return None
-            raw, position = record
-            if raw.name not in self._types:
+            if record.entry.name not in self._types:
                 continue
             return record
 
@@ -225,11 +221,13 @@ class InMemoryStorageStrategy(StorageStrategy):
         storage: Storage,
         dispatcher: Dispatcher,
         outbox_strategy: InMemoryOutboxStorageStrategy | None,
+        tenant_id: TenantId = DEFAULT_TENANT,
     ) -> None:
         self._names: dict[str | None, str] = {}
         self._storage = storage
         self._dispatcher = dispatcher
         self._outbox = outbox_strategy
+        self._tenant_id = tenant_id
 
     def fetch_events(
         self,
@@ -243,24 +241,29 @@ class InMemoryStorageStrategy(StorageStrategy):
             self._storage.read(stream_id),
             slice(start and start - 1, stop and stop - 1),
         )
-        return list(stream)
+        return [r.entry for r in stream if r.tenant_id == self._tenant_id]
 
     def insert_events(
         self, stream_id: StreamId, versioning: Versioning, events: list[RawEvent]
     ) -> None:
         position = self.current_position or 0
         self._ensure_stream(stream_id=stream_id, versioning=versioning)
-        self._storage.append(events)
         records = [
-            RecordedRaw(entry=raw, position=position)
+            RecordedRaw(entry=raw, position=position, tenant_id=self._tenant_id)
             for position, raw in enumerate(events, start=position + 1)
         ]
+        self._storage.append(records)
         if self._outbox:
             self._outbox.put_into_outbox(records)
         self._dispatcher.dispatch(*records)
 
     def save_snapshot(self, snapshot: RawEvent) -> None:
-        self._storage.replace(with_snapshot=snapshot)
+        record = RecordedRaw(
+            entry=snapshot,
+            position=(self.current_position or 0) + 1,
+            tenant_id=self._tenant_id,
+        )
+        self._storage.replace(with_snapshot=record)
 
     def _ensure_stream(self, stream_id: StreamId, versioning: Versioning) -> None:
         if stream_id not in self._storage:
@@ -289,6 +292,14 @@ class InMemoryStorageStrategy(StorageStrategy):
         current_position = self._storage.current_position
         return current_position and Position(current_position)
 
+    def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
+        return type(self)(
+            storage=self._storage,
+            dispatcher=self._dispatcher,
+            outbox_strategy=self._outbox,
+            tenant_id=tenant_id,
+        )
+
 
 class Config(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/interfaces.py

@@ -4,6 +4,8 @@ from contextlib import AbstractContextManager
 from datetime import timedelta
 from typing import Protocol
 
+from typing_extensions import Self
+
 from event_sourcery.event_store.event import Position, RawEvent, RecordedRaw
 from event_sourcery.event_store.stream_id import StreamId
 from event_sourcery.event_store.versioning import Versioning
@@ -80,3 +82,7 @@ class StorageStrategy(abc.ABC):
     @abc.abstractmethod
     def current_position(self) -> Position | None:
         pass
+
+    @abc.abstractmethod
+    def scoped_for_tenant(self, tenant_id: str) -> Self:
+        pass

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery/event_store/outbox.py

@@ -22,5 +22,6 @@ class Outbox:
                     wrapped_event=event,
                     stream_id=raw_record.entry.stream_id,
                     position=raw_record.position,
+                    tenant_id=raw_record.tenant_id,
                 )
                 publisher(record)

python_event_sourcery-0.4.0a10/event_sourcery/event_store/tenant_id.py

@@ -0,0 +1,5 @@
+from typing import Final, TypeAlias
+
+TenantId: TypeAlias = str
+
+DEFAULT_TENANT: Final[TenantId] = ""

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_esdb/dto.py

@@ -16,7 +16,7 @@ def raw_event(from_entry: RecordedEvent) -> RawEvent:
     position = stream.Position(from_entry.stream_position)
     return RawEvent(
         uuid=from_entry.id,
-        stream_id=stream.Name(stream_name=from_entry.stream_name).uuid,
+        stream_id=stream.Name.from_stream_name(from_entry.stream_name).uuid,
         created_at=created_at,
         version=position.as_version(),
         name=from_entry.type,
@@ -49,7 +49,9 @@ def new_entry(from_raw: RawEvent, **metadata: Any) -> NewEvent:
 
 
 def raw_record(from_entry: RecordedEvent) -> RecordedRaw:
+    stream_name = stream.Name.from_stream_name(from_entry.stream_name)
     return RecordedRaw(
-        entry=raw_event(from_entry=from_entry),
+        entry=raw_event(from_entry),
         position=Position(from_entry.commit_position or 0),
+        tenant_id=stream_name.tenant_id,
     )

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_esdb/event_store.py

@@ -1,18 +1,21 @@
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import cast
 
 from esdbclient import EventStoreDBClient, StreamState
 from esdbclient.exceptions import NotFound
+from typing_extensions import Self
 
 from event_sourcery.event_store import (
     NO_VERSIONING,
     Position,
     RawEvent,
     StreamId,
+    TenantId,
     Versioning,
 )
 from event_sourcery.event_store.exceptions import ConcurrentStreamWriteError
 from event_sourcery.event_store.interfaces import StorageStrategy
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT
 from event_sourcery_esdb import dto, stream
 
 
@@ -20,6 +23,7 @@ from event_sourcery_esdb import dto, stream
 class ESDBStorageStrategy(StorageStrategy):
     _client: EventStoreDBClient
     _timeout: float | None
+    _tenant_id: TenantId = DEFAULT_TENANT
 
     def fetch_events(
         self,
@@ -28,7 +32,7 @@ class ESDBStorageStrategy(StorageStrategy):
         stop: int | None = None,
     ) -> list[RawEvent]:
         snapshot = None
-        name = stream.Name(stream_id)
+        name = stream.Name(self._tenant_id, stream_id)
         if start is None and (snapshot := self._read_snapshot(name)) is not None:
             start = cast(int, snapshot.version) + 1
 
@@ -65,7 +69,7 @@ class ESDBStorageStrategy(StorageStrategy):
     ) -> None:
         for sid in {e.stream_id for e in events}:
             self._ensure_stream(stream_id=sid, versioning=versioning)
-            stream_name = stream.Name(sid)
+            stream_name = stream.Name(self._tenant_id, sid)
             stream_events = [e for e in events if e.stream_id == sid]
             self._append_events(stream_name, events=stream_events)
 
@@ -78,7 +82,7 @@ class ESDBStorageStrategy(StorageStrategy):
         )
 
     def save_snapshot(self, snapshot: RawEvent) -> None:
-        name = stream.Name(snapshot.stream_id)
+        name = stream.Name(self._tenant_id, snapshot.stream_id)
         stream_position = stream.Position.from_version(cast(int, snapshot.version))
         self._client.append_events(
             name.snapshot,
@@ -88,7 +92,7 @@ class ESDBStorageStrategy(StorageStrategy):
         )
 
     def _ensure_stream(self, stream_id: StreamId, versioning: Versioning) -> None:
-        name = stream.Name(stream_id)
+        name = stream.Name(self._tenant_id, stream_id)
 
         if versioning is not NO_VERSIONING and versioning.expected_version:
             expected = stream.Position.from_version(versioning.expected_version)
@@ -112,7 +116,7 @@ class ESDBStorageStrategy(StorageStrategy):
             return None
 
     def delete_stream(self, stream_id: StreamId) -> None:
-        name = stream.Name(stream_id)
+        name = stream.Name(self._tenant_id, stream_id)
         try:
             self._client.delete_stream(
                 str(name),
@@ -125,3 +129,6 @@ class ESDBStorageStrategy(StorageStrategy):
     @property
     def current_position(self) -> Position | None:
         return Position(self._client.get_commit_position(timeout=self._timeout))
+
+    def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
+        return replace(self, _tenant_id=tenant_id)

python_event_sourcery-0.4.0a10/event_sourcery_esdb/stream.py

@@ -0,0 +1,60 @@
+import sys
+from collections import UserString
+from typing import cast
+
+from typing_extensions import Self
+
+from event_sourcery.event_store import StreamId, TenantId
+from event_sourcery.event_store.exceptions import IllegalCategoryName, IllegalTenantId
+
+
+class Name(UserString):
+    tenant_id: TenantId
+    uuid: StreamId
+
+    def __init__(self, tenant_id: TenantId, stream_id: StreamId) -> None:
+        if "-" in tenant_id:
+            raise IllegalTenantId("ESDB can't handle tenant id with '-'")
+        self.tenant_id = tenant_id
+        self.uuid = stream_id
+        super().__init__(self._as_string(self.uuid))
+
+    @classmethod
+    def from_stream_name(cls, stream_name: str) -> Self:
+        if stream_name.endswith("-snapshot"):
+            stream_name, _ = stream_name.rsplit("-", 1)
+
+        category, tenant_id, id_as_hex = stream_name.split("-", 2)
+        return cls(tenant_id, StreamId(from_hex=id_as_hex, category=category or None))
+
+    def _as_string(self, stream_id: StreamId) -> str:
+        if stream_id.category and "-" in stream_id.category:
+            raise IllegalCategoryName("ESDB storage can't handle category with '-'")
+        return f"{stream_id.category or ''}-{self.tenant_id}-{stream_id.hex}"
+
+    @property
+    def snapshot(self) -> str:
+        return f"{self!s}-snapshot"
+
+
+class Position(int):
+    @classmethod
+    def from_version(cls, version: int) -> "Position":
+        return Position(version - 1)
+
+    def as_version(self) -> int:
+        return self + 1
+
+
+MAX_POSITION = Position(sys.maxsize)
+
+
+def scope(
+    start_version: int | None,
+    stop_version: int | None,
+) -> tuple[Position | None, int]:
+    start = cast(
+        Position | None, start_version and Position.from_version(start_version)
+    )
+    stop = stop_version and Position.from_version(stop_version) or MAX_POSITION
+    return start, stop - (start or 0)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_esdb/subscription.py

@@ -66,9 +66,7 @@ class ESDBSubscriptionStrategy(SubscriptionStrategy):
             self._client.subscribe_to_all,
             commit_position=start_from,
             timeout=timelimit.total_seconds(),
-            filter_include=[
-                f"{category}-\\w+",
-            ],
+            filter_include=[f"{category}-[^-]*-\\w+"],
             filter_by_stream_name=True,
         )
         return self._iterator(builder, batch_size)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_sqlalchemy/event_store.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import cast
 
 from more_itertools import first_true
@@ -7,6 +7,7 @@ from sqlalchemy import delete, func, select, update
 from sqlalchemy.dialects.postgresql import insert as postgresql_insert
 from sqlalchemy.exc import NoResultFound
 from sqlalchemy.orm import Session
+from typing_extensions import Self
 
 from event_sourcery.event_store import (
     NO_VERSIONING,
@@ -22,6 +23,7 @@ from event_sourcery.event_store.exceptions import (
     ConcurrentStreamWriteError,
 )
 from event_sourcery.event_store.interfaces import StorageStrategy
+from event_sourcery.event_store.tenant_id import DEFAULT_TENANT, TenantId
 from event_sourcery_sqlalchemy.models import Event as EventModel
 from event_sourcery_sqlalchemy.models import Snapshot as SnapshotModel
 from event_sourcery_sqlalchemy.models import Stream as StreamModel
@@ -33,6 +35,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
     _session: Session
     _dispatcher: Dispatcher
     _outbox: SqlAlchemyOutboxStorageStrategy | None = None
+    _tenant_id: TenantId = DEFAULT_TENANT
 
     def fetch_events(
         self,
@@ -42,7 +45,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
     ) -> list[RawEvent]:
         events_stmt = (
             select(EventModel)
-            .filter_by(stream_id=stream_id)
+            .filter_by(stream_id=stream_id, tenant_id=self._tenant_id)
             .order_by(EventModel.version)
         )
 
@@ -57,7 +60,10 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
             snapshot_stmt = (
                 select(SnapshotModel)
                 .join(StreamModel)
-                .filter(StreamModel.stream_id == stream_id)
+                .filter(
+                    StreamModel.stream_id == stream_id,
+                    StreamModel.tenant_id == self._tenant_id,
+                )
                 .order_by(SnapshotModel.created_at.desc())
                 .limit(1)
             )
@@ -97,13 +103,16 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
     def _ensure_stream(self, stream_id: StreamId, versioning: Versioning) -> None:
         initial_version = versioning.initial_version
 
-        condition = (StreamModel.uuid == stream_id) & (
-            StreamModel.category == (stream_id.category or "")
+        condition = (
+            (StreamModel.uuid == stream_id)
+            & (StreamModel.category == (stream_id.category or ""))
+            & (StreamModel.tenant_id == self._tenant_id)
         )
         if stream_id.name:
             condition = condition | (
                 (StreamModel.name == stream_id.name)
                 & (StreamModel.category == (stream_id.category or ""))
+                & (StreamModel.tenant_id == self._tenant_id)
             )
         matching_streams_stmt = select(StreamModel).where(condition)
         matching_streams = self._session.execute(matching_streams_stmt).scalars().all()
@@ -115,6 +124,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
                     name=stream_id.name,
                     category=stream_id.category or "",
                     version=initial_version,
+                    tenant_id=self._tenant_id,
                 )
                 .on_conflict_do_nothing()
             )
@@ -163,12 +173,14 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         self, stream_id: StreamId, versioning: Versioning, events: list[RawEvent]
     ) -> None:
         self._ensure_stream(stream_id=stream_id, versioning=versioning)
+
         stream = cast(
             StreamModel,
             first_true(
                 self._session.info["strong_set"],
                 pred=lambda model: isinstance(model, StreamModel)
-                and model.stream_id == stream_id,
+                and model.stream_id == stream_id
+                and model.tenant_id == self._tenant_id,
             ),
         )
 
@@ -186,7 +198,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         stream.events.extend(entries)
         self._session.flush()
         records = [
-            RecordedRaw(entry=raw, position=db.id)
+            RecordedRaw(entry=raw, position=db.id, tenant_id=db.tenant_id)
             for raw, db in zip(events, entries, strict=False)
         ]
         if self._outbox:
@@ -226,3 +238,6 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         stmt = select(func.max(EventModel.id))
         last_event = self._session.scalar(stmt)
         return last_event or Position(0)
+
+    def scoped_for_tenant(self, tenant_id: TenantId) -> Self:
+        return replace(self, _tenant_id=tenant_id)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_sqlalchemy/models.py

@@ -26,6 +26,7 @@ from sqlalchemy.orm import (
 )
 
 from event_sourcery.event_store import StreamId
+from event_sourcery.event_store.tenant_id import TenantId
 from event_sourcery_sqlalchemy.guid import GUID
 from event_sourcery_sqlalchemy.jsonb import JSONB
 
@@ -57,14 +58,15 @@ class StreamIdComparator(Comparator[StreamId]):
 class Stream:
     __tablename__ = "event_sourcery_streams"
     __table_args__ = (
-        UniqueConstraint("uuid", "category"),
-        UniqueConstraint("name", "category"),
+        UniqueConstraint("uuid", "category", "tenant_id"),
+        UniqueConstraint("name", "category", "tenant_id"),
     )
 
     id = mapped_column(BigInteger().with_variant(Integer(), "sqlite"), primary_key=True)
     uuid = mapped_column(GUID(), nullable=False)
     name = mapped_column(String(255), nullable=True, default=None)
     category = mapped_column(String(255), nullable=False, default="")
+    tenant_id = mapped_column(String(255), nullable=False)
     version = mapped_column(BigInteger(), nullable=True)
 
     events: Mapped[list["Event"]]
@@ -119,6 +121,7 @@ class Event:
     )
     stream: Mapped[Stream] = relationship(Stream, back_populates="events")
     stream_id: AssociationProxy[StreamId] = association_proxy("stream", "stream_id")
+    tenant_id: AssociationProxy[TenantId] = association_proxy("stream", "tenant_id")
     name = mapped_column(String(200), nullable=False)
     data = mapped_column(JSONB(), nullable=False)
     event_context = mapped_column(JSONB(), nullable=False)

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_sqlalchemy/outbox.py

@@ -36,6 +36,7 @@ class SqlAlchemyOutboxStorageStrategy(OutboxStorageStrategy):
             as_dict["created_at"] = created_at.isoformat()
             as_dict["uuid"] = str(as_dict["uuid"])
             as_dict["stream_id"] = str(as_dict["stream_id"])
+            as_dict["tenant_id"] = str(record.tenant_id)
             rows.append(
                 {
                     "created_at": datetime.utcnow(),
@@ -82,7 +83,11 @@ class SqlAlchemyOutboxStorageStrategy(OutboxStorageStrategy):
             context=entry.data["context"],
         )
         try:
-            yield RecordedRaw(entry=raw, position=entry.position)
+            yield RecordedRaw(
+                entry=raw,
+                position=entry.position,
+                tenant_id=entry.data["tenant_id"],
+            )
         except Exception:
             logger.exception("Failed to publish message #%d", entry.id)
             entry.tries_left -= 1

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/event_sourcery_sqlalchemy/subscription.py

@@ -171,6 +171,7 @@ class GapDetectingIterator(Iterator[list[RecordedRaw]]):
             RecordedRaw(
                 entry=dto.raw_event(event, event.stream),
                 position=event.id,
+                tenant_id=event.tenant_id,
             )
             for event in batch
         ]

{python_event_sourcery-0.4.0a9 → python_event_sourcery-0.4.0a10}/pyproject.toml

@@ -3,7 +3,7 @@ requires-python = ">=3.10"
 
 [tool.poetry]
 name = "python-event-sourcery"
-version = "0.4.0a9"
+version = "0.4.0a10"
 description = ""
 authors = ["Your Name <you@example.com>"]
 license = "MIT"

python_event_sourcery-0.4.0a9/event_sourcery_esdb/stream.py

@@ -1,65 +0,0 @@
-import sys
-from collections import UserString
-from typing import cast
-
-from event_sourcery.event_store import StreamId
-from event_sourcery.event_store.exceptions import IllegalCategoryName
-
-
-class Name(UserString):
-    uuid: StreamId
-
-    def __init__(
-        self,
-        stream_id: StreamId | None = None,
-        stream_name: str | None = None,
-    ) -> None:
-        self.uuid = stream_id or self._get_id(from_name=(stream_name or ""))
-        super().__init__(self._as_string(self.uuid))
-
-    @staticmethod
-    def _get_id(from_name: str) -> StreamId:
-        category: str | None = None
-        if from_name.endswith("-snapshot"):
-            from_name, _ = from_name.rsplit("-", 1)
-        if "-" in from_name:
-            category, from_name = from_name.split("-", 1)
-        return StreamId(from_hex=from_name, category=category)
-
-    @staticmethod
-    def _as_string(stream_id: StreamId) -> str:
-        if stream_id.category:
-            if "-" in stream_id.category:
-                raise IllegalCategoryName("ESDB storage can't handle category with '-'")
-            return f"{stream_id.category}-{stream_id.hex}"
-        return stream_id.hex
-
-    @property
-    def snapshot(self) -> str:
-        return f"{self!s}-snapshot"
-
-
-class Position(int):
-    def __new__(cls, value: int | str) -> "Position":
-        return super().__new__(Position, value)
-
-    @classmethod
-    def from_version(cls, version: int) -> "Position":
-        return Position(version - 1)
-
-    def as_version(self) -> int:
-        return self + 1
-
-
-MAX_POSITION = Position(sys.maxsize)
-
-
-def scope(
-    start_version: int | None,
-    stop_version: int | None,
-) -> tuple[Position | None, int]:
-    start = cast(
-        Position | None, start_version and Position.from_version(start_version)
-    )
-    stop = stop_version and Position.from_version(stop_version) or MAX_POSITION
-    return start, stop - (start or 0)