eventsourcing 9.4.0a7__py3-none-any.whl → 9.4.0b1__py3-none-any.whl

eventsourcing/domain.py

@@ -4,6 +4,8 @@ import dataclasses
 import importlib
 import inspect
 import os
+from collections import defaultdict
+from dataclasses import dataclass
 from datetime import datetime, tzinfo
 from functools import cache
 from types import FunctionType, WrapperDescriptorType
@@ -22,6 +24,8 @@ from typing import (
 from uuid import UUID, uuid4
 from warnings import warn
 
+from typing_extensions import Self
+
 from eventsourcing.utils import get_method_name, get_topic, resolve_topic
 
 if TYPE_CHECKING:
@@ -40,6 +44,38 @@ domain and convert to local timezones when presenting values in user interfaces.
 """
 
 
+class EventsourcingType(type):
+    """
+    Base type for event sourcing domain model types (aggregates and events).
+    """
+
+
+_T = TypeVar("_T")
+
+
+def patch_dataclasses_process_class() -> None:
+    dataclasses_module = importlib.import_module("dataclasses")
+    original_process_class_func = dataclasses_module.__dict__["_process_class"]
+
+    def _patched_dataclasses_process_class(
+        cls: type[_T], *args: Any, **kwargs: Any
+    ) -> type[_T]:
+        # Avoid processing aggregate and event dataclasses twice,
+        # because doing so screws up non-init and default fields.
+        if (
+            cls
+            and isinstance(cls, EventsourcingType)
+            and "__dataclass_fields__" in cls.__dict__
+        ):
+            return cls
+        return original_process_class_func(cls, *args, **kwargs)
+
+    dataclasses_module.__dict__["_process_class"] = _patched_dataclasses_process_class
+
+
+patch_dataclasses_process_class()
+
+
 @runtime_checkable
 class DomainEventProtocol(Protocol):
     """
@@ -52,20 +88,26 @@ class DomainEventProtocol(Protocol):
     kinds of domain event classes, such as Pydantic classes.
     """
 
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        pass  # pragma: no cover
+
     @property
     def originator_id(self) -> UUID:
         """
         UUID identifying an aggregate to which the event belongs.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def originator_version(self) -> int:
         """
         Integer identifying the version of the aggregate when the event occurred.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 TDomainEvent = TypeVar("TDomainEvent", bound=DomainEventProtocol)
+SDomainEvent = TypeVar("SDomainEvent", bound=DomainEventProtocol)
 
 
 class MutableAggregateProtocol(Protocol):
@@ -84,18 +126,21 @@ class MutableAggregateProtocol(Protocol):
         """
         Mutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @version.setter
     def version(self, value: int) -> None:
         """
         Mutable aggregates have a read-write version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 class ImmutableAggregateProtocol(Protocol):
@@ -114,12 +159,14 @@ class ImmutableAggregateProtocol(Protocol):
         """
         Immutable aggregates have a read-only ID that is a UUID.
         """
+        raise NotImplementedError  # pragma: no cover
 
     @property
     def version(self) -> int:
         """
         Immutable aggregates have a read-only version that is an int.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 MutableOrImmutableAggregate = Union[
@@ -144,6 +191,7 @@ class CollectEventsProtocol(Protocol):
         """
         Returns a sequence of events.
         """
+        raise NotImplementedError  # pragma: no cover
 
 
 @runtime_checkable
@@ -197,7 +245,7 @@ class CanCreateTimestamp:
         return datetime_now_with_tzinfo()
 
 
-TAggregate = TypeVar("TAggregate", bound="Aggregate")
+TAggregate = TypeVar("TAggregate", bound="BaseAggregate")
 
 
 class HasOriginatorIDVersion:
@@ -217,6 +265,7 @@ class CanMutateAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
     method that evolves the state of an aggregate.
     """
 
+    # Todo: Move this to a HasTimestamp? Why is it here??
     timestamp: datetime
     """Timezone-aware :class:`datetime` object representing when an event occurred."""
 
@@ -263,7 +312,7 @@ class CanMutateAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
         # Return the mutated aggregate.
         return aggregate
 
-    def apply(self, aggregate: Aggregate) -> None:
+    def apply(self, aggregate: Any) -> None:
         """
         Applies the domain event to its aggregate.
 
@@ -326,7 +375,7 @@ class CanInitAggregate(CanMutateAggregate):
         return agg
 
 
-class MetaDomainEvent(type):
+class MetaDomainEvent(EventsourcingType):
     """
     Metaclass which ensures all domain event classes are frozen dataclasses.
     """
@@ -342,6 +391,7 @@ class MetaDomainEvent(type):
         return event_cls
 
 
+@dataclass(frozen=True)
 class DomainEvent(CanCreateTimestamp, metaclass=MetaDomainEvent):
     """
     Frozen data class representing domain model events.
@@ -363,6 +413,7 @@ class AggregateEvent(CanMutateAggregate, DomainEvent):
     """
 
 
+@dataclass(frozen=True)
 class AggregateCreated(CanInitAggregate, AggregateEvent):
     """
     Frozen data class representing the initial creation of an aggregate.
@@ -392,10 +443,6 @@ class LogEvent(DomainEvent):
     """
 
 
-# Deprecated: Use TDomainEvent instead.
-TLogEvent = TypeVar("TLogEvent", bound=DomainEventProtocol)
-
-
 def _filter_kwargs_for_method_params(
     kwargs: dict[str, Any], method: Callable[..., Any]
 ) -> dict[str, Any]:
@@ -442,12 +489,12 @@ class CommandMethodDecorator:
         elif isinstance(event_spec, type) and issubclass(
             event_spec, CanMutateAggregate
         ):
-            if event_spec in given_event_classes:
+            if event_spec in _given_event_classes:
                 name = event_spec.__name__
                 msg = f"{name} event class used in more than one decorator"
                 raise TypeError(msg)
             self.given_event_cls = event_spec
-            given_event_classes.add(event_spec)
+            _given_event_classes.add(event_spec)
 
         # Process a decorated property.
         if isinstance(decorated_obj, property):
@@ -730,7 +777,7 @@ class BoundCommandMethodDecorator:
         kwargs = _coerce_args_to_kwargs(
             self.event_decorator.decorated_method, args, kwargs
         )
-        event_cls = decorated_event_classes[self.event_decorator]
+        event_cls = decorator_event_classes[self.event_decorator]
         kwargs = _filter_kwargs_for_method_params(kwargs, event_cls)
         self.aggregate.trigger_event(event_cls, **kwargs)
 
@@ -738,14 +785,30 @@ class BoundCommandMethodDecorator:
         self.trigger(*args, **kwargs)
 
 
-given_event_classes: set[type] = set()
-decorated_methods: dict[type, CommandMethod] = {}
-aggregate_has_many_created_event_classes: dict[type, list[str]] = {}
+class DecoratorEvent(CanMutateAggregate):
+    def apply(self, aggregate: Aggregate) -> None:
+        """
+        Applies event to aggregate by calling method decorated by @event.
+        """
+        # Call super method, just in case any base classes need it.
+        super().apply(aggregate)
+
+        # Identify the method that was decorated.
+        decorated_method = _decorated_methods[type(self)]
 
+        # Select event attributes mentioned in method signature.
+        kwargs = _filter_kwargs_for_method_params(self.__dict__, decorated_method)
 
-decorated_event_classes: dict[
-    CommandMethodDecorator, type[MetaAggregate.DecoratedEvent]
-] = {}
+        # Call the original method with event attribute values.
+        decorated_method(aggregate, **kwargs)
+
+
+_given_event_classes: set[type] = set()
+_decorated_methods: dict[type, CommandMethod] = {}
+_created_event_classes: dict[type, list[type[CanInitAggregate]]] = {}
+
+
+decorator_event_classes: dict[CommandMethodDecorator, type[DecoratorEvent]] = {}
 
 
 def _check_no_variable_params(method: FunctionType) -> None:
@@ -883,110 +946,283 @@ def _raise_missing_names_type_error(missing_names: list[str], msg: str) -> None:
     raise TypeError(msg)
 
 
-_annotations_mention_id: set[MetaAggregate[Aggregate]] = set()
-_init_mentions_id: set[MetaAggregate[Aggregate]] = set()
+_annotations_mention_id: set[type[BaseAggregate]] = set()
+_init_mentions_id: set[type[BaseAggregate]] = set()
+_create_id_param_names: dict[type[BaseAggregate], list[str]] = defaultdict(list)
 
 
-def _ensure_idempotent_dataclass(module_name: str) -> None:
-    module = importlib.import_module(module_name)
-    if (
-        "dataclass" in module.__dict__
-        and module.__dict__["dataclass"] == dataclasses.dataclass
-        and "__original_dataclass_func__" not in module.__dict__
-    ):
-        module.__dict__["__original_dataclass_func__"] = module.__dict__["dataclass"]
-        module.__dict__["dataclass"] = _idempotent_dataclass
+class MetaAggregate(EventsourcingType, Generic[TAggregate], type):
+    """
+    Metaclass for aggregate classes.
+    """
+
+    def _define_event_class(
+        cls,
+        name: str,
+        bases: tuple[type[CanMutateAggregate], ...],
+        apply_method: CommandMethod | None,
+    ) -> type[CanMutateAggregate]:
+        # Define annotations for the event class (specs the init method).
+        annotations = {}
+        if apply_method is not None:
+            method_signature = inspect.signature(apply_method)
+            supers = {
+                s for b in bases for s in b.__mro__ if hasattr(s, "__annotations__")
+            }
+            super_annotations = {a for s in supers for a in s.__annotations__}
+            for param_name, param in list(method_signature.parameters.items())[1:]:
+                # Don't define 'id' on a "created" class.
+                if param_name == "id" and apply_method.__name__ == "__init__":
+                    continue
+                # Don't override super class annotations, unless no default on param.
+                if param_name not in super_annotations or param.default == param.empty:
+                    annotations[param_name] = param.annotation or "typing.Any"
+        event_cls_qualname = f"{cls.__qualname__}.{name}"
+        event_cls_dict = {
+            "__annotations__": annotations,
+            "__module__": cls.__module__,
+            "__qualname__": event_cls_qualname,
+        }
 
+        # Create the event class object.
+        return cast(type[CanMutateAggregate], type(name, bases, event_cls_dict))
 
-def _idempotent_dataclass(cls: type[object] | None = None, /, **kwargs: Any) -> Any:
+    def __call__(
+        cls: MetaAggregate[TAggregate], *args: Any, **kwargs: Any
+    ) -> TAggregate:
+        created_event_classes = _created_event_classes[cls]
+        if len(created_event_classes) > 1:
+            msg = (
+                f"{cls.__qualname__} can't decide which of many "
+                '"created" event classes to use: '
+                f"""'{"', '".join(c.__name__ for c in created_event_classes)}'. """
+                "Please use class arg 'created_event_name' or"
+                " @event decorator on __init__ method."
+            )
+            raise TypeError(msg)
 
-    def idempotent_wrap(cls: type[object]) -> type[object]:
-        # Avoid processing dataclass twice.
-        if "__dataclass_fields__" in cls.__dict__:
-            return cls
-        return dataclasses.dataclass(**kwargs)(cls)
+        cls_init: FunctionType | WrapperDescriptorType = cls.__init__  # type: ignore
+        kwargs = _coerce_args_to_kwargs(
+            cls_init,
+            args,
+            kwargs,
+            expects_id=cls in _annotations_mention_id,
+        )
+        return cls._create(
+            event_class=created_event_classes[0],
+            **kwargs,
+        )
 
-    # See if we're being called as @dataclass or @dataclass().
-    if cls is None:
-        # We're called with parens.
-        return idempotent_wrap
+    def _create(
+        cls: MetaAggregate[TAggregate],
+        event_class: type[CanInitAggregate],
+        **kwargs: Any,
+    ) -> TAggregate:
+        raise NotImplementedError  # pragma: no cover
 
-    # We're called as @dataclass without parens.
-    return idempotent_wrap(cls)
+    _created_event_class: type[CanInitAggregate]
 
 
-class MetaAggregate(type, Generic[TAggregate]):
+class BaseAggregate(metaclass=MetaAggregate):
     """
-    Metaclass for aggregate classes.
-
-    Initialises aggregate classes by defining event classes.
+    Base class for aggregates.
     """
 
     INITIAL_VERSION = 1
 
-    class Event(AggregateEvent):
-        pass
+    @staticmethod
+    def create_id(*_: Any, **__: Any) -> UUID:
+        """
+        Returns a new aggregate ID.
+        """
+        return uuid4()
 
-    class Created(Event, AggregateCreated):
-        pass
+    @classmethod
+    def _create(
+        cls: type[Self],
+        event_class: type[CanInitAggregate],
+        *,
+        id: UUID | None = None,  # noqa: A002
+        **kwargs: Any,
+    ) -> Self:
+        """
+        Constructs a new aggregate object instance.
+        """
+        # Construct the domain event with an ID and a
+        # version, and a topic for the aggregate class.
+        create_id_kwargs = {
+            k: v for k, v in kwargs.items() if k in _create_id_param_names[cls]
+        }
+        if id is not None:
+            originator_id = id
+            if not isinstance(originator_id, UUID):
+                msg = f"Given id was not a UUID: {originator_id}"
+                raise TypeError(msg)
+        else:
+            originator_id = cls.create_id(**create_id_kwargs)
+            if not isinstance(originator_id, UUID):
+                msg = (
+                    f"{cls.create_id.__module__}.{cls.create_id.__qualname__}"
+                    f" did not return UUID, it returned: {originator_id}"
+                )
+                raise TypeError(msg)
 
-    class DecoratedEvent(CanMutateAggregate):
-        def apply(self, aggregate: Aggregate) -> None:
-            """
-            Applies event to aggregate by calling method decorated by @event.
-            """
-            # Call super method, just in case any base classes need it.
-            super().apply(aggregate)
+        # Impose the required common "created" event attribute values.
+        kwargs = kwargs.copy()
+        kwargs.update(
+            originator_topic=get_topic(cls),
+            originator_id=originator_id,
+            originator_version=cls.INITIAL_VERSION,
+        )
+        if kwargs.get("timestamp") is None:
+            kwargs["timestamp"] = event_class.create_timestamp()
 
-            # Identify the method that was decorated.
-            decorated_method = decorated_methods[type(self)]
+        try:
+            created_event = event_class(**kwargs)
+        except TypeError as e:
+            msg = f"Unable to construct '{event_class.__qualname__}' event: {e}"
+            raise TypeError(msg) from e
+        # Construct the aggregate object.
+        agg = cast(Self, created_event.mutate(None))
 
-            # Select event attributes mentioned in method signature.
-            kwargs = _filter_kwargs_for_method_params(self.__dict__, decorated_method)
+        assert agg is not None
+        # Append the domain event to pending list.
+        agg._pending_events.append(created_event)
+        # Return the aggregate.
+        return agg
 
-            # Call the original method with event attribute values.
-            decorated_method(aggregate, **kwargs)
+    def __base_init__(
+        self, originator_id: UUID, originator_version: int, timestamp: datetime
+    ) -> None:
+        """
+        Initialises an aggregate object with an :data:`id`, a :data:`version`
+        number, and a :data:`timestamp`.
+        """
+        self._id = originator_id
+        self._version = originator_version
+        self._created_on = timestamp
+        self._modified_on = timestamp
+        self._pending_events: list[CanMutateAggregate] = []
 
-    _created_event_class: type[CanInitAggregate]
+    @property
+    def id(self) -> UUID:
+        """
+        The ID of the aggregate.
+        """
+        return self._id
+
+    @property
+    def version(self) -> int:
+        """
+        The version number of the aggregate.
+        """
+        return self._version
+
+    @version.setter
+    def version(self, version: int) -> None:
+        self._version = version
+
+    @property
+    def created_on(self) -> datetime:
+        """
+        The date and time when the aggregate was created.
+        """
+        return self._created_on
+
+    @property
+    def modified_on(self) -> datetime:
+        """
+        The date and time when the aggregate was last modified.
+        """
+        return self._modified_on
+
+    @modified_on.setter
+    def modified_on(self, modified_on: datetime) -> None:
+        self._modified_on = modified_on
 
-    def __new__(cls, *args: Any, **_: Any) -> MetaAggregate[Aggregate]:
+    @property
+    def pending_events(self) -> list[CanMutateAggregate]:
         """
-        Configures aggregate class definition.
+        A list of pending events.
         """
+        return self._pending_events
 
-        # Avoid processing dataclass twice. This avoids dataclasses.Field(init=False)
-        # attributes being reduced to annotation only and then appearing in __init__
-        # method signature when class is reprocessed, and other similar problems.
-        _ensure_idempotent_dataclass(module_name=args[2]["__module__"])
+    def trigger_event(
+        self,
+        event_class: type[CanMutateAggregate],
+        **kwargs: Any,
+    ) -> None:
+        """
+        Triggers domain event of given type, by creating
+        an event object and using it to mutate the aggregate.
+        """
+        # Construct the domain event as the
+        # next in the aggregate's sequence.
+        # Use counting to generate the sequence.
+        next_version = self.version + 1
+
+        # Impose the required common domain event attribute values.
+        kwargs = kwargs.copy()
+        kwargs.update(
+            originator_id=self.id,
+            originator_version=next_version,
+        )
+        if kwargs.get("timestamp") is None:
+            kwargs["timestamp"] = event_class.create_timestamp()
 
         try:
-            class_annotations = args[2]["__annotations__"]
-        except KeyError:
-            class_annotations = None
-            annotations_mention_id = False
-        else:
-            try:
-                class_annotations.pop("id")
-            except KeyError:
-                annotations_mention_id = False
-            else:
-                annotations_mention_id = True
-        aggregate_cls = type.__new__(cls, *args)
-        if class_annotations or any(dataclasses.is_dataclass(base) for base in args[1]):
-            aggregate_cls = dataclasses.dataclass(eq=False, repr=False)(aggregate_cls)
-        if annotations_mention_id:
-            _annotations_mention_id.add(aggregate_cls)
-        return aggregate_cls
+            new_event = event_class(**kwargs)
+        except TypeError as e:
+            msg = f"Can't construct event {event_class}: {e}"
+            raise TypeError(msg) from None
 
-    def __init__(
-        cls: MetaAggregate[Aggregate],
-        *args: Any,
-        created_event_name: str = "",
+        # Mutate aggregate with domain event.
+        new_event.mutate(self)
+        # Append the domain event to pending list.
+        self._pending_events.append(new_event)
+
+    def collect_events(self) -> Sequence[CanMutateAggregate]:
+        """
+        Collects and returns a list of pending aggregate
+        :class:`AggregateEvent` objects.
+        """
+        collected = []
+        while self._pending_events:
+            collected.append(self._pending_events.pop(0))
+        return collected
+
+    def __eq__(self, other: object) -> bool:
+        return type(self) is type(other) and self.__dict__ == other.__dict__
+
+    def __repr__(self) -> str:
+        attrs = [
+            f"{k.lstrip('_')}={v!r}"
+            for k, v in self.__dict__.items()
+            if k != "_pending_events"
+        ]
+        return f"{type(self).__name__}({', '.join(attrs)})"
+
+    def __init_subclass__(
+        cls: type[BaseAggregate], *, created_event_name: str | None = None
     ) -> None:
         """
-        Initialises aggregate class by completing the definition of its event classes.
+        Initialises aggregate subclass by defining __init__ method and event classes.
         """
-        super().__init__(*args)
+        super().__init_subclass__()
+
+        class_annotations = cls.__dict__.get("__annotations__", {})
+        try:
+            class_annotations.pop("id")
+            _annotations_mention_id.add(cls)
+        except KeyError:
+            pass
+
+        if (
+            class_annotations
+            or cls in _annotations_mention_id
+            or any(dataclasses.is_dataclass(base) for base in cls.__bases__)
+        ):
+            dataclasses.dataclass(eq=False, repr=False)(cls)
 
         # Identify or define a base event class for this aggregate.
         base_event_name = "Event"
@@ -995,7 +1231,9 @@ class MetaAggregate(type, Generic[TAggregate]):
             base_event_cls = cls.__dict__[base_event_name]
         except KeyError:
             base_event_cls = cls._define_event_class(
-                base_event_name, (cls.Event,), None
+                name=base_event_name,
+                bases=(getattr(cls, base_event_name, AggregateEvent),),
+                apply_method=None,
             )
             setattr(cls, base_event_name, base_event_cls)
 
@@ -1019,15 +1257,8 @@ class MetaAggregate(type, Generic[TAggregate]):
             if isinstance(value, type) and issubclass(value, CanInitAggregate):
                 created_event_classes[name] = value
 
-        # Disallow using both '_created_event_class' and 'created_event_name'.
-        created_event_class: type[CanInitAggregate] | None = cls.__dict__.get(
-            "_created_event_class"
-        )
-        if created_event_class and created_event_name:
-            msg = "Can't use both '_created_event_class' and 'created_event_name'"
-            raise TypeError(msg)
-
         # Identify or define the aggregate's "created" event class.
+        created_event_class: type[CanInitAggregate] | None = None
 
         # Is the init method decorated with a CommandMethodDecorator?
         if isinstance(cls.__dict__.get("__init__"), CommandMethodDecorator):
@@ -1040,16 +1271,13 @@ class MetaAggregate(type, Generic[TAggregate]):
             if created_event_name:
                 msg = "Can't use both 'created_event_name' and decorator on __init__"
                 raise TypeError(msg)
-            # Disallow using both '_created_event_class' and decorator on __init__.
-            if created_event_class:
-                msg = "Can't use both '_created_event_class' and decorator on __init__"
-                raise TypeError(msg)
 
             # Does the decorator specify a "created" event class?
             if init_decorator.given_event_cls:
                 created_event_class = cast(
                     type[CanInitAggregate], init_decorator.given_event_cls
                 )
+
             # Does the decorator specify a "created" event name?
             elif init_decorator.event_cls_name:
                 created_event_name = init_decorator.event_cls_name
@@ -1061,7 +1289,7 @@ class MetaAggregate(type, Generic[TAggregate]):
 
         # TODO: Write a test to cover this when "Created" class is explicitly defined.
         # Check if init mentions ID.
-        for param_name in inspect.signature(cls.__init__).parameters:  # type: ignore
+        for param_name in inspect.signature(cls.__init__).parameters:
             if param_name == "id":
                 _init_mentions_id.add(cls)
                 break
@@ -1095,17 +1323,21 @@ class MetaAggregate(type, Generic[TAggregate]):
             if created_event_name and len(created_event_classes) == 1:
                 base_created_event_cls = next(iter(created_event_classes.values()))
             else:
+                # Todo: This could probably be improved.
+                # Look for first class in MRO that has one specified "created" class.
                 for base_cls in cls.__mro__:
-                    if base_cls is cls:
-                        continue
-                    base_created_event_cls = base_cls.__dict__.get(
-                        "_created_event_class",
-                        base_cls.__dict__.get("Created"),
-                    )
-                    if base_created_event_cls:
+                    if (
+                        base_cls in _created_event_classes
+                        and len(_created_event_classes[base_cls]) == 1
+                    ):
+                        base_created_event_cls = _created_event_classes[base_cls][0]
                         break
                 else:  # pragma: no cover
-                    msg = "Can't decide base class for new 'created' event class"
+                    # Todo: Write a test to cover this.
+                    msg = (
+                        "Can't find base aggregate class with "
+                        "a specified 'created' event class"
+                    )
                     raise TypeError(msg)
 
             if not created_event_name:
@@ -1141,10 +1373,10 @@ class MetaAggregate(type, Generic[TAggregate]):
             setattr(cls, created_event_name, created_event_class)
 
         if created_event_class:
-            cls._created_event_class = created_event_class
+            _created_event_classes[cls] = [created_event_class]
         else:
             # Prepare to disallow ambiguity of choice between created event classes.
-            aggregate_has_many_created_event_classes[cls] = list(created_event_classes)
+            _created_event_classes[cls] = list(created_event_classes.values())
 
         # Prepare the subsequent event classes.
         for attr_name, attr_value in tuple(cls.__dict__.items()):
@@ -1198,7 +1430,7 @@ class MetaAggregate(type, Generic[TAggregate]):
                     )
                     event_cls = cls._define_event_class(
                         event_decorator.given_event_cls.__name__,
-                        (cls.DecoratedEvent, given_subclass),
+                        (DecoratorEvent, given_subclass),
                         None,
                     )
 
@@ -1215,19 +1447,19 @@ class MetaAggregate(type, Generic[TAggregate]):
                     # Define event class from signature of original method.
                     event_cls = cls._define_event_class(
                         event_decorator.event_cls_name,
-                        (cls.DecoratedEvent, base_event_cls),
+                        (DecoratorEvent, base_event_cls),
                         event_decorator.decorated_method,
                     )
 
                 # Cache the decorated method for the event class to use.
-                decorated_methods[event_cls] = event_decorator.decorated_method
+                _decorated_methods[event_cls] = event_decorator.decorated_method
 
                 # Set the event class as an attribute of the aggregate class.
                 setattr(cls, event_cls.__name__, event_cls)
 
                 # Remember which event class to trigger.
-                decorated_event_classes[event_decorator] = cast(
-                    type[MetaAggregate.DecoratedEvent], event_cls
+                decorator_event_classes[event_decorator] = cast(
+                    type[DecoratorEvent], event_cls
                 )
 
         # Check any create_id method defined on this class is static or class method.
@@ -1241,13 +1473,12 @@ class MetaAggregate(type, Generic[TAggregate]):
             raise TypeError(msg)
 
         # Get the parameters of the create_id method that will be used by this class.
-        cls._create_id_param_names: list[str] = []
         for name, param in inspect.signature(cls.create_id).parameters.items():
             if param.kind in [param.KEYWORD_ONLY, param.POSITIONAL_OR_KEYWORD]:
-                cls._create_id_param_names.append(name)
+                _create_id_param_names[cls].append(name)
 
         # Define event classes for all events on bases.
-        for aggregate_base_class in args[1]:
+        for aggregate_base_class in cls.__bases__:
             for name, value in aggregate_base_class.__dict__.items():
                 if (
                     isinstance(value, type)
@@ -1260,253 +1491,23 @@ class MetaAggregate(type, Generic[TAggregate]):
                     )
                     setattr(cls, name, sub_class)
 
-    def _define_event_class(
-        cls,
-        name: str,
-        bases: tuple[type[CanMutateAggregate], ...],
-        apply_method: CommandMethod | None,
-    ) -> type[CanMutateAggregate]:
-        # Define annotations for the event class (specs the init method).
-        annotations = {}
-        if apply_method is not None:
-            method_signature = inspect.signature(apply_method)
-            supers = {
-                s for b in bases for s in b.__mro__ if hasattr(s, "__annotations__")
-            }
-            super_annotations = {a for s in supers for a in s.__annotations__}
-            for param_name, param in list(method_signature.parameters.items())[1:]:
-                # Don't define 'id' on a "created" class.
-                if param_name == "id" and apply_method.__name__ == "__init__":
-                    continue
-                # Don't override super class annotations, unless no default on param.
-                if param_name not in super_annotations or param.default == param.empty:
-                    annotations[param_name] = param.annotation or "typing.Any"
-        event_cls_qualname = f"{cls.__qualname__}.{name}"
-        event_cls_dict = {
-            "__annotations__": annotations,
-            "__module__": cls.__module__,
-            "__qualname__": event_cls_qualname,
-        }
-
-        # Create the event class object.
-        return cast(type[CanMutateAggregate], type(name, bases, event_cls_dict))
-
-    def __call__(
-        cls: MetaAggregate[TAggregate], *args: Any, **kwargs: Any
-    ) -> TAggregate:
-        try:
-            created_event_classes = aggregate_has_many_created_event_classes[cls]
-            msg = (
-                """Can't decide which of many "created" event classes to use: """
-                f"""'{"', '".join(created_event_classes)}'. Please use class """
-                "arg 'created_event_name' or @event decorator on __init__ method."
-            )
-            raise TypeError(msg)
-        except KeyError:
-            pass
-
-        cls_init: FunctionType | WrapperDescriptorType = cls.__init__  # type: ignore
-        kwargs = _coerce_args_to_kwargs(
-            cls_init,
-            args,
-            kwargs,
-            expects_id=cls in _annotations_mention_id,
-        )
-        return cls._create(
-            event_class=cls._created_event_class,
-            **kwargs,
-        )
-
-    def _create(
-        cls: MetaAggregate[TAggregate],
-        event_class: type[CanInitAggregate],
-        **kwargs: Any,
-    ) -> TAggregate:
-        raise NotImplementedError  # pragma: no cover
-
-    @staticmethod
-    def create_id(**_: Any) -> UUID:
-        """
-        Returns a new aggregate ID.
-        """
-        return uuid4()
-
-
-class Aggregate(metaclass=MetaAggregate):
-    """
-    Base class for aggregate roots.
-
-    .. automethod:: _create
-    """
-
-    @classmethod
-    def _create(
-        cls: type[TAggregate],
-        event_class: type[CanInitAggregate],
-        *,
-        id: UUID | None = None,  # noqa: A002
-        **kwargs: Any,
-    ) -> TAggregate:
-        """
-        Constructs a new aggregate object instance.
-        """
-        # Construct the domain event with an ID and a
-        # version, and a topic for the aggregate class.
-        create_id_kwargs = {
-            k: v for k, v in kwargs.items() if k in cls._create_id_param_names
-        }
-        originator_id = id or cls.create_id(**create_id_kwargs)
-
-        # Impose the required common "created" event attribute values.
-        kwargs = kwargs.copy()
-        kwargs.update(
-            originator_topic=get_topic(cls),
-            originator_id=originator_id,
-            originator_version=cls.INITIAL_VERSION,
-        )
-        if kwargs.get("timestamp") is None:
-            kwargs["timestamp"] = event_class.create_timestamp()
-
-        try:
-            created_event = event_class(**kwargs)
-        except TypeError as e:
-            msg = f"Unable to construct '{event_class.__name__}' event: {e}"
-            raise TypeError(msg) from None
-        # Construct the aggregate object.
-        agg = cast(TAggregate, created_event.mutate(None))
-
-        assert agg is not None
-        # Append the domain event to pending list.
-        agg.pending_events.append(created_event)
-        # Return the aggregate.
-        return agg
-
-    def __base_init__(
-        self, originator_id: UUID, originator_version: int, timestamp: datetime
-    ) -> None:
-        """
-        Initialises an aggregate object with an :data:`id`, a :data:`version`
-        number, and a :data:`timestamp`.
-        """
-        self._id = originator_id
-        self._version = originator_version
-        self._created_on = timestamp
-        self._modified_on = timestamp
-        self._pending_events: list[CanMutateAggregate] = []
-
-    @property
-    def id(self) -> UUID:
-        """
-        The ID of the aggregate.
-        """
-        return self._id
-
-    @property
-    def version(self) -> int:
-        """
-        The version number of the aggregate.
-        """
-        return self._version
-
-    @version.setter
-    def version(self, version: int) -> None:
-        self._version = version
-
-    @property
-    def created_on(self) -> datetime:
-        """
-        The date and time when the aggregate was created.
-        """
-        return self._created_on
-
-    @property
-    def modified_on(self) -> datetime:
-        """
-        The date and time when the aggregate was last modified.
-        """
-        return self._modified_on
-
-    @modified_on.setter
-    def modified_on(self, modified_on: datetime) -> None:
-        self._modified_on = modified_on
-
-    @property
-    def pending_events(self) -> list[CanMutateAggregate]:
-        """
-        A list of pending events.
-        """
-        return self._pending_events
 
+class Aggregate(BaseAggregate):
     class Event(AggregateEvent):
         pass
 
     class Created(Event, AggregateCreated):
         pass
 
-    def __eq__(self, other: object) -> bool:
-        return type(self) is type(other) and self.__dict__ == other.__dict__
-
-    def __repr__(self) -> str:
-        attrs = [
-            f"{k.lstrip('_')}={v!r}"
-            for k, v in self.__dict__.items()
-            if k != "_pending_events"
-        ]
-        return f"{type(self).__name__}({', '.join(attrs)})"
-
-    def trigger_event(
-        self,
-        event_class: type[CanMutateAggregate],
-        **kwargs: Any,
-    ) -> None:
-        """
-        Triggers domain event of given type, by creating
-        an event object and using it to mutate the aggregate.
-        """
-        # Construct the domain event as the
-        # next in the aggregate's sequence.
-        # Use counting to generate the sequence.
-        next_version = self.version + 1
-
-        # Impose the required common domain event attribute values.
-        kwargs = kwargs.copy()
-        kwargs.update(
-            originator_id=self.id,
-            originator_version=next_version,
-        )
-        if kwargs.get("timestamp") is None:
-            kwargs["timestamp"] = event_class.create_timestamp()
-
-        try:
-            new_event = event_class(**kwargs)
-        except TypeError as e:
-            msg = f"Can't construct event {event_class}: {e}"
-            raise TypeError(msg) from None
 
-        # Mutate aggregate with domain event.
-        new_event.mutate(self)
-        # Append the domain event to pending list.
-        self._pending_events.append(new_event)
-
-    def collect_events(self) -> Sequence[CanMutateAggregate]:
-        """
-        Collects and returns a list of pending aggregate
-        :class:`AggregateEvent` objects.
-        """
-        collected = []
-        while self._pending_events:
-            collected.append(self._pending_events.pop(0))
-        return collected
+@overload
+def aggregate(*, created_event_name: str) -> Callable[[Any], type[Aggregate]]:
+    pass  # pragma: no cover
 
 
-# @overload
-# def aggregate(*, created_event_name: str) -> Callable[[Any], Type[Aggregate]]:
-#     ...
-#
-#
-# @overload
-# def aggregate(cls: Any) -> Type[Aggregate]:
-#     ...
+@overload
+def aggregate(cls: Any) -> type[Aggregate]:
+    pass  # pragma: no cover
 
 
 def aggregate(
@@ -1590,6 +1591,7 @@ class SnapshotProtocol(DomainEventProtocol, Protocol):
         """
         Snapshots have a read-only 'state'.
         """
+        raise NotImplementedError  # pragma: no cover
 
     # TODO: Improve on this 'Any'.
     @classmethod
@@ -1606,6 +1608,16 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
     topic: str
     state: Any
 
+    def __init__(
+        self,
+        originator_id: UUID,
+        originator_version: int,
+        timestamp: datetime,
+        topic: str,
+        state: Any,
+    ) -> None:
+        raise NotImplementedError  # pragma: no cover
+
     @classmethod
     def take(
         cls: type[TCanSnapshotAggregate],
@@ -1622,7 +1634,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
             aggregate_state.pop("_id")
             aggregate_state.pop("_version")
             aggregate_state.pop("_pending_events")
-        return cls(  # type: ignore
+        return cls(
             originator_id=aggregate.id,
             originator_version=aggregate.version,
             timestamp=cls.create_timestamp(),
@@ -1652,6 +1664,7 @@ class CanSnapshotAggregate(HasOriginatorIDVersion, CanCreateTimestamp):
         return aggregate
 
 
+@dataclass(frozen=True)
 class Snapshot(CanSnapshotAggregate, DomainEvent):
     """
     Snapshots represent the state of an aggregate at a particular