Shared – Contracts

The Contracts layer provides common shared parts of TD domain. Should be reference cross all valid projects. Must be pure contract layer.

Contents

Split into folders by business logic, but can be shared across all projects.

• DTOs (Try to use Immutable DTOs implemented with Records)
• Enums
• Interfaces

USAGE IMPLEMENTATION EXAMPLE FluentValidationFilter

• In this package we have "IFluentValidate" interface, which is implemented by DTOs that need validation.

example implementation of FluentValidationFilter in WebApi project:

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)]
public sealed class FluentValidation : Attribute, IAsyncActionFilter
{
    public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
    {
        IServiceProvider serviceProvider = context.HttpContext.RequestServices;
        CancellationToken ct = context.HttpContext.RequestAborted;
        var allErrors = new Dictionary<string, List<string>>();

        IEnumerable<IFluentValidate> singleValidatableArgs = context.ActionArguments.Values.OfType<IFluentValidate>();
        IEnumerable<IFluentValidate> collectionValidatableArgs = context.ActionArguments.Values
            .OfType<IEnumerable>()
            .SelectMany(c => c.OfType<IFluentValidate>());

        List<IFluentValidate> validationArgs = singleValidatableArgs.Concat(collectionValidatableArgs).ToList();
        await ValidateArgumentsAsync(serviceProvider, allErrors, validationArgs, ct);

        if (allErrors.Count > 0)
        {
            List<ErrorDetail> errorDetails = allErrors.SelectMany(kv => kv.Value.Select(errorMessage =>
                new ErrorDetail
                {
                    ErrorCode = ErrorCode.InvalidParameterValues.GetCode(),
                    Message = errorMessage,
                    Field = kv.Key
                })).ToList();

            throw new BadRequestException("One or more validation errors occurred.", ErrorCode.InvalidParameterValues, errorDetails);
        }

        await next();
    }

    private static async Task ValidateArgumentsAsync(
        IServiceProvider serviceProvider,
        Dictionary<string, List<string>> allErrors,
        IEnumerable<IFluentValidate> singleValidatableArgs,
        CancellationToken ct)
    {
        foreach (IFluentValidate argument in singleValidatableArgs)
        {
            Dictionary<string, List<string>> errors = await ValidateItemAsync(argument, serviceProvider, ct);
            foreach (var (key, messages) in errors)
            {
                allErrors[key] = messages;
            }
        }
    }

    private static async Task<Dictionary<string, List<string>>> ValidateItemAsync(
        IFluentValidate item,
        IServiceProvider serviceProvider,
        CancellationToken ct)
    {
        var validatorType = typeof(IValidator<>).MakeGenericType(item.GetType());
        if (serviceProvider.GetService(validatorType) is not IValidator validator)
        {
            return [];
        }

        var validationContext = new ValidationContext<IFluentValidate>(item);

        var result = await validator.ValidateAsync(validationContext, ct);
        if (result.IsValid)
        {
            return [];
        }

        return result.Errors
            .GroupBy(e => e.PropertyName)
            .ToDictionary(
                g => g.Key,
                g => g.Select(e => e.ErrorMessage).ToList());
    }
}