Domain Events: события домена и путь к Event-Driven

Domain Events: события домена и путь к Event-Driven

Пользователь прошёл урок. Что должно произойти дальше? Обновить прогресс, пересчитать процент завершения курса, отправить email "Поздравляем!", записать аналитику, проверить - может, пора выдать сертификат.

Если всю эту логику запихнуть в один метод CompleteLesson, получится бог-функция на 200 строк. Добавление каждой новой реакции потребует правки этого метода, а падение email-сервиса сломает основной сценарий.

Domain Events решают эту проблему: основной метод фиксирует факт ("урок пройден"), а все побочные реакции запускаются отдельно. Это базовый кирпичик event-driven архитектуры.

Событие - это факт в прошедшем времени

Domain Event - это неизменяемая запись о том, что уже произошло в домене. Не запрос, не команда, а свершившийся факт.

Command (Команда)Event (Событие)
ВремяБудущее, императивПрошедшее, свершившийся факт
ПримерCompleteLessonLessonCompleted
Может быть отклонена?ДаНет (факт уже случился)
Отправитель знает получателя?ДаНет (pub/sub)
ИзменяемостьМожет быть переформулированаИммутабельна

Команда говорит: "Сделай это". Событие говорит: "Это случилось".

События BackendStart

На платформе BackendStart можно выделить такие доменные события:

package domain

import "time"

// Пользователь завершил урок
type LessonCompleted struct {
    UserID     int64
    CourseSlug string
    LessonSlug string
    OccurredAt time.Time
}

// Пользователь прошёл квиз
type QuizPassed struct {
    UserID     int64
    LessonSlug string
    Score      int // процент правильных ответов
    OccurredAt time.Time
}

// Пользователь завершил весь курс
type CourseFinished struct {
    UserID     int64
    CourseSlug string
    OccurredAt time.Time
}

// Новый пользователь зарегистрировался
type UserRegistered struct {
    UserID    int64
    Email     string
    Provider  string // "github", "email"
    OccurredAt time.Time
}
<?php
declare(strict_types=1);

namespace App\Learning\Domain;

use DateTimeImmutable;

// Domain Event - final readonly: факт в прошедшем времени, иммутабельный.

// Пользователь завершил урок
final readonly class LessonCompleted
{
    public function __construct(
        public int $userId,
        public string $courseSlug,
        public string $lessonSlug,
        public DateTimeImmutable $occurredAt,
    ) {}
}

// Пользователь прошёл квиз
final readonly class QuizPassed
{
    public function __construct(
        public int $userId,
        public string $lessonSlug,
        public int $score, // процент правильных ответов
        public DateTimeImmutable $occurredAt,
    ) {}
}

// Пользователь завершил весь курс
final readonly class CourseFinished
{
    public function __construct(
        public int $userId,
        public string $courseSlug,
        public DateTimeImmutable $occurredAt,
    ) {}
}

// Новый пользователь зарегистрировался
final readonly class UserRegistered
{
    public function __construct(
        public int $userId,
        public string $email,
        public string $provider, // 'github', 'email'
        public DateTimeImmutable $occurredAt,
    ) {}
}
from dataclasses import dataclass
from datetime import datetime


# Domain Event - frozen dataclass: факт в прошедшем времени, иммутабельный.

# Пользователь завершил урок
@dataclass(frozen=True, slots=True)
class LessonCompleted:
    user_id: int
    course_slug: str
    lesson_slug: str
    occurred_at: datetime


# Пользователь прошёл квиз
@dataclass(frozen=True, slots=True)
class QuizPassed:
    user_id: int
    lesson_slug: str
    score: int  # процент правильных ответов
    occurred_at: datetime


# Пользователь завершил весь курс
@dataclass(frozen=True, slots=True)
class CourseFinished:
    user_id: int
    course_slug: str
    occurred_at: datetime


