Dosaic.Plugins.Validations.Abstractions 1.2.9

Dosaic.Plugins.Validations.Abstractions

Core contracts and shared types for the Dosaic validation subsystem. This package defines the interfaces that all validation plugin implementations must fulfil, along with the result model and a rich set of predefined validation-error codes.

Installation

dotnet add package Dosaic.Plugins.Validations.Abstractions

Types

IValidator

The top-level validation entry point. Accepts a model or an explicit list of IValueValidator instances and returns a ValidationResult.

public interface IValidator
{
    // Validate a model using its own declared validators
    Task<ValidationResult> ValidateAsync(object model, CancellationToken cancellationToken = default);

    // Strongly-typed convenience overload
    Task<ValidationResult> ValidateAsync<T>(T model, CancellationToken cancellationToken = default);

    // Validate a single value against an explicit validator list
    Task<ValidationResult> ValidateAsync(object value, IList<IValueValidator> validators, CancellationToken cancellationToken = default);
}

IValueValidator

Represents a single validation rule applied to one value. Implementations carry their own error message, a structured error code, optional arguments, and a null-handling policy.

public interface IValueValidator
{
    string ErrorMessage { get; }
    string Code { get; }
    object Arguments { get; }
    bool TreatNullAsValid { get; }
    Task<bool> IsValidAsync(ValidationContext context, CancellationToken cancellationToken = default);
}

ValidationContext

Immutable record passed into every IValueValidator.IsValidAsync call.

public sealed record ValidationContext(object Value, string Path, IServiceProvider Services);

ValidationResult

Returned by every IValidator.ValidateAsync call.

public class ValidationResult
{
    public required ValidationError[] Errors { get; init; }
    public bool IsValid => Errors.Length == 0;
}

ValidationError

Describes a single constraint violation.

public class ValidationError
{
    public required string Validator { get; init; }
    public required IDictionary<string, object> Arguments { get; init; }
    public required string Path { get; init; }
    public required string Code { get; init; }
    public required string Message { get; init; }
}

ValidationCodes

A static hierarchy of well-known, string-typed error-code constants used by all built-in validators.

ValueValidatorExtensions

Extension methods that simplify working with IValueValidator implementations.

Usage

Injecting and using IValidator

public class CreateUserHandler(IValidator validator)
{
    public async Task HandleAsync(CreateUserRequest request, CancellationToken ct)
    {
        var result = await validator.ValidateAsync(request, ct);
        if (!result.IsValid)
        {
            foreach (var error in result.Errors)
                Console.WriteLine($"[{error.Code}] {error.Path}: {error.Message}");

            return;
        }

        // proceed with valid request …
    }
}

Implementing a custom IValueValidator

using Dosaic.Plugins.Validations.Abstractions;

public class PositiveNumberValidator : IValueValidator
{
    public string ErrorMessage => "Value must be a positive number";
    public string Code => ValidationCodes.Int.Positive;
    public object Arguments => new { };
    public bool TreatNullAsValid => true;

    public Task<bool> IsValidAsync(ValidationContext context, CancellationToken cancellationToken = default)
    {
        if (context.IsNullValue) return Task.FromResult(true);
        if (context.Value is int i) return Task.FromResult(i > 0);
        return Task.FromResult(false);
    }
}

Validating a value against an explicit validator list

var validators = new List<IValueValidator> { new PositiveNumberValidator() };
var result = await validator.ValidateAsync(userInput, validators, ct);

if (!result.IsValid)
    Console.WriteLine(result.Errors[0].Message);

Inspecting a validator via extensions

IValueValidator v = new PositiveNumberValidator();

var name = v.GetName();                   // "PositiveNumber"
var args = v.GetArguments();              // Dictionary<string, object>