python-event-sourcery 0.4.0a18__tar.gz → 0.4.0a19__tar.gz

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: python-event-sourcery
-Version: 0.4.0a18
+Version: 0.4.0a19
 Summary: 
 License: MIT
 Author: Your Name

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/__init__.py

@@ -1,11 +1,18 @@
 __all__ = [
+    "BaseEvent",
+    "BaseOutboxEntry",
+    "BaseProjectorCursor",
+    "BaseSnapshot",
+    "BaseStream",
     "Config",
+    "Models",
     "SQLAlchemyBackend",
     "SqlAlchemyStorageStrategy",
     "configure_models",
     "models",
 ]
 
+from dataclasses import dataclass
 from datetime import timedelta
 
 from pydantic import BaseModel, ConfigDict, PositiveInt
@@ -23,10 +30,31 @@ from event_sourcery.event_store.interfaces import (
 from event_sourcery_sqlalchemy import models
 from event_sourcery_sqlalchemy.event_store import SqlAlchemyStorageStrategy
 from event_sourcery_sqlalchemy.models import configure_models
+from event_sourcery_sqlalchemy.models.base import (
+    BaseEvent,
+    BaseOutboxEntry,
+    BaseProjectorCursor,
+    BaseSnapshot,
+    BaseStream,
+)
+from event_sourcery_sqlalchemy.models.default import (
+    DefaultEvent,
+    DefaultOutboxEntry,
+    DefaultSnapshot,
+    DefaultStream,
+)
 from event_sourcery_sqlalchemy.outbox import SqlAlchemyOutboxStorageStrategy
 from event_sourcery_sqlalchemy.subscription import SqlAlchemySubscriptionStrategy
 
 
+@dataclass(frozen=True)
+class Models:
+    event_model: type[BaseEvent]
+    stream_model: type[BaseStream]
+    snapshot_model: type[BaseSnapshot]
+    outbox_entry_model: type[BaseOutboxEntry] = DefaultOutboxEntry
+
+
 class Config(BaseModel):
     model_config = ConfigDict(extra="forbid", frozen=True)
 
@@ -35,27 +63,51 @@ class Config(BaseModel):
 
 
 class SQLAlchemyBackend(TransactionalBackend):
+    UNCONFIGURED_MESSAGE = "Configure backend with `.configure(session, config)`"
+
     def __init__(self) -> None:
         super().__init__()
-        self[Session] = not_configured(
-            "Configure backend with `.configure(session, config)`",
-        )
-        self[Config] = not_configured(
-            "Configure backend with `.configure(session, config)`",
-        )
+        self[BaseEvent] = not_configured(self.UNCONFIGURED_MESSAGE)
+        self[BaseStream] = not_configured(self.UNCONFIGURED_MESSAGE)
+        self[BaseSnapshot] = not_configured(self.UNCONFIGURED_MESSAGE)
+        self[BaseOutboxEntry] = not_configured(self.UNCONFIGURED_MESSAGE)
+        self[Session] = not_configured(self.UNCONFIGURED_MESSAGE)
+        self[Config] = not_configured(self.UNCONFIGURED_MESSAGE)
         self[StorageStrategy] = lambda c: SqlAlchemyStorageStrategy(
             c[Session],
             c[Dispatcher],
             c.get(SqlAlchemyOutboxStorageStrategy, None),
+            c[BaseEvent],
+            c[BaseSnapshot],
+            c[BaseStream],
         ).scoped_for_tenant(c.tenant_id)
         self[SubscriptionStrategy] = lambda c: SqlAlchemySubscriptionStrategy(
             c[Session],
             c[Config].gap_retry_interval,
+            c[BaseEvent],
+            c[BaseStream],
         )
 
-    def configure(self, session: Session, config: Config | None = None) -> Self:
+    def configure(
+        self,
+        session: Session,
+        config: Config | None = None,
+        custom_models: Models | None = None,
+    ) -> Self:
+        if custom_models is None:
+            custom_models = Models(
+                event_model=DefaultEvent,
+                stream_model=DefaultStream,
+                snapshot_model=DefaultSnapshot,
+                outbox_entry_model=DefaultOutboxEntry,
+            )
+
         self[Session] = session
         self[Config] = config or Config()
+        self[BaseEvent] = lambda _: custom_models.event_model
+        self[BaseStream] = lambda _: custom_models.stream_model
+        self[BaseSnapshot] = lambda _: custom_models.snapshot_model
+        self[BaseOutboxEntry] = lambda _: custom_models.outbox_entry_model
         return self
 
     def with_outbox(self, filterer: OutboxFiltererStrategy = no_filter) -> Self:
@@ -65,6 +117,7 @@ class SQLAlchemyBackend(TransactionalBackend):
                 c[Session],
                 c[OutboxFiltererStrategy],
                 c[Config].outbox_attempts,
+                c[BaseOutboxEntry],
             )
         )
         self[OutboxStorageStrategy] = lambda c: c[SqlAlchemyOutboxStorageStrategy]

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/cursors_dao.py