# Новый пользователь зарегистрировался
@dataclass(frozen=True, slots=True)
class UserRegistered:
    user_id: int
    email: str
    provider: str  # "github", "email"
    occurred_at: datetime

Обрати внимание на паттерн: имя в прошедшем времени, событие передаётся по значению и после создания не меняется, есть метка времени OccurredAt.

ℹ️ Событие - контракт между контекстами

Структура события - это публичный контракт. Если контекст Analytics слушает LessonCompleted, любое удаление поля сломает подписчика. Добавлять поля безопасно, удалять - нет.

Publisher: интерфейс и реализация

Для публикации событий нужен простой интерфейс и in-memory реализация для старта. Внутри одного процесса это в точности Observer: publisher держит список подписчиков и не знает, кто и зачем подписался, поэтому новый обработчик добавляется без правок домена.

package domain

import (
    "context"
)

// Интерфейс публикации событий.
// Возвращает error: публикация в брокер может упасть, и вызывающий
// должен об этом узнать. In-memory реализация просто вернёт nil.
type EventPublisher interface {
    Publish(ctx context.Context, events ...any) error
}
<?php
declare(strict_types=1);

namespace App\Learning\Domain;

// Интерфейс публикации событий
interface EventPublisher
{
    public function publish(object ...$events): void;
}
from typing import Protocol


# Интерфейс публикации событий
class EventPublisher(Protocol):
    def publish(self, *events: object) -> None: ...
package infra

import (
    "context"
    "log/slog"
    "sync"
)

// EventHandler обрабатывает одно событие
type EventHandler interface {
    Handle(ctx context.Context, event interface{})
}

// InMemoryPublisher - синхронная реализация для монолита
type InMemoryPublisher struct {
    mu       sync.RWMutex
    handlers []EventHandler
}

func NewInMemoryPublisher() *InMemoryPublisher {
    return &InMemoryPublisher{}
}

func (p *InMemoryPublisher) Subscribe(h EventHandler) {
    p.mu.Lock()
    defer p.mu.Unlock()
    p.handlers = append(p.handlers, h)
}

func (p *InMemoryPublisher) Publish(ctx context.Context, events ...any) error {
    // Снимаем копию списка под блокировкой и отпускаем её ДО вызовов.
    //
    // Держать RLock во время Handle нельзя: обработчик, который сам вызовет
    // Subscribe, встанет на Lock и не дождётся - sync.RWMutex
    // не реентерабелен, и получится дедлок. Копия списка стоит дёшево,
    // а инварианта «Publish не держит блокировку на время чужого кода»
    // достаточно, чтобы такой случай стал невозможен.
    p.mu.RLock()
    handlers := make([]EventHandler, len(p.handlers))
    copy(handlers, p.handlers)
    p.mu.RUnlock()

    for _, event := range events {
        for _, h := range handlers {
            // Паника одного обработчика не должна ронять остальных
            // и тем более транзакцию, которая опубликовала событие.
            func() {
                defer func() {
                    if r := recover(); r != nil {
                        slog.Error("обработчик события упал",
                            slog.Any("event", event),
                            slog.Any("panic", r))
                    }
                }()
                h.Handle(ctx, event)
            }()
        }
    }
    // Синхронной доставке нечему падать: сбои обработчиков уже залогированы.
    return nil
}
<?php
declare(strict_types=1);

namespace App\Learning\Infrastructure;

use App\Learning\Domain\EventPublisher;

// EventHandler обрабатывает одно событие
interface EventHandler
{
    public function handle(object $event): void;
}

// InMemoryPublisher - синхронная реализация для монолита.
// В продакшене можно заменить на Symfony Messenger или RabbitMQ - интерфейс тот же.
final class InMemoryPublisher implements EventPublisher
{
    /** @var EventHandler[] */
    private array $handlers = [];

    public function subscribe(EventHandler $h): void
    {
        $this->handlers[] = $h;
    }

    public function publish(object ...$events): void
    {
        foreach ($events as $event) {
            foreach ($this->handlers as $h) {
                $h->handle($event);
            }
        }
    }
}
import logging
import threading
from typing import Protocol

