CQRS Validation

In modern software development, maintaining clear, decoupled communication between components is essential for building scalable and maintainable applications. The mediator pattern is a popular design strategy that centralizes interactions, thereby reducing tight coupling between individual components. This pattern enables developers to manage communication in a structured manner, simplifying both the development and maintenance processes.

Validation plays a critical role in this ecosystem. By ensuring incoming data conforms to expected formats and business rules, validation not only prevents errors from propagating through the system but also secures the application against invalid or malicious inputs.

This blog post will explore how to seamlessly integrate validation within the mediator pattern using Mediatr and FluentValidation. By combining these two libraries, you can create a robust validation pipeline that ensures data integrity and consistency throughout your application.

🚀 Getting Started

Before diving into the implementation details, you’ll need to add the necessary packages to your .NET application. To add Mediatr and FluentValidation to your project, run the following commands in your terminal:

dotnet add package MediatR
dotnet add package FluentValidation
dotnet add package FluentValidation.AspNetCore

Next you’ll want to add the above services to your Dependency Injection (DI) container:

services.AddMediatR(x => x.RegisterServicesFromAssemblyContaining<Program>());
services.AddValidatorsFromAssemblyContaining<Program>();

📝 Creating a Request and Validator

To demonstrate how to integrate FluentValidation with Mediatr, let’s pretend we want to create a user. We’ll start by defining a simple user class:

public sealed class User
{
    public Guid Id { get; set; }
    public string Email { get; set; } = string.Empty;
}

Next we’ll add a simple request and its corresponding validator. In this example, we’ll define a CreateUserRequest that contains an email property, which must be a valid email address.

public class CreateUserRequest : IRequest<User>
{
    public string Email { get; set; } = string.Empty;
}

public class CreateUserRequestValidator : AbstractValidator<CreateUserRequest>
{
    public CreateUserRequestValidator()
    {
        RuleFor(x => x.Email)
            .NotEmpty()
            .EmailAddress();
    }
}

Finally we’ll define a basic request handler to return a User object when the request is valid:

public class CreateUserHandler : IRequestHandler<CreateUserRequest, User>
{
    public Task<User> Handle(CreateUserRequest request, CancellationToken cancellationToken)
    {
        var user = new User
        {
            Id = Guid.NewGuid(),
            Email = request.Email
        };

        return Task.FromResult(user);
    }
}

🧑‍💻 Implementing the Validation Pipeline

With the request and validator in place, we can now implement the validation pipeline using Mediatr. To do this, we’ll create a ValidationBehavior class that intercepts requests and validates them before passing them along to their handlers.

/// <summary>
/// Pipeline behavior that validates a request using all registered FluentValidation validators
/// before passing it to the next delegate in the MediatR pipeline.
/// </summary>
/// <typeparam name="TRequest">The type of the request.</typeparam>
/// <typeparam name="TResponse">The type of the response.</typeparam>
public sealed class ValidationBehavior<TRequest, TResponse>
    : IPipelineBehavior<TRequest, TResponse>
    where TRequest : IBaseRequest
{
    private readonly IEnumerable<IValidator<TRequest>> _validators;

    /// <summary>
    /// Initializes a new instance of the <see cref="ValidationBehavior{TRequest, TResponse}"/> class.
    /// </summary>
    /// <param name="validators">The collection of validators to apply to the request.</param>
    public ValidationBehavior(IEnumerable<IValidator<TRequest>> validators)
    {
        _validators = validators;
    }

    /// <summary>
    /// Validates the request using the registered validators and, if valid, passes the request to the next delegate.
    /// </summary>
    /// <param name="request">The request to validate.</param>
    /// <param name="next">The next delegate in the pipeline.</param>
    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
    /// <returns>The response from the next delegate if validation succeeds.</returns>
    public async Task<TResponse> Handle(
        TRequest request, 
        RequestHandlerDelegate<TResponse> next, 
        CancellationToken cancellationToken)
    {
        foreach (var validator in _validators)
        {
            await validator.ValidateAndThrowAsync(request, cancellationToken);
        }
        
        return await next();
    }
}

