eventsourcing 9.2.22__py3-none-any.whl → 9.3.0a1__py3-none-any.whl

eventsourcing/examples/contentmanagement/application.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, ClassVar, Dict, Iterator, Type, Union, cast
+from uuid import NAMESPACE_URL, UUID, uuid5
+
+from eventsourcing.application import (
+    AggregateNotFoundError,
+    Application,
+    EventSourcedLog,
+)
+from eventsourcing.examples.contentmanagement.domainmodel import Index, Page, PageLogged
+
+if TYPE_CHECKING:  # pragma: nocover
+    from eventsourcing.domain import MutableOrImmutableAggregate
+    from eventsourcing.utils import EnvType
+
+PageDetailsType = Dict[str, Union[str, Any]]
+
+
+class ContentManagementApplication(Application):
+    env: ClassVar[Dict[str, str]] = {"COMPRESSOR_TOPIC": "gzip"}
+    snapshotting_intervals: ClassVar[Dict[Type[MutableOrImmutableAggregate], int]] = {
+        Page: 5
+    }
+
+    def __init__(self, env: EnvType | None = None) -> None:
+        super().__init__(env)
+        self.page_log: EventSourcedLog[PageLogged] = EventSourcedLog(
+            self.events, uuid5(NAMESPACE_URL, "/page_log"), PageLogged
+        )
+
+    def create_page(self, title: str, slug: str) -> None:
+        page = Page(title=title, slug=slug)
+        page_logged = self.page_log.trigger_event(page_id=page.id)
+        index_entry = Index(slug, ref=page.id)
+        self.save(page, page_logged, index_entry)
+
+    def get_page_by_slug(self, slug: str) -> PageDetailsType:
+        page = self._get_page_by_slug(slug)
+        return self._details_from_page(page)
+
+    def get_page_by_id(self, page_id: UUID) -> PageDetailsType:
+        page = self._get_page_by_id(page_id)
+        return self._details_from_page(page)
+
+    def _details_from_page(self, page: Page) -> PageDetailsType:
+        return {
+            "title": page.title,
+            "slug": page.slug,
+            "body": page.body,
+            "modified_by": page.modified_by,
+        }
+
+    def update_title(self, slug: str, title: str) -> None:
+        page = self._get_page_by_slug(slug)
+        page.update_title(title=title)
+        self.save(page)
+
+    def update_slug(self, old_slug: str, new_slug: str) -> None:
+        page = self._get_page_by_slug(old_slug)
+        page.update_slug(new_slug)
+        old_index = self._get_index(old_slug)
+        old_index.update_ref(None)
+        try:
+            new_index = self._get_index(new_slug)
+        except AggregateNotFoundError:
+            new_index = Index(new_slug, page.id)
+        else:
+            if new_index.ref is None:
+                new_index.update_ref(page.id)
+            else:
+                raise SlugConflictError
+        self.save(page, old_index, new_index)
+
+    def update_body(self, slug: str, body: str) -> None:
+        page = self._get_page_by_slug(slug)
+        page.update_body(body)
+        self.save(page)
+
+    def _get_page_by_slug(self, slug: str) -> Page:
+        try:
+            index = self._get_index(slug)
+        except AggregateNotFoundError:
+            raise PageNotFoundError(slug) from None
+        if index.ref is None:
+            raise PageNotFoundError(slug)
+        page_id = index.ref
+        return self._get_page_by_id(page_id)
+
+    def _get_page_by_id(self, page_id: UUID) -> Page:
+        return cast(Page, self.repository.get(page_id))
+
+    def _get_index(self, slug: str) -> Index:
+        return cast(Index, self.repository.get(Index.create_id(slug)))
+
+    def get_pages(
+        self,
+        *,
+        gt: int | None = None,
+        lte: int | None = None,
+        desc: bool = False,
+        limit: int | None = None,
+    ) -> Iterator[PageDetailsType]:
+        for page_logged in self.page_log.get(gt=gt, lte=lte, desc=desc, limit=limit):
+            page = self._get_page_by_id(page_logged.page_id)
+            yield self._details_from_page(page)
+
+
+class PageNotFoundError(Exception):
+    """
+    Raised when a page is not found.
+    """
+
+
+class SlugConflictError(Exception):
+    """
+    Raised when updating a page to a slug used by another page.
+    """