log = logging.getLogger(__name__)


class EventHandler(Protocol):
    """Обрабатывает одно событие."""

    def handle(self, event: object) -> None: ...


class InMemoryPublisher:
    """Синхронная реализация для монолита."""

    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._handlers: list[EventHandler] = []

    def subscribe(self, handler: EventHandler) -> None:
        with self._lock:
            self._handlers.append(handler)

    def publish(self, *events: object) -> None:
        # Снимаем копию списка под блокировкой и отпускаем её ДО вызовов.
        #
        # Держать lock во время handle нельзя: обработчик, который сам вызовет
        # subscribe, встанет на тот же lock и не дождётся - threading.Lock
        # не реентерабелен, и получится дедлок. Копия списка стоит дёшево,
        # а инварианта «publish не держит блокировку на время чужого кода»
        # достаточно, чтобы такой случай стал невозможен.
        with self._lock:
            handlers = list(self._handlers)

        for event in events:
            for handler in handlers:
                # Исключение одного обработчика не должно ронять остальных
                # и тем более транзакцию, которая опубликовала событие.
                try:
                    handler.handle(event)
                except Exception:
                    log.exception("обработчик события упал: event=%r", event)

В монолите этого достаточно. Когда появится потребность в асинхронности, реализацию можно заменить на Kafka или NATS: Go-сигнатура уже возвращает ошибку (а в PHP и Python сбой придёт исключением), поэтому вызывающий код менять не придётся.

Агрегат собирает события

Агрегат не публикует события сразу. Он накапливает их в слайсе, а публикация происходит после успешного сохранения в базу. Забирает накопленное и публикует не сам агрегат, а сценарий поверх него - роль этого слоя разобрана в уроке Domain Service vs Application Service:

package domain

import (
    "fmt"
    "time"
)

// Поля закрыты, как в уроке про агрегаты: состояние меняют только методы.
// Чтение - через геттеры (Percent(), Lessons() и т.д.), их здесь опускаем.
type CourseProgress struct {
    id         int64
    userID     int64
    courseSlug CourseSlug
    lessons    []LessonProgress
    percent    int

    events []interface{} // накопленные события
}

// collectEvent добавляет событие в очередь.
// Неэкспортируемый: события рождает только сам агрегат,
// внешний код не может подложить ему чужое событие.
func (p *CourseProgress) collectEvent(e interface{}) {
    p.events = append(p.events, e)
}

// FlushEvents возвращает накопленные события и очищает очередь
func (p *CourseProgress) FlushEvents() []interface{} {
    events := p.events
    p.events = nil
    return events
}

// CompleteLesson - бизнес-операция, которая генерирует событие
func (p *CourseProgress) CompleteLesson(lessonSlug string) error {
    for i, lp := range p.lessons {
        if lp.slug == lessonSlug {
            // В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
            // идемпотентный вариант: повторный запрос (ретрай, двойной клик)
            // не должен ни падать, ни порождать второе событие. Это решение
            // домена, а не правило DDD; важно лишь, чтобы второго
            // LessonCompleted не было.
            if lp.completed {
                return nil // идемпотентность
            }
            p.lessons[i].completed = true
            p.recalcPercent()

            p.collectEvent(LessonCompleted{
                UserID:     p.userID,
                CourseSlug: string(p.courseSlug),
                LessonSlug: lessonSlug,
                OccurredAt: time.Now(),
            })

            if p.percent == 100 {
                p.collectEvent(CourseFinished{
                    UserID:     p.userID,
                    CourseSlug: string(p.courseSlug),
                    OccurredAt: time.Now(),
                })
            }
            return nil
        }
    }
    return fmt.Errorf("lesson %s not found in course %s", lessonSlug, p.courseSlug)
}
<?php
declare(strict_types=1);

namespace App\Learning\Domain;

use DateTimeImmutable;
use DomainException;