In the ValidationBehavior class, we define a pipeline behavior that validates requests using all registered FluentValidation validators before passing them to the next delegate in the Mediatr pipeline. This behavior ensures that all incoming requests are validated according to their respective rules, preventing invalid data from being processed further. If the request is invalid an exception will be thrown, halting the pipeline and preventing the request from being handled.

To register the validation pipeline with Mediatr, you’ll need to add the ValidationBehavior to the Mediatr pipeline:

services.AddMediatR(x =>
{
    // Add the ValidationBehavior to the Mediatr pipeline
    x.AddOpenBehavior(typeof(ValidationBehavior<,>));
    x.RegisterServicesFromAssemblyContaining<Program>();
});

By adding the ValidationBehavior to the Mediatr pipeline, you ensure that all incoming requests are validated before being processed by their respective handlers. This validation step helps maintain data integrity and consistency throughout your application, reducing the likelihood of errors and security vulnerabilities.

However, since we throw an exception when validation fails, you’ll need to handle these exceptions in your application to provide meaningful feedback to the user. Let’s take a look at how you can handle validation errors in your API controllers by leveraging the IExceptionHandler introduced in .NET 8.

✅ Handling Validation Exceptions

To handle validation exceptions thrown by the validation behavior, you can create a custom exception handler that intercepts validation exceptions and returns a meaningful error response to the client. In this example, we’ll create a ValidationExceptionHandler that catches FluentValidation.ValidationException and returns a 400 Bad Request response with the validation errors.

/// <summary>
/// Exception handler for converting FluentValidation ValidationException into a standardized HTTP response.
/// </summary>
/// <remarks>
/// This handler returns a 400 Bad Request status with detailed validation errors.
/// </remarks>
public sealed class ValidationExceptionHandler : IExceptionHandler
{
    /// <summary>
    /// Attempts to handle the exception if it is a ValidationException.
    /// </summary>
    /// <param name="httpContext">The current HTTP context.</param>
    /// <param name="exception">The exception that occurred.</param>
    /// <param name="cancellationToken">A token to monitor for cancellation requests.</param>
    /// <returns>A ValueTask containing true if the exception was handled, false otherwise.</returns>
    public async ValueTask<bool> TryHandleAsync(
        HttpContext httpContext, 
        Exception exception, 
        CancellationToken cancellationToken)
    {
        // Check if the exception is a ValidationException, if not return false
        if (exception is ValidationException validationException is false)
            return false;
        
        // Group validation errors by property name and convert them to a dictionary
        var errors = validationException.Errors
            .GroupBy(x => x.PropertyName)
            .ToDictionary(x => x.Key, x => x.Select(y => y.ErrorMessage).ToArray());
        
        var problemDetails = new ProblemDetails
        {
            Type = "https://tools.ietf.org/html/rfc9110#section-15.5.1",
            Title = "One or more validation errors occurred.",
            Status = StatusCodes.Status400BadRequest,
            Extensions = new Dictionary<string, object?>
            {
                ["errors"] = errors,
            }
        };
        
        httpContext.Response.StatusCode = StatusCodes.Status400BadRequest;
        
        await httpContext.Response.WriteAsJsonAsync(problemDetails, cancellationToken);

        return true;
    }
}

You’ll need to register the ValidationExceptionHandler wherever you are configuring your services:

services.AddProblemDetails();
services.AddExceptionHandler<ValidationExceptionHandler>();

And add the exception handler middleware to your application:

app.UseExceptionHandler();

And that’s it! You’ve successfully integrated FluentValidation with Mediatr to create a robust validation pipeline in your CQRS applications.

🎉 Conclusion

By combining Mediatr and FluentValidation, you can ensure that all incoming requests are validated according to their respective rules, preventing invalid data from being processed further. This validation step helps maintain data integrity and consistency throughout your application, reducing the likelihood of errors and security vulnerabilities.

A full working example of this post’s implementation can be found on GitHub. Until next time, stay curious! 🚀