eventsourcing/examples/contentmanagement/domainmodel.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from contextvars import ContextVar
+from dataclasses import dataclass, field
+from typing import cast
+from uuid import NAMESPACE_URL, UUID, uuid5
+
+from eventsourcing.domain import Aggregate, DomainEvent, event
+from eventsourcing.examples.contentmanagement.utils import apply_patch, create_diff
+
+user_id_cvar: ContextVar[UUID | None] = ContextVar("user_id", default=None)
+
+
+class Page(Aggregate):
+    class Event(Aggregate.Event):
+        user_id: UUID | None = field(default_factory=user_id_cvar.get, init=False)
+
+        def apply(self, aggregate: Aggregate) -> None:
+            cast(Page, aggregate).modified_by = self.user_id
+
+    class Created(Event, Aggregate.Created):
+        title: str
+        slug: str
+        body: str
+
+    def __init__(self, title: str, slug: str, body: str = ""):
+        self.title = title
+        self.slug = slug
+        self.body = body
+        self.modified_by: UUID | None = None
+
+    @event("SlugUpdated")
+    def update_slug(self, slug: str) -> None:
+        self.slug = slug
+
+    @event("TitleUpdated")
+    def update_title(self, title: str) -> None:
+        self.title = title
+
+    def update_body(self, body: str) -> None:
+        self._update_body(create_diff(old=self.body, new=body))
+
+    class BodyUpdated(Event):
+        diff: str
+
+    @event(BodyUpdated)
+    def _update_body(self, diff: str) -> None:
+        self.body = apply_patch(old=self.body, diff=diff)
+
+
+@dataclass
+class Index(Aggregate):
+    slug: str
+    ref: UUID | None
+
+    class Event(Aggregate.Event):
+        pass
+
+    @staticmethod
+    def create_id(slug: str) -> UUID:
+        return uuid5(NAMESPACE_URL, f"/slugs/{slug}")
+
+    @event("RefChanged")
+    def update_ref(self, ref: UUID | None) -> None:
+        self.ref = ref
+
+
+class PageLogged(DomainEvent):
+    page_id: UUID

eventsourcing/examples/contentmanagement/test.py