// Aggregate Root - final, но НЕ readonly: меняются Lessons, Percent, events.
final class CourseProgress
{
    /**
     * @param LessonProgress[] $lessons
     * @param object[]         $events
     */
    public function __construct(
        public readonly int $id,
        public readonly int $userId,
        public readonly CourseSlug $courseSlug,
        private array $lessons,
        private int $percent,
        private array $events = [],
    ) {}

    // recordEvent добавляет событие в очередь
    private function recordEvent(object $e): void
    {
        $this->events[] = $e;
    }

    // pullEvents возвращает накопленные события и очищает очередь
    /** @return object[] */
    public function pullEvents(): array
    {
        $events = $this->events;
        $this->events = [];
        return $events;
    }

    // completeLesson - бизнес-операция, которая генерирует событие
    public function completeLesson(string $lessonSlug): void
    {
        foreach ($this->lessons as $i => $lp) {
            if ($lp->slug === $lessonSlug) {
                // В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
                // идемпотентный вариант: повторный запрос (ретрай, двойной клик)
                // не должен ни падать, ни порождать второе событие. Это решение
                // домена, а не правило DDD; важно лишь, чтобы второго
                // LessonCompleted не было.
                if ($lp->completed) {
                    return; // идемпотентность
                }
                $this->lessons[$i] = $lp->withCompleted(true);
                $this->recalcPercent();

                $this->recordEvent(new LessonCompleted(
                    userId: $this->userId,
                    courseSlug: $this->courseSlug->value(),
                    lessonSlug: $lessonSlug,
                    occurredAt: new DateTimeImmutable(),
                ));

                if ($this->percent === 100) {
                    $this->recordEvent(new CourseFinished(
                        userId: $this->userId,
                        courseSlug: $this->courseSlug->value(),
                        occurredAt: new DateTimeImmutable(),
                    ));
                }
                return;
            }
        }
        throw new DomainException(sprintf(
            'lesson %s not found in course %s',
            $lessonSlug,
            $this->courseSlug->value(),
        ));
    }
}
from dataclasses import dataclass, field
from datetime import datetime


class DomainError(Exception):
    """Нарушение правил домена."""


# Aggregate Root - обычный dataclass, не frozen: меняются _lessons, _percent, _events.
# Подчёркивание - «приватно по соглашению», как в уроке про агрегаты:
# менять состояние можно только методами (свойства для чтения здесь опущены).
@dataclass
class CourseProgress:
    progress_id: int
    user_id: int
    course_slug: CourseSlug
    _lessons: list[LessonProgress]
    _percent: int = 0

    _events: list[object] = field(default_factory=list, repr=False)  # накопленные события

    def _collect_event(self, event: object) -> None:
        """Добавляет событие в очередь.

        Приватный: события рождает только сам агрегат.
        """
        self._events.append(event)

    def flush_events(self) -> list[object]:
        """Возвращает накопленные события и очищает очередь."""
        events = self._events
        self._events = []
        return events

    def complete_lesson(self, lesson_slug: str) -> None:
        """Бизнес-операция, которая генерирует событие."""
        for lp in self._lessons:
            if lp.slug == lesson_slug:
                # В уроке про агрегаты повтор возвращал ошибку. Здесь выбран
                # идемпотентный вариант: повторный запрос (ретрай, двойной клик)
                # не должен ни падать, ни порождать второе событие. Это решение
                # домена, а не правило DDD; важно лишь, чтобы второго
                # LessonCompleted не было.
                if lp.completed:
                    return  # идемпотентность
                lp.completed = True
                self._recalc_percent()

                self._collect_event(LessonCompleted(
                    user_id=self.user_id,
                    course_slug=str(self.course_slug),
                    lesson_slug=lesson_slug,
                    occurred_at=datetime.now(),
                ))

                if self._percent == 100:
                    self._collect_event(CourseFinished(
                        user_id=self.user_id,
                        course_slug=str(self.course_slug),
                        occurred_at=datetime.now(),
                    ))
                return
        raise DomainError(f"lesson {lesson_slug} not found in course {self.course_slug}")

