FunctionalDdd.FluentValidation 3.0.0-alpha.3

Fluent Validation Extension

This library seamlessly integrates FluentValidation with Railway Oriented Programming, converting FluentValidation errors into FunctionalDDD ValidationError objects.

Table of Contents

• Installation
• Why Use This Extension
• Quick Start
  • Inline Validator
  • Separate Validator Class
• Core Concepts
• Best Practices
• Resources

Installation

Install both packages via NuGet:

dotnet add package FunctionalDDD.FluentValidation
dotnet add package FluentValidation

Why Use This Extension

Without this extension, you would manually convert validation errors:

var validator = new UserValidator();
var validationResult = validator.Validate(user);
if (!validationResult.IsValid)
{
    var errors = validationResult.Errors
        .Select(e => Error.Validation(e.ErrorMessage, e.PropertyName));
    return Result.Failure<User>(Error.Aggregate(errors));
}
return Result.Success(user);

With this extension, validation integrates seamlessly with ROP:

return Validator.ValidateToResult(user);

Quick Start

Inline Validator

The simplest approach using InlineValidator:

public partial class User : Aggregate<UserId>
{
    public FirstName FirstName { get; }
    public LastName LastName { get; }
    public EmailAddress Email { get; }
    public int Age { get; }

    public static Result<User> TryCreate(
        FirstName firstName, 
        LastName lastName, 
        EmailAddress email,
        int age)
    {
        var user = new User(firstName, lastName, email, age);
        return Validator.ValidateToResult(user);
    }

    private User(FirstName firstName, LastName lastName, EmailAddress email, int age)
        : base(UserId.NewUnique())
    {
        FirstName = firstName;
        LastName = lastName;
        Email = email;
        Age = age;
    }

    // Fluent Validation
    private static readonly InlineValidator<User> Validator = new()
    {
        v => v.RuleFor(x => x.FirstName).NotNull(),
        v => v.RuleFor(x => x.LastName).NotNull(),
        v => v.RuleFor(x => x.Email).NotNull(),
        v => v.RuleFor(x => x.Age)
            .GreaterThanOrEqualTo(18)
            .WithMessage("Must be 18 or older")
    };
}

Separate Validator Class

For complex validation logic, create a dedicated validator:

public class UserValidator : AbstractValidator<User>
{
    public UserValidator()
    {
        RuleFor(x => x.FirstName)
            .NotNull()
            .WithMessage("First name is required");
            
        RuleFor(x => x.LastName)
            .NotNull()
            .WithMessage("Last name is required");
            
        RuleFor(x => x.Email)
            .NotNull()
            .EmailAddress()
            .WithMessage("Valid email address is required");
            
        RuleFor(x => x.Age)
            .GreaterThanOrEqualTo(18)
            .WithMessage("Must be 18 or older")
            .LessThan(120)
            .WithMessage("Age must be realistic");
    }
}

public class User
{
    private static readonly UserValidator Validator = new();
    
    public static Result<User> TryCreate(
        FirstName firstName, 
        LastName lastName, 
        EmailAddress email,
        int age)
    {
        var user = new User(firstName, lastName, email, age);
        return Validator.ValidateToResult(user);
    }
}

Core Concepts

Best Practices

1. Use InlineValidator for simple cases, AbstractValidator for complex logic with dependencies.

2. Validate value objects separately from aggregates
   First validate value objects, then validate aggregate invariants.

3. Use async validation only when necessary
   Database checks and API calls justify async, simple format checks do not.

4. Provide meaningful error messages with context
   Use WithMessage(x => ...) to include property values in error messages.

5. Use When() for conditional validation
   Apply rules based on object state or external conditions.

6. Leverage RuleSets for different validation scenarios
   Separate validation rules for Create, Update, Delete operations.

7. Combine FluentValidation with ROP
   Use FluentValidation for structure/format, ROP Ensure for business rules.

Resources

• SAMPLES.md - Comprehensive examples and advanced patterns
• FluentValidation Documentation - Official FluentValidation docs
• Railway Oriented Programming - Core Result<T> concepts
• Domain-Driven Design - Entity and value object patterns