Created New Validation Library that Integrates with Vogen

[CodingFlow]

Hello everyone. I've created a new fluent API validation library that integrates with Vogen, CodingFlow.FluentValidation. Here is a quick sample of what it looks like:

[ValueObject]
public readonly partial struct Age
{
    public static Validation Validate(int value)
    {
        return RuleFor(value)
            .BetweenInclusive(0, 200)
            .VogenResult();
    }
}

I hope this is useful to someone. Let me know what you think!

[MatteoZampariniDev]

I did a similar thing yesterday but using the FluentValidation library directly and with source generation.

Not used in real-world applications yet.

It should help with #866 too.

Generic code:

public abstract class VogenValidator<T> : AbstractValidator<T>
{
    public sealed override Task<ValidationResult> ValidateAsync(ValidationContext<T> context, CancellationToken cancellation = default)
    {
        throw new Exception("Vogen value objects cannot be validated asynchronously.");
    }
}

public static class VogenUtil
{
    public static Validation Validate<TValidator, TProperty>(TProperty value)
        where TValidator : VogenValidator<TProperty>, new()
    {
        ValidationResult validationResult = new TValidator().Validate(value);

        if (!validationResult.IsValid)
            return Validation.Invalid(string.Join(", ", validationResult.Errors.Select(e => e.ErrorMessage)));

        return Validation.Ok;
    }
}

Use case:

[ValueObject<int>]
[LessThanOrEqual(120, WithMessage = "Age must be 120 or less")]
public readonly partial struct Age
{
    private static Validation Validate(in int value) => VogenUtil.Validate<AgeValidator, int>(value);
}

Source generated code:

public partial class AgeValidator : VogenValidator<int>
{
    public AgeValidator()
    {
        RuleFor(x => x)
            .LessThanOrEqualTo(120).WithMessage("Age must be 120 or less")
        ;

        ConfigureAdditionalRules();
    }

    partial void ConfigureAdditionalRules();
}

Need anything special?

public partial class AgeValidator
{
    partial void ConfigureAdditionalRules()
    {
        // complex custom rule example
    }
}

Your idea is similar and should work well, I'm not sure you want to maintain a whole new validation library, maybe a wrapper for an existing robust validation library is more sustainable

[CodingFlow]

Nice, definitely a useful alternative. It makes sense now that something can be done to wrap the existing FluentValidation library using generics and source generation. I considered wrapping the original FluentValidation library initially, but wasn't too sure how feasible it was.

The difference between our two solutions is the one you made has an attribute-based API, which is typical of source generated solutions. The one I made is a fluent API. Some people are a bit averse to putting a lot of things in attributes.

Yeah, I'd have to maintain a lot more with an entire library from scratch. But it's actually a fairly simple library, at least right now. It will only grow if people start using and asking for bug fixes and feature requests. But if that's true, than that means the library is useful.

I could take a look to see if I can keep the same fluent API but still wrap the original FluentValidation library, although I'm not sure how to do that exactly.

Thanks for sharing and the feedback!

[MatteoZampariniDev]

Well I started from the same idea of having fluent validation, one could write the AbstractValidator manually but it's more code... the source generation through attributes is built on top of that.

If you'd like to avoid both attributes and writing the whole validator I think that there is an hybrid solution that might look something like this:

[ValueObject<int>(conversions: Conversions.SystemTextJson)]
public readonly partial struct Age
{
    private static Validation Validate(in int value) => VogenUtil.Validate<AgeValidator, int>(value);

    [VogenValidator] // Source generator will pick this up
    private static IRuleBuilderOptions<int, int> InternalValidator(IRuleBuilderInitial<int, int> ruleBuilder)
    {
        // Custom validation logic
        return ruleBuilder.LessThanOrEqualTo(120).WithMessage("Age must be 120 or less");
    }
}

// Source generated
public readonly partial struct Age
{
    private partial class AgeValidator : VogenValidator<int>
    {
        public AgeValidator()
        {
            InternalValidator(RuleFor(x => x));
        }
    }
}

Just a quick sample, might be improved or have some fault I guess.