Порядок в use-case: (1) загрузить агрегат, (2) вызвать бизнес-метод, (3) сохранить, (4) опубликовать события:

Aggregate накапливает события через collectEvent, use case вызывает Save и затем FlushEvents в event bus, обработчики SendEmail/Stats/Cert работают независимо

func (uc *CompleteLessonUseCase) Execute(ctx context.Context, cmd CompleteLesson) error {
    progress, err := uc.progressRepo.FindByUserAndCourse(ctx, cmd.UserID, cmd.CourseSlug)
    if err != nil {
        return err
    }

    if err := progress.CompleteLesson(cmd.LessonSlug); err != nil {
        return err
    }

    if err := uc.progressRepo.Save(ctx, progress); err != nil {
        return err
    }

    // Публикуем ПОСЛЕ успешного сохранения: подписчики не должны узнать
    // о том, чего в базе нет. Цену этого порядка см. во врезке под кодом.
    if err := uc.publisher.Publish(ctx, progress.FlushEvents()...); err != nil {
        return fmt.Errorf("publish events: %w", err)
    }
    return nil
}
final class CompleteLessonUseCase
{
    public function __construct(
        private readonly ProgressRepository $progressRepo,
        private readonly EventPublisher $publisher,
    ) {}

    public function execute(CompleteLessonCommand $cmd): void
    {
        $progress = $this->progressRepo->findByUserAndCourse(
            $cmd->userId,
            $cmd->courseSlug,
        );

        $progress->completeLesson($cmd->lessonSlug);

        $this->progressRepo->save($progress);

        // Публикуем ПОСЛЕ успешного сохранения
        $this->publisher->publish(...$progress->pullEvents());
    }
}
class CompleteLessonUseCase:
    def __init__(self, progress_repo: ProgressRepository, publisher: EventPublisher) -> None:
        self._progress_repo = progress_repo
        self._publisher = publisher

    def execute(self, cmd: CompleteLesson) -> None:
        progress = self._progress_repo.find_by_user_and_course(cmd.user_id, cmd.course_slug)

        progress.complete_lesson(cmd.lesson_slug)

        self._progress_repo.save(progress)

        # Публикуем ПОСЛЕ успешного сохранения: подписчики не должны узнать
        # о том, чего в базе нет. Цену этого порядка см. во врезке под кодом.
        self._publisher.publish(*progress.flush_events())

⚠️ Между Save и Publish есть окно, и его надо назвать

Порядок «сначала сохранить, потом публиковать» правильный: подписчики не должны узнать о том, чего в базе нет. Но он не делает доставку надёжной, и этот пример её не гарантирует.

Что происходит, если процесс упадёт (или сеть до брокера пропадёт) между третьим и четвёртым шагом: прогресс в базе есть, события нет и уже никогда не будет. Никто не заметит - в базе всё консистентно, а письмо о завершении курса просто не придёт.

Обратный порядок не помогает, а делает хуже: публикация до сохранения означает событие о том, чего не случилось, - подписчики отреагируют на непроизошедший факт.

Транзакцией это тоже не закрывается: брокер не участвует в транзакции базы. ROLLBACK не отзывает уже отправленное сообщение.

Чем закрывается по-настоящему: событие пишется в ту же транзакцию, что и бизнес-данные - в таблицу-очередь, а отдельный процесс дочитывает её и публикует. Это паттерн Transactional Outbox, и он разобран в уроке Outbox и Inbox, с рабочим стендом и тестами на сбой в каждой точке.

Здесь его нет намеренно: цель урока - показать, как агрегат порождает события и как они доходят до обработчиков, а не собрать надёжную шину. Для процесса в одном приложении, где потеря уведомления неприятна, но не критична, показанного достаточно. Если потеря события означает потерю денег или расхождение данных между сервисами - нужен outbox.