@@ -0,0 +1,180 @@
+from __future__ import annotations
+
+from typing import cast
+from unittest import TestCase
+from uuid import uuid4
+
+from eventsourcing.examples.contentmanagement.application import (
+    ContentManagementApplication,
+    PageNotFoundError,
+    SlugConflictError,
+)
+from eventsourcing.examples.contentmanagement.domainmodel import (
+    Index,
+    Page,
+    user_id_cvar,
+)
+from eventsourcing.system import NotificationLogReader
+
+
+class TestContentManagement(TestCase):
+    def test(self) -> None:
+        # Set user_id context variable.
+        user_id = uuid4()
+        user_id_cvar.set(user_id)
+
+        # Construct application.
+        app = ContentManagementApplication()
+
+        # Check the page doesn't exist.
+        with self.assertRaises(PageNotFoundError):
+            app.get_page_by_slug(slug="welcome")
+
+        # Check the list of pages is empty.
+        pages = list(app.get_pages())
+        self.assertEqual(len(pages), 0)
+
+        # Create a page.
+        app.create_page(title="Welcome", slug="welcome")
+
+        # Present page identified by the given slug.
+        page = app.get_page_by_slug(slug="welcome")
+
+        # Check we got a dict that has the given title and slug.
+        self.assertEqual(page["title"], "Welcome")
+        self.assertEqual(page["slug"], "welcome")
+        self.assertEqual(page["body"], "")
+        self.assertEqual(page["modified_by"], user_id)
+
+        # Update the title.
+        app.update_title(slug="welcome", title="Welcome Visitors")
+
+        # Check the title was updated.
+        page = app.get_page_by_slug(slug="welcome")
+        self.assertEqual(page["title"], "Welcome Visitors")
+        self.assertEqual(page["modified_by"], user_id)
+
+        # Update the slug.
+        app.update_slug(old_slug="welcome", new_slug="welcome-visitors")
+
+        # Check the index was updated.
+        with self.assertRaises(PageNotFoundError):
+            app.get_page_by_slug(slug="welcome")
+
+        # Check we can get the page by the new slug.
+        page = app.get_page_by_slug(slug="welcome-visitors")
+        self.assertEqual(page["title"], "Welcome Visitors")
+        self.assertEqual(page["slug"], "welcome-visitors")
+
+        # Update the body.
+        app.update_body(slug="welcome-visitors", body="Welcome to my wiki")
+
+        # Check the body was updated.
+        page = app.get_page_by_slug(slug="welcome-visitors")
+        self.assertEqual(page["body"], "Welcome to my wiki")
+
+        # Update the body.
+        app.update_body(slug="welcome-visitors", body="Welcome to this wiki")
+
+        # Check the body was updated.
+        page = app.get_page_by_slug(slug="welcome-visitors")
+        self.assertEqual(page["body"], "Welcome to this wiki")
+
+        # Update the body.
+        app.update_body(
+            slug="welcome-visitors",
+            body="""
+Welcome to this wiki!
+
+This is a wiki about...
+""",
+        )
+
+        # Check the body was updated.
+        page = app.get_page_by_slug(slug="welcome-visitors")
+        self.assertEqual(
+            page["body"],
+            """
+Welcome to this wiki!
+
+This is a wiki about...
+""",
+        )
+
+        # Check all the Page events have the user_id.
+        for notification in NotificationLogReader(app.notification_log).read(start=1):
+            domain_event = app.mapper.to_domain_event(notification)
+            if isinstance(domain_event, Page.Event):
+                self.assertEqual(domain_event.user_id, user_id)
+
+        # Change user_id context variable.
+        user_id = uuid4()
+        user_id_cvar.set(user_id)
+
+        # Update the body.
+        app.update_body(
+            slug="welcome-visitors",
+            body="""
+Welcome to this wiki!
+
+This is a wiki about us!
+""",
+        )
+
+        # Check 'modified_by' changed.
+        page = app.get_page_by_slug(slug="welcome-visitors")
+        self.assertEqual(page["title"], "Welcome Visitors")
+        self.assertEqual(page["modified_by"], user_id)
+
+        # Check a snapshot was created by now.
+        assert app.snapshots
+        index = cast(Index, app.repository.get(Index.create_id("welcome-visitors")))
+        assert index.ref
+        self.assertTrue(len(list(app.snapshots.get(index.ref))))
+
+        # Create some more pages and list all the pages.
+        app.create_page("Page 2", "page-2")
+        app.create_page("Page 3", "page-3")
+        app.create_page("Page 4", "page-4")
+        app.create_page("Page 5", "page-5")
+
+        pages = list(app.get_pages(desc=True))
+        self.assertEqual(pages[0]["title"], "Page 5")
+        self.assertEqual(pages[0]["slug"], "page-5")
+        self.assertEqual(pages[1]["title"], "Page 4")
+        self.assertEqual(pages[1]["slug"], "page-4")
+        self.assertEqual(pages[2]["title"], "Page 3")
+        self.assertEqual(pages[2]["slug"], "page-3")
+        self.assertEqual(pages[3]["title"], "Page 2")
+        self.assertEqual(pages[3]["slug"], "page-2")
+        self.assertEqual(pages[4]["title"], "Welcome Visitors")
+        self.assertEqual(pages[4]["slug"], "welcome-visitors")
+
+        pages = list(app.get_pages(desc=True, limit=3))
+        self.assertEqual(len(pages), 3)
+        self.assertEqual(pages[0]["slug"], "page-5")
+        self.assertEqual(pages[1]["slug"], "page-4")
+        self.assertEqual(pages[2]["slug"], "page-3")
+
+        pages = list(app.get_pages(desc=True, limit=3, lte=2))
+        self.assertEqual(len(pages), 2)
+        self.assertEqual(pages[0]["slug"], "page-2")
+        self.assertEqual(pages[1]["slug"], "welcome-visitors")
+
+        pages = list(app.get_pages(desc=True, lte=2))
+        self.assertEqual(len(pages), 2)
+        self.assertEqual(pages[0]["slug"], "page-2")
+        self.assertEqual(pages[1]["slug"], "welcome-visitors")
+
+        # Check we can't change the slug of a page to one
+        # that is being used by another page.
+        with self.assertRaises(SlugConflictError):
+            app.update_slug("page-2", "page-3")
+
+        # Check we can change the slug of a page to one
+        # that was previously being used.
+        app.update_slug("welcome-visitors", "welcome")
+
+        page = app.get_page_by_slug(slug="welcome")
+        self.assertEqual(page["title"], "Welcome Visitors")
+        self.assertEqual(page["modified_by"], user_id)

eventsourcing/examples/contentmanagement/utils.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+import os
+from tempfile import TemporaryDirectory
+
+
+def create_diff(old: str, new: str) -> str:
+    return run("diff %s %s > %s", old, new)
+
+
+def apply_patch(old: str, diff: str) -> str:
+    return run("patch -s %s %s -o %s", old, diff)
+
+
+def run(cmd: str, a: str, b: str) -> str:
+    with TemporaryDirectory() as td:
+        a_path = os.path.join(td, "a")
+        b_path = os.path.join(td, "b")
+        c_path = os.path.join(td, "c")
+        with open(a_path, "w") as a_file:
+            a_file.write(a)
+        with open(b_path, "w") as b_file:
+            b_file.write(b)
+        os.system(cmd % (a_path, b_path, c_path))  # noqa: S605
+        with open(c_path) as c_file:
+            return c_file.read()

