CleanArch.DevKit.Mediator.Validation 1.1.1

CleanArch.DevKit.Mediator.Validation

Validation fluide à la FluentValidation, découverte des validators à la compilation, intégration au pipeline du médiateur.

Rôle

Permet de déclarer des règles de validation par propriété dans une classe Validator<T>, puis de les exécuter automatiquement avant chaque handler grâce à un IPipelineBehavior<,>. Les validators sont découverts à la compilation par un générateur Roslyn — pas de scan d'assembly au runtime.

Installation

dotnet add package CleanArch.DevKit.Mediator.Validation

Le générateur Roslyn est embarqué dans le package.

Fonctionnalités

• Déclarer un validator avec Validator<T> + Rule(...)
• Composer des checks fluides (Required, Email, Between, Match, etc.)
• Personnaliser le message et le code d'erreur
• Appliquer une règle conditionnelle (When / Unless)
• Contrôler la cascade (continuer ou s'arrêter au premier échec)
• Déléguer à un sous-validator (SetValidator)
• Valider une collection (RuleForEach)
• Activer le ValidationBehavior dans le pipeline
• Enregistrer tous les validators (générateur ou réflexion)

Déclarer un validator

public sealed class CreateUserValidator : Validator<CreateUser>
{
    public CreateUserValidator()
    {
        Rule(x => x.Email).Required().Email().MaxLength(200);
        Rule(x => x.Name).Required().MinLength(2).MaxLength(50);
        Rule(x => x.Age).Between(1, 149);
    }
}

Validator<T> implémente IValidator<T> ; les règles sont déclarées dans le constructeur.

Checks fluides disponibles

Rule(x => x.Price).GreaterThan(0m).LessThan(10_000m);
Rule(x => x.Code).Match(@"^[A-Z]{3}-\d{4}$");
Rule(x => x.Status).OneOf("draft", "published", "archived");
Rule(x => x.Username).MustAsync(async (name, ct) => !await repo.ExistsAsync(name, ct));

Personnaliser message et code d'erreur

Les modifiers s'appliquent au check qui précède :

Rule(x => x.Age)
    .Between(1, 149)
    .Message("L'âge doit être réaliste.")
    .ErrorCode("user.age_unrealistic");

Appliquer une règle conditionnelle

Rule(x => x.CompanyTaxId)
    .Required()
    .When(x => x.Kind == CustomerKind.Business);

Rule(x => x.SsnNumber)
    .Required()
    .Unless(x => x.IsAnonymous);

Contrôler la cascade

Par défaut, tous les checks d'une règle s'exécutent et toutes les erreurs sont collectées. Cascade(CascadeMode.Stop) arrête au premier échec :

Rule(x => x.Email)
    .Cascade(CascadeMode.Stop)   // évite Email() si Required() échoue déjà
    .Required()
    .Email();

Le mode peut aussi être global pour tout le validator :

public sealed class StrictValidator : Validator<MyDto>
{
    public StrictValidator()
    {
        CascadeMode = CascadeMode.Stop;
        Rule(x => x.Field).Required().MinLength(3);
    }
}

Déléguer à un sous-validator

Pour valider un objet imbriqué, réutiliser un IValidator<T> existant :

public sealed class AddressValidator : Validator<Address>
{
    public AddressValidator()
    {
        Rule(x => x.Street).Required();
        Rule(x => x.City).Required();
    }
}

public sealed class OrderValidator : Validator<Order>
{
    public OrderValidator()
    {
        Rule(x => x.ShippingAddress).SetValidator(new AddressValidator());
    }
}

Pour une propriété nullable de type référence, envelopper avec ForNullable() :

Rule(x => x.BillingAddress).SetValidator(new AddressValidator().ForNullable());

Le wrapper court-circuite à Success quand la valeur est null.

Valider une collection

RuleForEach(x => x.Items).SetValidator(new OrderItemValidator());

Les échecs incluent l'index dans le chemin (Items[2].Quantity).

Activer le ValidationBehavior

Le behavior récupère tous les IValidator<TRequest> du container, les exécute en parallèle, agrège les échecs et lance une ValidationException si la requête est invalide. Sinon, le handler s'exécute normalement.

services.AddValidationBehavior();

Combiner avec CleanArch.DevKit.Mediator.Results pour convertir automatiquement la ValidationException en Result<T>.Fail(new ValidationError(...)) — voir AddResultBehavior().

Enregistrer les validators (générateur)

Le générateur émet une méthode AddValidators() qui inscrit tous les concrete Validator<T> du projet sans réflexion :

services.AddValidators();           // émis par le générateur
services.AddValidationBehavior();

Pour scanner une assembly externe (plugin chargé au runtime), utiliser la surcharge avec réflexion :

services.AddValidators(typeof(SomeValidator).Assembly);

Ou les deux d'un coup :

services.AddValidation(typeof(SomeValidator).Assembly);  // = AddValidators(asm) + AddValidationBehavior()