Обработчики событий

Каждый обработчик выполняет одну побочную реакцию:

// Отправка email при завершении курса
type SendCourseFinishedEmail struct {
    mailer EmailSender
    log    *slog.Logger
}

func (h *SendCourseFinishedEmail) Handle(ctx context.Context, event interface{}) {
    e, ok := event.(domain.CourseFinished)
    if !ok {
        return
    }
    // Handle не возвращает ошибку - значит лог единственный канал, где сбой
    // может стать видимым. `_ =` вместо лога превращает недоставленное
    // письмо в событие, о котором никто никогда не узнает.
    if err := h.mailer.Send(ctx, e.UserID, "course-finished", map[string]string{
        "course": e.CourseSlug,
    }); err != nil {
        h.log.ErrorContext(ctx, "course-finished email failed",
            slog.Int64("user_id", e.UserID),
            slog.String("course", e.CourseSlug),
            slog.String("err", err.Error()),
        )
    }
}

// Обновление статистики при прохождении урока
type UpdateProgressStats struct {
    statsRepo StatsRepository
    log       *slog.Logger
}

func (h *UpdateProgressStats) Handle(ctx context.Context, event interface{}) {
    e, ok := event.(domain.LessonCompleted)
    if !ok {
        return
    }
    // Здесь проглоченная ошибка опаснее, чем с письмом: это запись в базу,
    // и её потеря означает, что статистика тихо расходится с реальностью.
    // Письмо пользователь хотя бы не получит и заметит, а расхождение
    // в счётчике не заметит никто.
    if err := h.statsRepo.IncrementLessonsCompleted(ctx, e.UserID); err != nil {
        h.log.ErrorContext(ctx, "stats increment failed",
            slog.Int64("user_id", e.UserID),
            slog.String("err", err.Error()),
        )
    }
}
<?php
declare(strict_types=1);

namespace App\Learning\Application\Handler;

use App\Learning\Domain\CourseFinished;
use App\Learning\Domain\EmailSender;
use App\Learning\Domain\LessonCompleted;
use App\Learning\Domain\StatsRepository;
use App\Learning\Infrastructure\EventHandler;
use Throwable;

// Отправка email при завершении курса
final class SendCourseFinishedEmail implements EventHandler
{
    public function __construct(
        private readonly EmailSender $mailer,
        private readonly LoggerInterface $logger,
    ) {}

    public function handle(object $event): void
    {
        if (!$event instanceof CourseFinished) {
            return;
        }
        // Исключение здесь ловится намеренно: сбой письма не должен
        // отменять прохождение курса. Но пустой catch превратил бы
        // недоставленное письмо в невидимое событие - поэтому логируем.
        try {
            $this->mailer->send(
                userId: $event->userId,
                template: 'course-finished',
                params: ['course' => $event->courseSlug],
            );
        } catch (Throwable $e) {
            $this->logger->error('course-finished email failed', [
                'user_id' => $event->userId,
                'course' => $event->courseSlug,
                'exception' => $e,
            ]);
        }
    }
}

// Обновление статистики при прохождении урока
final class UpdateProgressStats implements EventHandler
{
    public function __construct(
        private readonly StatsRepository $statsRepo,
        private readonly LoggerInterface $logger,
    ) {}

    public function handle(object $event): void
    {
        if (!$event instanceof LessonCompleted) {
            return;
        }
        try {
            $this->statsRepo->incrementLessonsCompleted($event->userId);
        } catch (Throwable $e) {
            $this->logger->error('stats increment failed', [
                'user_id' => $event->userId,
                'exception' => $e,
            ]);
        }
    }
}
import logging