eventsourcing/examples/contentmanagementsystem/application.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, ClassVar, Dict, List, cast
+
+from eventsourcing.examples.contentmanagement.domainmodel import Page
+from eventsourcing.examples.contentmanagement.utils import apply_patch
+from eventsourcing.examples.searchablecontent.persistence import (
+    SearchableContentRecorder,
+)
+from eventsourcing.system import ProcessApplication
+
+if TYPE_CHECKING:  # pragma: nocover
+    from uuid import UUID
+
+    from eventsourcing.application import ProcessingEvent
+    from eventsourcing.domain import DomainEventProtocol
+
+
+class SearchIndexApplication(ProcessApplication):
+    env: ClassVar[Dict[str, str]] = {
+        "COMPRESSOR_TOPIC": "gzip",
+    }
+
+    def policy(
+        self,
+        domain_event: DomainEventProtocol,
+        processing_event: ProcessingEvent,
+    ) -> None:
+        if isinstance(domain_event, Page.Created):
+            processing_event.saved_kwargs["insert_pages"] = [
+                (
+                    domain_event.originator_id,
+                    domain_event.slug,
+                    domain_event.title,
+                    domain_event.body,
+                )
+            ]
+        elif isinstance(domain_event, Page.BodyUpdated):
+            recorder = cast(SearchableContentRecorder, self.recorder)
+            page_id = domain_event.originator_id
+            page_slug, page_title, page_body = recorder.select_page(page_id)
+            page_body = apply_patch(page_body, domain_event.diff)
+            processing_event.saved_kwargs["update_pages"] = [
+                (
+                    page_id,
+                    page_slug,
+                    page_title,
+                    page_body,
+                )
+            ]
+
+    def search(self, query: str) -> List[UUID]:
+        recorder = cast(SearchableContentRecorder, self.recorder)
+        return recorder.search_pages(query)

eventsourcing/examples/contentmanagementsystem/postgres.py

@@ -0,0 +1,17 @@
+from eventsourcing.examples.searchablecontent.postgres import (
+    PostgresSearchableContentRecorder,
+)
+from eventsourcing.postgres import Factory, PostgresProcessRecorder
+
+
+class SearchableContentProcessRecorder(
+    PostgresSearchableContentRecorder, PostgresProcessRecorder
+):
+    pass
+
+
+class SearchableContentInfrastructureFactory(Factory):
+    process_recorder_class = SearchableContentProcessRecorder
+
+
+del Factory

eventsourcing/examples/contentmanagementsystem/sqlite.py

@@ -0,0 +1,17 @@
+from eventsourcing.examples.searchablecontent.sqlite import (
+    SQLiteSearchableContentRecorder,
+)
+from eventsourcing.sqlite import Factory, SQLiteProcessRecorder
+
+
+class SearchableContentProcessRecorder(
+    SQLiteSearchableContentRecorder, SQLiteProcessRecorder
+):
+    pass
+
+
+class SearchableContentInfrastructureFactory(Factory):
+    process_recorder_class = SearchableContentProcessRecorder
+
+
+del Factory

eventsourcing/examples/contentmanagementsystem/system.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from eventsourcing.examples.contentmanagement.application import (
+    ContentManagementApplication,
+)
+from eventsourcing.examples.contentmanagementsystem.application import (
+    SearchIndexApplication,
+)
+from eventsourcing.system import System
+
+
+class ContentManagementSystem(System):
+    def __init__(self) -> None:
+        super().__init__(pipes=[[ContentManagementApplication, SearchIndexApplication]])