@@ -5,12 +5,15 @@ from sqlalchemy.orm import Session
 
 from event_sourcery.event_store import StreamId
 from event_sourcery.read_model import CursorsDao
-from event_sourcery_sqlalchemy.models import ProjectorCursor
+from event_sourcery_sqlalchemy.models.base import BaseProjectorCursor
 
 
 class SqlAlchemyCursorsDao(CursorsDao):
-    def __init__(self, session: Session) -> None:
+    def __init__(
+        self, session: Session, projector_cursor_model: type[BaseProjectorCursor]
+    ) -> None:
         self._session = session
+        self._projector_cursor_model = projector_cursor_model
 
     def increment(self, name: str, stream_id: StreamId, version: int) -> None:
         if version == 1:
@@ -18,7 +21,7 @@ class SqlAlchemyCursorsDao(CursorsDao):
             if current_version is not None:
                 raise self.AheadOfStream(current_version=current_version)
 
-            stmt = insert(ProjectorCursor).values(
+            stmt = insert(self._projector_cursor_model).values(
                 name=name,
                 stream_id=stream_id,
                 category=stream_id.category,
@@ -28,14 +31,14 @@ class SqlAlchemyCursorsDao(CursorsDao):
             return
 
         update_stmt = (
-            update(ProjectorCursor)
+            update(self._projector_cursor_model)
             .where(
-                ProjectorCursor.name == name,
-                ProjectorCursor.stream_id == stream_id,
-                ProjectorCursor.category == stream_id.category,
-                ProjectorCursor.version == version - 1,
+                self._projector_cursor_model.name == name,
+                self._projector_cursor_model.stream_id == stream_id,
+                self._projector_cursor_model.category == stream_id.category,
+                self._projector_cursor_model.version == version - 1,
             )
-            .values({ProjectorCursor.version: version})
+            .values({self._projector_cursor_model.version: version})
         )
         result = self._session.execute(update_stmt)
         if result.rowcount == 1:
@@ -51,15 +54,15 @@ class SqlAlchemyCursorsDao(CursorsDao):
                 raise self.AheadOfStream(current_version=current_version)
 
     def _current_version(self, name: str, stream_id: StreamId) -> int | None:
-        stmt = select(ProjectorCursor.version).filter(
-            ProjectorCursor.name == name,
-            ProjectorCursor.stream_id == stream_id,
-            ProjectorCursor.category == stream_id.category,
+        stmt = select(self._projector_cursor_model.version).filter(
+            self._projector_cursor_model.name == name,
+            self._projector_cursor_model.stream_id == stream_id,
+            self._projector_cursor_model.category == stream_id.category,
         )
         return cast(int | None, self._session.execute(stmt).scalar())
 
     def put_at(self, name: str, stream_id: StreamId, version: int) -> None:
-        stmt = insert(ProjectorCursor).values(
+        stmt = insert(self._projector_cursor_model).values(
             name=name,
             stream_id=stream_id,
             category=stream_id.category,
@@ -69,12 +72,12 @@ class SqlAlchemyCursorsDao(CursorsDao):
 
     def move_to(self, name: str, stream_id: StreamId, version: int) -> None:
         stmt = (
-            update(ProjectorCursor)
+            update(self._projector_cursor_model)
             .where(
-                ProjectorCursor.name == name,
-                ProjectorCursor.stream_id == stream_id,
-                ProjectorCursor.category == stream_id.category,
+                self._projector_cursor_model.name == name,
+                self._projector_cursor_model.stream_id == stream_id,
+                self._projector_cursor_model.category == stream_id.category,
             )
-            .values({ProjectorCursor.version: version})
+            .values({self._projector_cursor_model.version: version})
         )
         self._session.execute(stmt)

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/dto.py

@@ -1,8 +1,8 @@
 from event_sourcery.event_store import RawEvent, StreamId
-from event_sourcery_sqlalchemy.models import Event, Stream
+from event_sourcery_sqlalchemy.models.base import BaseEvent, BaseStream
 
 
-def raw_event(from_entry: Event, in_stream: Stream) -> RawEvent:
+def raw_event(from_entry: BaseEvent, in_stream: BaseStream) -> RawEvent:
     return RawEvent(
         uuid=from_entry.uuid,
         stream_id=StreamId(

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/event_store.py

@@ -24,9 +24,7 @@ from event_sourcery.event_store.exceptions import (
 )
 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
+from event_sourcery_sqlalchemy.models.base import BaseEvent, BaseSnapshot, BaseStream
 from event_sourcery_sqlalchemy.outbox import SqlAlchemyOutboxStorageStrategy
 
 
@@ -34,7 +32,10 @@ from event_sourcery_sqlalchemy.outbox import SqlAlchemyOutboxStorageStrategy
 class SqlAlchemyStorageStrategy(StorageStrategy):
     _session: Session
     _dispatcher: Dispatcher
-    _outbox: SqlAlchemyOutboxStorageStrategy | None = None
+    _outbox: SqlAlchemyOutboxStorageStrategy
+    _event_model: type[BaseEvent]
+    _snapshot_model: type[BaseSnapshot]
+    _stream_model: type[BaseStream]
     _tenant_id: TenantId = DEFAULT_TENANT
 
     def fetch_events(
@@ -44,41 +45,45 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         stop: int | None = None,
     ) -> list[RawEvent]:
         events_stmt = (
-            select(EventModel)
+            select(self._event_model)
             .filter_by(stream_id=stream_id, tenant_id=self._tenant_id)
-            .order_by(EventModel.version)
+            .order_by(self._event_model.version)
         )
 
         if start is not None:
-            events_stmt = events_stmt.filter(EventModel.version >= start)
+            events_stmt = events_stmt.filter(self._event_model.version >= start)
 
         if stop is not None:
-            events_stmt = events_stmt.filter(EventModel.version < stop)
+            events_stmt = events_stmt.filter(self._event_model.version < stop)
 
-        events: Sequence[EventModel | SnapshotModel]
+        events: Sequence[BaseEvent | BaseSnapshot]
         try:
             snapshot_stmt = (
-                select(SnapshotModel)
-                .join(StreamModel)
+                select(self._snapshot_model)
+                .join(self._stream_model)
                 .filter(
-                    StreamModel.stream_id == stream_id,
-                    StreamModel.tenant_id == self._tenant_id,
+                    self._stream_model.stream_id == stream_id,
+                    self._stream_model.tenant_id == self._tenant_id,
                 )
-                .order_by(SnapshotModel.created_at.desc())
+                .order_by(self._snapshot_model.created_at.desc())
                 .limit(1)
             )
             if start is not None:
-                snapshot_stmt = snapshot_stmt.filter(SnapshotModel.version >= start)
+                snapshot_stmt = snapshot_stmt.filter(
+                    self._snapshot_model.version >= start
+                )
 
             if stop is not None:
-                snapshot_stmt = snapshot_stmt.filter(SnapshotModel.version < stop)
+                snapshot_stmt = snapshot_stmt.filter(
+                    self._snapshot_model.version < stop
+                )
 
             latest_snapshot = self._session.execute(snapshot_stmt).scalars().one()
         except NoResultFound:
             events = self._session.execute(events_stmt).scalars().all()
         else:
             events_stmt = events_stmt.filter(
-                EventModel.version > latest_snapshot.version
+                self._event_model.version > latest_snapshot.version
             )
             newer_events = list(self._session.execute(events_stmt).scalars().all())
             events = [latest_snapshot, *newer_events]
@@ -104,21 +109,21 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         initial_version = versioning.initial_version
 
         condition = (
-            (StreamModel.uuid == stream_id)
-            & (StreamModel.category == (stream_id.category or ""))
-            & (StreamModel.tenant_id == self._tenant_id)
+            (self._stream_model.uuid == stream_id)
+            & (self._stream_model.category == (stream_id.category or ""))
+            & (self._stream_model.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)
+                (self._stream_model.name == stream_id.name)
+                & (self._stream_model.category == (stream_id.category or ""))
+                & (self._stream_model.tenant_id == self._tenant_id)
             )
-        matching_streams_stmt = select(StreamModel).where(condition)
+        matching_streams_stmt = select(self._stream_model).where(condition)
         matching_streams = self._session.execute(matching_streams_stmt).scalars().all()
         if not matching_streams:
             ensure_stream_stmt = (
-                postgresql_insert(StreamModel)
+                postgresql_insert(self._stream_model)
                 .values(
                     uuid=stream_id,
                     name=stream_id.name,
@@ -134,7 +139,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
             )
 
         if stream_id.name is not None:
-            matching_stream_with_same_name: StreamModel = [
+            matching_stream_with_same_name: BaseStream = [
                 stream
                 for stream in matching_streams
                 if stream.name == stream_id.name
@@ -144,7 +149,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
                 raise AnotherStreamWithThisNameButOtherIdExists()
 
         stream = cast(
-            StreamModel,
+            BaseStream,
             first_true(
                 matching_streams, pred=lambda stream: stream.stream_id == stream_id
             ),
@@ -156,10 +161,10 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
 
         if versioning.expected_version and versioning is not NO_VERSIONING:
             bump_version_stmt = (
-                update(StreamModel)
+                update(self._stream_model)
                 .where(
-                    StreamModel.stream_id == stream_id,
-                    StreamModel.version == versioning.expected_version,
+                    self._stream_model.stream_id == stream_id,
+                    self._stream_model.version == versioning.expected_version,
                 )
                 .values(version=versioning.initial_version)
             )
@@ -175,17 +180,17 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         self._ensure_stream(stream_id=stream_id, versioning=versioning)
 
         stream = cast(
-            StreamModel,
+            BaseStream,
             first_true(
                 self._session.info["strong_set"],
-                pred=lambda model: isinstance(model, StreamModel)
+                pred=lambda model: isinstance(model, self._stream_model)
                 and model.stream_id == stream_id
                 and model.tenant_id == self._tenant_id,
             ),
         )
 
         entries = [
-            EventModel(
+            self._event_model(
                 uuid=event.uuid,
                 created_at=event.created_at,
                 name=event.name,
@@ -207,7 +212,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         self._dispatcher.dispatch(*records)
 
     def save_snapshot(self, snapshot: RawEvent) -> None:
-        entry = SnapshotModel(
+        entry = self._snapshot_model(
             uuid=snapshot.uuid,
             created_at=snapshot.created_at,
             version=snapshot.version,
@@ -216,7 +221,7 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
             event_context=snapshot.context,
         )
         stream = (
-            self._session.query(StreamModel)
+            self._session.query(self._stream_model)
             .filter_by(stream_id=snapshot.stream_id)
             .one()
         )
@@ -224,18 +229,18 @@ class SqlAlchemyStorageStrategy(StorageStrategy):
         self._session.flush()
 
     def delete_stream(self, stream_id: StreamId) -> None:
-        delete_events_stmt = delete(EventModel).where(
-            EventModel.stream_id == stream_id,
+        delete_events_stmt = delete(self._event_model).where(
+            self._event_model.stream_id == stream_id,
         )
         self._session.execute(delete_events_stmt)
-        delete_stream_stmt = delete(StreamModel).where(
-            StreamModel.stream_id == stream_id,
+        delete_stream_stmt = delete(self._stream_model).where(
+            self._stream_model.stream_id == stream_id,
         )
         self._session.execute(delete_stream_stmt)
 
     @property
     def current_position(self) -> Position | None:
-        stmt = select(func.max(EventModel.id))
+        stmt = select(func.max(self._event_model.id))
         last_event = self._session.scalar(stmt)
         return last_event or Position(0)
 

python_event_sourcery-0.4.0a19/event_sourcery_sqlalchemy/models/__init__.py

@@ -0,0 +1,53 @@
+from typing import Protocol
+
+from sqlalchemy import MetaData
+from sqlalchemy.orm import registry
+from sqlalchemy.orm.clsregistry import ClsRegistryToken
+
+from event_sourcery_sqlalchemy.models.base import (
+    BaseEvent,
+    BaseOutboxEntry,
+    BaseProjectorCursor,
+    BaseSnapshot,
+    BaseStream,
+)
+from event_sourcery_sqlalchemy.models.default import (
+    DefaultEvent,
+    DefaultOutboxEntry,
+    DefaultProjectorCursor,
+    DefaultSnapshot,
+    DefaultStream,
+)
+
+
+class BaseProto(Protocol):
+    metadata: MetaData
+
+
+_class_registry: dict[str, type | ClsRegistryToken] = {}
+
+
+def configure_models(
+    base: type[BaseProto],
+    event_model: type[BaseEvent] = DefaultEvent,
+    stream_model: type[BaseStream] = DefaultStream,
+    snapshot_model: type[BaseSnapshot] = DefaultSnapshot,
+    outbox_entry_model: type[BaseOutboxEntry] = DefaultOutboxEntry,
+    projector_cursor_model: type[BaseProjectorCursor] = DefaultProjectorCursor,
+) -> None:
+    event_model.__set_mapping_information__(stream_model)
+    snapshot_model.__set_mapping_information__(stream_model)
+    stream_model.__set_mapping_information__(event_model, snapshot_model)
+
+    mapping_registry = registry(metadata=base.metadata, class_registry=_class_registry)
+    for model_cls in (
+        stream_model,
+        event_model,
+        snapshot_model,
+        outbox_entry_model,
+        projector_cursor_model,
+    ):
+        if model_cls in _class_registry.values():
+            continue
+
+        mapping_registry.map_declaratively(model_cls)

python_event_sourcery-0.4.0a18/event_sourcery_sqlalchemy/models.py → python_event_sourcery-0.4.0a19/event_sourcery_sqlalchemy/models/base.py

@@ -20,8 +20,9 @@ from sqlalchemy.orm import (
     Composite,
     InstrumentedAttribute,
     Mapped,
+    MappedColumn,
+    declared_attr,
     mapped_column,
-    registry,
     relationship,
 )
 
@@ -31,11 +32,6 @@ from event_sourcery_sqlalchemy.guid import GUID
 from event_sourcery_sqlalchemy.jsonb import JSONB
 
 
-def configure_models(base: type[Any]) -> None:
-    for model_cls in (Stream, Event, Snapshot, OutboxEntry, ProjectorCursor):
-        registry(metadata=base.metadata, class_registry={}).map_declaratively(model_cls)
-
-
 class StreamIdComparator(Comparator[StreamId]):
     def __init__(
         self,
@@ -55,12 +51,17 @@ class StreamIdComparator(Comparator[StreamId]):
         return and_(same_uuid, same_name, same_category)  # type: ignore
 
 
-class Stream:
-    __tablename__ = "event_sourcery_streams"
-    __table_args__ = (
-        UniqueConstraint("uuid", "category", "tenant_id"),
-        UniqueConstraint("name", "category", "tenant_id"),
-    )
+class BaseStream:
+    __event_model__: type["BaseEvent"]
+    __snapshot_model__: type["BaseSnapshot"]
+
+    @declared_attr  # type: ignore[arg-type]
+    @classmethod
+    def __table_args__(cls) -> tuple[Index | UniqueConstraint, ...]:
+        return (
+            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)
@@ -69,8 +70,22 @@ class Stream:
     tenant_id = mapped_column(String(255), nullable=False)
     version = mapped_column(BigInteger(), nullable=True)
 
-    events: Mapped[list["Event"]]
-    snapshots: Mapped[list["Snapshot"]]
+    @classmethod
+    def __set_mapping_information__(
+        cls, event_model: type["BaseEvent"], snapshot_model: type["BaseSnapshot"]
+    ) -> None:
+        cls.__event_model__ = event_model
+        cls.__snapshot_model__ = snapshot_model
+
+    @declared_attr
+    @classmethod
+    def events(cls) -> Mapped[list["BaseEvent"]]:
+        return relationship(cls.__event_model__, back_populates="stream")
+
+    @declared_attr
+    @classmethod
+    def snapshots(cls) -> Mapped[list["BaseSnapshot"]]:
+        return relationship(cls.__snapshot_model__, back_populates="stream")
 
     @hybrid_property
     def stream_id(self) -> StreamId:
@@ -82,16 +97,21 @@ class Stream:
         return StreamIdComparator(cls.uuid, cls.name, cls.category)
 
 
-class Event:
-    __tablename__ = "event_sourcery_events"
-    __table_args__ = (
-        Index(
-            "ix_events_stream_id_version",
-            "db_stream_id",
-            "version",
-            unique=True,
-        ),
-    )
+class BaseEvent:
+    __stream_model__: type["BaseStream"]
+    __tablename__: str
+
+    @declared_attr  # type: ignore[arg-type]
+    @classmethod
+    def __table_args__(cls) -> tuple[Index | UniqueConstraint, ...]:
+        return (
+            Index(
+                f"ix_events_stream_id_version_{cls.__tablename__}",
+                "db_stream_id",
+                "version",
+                unique=True,
+            ),
+        )
 
     def __init__(
         self,
@@ -109,17 +129,29 @@ class Event:
         self.event_context = event_context
         self.version = version
 
+    @classmethod
+    def __set_mapping_information__(cls, stream_model: type[BaseStream]) -> None:
+        cls.__stream_model__ = stream_model
+
+    @declared_attr
+    @classmethod
+    def _db_stream_id(cls) -> MappedColumn[Any]:
+        return mapped_column(
+            "db_stream_id",
+            BigInteger().with_variant(Integer(), "sqlite"),
+            ForeignKey(cls.__stream_model__.id),
+            nullable=False,
+            index=True,
+        )
+
+    @declared_attr
+    @classmethod
+    def stream(cls) -> Mapped[BaseStream]:
+        return relationship(cls.__stream_model__, back_populates="events")
+
     id = mapped_column(BigInteger().with_variant(Integer(), "sqlite"), primary_key=True)
     version = mapped_column(Integer(), nullable=True)
     uuid = mapped_column(GUID(), index=True, unique=True)
-    _db_stream_id = mapped_column(
-        "db_stream_id",
-        BigInteger().with_variant(Integer(), "sqlite"),
-        ForeignKey(Stream.id),
-        nullable=False,
-        index=True,
-    )
-    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)
@@ -128,8 +160,8 @@ class Event:
     created_at = mapped_column(DateTime(), nullable=False, index=True)
 
 
-class Snapshot:
-    __tablename__ = "event_sourcery_snapshots"
+class BaseSnapshot:
+    __stream_model__: type["BaseStream"]
 
     def __init__(
         self,
@@ -147,16 +179,28 @@ class Snapshot:
         self.event_context = event_context
         self.version = version
 
+    @classmethod
+    def __set_mapping_information__(cls, stream_model: type[BaseStream]) -> None:
+        cls.__stream_model__ = stream_model
+
+    @declared_attr
+    @classmethod
+    def _db_stream_id(cls) -> MappedColumn[Any]:
+        return mapped_column(
+            "db_stream_id",
+            BigInteger().with_variant(Integer(), "sqlite"),
+            ForeignKey(cls.__stream_model__.id),
+            nullable=False,
+            index=True,
+        )
+
+    @declared_attr
+    @classmethod
+    def stream(cls) -> Mapped[BaseStream]:
+        return relationship(cls.__stream_model__, back_populates="snapshots")
+
     uuid = mapped_column(GUID, primary_key=True)
     version = mapped_column(Integer(), nullable=False)
-    _db_stream_id = mapped_column(
-        "db_stream_id",
-        BigInteger().with_variant(Integer(), "sqlite"),
-        ForeignKey(Stream.id),
-        nullable=False,
-        index=True,
-    )
-    stream = relationship(Stream, back_populates="snapshots")
     stream_id: AssociationProxy[StreamId] = association_proxy("stream", "stream_id")
     name = mapped_column(String(50), nullable=False)
     data = mapped_column(JSONB(), nullable=False)
@@ -164,9 +208,7 @@ class Snapshot:
     created_at = mapped_column(DateTime(), nullable=False)
 
 
-class OutboxEntry:
-    __tablename__ = "event_sourcery_outbox_entries"
-
+class BaseOutboxEntry:
     id = mapped_column(BigInteger().with_variant(Integer(), "sqlite"), primary_key=True)
     created_at = mapped_column(DateTime(), nullable=False, index=True)
     data = mapped_column(JSONB(), nullable=False)
@@ -175,24 +217,24 @@ class OutboxEntry:
     tries_left = mapped_column(Integer(), nullable=False)
 
 
-class ProjectorCursor:
-    __tablename__ = "event_sourcery_projector_cursors"
-    __table_args__ = (
-        Index(
-            "ix_name_stream_id",
-            "name",
-            "stream_id",
-            "category",
-            unique=True,
-        ),
-    )
+class BaseProjectorCursor:
+    __tablename__: str
+
+    @declared_attr  # type: ignore[arg-type]
+    @classmethod
+    def __table_args__(cls) -> tuple[Index | UniqueConstraint, ...]:
+        return (
+            Index(
+                f"ix_name_stream_id_{cls.__tablename__}",
+                "name",
+                "stream_id",
+                "category",
+                unique=True,
+            ),
+        )
 
     id = mapped_column(BigInteger().with_variant(Integer(), "sqlite"), primary_key=True)
     name = mapped_column(String(255), nullable=False)
     stream_id = mapped_column(GUID(), nullable=False, index=True)
     category = mapped_column(String(255), nullable=True)
     version = mapped_column(BigInteger(), nullable=False)
-
-
-Stream.events = relationship(Event, back_populates="stream")
-Stream.snapshots = relationship(Snapshot, back_populates="stream")

python_event_sourcery-0.4.0a19/event_sourcery_sqlalchemy/models/default.py

@@ -0,0 +1,27 @@
+from event_sourcery_sqlalchemy.models.base import (
+    BaseEvent,
+    BaseOutboxEntry,
+    BaseProjectorCursor,
+    BaseSnapshot,
+    BaseStream,
+)
+
+
+class DefaultStream(BaseStream):
+    __tablename__ = "event_sourcery_streams"
+
+
+class DefaultEvent(BaseEvent):
+    __tablename__ = "event_sourcery_events"
+
+
+class DefaultSnapshot(BaseSnapshot):
+    __tablename__ = "event_sourcery_snapshots"
+
+
+class DefaultOutboxEntry(BaseOutboxEntry):
+    __tablename__ = "event_sourcery_outbox_entries"
+
+
+class DefaultProjectorCursor(BaseProjectorCursor):
+    __tablename__ = "event_sourcery_projector_cursors"

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/outbox.py

@@ -15,7 +15,7 @@ from event_sourcery.event_store.interfaces import (
     OutboxFiltererStrategy,
     OutboxStorageStrategy,
 )
-from event_sourcery_sqlalchemy.models import OutboxEntry
+from event_sourcery_sqlalchemy.models.base import BaseOutboxEntry
 
 logger = logging.getLogger(__name__)
 
@@ -25,6 +25,7 @@ class SqlAlchemyOutboxStorageStrategy(OutboxStorageStrategy):
     _session: Session
     _filterer: OutboxFiltererStrategy
     _max_publish_attempts: int
+    _outbox_entry_model: type[BaseOutboxEntry]
 
     def put_into_outbox(self, records: list[RecordedRaw]) -> None:
         rows = []
@@ -53,15 +54,15 @@ class SqlAlchemyOutboxStorageStrategy(OutboxStorageStrategy):
         if len(rows) == 0:
             return
 
-        self._session.execute(insert(OutboxEntry), rows)
+        self._session.execute(insert(self._outbox_entry_model), rows)
 
     def outbox_entries(
         self, limit: int
     ) -> Iterator[AbstractContextManager[RecordedRaw]]:
         stmt = (
-            select(OutboxEntry)
-            .filter(OutboxEntry.tries_left > 0)
-            .order_by(OutboxEntry.id)
+            select(self._outbox_entry_model)
+            .filter(self._outbox_entry_model.tries_left > 0)
+            .order_by(self._outbox_entry_model.id)
             .limit(limit)
             .with_for_update(skip_locked=True)
         )
@@ -71,7 +72,7 @@ class SqlAlchemyOutboxStorageStrategy(OutboxStorageStrategy):
 
     @contextmanager
     def _publish_context(
-        self, entry: OutboxEntry
+        self, entry: BaseOutboxEntry
     ) -> Generator[RecordedRaw, None, None]:
         raw = RawEvent(
             uuid=UUID(entry.data["uuid"]),

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/event_sourcery_sqlalchemy/subscription.py

@@ -9,13 +9,22 @@ from sqlalchemy.orm import Session
 
 from event_sourcery.event_store import Position, RecordedRaw
 from event_sourcery.event_store.interfaces import SubscriptionStrategy
-from event_sourcery_sqlalchemy import dto, models
+from event_sourcery_sqlalchemy import dto
+from event_sourcery_sqlalchemy.models.base import BaseEvent, BaseStream
 
 
 class SqlAlchemySubscriptionStrategy(SubscriptionStrategy):
-    def __init__(self, session: Session, gap_retry_interval: timedelta) -> None:
+    def __init__(
+        self,
+        session: Session,
+        gap_retry_interval: timedelta,
+        event_model: type[BaseEvent],
+        stream_model: type[BaseStream],
+    ) -> None:
         self._session = session
         self._gap_retry_interval = gap_retry_interval
+        self._event_model = event_model
+        self._stream_model = stream_model
 
     def subscribe_to_all(
         self,
@@ -24,7 +33,9 @@ class SqlAlchemySubscriptionStrategy(SubscriptionStrategy):
         timelimit: timedelta,
     ) -> Iterator[list[RecordedRaw]]:
         return GapDetectingIterator(
-            get_batch=GetBatchToAll(self._session, batch_size),
+            get_batch=GetBatchToAll(
+                self._session, batch_size, self._event_model, self._stream_model
+            ),
             gap_retry_interval=self._gap_retry_interval,
             start_from=start_from,
             batch_size=batch_size,
@@ -39,7 +50,13 @@ class SqlAlchemySubscriptionStrategy(SubscriptionStrategy):
         category: str,
     ) -> Iterator[list[RecordedRaw]]:
         return GapDetectingIterator(
-            get_batch=GetBatchToCategory(self._session, batch_size, category),
+            get_batch=GetBatchToCategory(
+                self._session,
+                batch_size,
+                category,
+                self._event_model,
+                self._stream_model,
+            ),
             gap_retry_interval=self._gap_retry_interval,
             start_from=start_from,
             batch_size=batch_size,
@@ -54,7 +71,9 @@ class SqlAlchemySubscriptionStrategy(SubscriptionStrategy):
         events: list[str],
     ) -> Iterator[list[RecordedRaw]]:
         return GapDetectingIterator(
-            get_batch=GetBatchToEvents(self._session, batch_size, events),
+            get_batch=GetBatchToEvents(
+                self._session, batch_size, events, self._event_model, self._stream_model
+            ),
             gap_retry_interval=self._gap_retry_interval,
             start_from=start_from,
             batch_size=batch_size,
@@ -63,20 +82,28 @@ class SqlAlchemySubscriptionStrategy(SubscriptionStrategy):
 
 
 class GetBatch(Protocol):
-    def __call__(self, position: Position) -> list[models.Event]: ...
+    def __call__(self, position: Position) -> list[BaseEvent]: ...
 
 
 class GetBatchToAll(GetBatch):
-    def __init__(self, session: Session, batch_size: int) -> None:
+    def __init__(
+        self,
+        session: Session,
+        batch_size: int,
+        event_model: type[BaseEvent],
+        stream_model: type[BaseStream],
+    ) -> None:
         self._session = session
         self._batch_size = batch_size
+        self._event_model = event_model
+        self._stream_model = stream_model
 
-    def __call__(self, position: Position) -> list[models.Event]:
+    def __call__(self, position: Position) -> list[BaseEvent]:
         stmt = (
-            select(models.Event)
-            .join(models.Stream)
-            .where(models.Event.id > position)
-            .order_by(models.Event.id)
+            select(self._event_model)
+            .join(self._stream_model)
+            .where(self._event_model.id > position)
+            .order_by(self._event_model.id)
             .limit(self._batch_size)
         )
 
@@ -84,18 +111,27 @@ class GetBatchToAll(GetBatch):
 
 
 class GetBatchToCategory(GetBatch):
-    def __init__(self, session: Session, batch_size: int, category: str) -> None:
+    def __init__(
+        self,
+        session: Session,
+        batch_size: int,
+        category: str,
+        event_model: type[BaseEvent],
+        stream_model: type[BaseStream],
+    ) -> None:
         self._session = session
         self._batch_size = batch_size
         self._category = category
+        self._event_model = event_model
+        self._stream_model = stream_model
 
-    def __call__(self, position: Position) -> list[models.Event]:
+    def __call__(self, position: Position) -> list[BaseEvent]:
         stmt = (
-            select(models.Event)
-            .join(models.Stream)
-            .where(models.Stream.category == self._category)
-            .where(models.Event.id > position)
-            .order_by(models.Event.id)
+            select(self._event_model)
+            .join(self._stream_model)
+            .where(self._stream_model.category == self._category)
+            .where(self._event_model.id > position)
+            .order_by(self._event_model.id)
             .limit(self._batch_size)
         )
 
@@ -103,18 +139,27 @@ class GetBatchToCategory(GetBatch):
 
 
 class GetBatchToEvents(GetBatch):
-    def __init__(self, session: Session, batch_size: int, events: list[str]) -> None:
+    def __init__(
+        self,
+        session: Session,
+        batch_size: int,
+        events: list[str],
+        event_model: type[BaseEvent],
+        stream_model: type[BaseStream],
+    ) -> None:
         self._session = session
         self._batch_size = batch_size
         self._events = events
+        self._event_model = event_model
+        self._stream_model = stream_model
 
-    def __call__(self, position: Position) -> list[models.Event]:
+    def __call__(self, position: Position) -> list[BaseEvent]:
         stmt = (
-            select(models.Event)
-            .join(models.Stream)
-            .where(models.Event.name.in_(self._events))
-            .where(models.Event.id > position)
-            .order_by(models.Event.id)
+            select(self._event_model)
+            .join(self._stream_model)
+            .where(self._event_model.name.in_(self._events))
+            .where(self._event_model.id > position)
+            .order_by(self._event_model.id)
             .limit(self._batch_size)
         )
 
@@ -125,7 +170,7 @@ class GetBatchToEvents(GetBatch):
 class Cursor:
     position: Position
 
-    def advance(self, batch: list[models.Event]) -> None:
+    def advance(self, batch: list[BaseEvent]) -> None:
         if len(batch) > 0:
             self.position = batch[-1].id
 
@@ -159,14 +204,14 @@ class GapDetectingIterator(Iterator[list[RecordedRaw]]):
                 time.sleep(self._gap_retry_interval.total_seconds())
 
     @staticmethod
-    def _is_continuous(batch: list[models.Event]) -> bool:
+    def _is_continuous(batch: list[BaseEvent]) -> bool:
         if len(batch) < 2:
             return False
 
         return cast(bool, batch[-1].id - batch[0].id + 1 == len(batch))
 
     @staticmethod
-    def _batch_to_recorded_raw(batch: list[models.Event]) -> list[RecordedRaw]:
+    def _batch_to_recorded_raw(batch: list[BaseEvent]) -> list[RecordedRaw]:
         return [
             RecordedRaw(
                 entry=dto.raw_event(event, event.stream),

{python_event_sourcery-0.4.0a18 → python_event_sourcery-0.4.0a19}/pyproject.toml

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