Delete global_domain_event_dispatcher (bump version to 22.0.0) (#303)

mofr · web-flow · commit 6f10c8c6733c · 2024-05-08T17:40:31.000+02:00
* Delete global_domain_event_dispatcher

* Bump version to 22.0.0
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -4,6 +4,14 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [22.0.0] - 2024-05-07
+### Changed
+
+- Delete `winter_ddd.global_domain_event_dispatcher`
+- It's now application responsibility to configure `DomainEventDispatcher`
+- For convenience there are a number of methods in `DomainEventDispatcher` class to add handlers
+- It's not a final form as it requires a lot of manual effort and configuration, so more changes to come
+
 ## [21.0.0] - 2024-04-22
 ### Changed
 
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "winter"
-version = "21.0.0"
+version = "22.0.0"
 homepage = "https://github.com/WinterFramework/winter"
 description = "Web Framework with focus on python typing, dataclasses and modular design"
 authors = ["Alexander Egorov <mofr@zond.org>"]
diff --git a/tests/winter_ddd/test_domain_event_dispatcher.py b/tests/winter_ddd/test_domain_event_dispatcher.py
@@ -0,0 +1,22 @@
+from winter_ddd import DomainEventDispatcher
+from tests.winter_ddd.test_domain_event_dispatcher_fixture.events import DomainEvent1
+from tests.winter_ddd.test_domain_event_dispatcher_fixture.events import DomainEvent2
+
+
+def test_add_handlers_from_package():
+    dispatcher = DomainEventDispatcher()
+    dispatcher.add_handlers_from_package('tests.winter_ddd.test_domain_event_dispatcher_fixture')
+    event1 = DomainEvent1()
+    event2 = DomainEvent2()
+
+    # Act
+    dispatcher.dispatch([event1, event2])
+
+    # Assert
+    # Intentionally importing here to make sure that handlers are registered without explicit imports
+    from tests.winter_ddd.test_domain_event_dispatcher_fixture.handler1 import Handler1
+    from tests.winter_ddd.test_domain_event_dispatcher_fixture.subpackage.handler2 import Handler2
+    assert len(Handler1.received_events) == 1
+    assert len(Handler2.received_events) == 1
+    assert Handler1.received_events[0] is event1
+    assert Handler2.received_events[0] is event2
diff --git a/tests/winter_ddd/test_domain_event_dispatcher_fixture/__init__.py b/tests/winter_ddd/test_domain_event_dispatcher_fixture/__init__.py
diff --git a/tests/winter_ddd/test_domain_event_dispatcher_fixture/events.py b/tests/winter_ddd/test_domain_event_dispatcher_fixture/events.py
@@ -0,0 +1,9 @@
+from winter_ddd import DomainEvent
+
+
+class DomainEvent1(DomainEvent):
+    pass
+
+
+class DomainEvent2(DomainEvent):
+    pass
diff --git a/tests/winter_ddd/test_domain_event_dispatcher_fixture/handler1.py b/tests/winter_ddd/test_domain_event_dispatcher_fixture/handler1.py
@@ -0,0 +1,10 @@
+from winter_ddd import domain_event_handler
+from .events import DomainEvent1
+
+
+class Handler1:
+    received_events = []
+
+    @domain_event_handler
+    def handle_event(self, event: DomainEvent1):
+        self.received_events.append(event)
diff --git a/tests/winter_ddd/test_domain_event_dispatcher_fixture/subpackage/__init__.py b/tests/winter_ddd/test_domain_event_dispatcher_fixture/subpackage/__init__.py
diff --git a/tests/winter_ddd/test_domain_event_dispatcher_fixture/subpackage/handler2.py b/tests/winter_ddd/test_domain_event_dispatcher_fixture/subpackage/handler2.py
@@ -0,0 +1,24 @@
+from winter.core import annotate
+from winter_ddd import domain_event_handler
+from ..events import DomainEvent2
+
+
+class AnotherAnnotation:
+    pass
+
+
+class Handler2:
+    received_events = []
+
+    @domain_event_handler
+    def handle_event(self, event: DomainEvent2):
+        self.received_events.append(event)
+
+    def intentionally_without_annotation(self, event: DomainEvent2):  # pragma: no cover
+        # This shouldn't happen
+        self.received_events.append(event)
+
+    @annotate(AnotherAnnotation())
+    def intentionally_with_another_annotation(self, event: DomainEvent2):  # pragma: no cover
+        # This shouldn't happen
+        self.received_events.append(event)
diff --git a/tests/winter_ddd/test_process_domain_events.py b/tests/winter_ddd/test_process_domain_events.py
@@ -3,9 +3,10 @@
 
 import pytest
 
+from winter.core import ComponentMethod
 from winter_ddd import DomainEvent
 from winter_ddd import domain_event_handler
-from winter_ddd import global_domain_event_dispatcher
+from winter_ddd import DomainEventDispatcher
 
 
 class CustomDomainEvent(DomainEvent):
@@ -20,41 +21,37 @@ class YetAnotherCustomEvent(DomainEvent):
     pass
 
 
-@pytest.fixture
-def empty_handler():
-    class Handler:
-        handled_domain_events = []
-        handled_another_domain_events = []
-        handled_many_domain_events = []
-        handled_many_another_domain_events = []
-        handled_union_domain_events = []
-        handled_union_list_domain_events = []
-
-        @domain_event_handler
-        def empty_handle(self, domain_event: CustomDomainEvent):
-            self.handled_domain_events.append(domain_event)
+class _TestHandler:
+    handled_domain_events = []
+    handled_another_domain_events = []
+    handled_many_domain_events = []
+    handled_many_another_domain_events = []
+    handled_union_domain_events = []
+    handled_union_list_domain_events = []
 
-        @domain_event_handler
-        def handle_many(self, domain_events: List[CustomDomainEvent]):
-            self.handled_many_domain_events.append(domain_events)
+    @domain_event_handler
+    def empty_handle(self, domain_event: CustomDomainEvent):
+        self.handled_domain_events.append(domain_event)
 
-        @domain_event_handler
-        def handle_another(self, domain_event: AnotherCustomEvent):
-            self.handled_another_domain_events.append(domain_event)
+    @domain_event_handler
+    def handle_many(self, domain_events: List[CustomDomainEvent]):
+        self.handled_many_domain_events.append(domain_events)
 
-        @domain_event_handler
-        def handle_many_another(self, domain_events: List[AnotherCustomEvent]):
-            self.handled_many_another_domain_events.append(domain_events)
+    @domain_event_handler
+    def handle_another(self, domain_event: AnotherCustomEvent):
+        self.handled_another_domain_events.append(domain_event)
 
-        @domain_event_handler
-        def handle_union(self, domain_event: Union[CustomDomainEvent, AnotherCustomEvent]):
-            self.handled_union_domain_events.append(domain_event)
+    @domain_event_handler
+    def handle_many_another(self, domain_events: List[AnotherCustomEvent]):
+        self.handled_many_another_domain_events.append(domain_events)
 
-        @domain_event_handler
-        def handle_union_list(self, domain_events: List[Union[CustomDomainEvent, AnotherCustomEvent]]):
-            self.handled_union_list_domain_events.append(domain_events)
+    @domain_event_handler
+    def handle_union(self, domain_event: Union[CustomDomainEvent, AnotherCustomEvent]):
+        self.handled_union_domain_events.append(domain_event)
 
-    yield Handler()
+    @domain_event_handler
+    def handle_union_list(self, domain_events: List[Union[CustomDomainEvent, AnotherCustomEvent]]):
+        self.handled_union_list_domain_events.append(domain_events)
 
 
 class DomainEventForOrder(DomainEvent):
@@ -101,27 +98,30 @@ def handle_one(self, domain_event: DomainEventForOrder):
         self.handled_domain_events.append('handle_one_3')
 
 
-def test_process_domain_events(empty_handler):
+def test_process_domain_events():
     domain_event1 = CustomDomainEvent()
     domain_event2 = CustomDomainEvent()
     another_domain_event = AnotherCustomEvent()
     yet_another_domain_event = YetAnotherCustomEvent()
 
+    dispatcher = DomainEventDispatcher()
+    dispatcher.add_handlers_from_class(_TestHandler)
+
     # Act
-    global_domain_event_dispatcher.dispatch([
+    dispatcher.dispatch([
         domain_event1,
         another_domain_event,
         yet_another_domain_event,
         domain_event2,
     ])
 
     # Assert
-    assert empty_handler.handled_domain_events == [domain_event1, domain_event2]
-    assert empty_handler.handled_another_domain_events == [another_domain_event]
-    assert empty_handler.handled_many_domain_events == [[domain_event1, domain_event2]]
-    assert empty_handler.handled_many_another_domain_events == [[another_domain_event]]
-    assert empty_handler.handled_union_domain_events == [domain_event1, another_domain_event, domain_event2]
-    assert empty_handler.handled_union_list_domain_events == [[domain_event1, another_domain_event, domain_event2]]
+    assert _TestHandler.handled_domain_events == [domain_event1, domain_event2]
+    assert _TestHandler.handled_another_domain_events == [another_domain_event]
+    assert _TestHandler.handled_many_domain_events == [[domain_event1, domain_event2]]
+    assert _TestHandler.handled_many_another_domain_events == [[another_domain_event]]
+    assert _TestHandler.handled_union_domain_events == [domain_event1, another_domain_event, domain_event2]
+    assert _TestHandler.handled_union_list_domain_events == [[domain_event1, another_domain_event, domain_event2]]
 
 
 def test_order_process_domain_events():
@@ -132,9 +132,14 @@ def test_order_process_domain_events():
     OrderHandler2.handled_domain_events = handled_events
     OrderHandler3.handled_domain_events = handled_events
 
+    dispatcher = DomainEventDispatcher()
+    dispatcher.add_handlers_from_class(OrderHandler1)
+    dispatcher.add_handlers_from_class(OrderHandler2)
+    dispatcher.add_handlers_from_class(OrderHandler3)
+
     # Act
     for _ in range(5):
-        global_domain_event_dispatcher.dispatch([
+        dispatcher.dispatch([
             domain_event,
         ])
 
diff --git a/tests/winter_sqlalchemy/test_sqla_crud.py b/tests/winter_sqlalchemy/test_sqla_crud.py
@@ -19,6 +19,7 @@
 from winter.data.exceptions import NotFoundException
 from winter_ddd import AggregateRoot
 from winter_ddd import DomainEvent
+from winter_ddd import DomainEventDispatcher
 from winter_ddd import domain_event_handler
 from winter_sqlalchemy import sqla_crud
 
@@ -103,6 +104,9 @@ class Fixture:
     @inject
     def __init__(self, engine: Engine):
         injector = get_injector()
+        domain_event_dispatcher = DomainEventDispatcher()
+        domain_event_dispatcher.add_handlers_from_class(DomainEventHandlers)
+        injector.binder.bind(DomainEventDispatcher, domain_event_dispatcher)
         injector.binder.bind(MyRepository, to=ClassProvider(sqla_crud(MyRepository)))
         self._engine = engine
         self.repository = injector.get(MyRepository)
diff --git a/winter/messaging/event_dispacher.py b/winter/messaging/event_dispacher.py
@@ -1,3 +1,4 @@
+from typing import Callable
 from typing import Dict
 from typing import List
 
@@ -32,7 +33,13 @@ def dispatch_many(self, events: List[Event]):
             handler_instance = injector.get(event_subscription.handler_method.component.component_cls)
 
             if event_subscription.collection:
-                event_subscription.handler_method.func(handler_instance, events)
+                self._execute_handler(event_subscription.handler_method.func, handler_instance, events)
             else:
                 for event in events:
-                    event_subscription.handler_method.func(handler_instance, event)
+                    self._execute_handler(event_subscription.handler_method.func, handler_instance, event)
+
+    def _execute_handler(self, func: Callable, *args, **kwargs):
+        """
+        The method is intentionally extracted to make it possible to override it externally for logging purposes.
+        """
+        func(*args, **kwargs)
diff --git a/winter/messaging/event_subscription_registry.py b/winter/messaging/event_subscription_registry.py
@@ -1,4 +1,3 @@
-from typing import Callable
 from typing import Dict
 from typing import Iterable
 from typing import List
diff --git a/winter_ddd/__init__.py b/winter_ddd/__init__.py
@@ -1,5 +1,5 @@
 from .aggregate_root import AggregateRoot
 from .domain_event import DomainEvent
-from .domain_event_dispatcher import global_domain_event_dispatcher
+from .domain_event_dispatcher import DomainEventDispatcher
 from .domain_event_handler import domain_event_handler
 from .domain_events import DomainEvents
diff --git a/winter_ddd/domain_event_dispatcher.py b/winter_ddd/domain_event_dispatcher.py
@@ -1,21 +1,39 @@
+from typing import Callable
 from typing import Dict
 from typing import Iterable
 from typing import List
 from typing import Type
 
+from winter.core import Component
+from winter.core import ComponentMethod
 from winter.core import get_injector
+from winter.core.module_discovery import get_all_classes
+from winter.core.module_discovery import import_recursively
 from .domain_event import DomainEvent
+from .domain_event_handler import DomainEventHandlerAnnotation
 from .domain_event_subscription import DomainEventSubscription
 
 
 class DomainEventDispatcher:
     def __init__(self):
         self.event_type_to_subscription_map: Dict[Type[DomainEvent], List[DomainEventSubscription]] = {}
 
-    def add_subscription(self, subscription: DomainEventSubscription):
+    def add_handler(self, handler: ComponentMethod):
+        subscription = DomainEventSubscription.create(handler.component.component_cls, handler.func)
         for event_type in subscription.event_filter:
             self.event_type_to_subscription_map.setdefault(event_type, []).append(subscription)
 
+    def add_handlers_from_package(self, package_name: str):
+        import_recursively(package_name)
+        for class_name, class_ in get_all_classes(package_name):
+            self.add_handlers_from_class(class_)
+
+    def add_handlers_from_class(self, handler_class: Type):
+        component = Component.get_by_cls(handler_class)
+        for component_method in component.methods:
+            if component_method.annotations.get_one_or_none(DomainEventHandlerAnnotation):
+                self.add_handler(component_method)
+
     def dispatch(self, events: Iterable[DomainEvent]):
         events_grouped_by_subscription: Dict[DomainEventSubscription, List[DomainEvent]] = {}
 
@@ -30,10 +48,13 @@ def dispatch(self, events: Iterable[DomainEvent]):
         for domain_event_subscription, events in events_grouped_by_subscription.items():
             handler_instance = injector.get(domain_event_subscription.handler_class)
             if domain_event_subscription.collection:
-                domain_event_subscription.handler_method(handler_instance, events)
+                self._execute_handler(domain_event_subscription.handler_method, handler_instance, events)
             else:
                 for event in events:
-                    domain_event_subscription.handler_method(handler_instance, event)
-
+                    self._execute_handler(domain_event_subscription.handler_method, handler_instance, event)
 
-global_domain_event_dispatcher = DomainEventDispatcher()
+    def _execute_handler(self, func: Callable, *args, **kwargs):
+        """
+        The method is intentionally extracted to make it possible to override it externally for logging purposes.
+        """
+        func(*args, **kwargs)
diff --git a/winter_ddd/domain_event_handler.py b/winter_ddd/domain_event_handler.py
@@ -1,34 +1,8 @@
-import inspect
-import re
+from winter.core import annotate
 
-from winter.core.utils.typing import is_union
-from .domain_event_dispatcher import global_domain_event_dispatcher
-from .domain_event_subscription import DomainEventSubscription
 
-domain_events_class_name_pattern = re.compile(r'typing.List\[.+\]')
+class DomainEventHandlerAnnotation:
+    pass
 
 
-# noinspection PyPep8Naming
-class domain_event_handler:
-    """Decorator for method in class"""
-
-    def __init__(self, method):
-        self._method = method
-        func_spec = inspect.getfullargspec(self._method)
-
-        if len(func_spec.args) != 2:  # One argument and self
-            raise AssertionError(f'Method must have only 1 arguments: {method.__qualname__}.')
-        arg_type = func_spec.annotations[func_spec.args[1]]
-        if (
-            not inspect.isclass(arg_type) and
-            not domain_events_class_name_pattern.match(str(arg_type)) and
-            not is_union(arg_type)
-        ):
-            raise AssertionError('First argument must have annotation and this annotation must be class')
-
-    def __get__(self, instance, owner):  # pragma: no cover
-        return self._method.__get__(instance, owner)
-
-    def __set_name__(self, owner, name):
-        subscription = DomainEventSubscription.create(owner, self._method)
-        global_domain_event_dispatcher.add_subscription(subscription)
+domain_event_handler = annotate(DomainEventHandlerAnnotation(), single=True)
diff --git a/winter_sqlalchemy/repository.py b/winter_sqlalchemy/repository.py
