CleanArch.DevKit.Mediator.Domain 1.1.1

CleanArch.DevKit.Mediator.Domain

Pont entre les événements de domaine (IDomainEvent) et le médiateur (IMediator.Publish).

Rôle

Le package CleanArch.DevKit.Domain définit IDomainEvent comme primitive pure, sans dépendance sur un dispatcher. Ce package fournit le minimum nécessaire pour publier ces événements à travers le médiateur — sans coupler la couche domaine à Mediator.Core. Concrètement : une interface marqueuse IDomainEventNotification (qui combine les deux), et une extension PublishDomainEventsAsync qui drain le buffer d'un agrégat et dispatche chaque événement avec son type concret.

Installation

dotnet add package CleanArch.DevKit.Mediator.Domain

Dépend de CleanArch.DevKit.Domain et de CleanArch.DevKit.Mediator.

Fonctionnalités

• Marquer un événement de domaine comme dispatchable via IDomainEventNotification
• Publier les événements bufferisés d'un agrégat avec PublishDomainEventsAsync
• Dispatch par type runtime (les handlers du type concret sont atteints)

Marquer un événement comme dispatchable

IDomainEventNotification combine IDomainEvent (côté domaine) et INotification (côté médiateur) :

public interface IDomainEventNotification : IDomainEvent, INotification { }

Implémenter cette interface sur les événements que les handlers du médiateur doivent recevoir :

public sealed record UserCreated(UserId Id, string Email) : IDomainEventNotification;

public sealed record InternalAuditTouch(UserId Id) : IDomainEvent;
// (reste interne à l'agrégat, jamais publié via le médiateur)

Les événements qui n'implémentent que IDomainEvent restent dans le buffer de l'agrégat mais ne sont pas publiés par PublishDomainEventsAsync.

Publier les événements d'un agrégat

Après que l'agrégat ait fait son travail et bufferisé ses événements via Raise(...), appeler PublishDomainEventsAsync pour les vider et les dispatcher :

public sealed class CreateUserHandler(IMediator mediator, IUserRepository repo)
    : IRequestHandler<CreateUser, Result<UserId>>
{
    public async Task<Result<UserId>> Handle(CreateUser cmd, CancellationToken ct)
    {
        var user = User.Create(cmd.Email, cmd.Name, cmd.Age);

        await repo.SaveAsync(user, ct);           // 1. commit
        await mediator.PublishDomainEventsAsync(user, ct);  // 2. drain + publish

        return user.Id;
    }
}

La méthode :

1. Snapshot des événements bufferisés
2. ClearDomainEvents() sur l'agrégat
3. Pour chaque événement qui implémente INotification, mediator.Publish(...) avec le type concret runtime

L'usage du type runtime garantit que les INotificationHandler<UserCreated> sont atteints — un dispatch via le type statique IDomainEvent ne trouverait personne.

Côté handler

Le handler ne sait rien du pont — c'est un INotificationHandler<T> classique :

public sealed class SendWelcomeEmailOnUserCreated(IEmailService emails)
    : INotificationHandler<UserCreated>
{
    public Task Handle(UserCreated evt, CancellationToken ct)
        => emails.SendWelcomeAsync(evt.Email, ct);
}

Le pattern recommandé est commit puis publish : si le commit échoue, aucun événement n'est diffusé ; si la publication échoue, les changements sont déjà persistés mais l'agrégat n'a plus d'événement en mémoire (pour rejouer, utiliser un outbox).