eventsourcing/examples/contentmanagementsystem/test_system.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from typing import ClassVar, Dict
+from unittest import TestCase
+from uuid import uuid4
+
+from eventsourcing.examples.contentmanagement.application import (
+    ContentManagementApplication,
+)
+from eventsourcing.examples.contentmanagement.domainmodel import user_id_cvar
+from eventsourcing.examples.contentmanagementsystem.application import (
+    SearchIndexApplication,
+)
+from eventsourcing.examples.contentmanagementsystem.system import (
+    ContentManagementSystem,
+)
+from eventsourcing.postgres import PostgresDatastore
+from eventsourcing.system import SingleThreadedRunner
+from eventsourcing.tests.postgres_utils import drop_postgres_table
+
+
+class ContentManagementSystemTestCase(TestCase):
+    env: ClassVar[Dict[str, str]] = {}
+
+    def test_system(self) -> None:
+        runner = SingleThreadedRunner(system=ContentManagementSystem(), env=self.env)
+        runner.start()
+
+        content_management_app = runner.get(ContentManagementApplication)
+        search_index_app = runner.get(SearchIndexApplication)
+
+        # Set user_id context variable.
+        user_id = uuid4()
+        user_id_cvar.set(user_id)
+
+        # Create empty pages.
+        content_management_app.create_page(title="Animals", slug="animals")
+        content_management_app.create_page(title="Plants", slug="plants")
+        content_management_app.create_page(title="Minerals", slug="minerals")
+
+        # Search, expect no results.
+        self.assertEqual(0, len(search_index_app.search("cat")))
+        self.assertEqual(0, len(search_index_app.search("rose")))
+        self.assertEqual(0, len(search_index_app.search("calcium")))
+
+        # Update the pages.
+        content_management_app.update_body(slug="animals", body="cat")
+        content_management_app.update_body(slug="plants", body="rose")
+        content_management_app.update_body(slug="minerals", body="calcium")
+
+        # Search for single words.
+        page_ids = search_index_app.search("cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat")
+
+        page_ids = search_index_app.search("rose")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "rose")
+
+        page_ids = search_index_app.search("calcium")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "calcium")
+
+        self.assertEqual(len(search_index_app.search("dog")), 0)
+        self.assertEqual(len(search_index_app.search("bluebell")), 0)
+        self.assertEqual(len(search_index_app.search("zinc")), 0)
+
+        # Update the pages again.
+        content_management_app.update_body(slug="animals", body="cat dog zebra")
+        content_management_app.update_body(slug="plants", body="bluebell rose jasmine")
+        content_management_app.update_body(slug="minerals", body="iron zinc calcium")
+
+        # Search for single words.
+        page_ids = search_index_app.search("cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        page_ids = search_index_app.search("rose")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "bluebell rose jasmine")
+
+        page_ids = search_index_app.search("calcium")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "iron zinc calcium")
+
+        page_ids = search_index_app.search("dog")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        page_ids = search_index_app.search("bluebell")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "plants")
+        self.assertEqual(page["body"], "bluebell rose jasmine")
+
+        page_ids = search_index_app.search("zinc")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "minerals")
+        self.assertEqual(page["body"], "iron zinc calcium")
+
+        # Search for multiple words in same page.
+        page_ids = search_index_app.search("dog cat")
+        self.assertEqual(1, len(page_ids))
+        page = content_management_app.get_page_by_id(page_ids[0])
+        self.assertEqual(page["slug"], "animals")
+        self.assertEqual(page["body"], "cat dog zebra")
+
+        # Search for multiple words in same page, expect no results.
+        page_ids = search_index_app.search("rose zebra")
+        self.assertEqual(0, len(page_ids))
+
+        # Search for alternative words, expect two results.
+        page_ids = search_index_app.search("rose OR zebra")
+        pages = [content_management_app.get_page_by_id(page_id) for page_id in page_ids]
+        self.assertEqual(2, len(pages))
+        self.assertEqual(["animals", "plants"], sorted(p["slug"] for p in pages))
+
+
+class TestWithSQLite(ContentManagementSystemTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.contentmanagementsystem.sqlite",
+        "SQLITE_DBNAME": ":memory:",
+    }
+
+
+class TestWithPostgres(ContentManagementSystemTestCase):
+    env: ClassVar[Dict[str, str]] = {
+        "PERSISTENCE_MODULE": "eventsourcing.examples.contentmanagementsystem.postgres",
+        "POSTGRES_DBNAME": "eventsourcing",
+        "POSTGRES_HOST": "127.0.0.1",
+        "POSTGRES_PORT": "5432",
+        "POSTGRES_USER": "eventsourcing",
+        "POSTGRES_PASSWORD": "eventsourcing",
+    }
+
+    def setUp(self) -> None:
+        super().setUp()
+        self.drop_tables()
+
+    def tearDown(self) -> None:
+        self.drop_tables()
+        super().tearDown()
+
+    def drop_tables(self) -> None:
+        db = PostgresDatastore(
+            self.env["POSTGRES_DBNAME"],
+            self.env["POSTGRES_HOST"],
+            self.env["POSTGRES_PORT"],
+            self.env["POSTGRES_USER"],
+            self.env["POSTGRES_PASSWORD"],
+        )
+        drop_postgres_table(db, "public.contentmanagementapplication_events")
+        drop_postgres_table(db, "public.pages_projection_example")
+        drop_postgres_table(db, "public.searchindexapplication_events")
+        drop_postgres_table(db, "public.searchindexapplication_tracking")
+        db.close()
+
+
+del ContentManagementSystemTestCase