# Отправка email при завершении курса
class SendCourseFinishedEmail:
    def __init__(self, mailer: EmailSender, log: logging.Logger) -> None:
        self._mailer = mailer
        self._log = log

    def handle(self, event: object) -> None:
        if not isinstance(event, CourseFinished):
            return
        # handle ничего не возвращает - значит лог единственный канал, где сбой
        # может стать видимым. Пустой except вместо лога превращает недоставленное
        # письмо в событие, о котором никто никогда не узнает.
        try:
            self._mailer.send(event.user_id, "course-finished", {"course": event.course_slug})
        except Exception as err:
            self._log.error(
                "course-finished email failed",
                extra={"user_id": event.user_id, "course": event.course_slug, "err": str(err)},
            )


# Обновление статистики при прохождении урока
class UpdateProgressStats:
    def __init__(self, stats_repo: StatsRepository, log: logging.Logger) -> None:
        self._stats_repo = stats_repo
        self._log = log

    def handle(self, event: object) -> None:
        if not isinstance(event, LessonCompleted):
            return
        # Здесь проглоченная ошибка опаснее, чем с письмом: это запись в базу,
        # и её потеря означает, что статистика тихо расходится с реальностью.
        # Письмо пользователь хотя бы не получит и заметит, а расхождение
        # в счётчике не заметит никто.
        try:
            self._stats_repo.increment_lessons_completed(event.user_id)
        except Exception as err:
            self._log.error(
                "stats increment failed",
                extra={"user_id": event.user_id, "err": str(err)},
            )

⚠️ Падение обработчика не должно ломать основной сценарий

Если email-сервис недоступен, урок всё равно должен считаться пройденным. Обработчик событий - это побочный эффект. В синхронной реализации оборачивай вызов в recover или логируй ошибку без возврата. В асинхронной - используй retry-очередь.

Eventual Consistency

В синхронном монолите события обрабатываются мгновенно. Но при переходе к очередям (Kafka, RabbitMQ) обработка становится eventually consistent: факт записан, а побочные эффекты придут позже.

Пример: пользователь завершил курс, но сертификат появится через 2-3 секунды, когда обработчик прочитает событие из очереди. Для пользователя это незаметно, но архитектурно - принципиальная разница.

Правило: если побочный эффект может быть задержан на секунды без ущерба для UX - используй события. Если нет (например, проверка прав доступа) - это не событие, а часть основного потока.

Event Store: аудит и воспроизведение

Журнал доменных событий (event log) - хранилище всех событий в хронологическом порядке. В DDD Lite это не замена базы данных, а дополнение: текущее состояние хранится в таблицах, а история изменений - в журнале. В Event Sourcing тот же журнал становится Event Store - единственным источником правды, из которого восстанавливается состояние.

package domain

import (
    "context"
    "time"
)

type StoredEvent struct {
    ID         int64
    EventType  string
    Payload    []byte // JSON
    OccurredAt time.Time
    AggregateID int64
}

type EventStore interface {
    Append(ctx context.Context, events ...StoredEvent) error
    LoadByAggregate(ctx context.Context, aggregateID int64) ([]StoredEvent, error)
}

Зачем это нужно:

  • Аудит: видно, кто и когда прошёл урок, даже если прогресс был сброшен
  • Отладка: можно воспроизвести последовательность действий пользователя
  • Аналитика: построить воронку прохождения курса по событиям

Для DDD Lite полноценный Event Sourcing избыточен. Достаточно простого лога событий в таблице domain_events - это даст аудит без сложности CQRS.

Увидеть события в работе, а не по частям, можно в мини-проекте трека: там агрегат накапливает LessonCompleted и CourseFinished, сценарий публикует их после сохранения, а обработчик по CourseFinished выдаёт сертификат.

Мини-задание

  • Определи 3 доменных события для своего проекта (имена в прошедшем времени)
  • Реализуй структуру одного события со всеми необходимыми полями
  • Напиши интерфейс EventPublisher и InMemoryPublisher
  • Добавь методы collectEvent/FlushEvents в один из своих агрегатов
  • Реализуй обработчик для одного события (логирование или запись статистики)

Зарегистрируйтесь бесплатно, чтобы пройти квиз, решить задание с автопроверкой, вести прогресс.