ResultToProblem 2.0.7

ResultToProblem

https://www.nuget.org/packages/ResultToProblem/

ResultToProblem is a .NET library that extends the Result pattern and simplifies the conversion of domain results into standard HTTP responses using ProblemDetails.

Its purpose is to streamline error handling in ASP.NET Core applications, maintaining a clean and consistent style across endpoints and controllers.

Installation

Install the package from NuGet:

bash dotnet add package ResultToProblem

Basic Usage

Examples in an ASP.NET Core project

Minimal API endpoint using ResultToProblem:

Example 1:

program.cs:

using ResultToProblem.Domain.Common;
using ResultToProblem.Domain.Enums;
using ResultToProblem.Api.Extensions;

//....

app.MapGet("/", () =>
{
    var random = new Random();
    var temperature = random.Next(-10, 40);

    if (temperature < -5)
    {
        var result = Result.Failure(
            code: "WEATHER_SENSOR_FAILURE",
            message: "Temperature sensor error",            
            type: ErrorType.Unexpected
        );

        return Results.Problem(result.ToProblemDetails());
    }

    var success = Result.Success($"Today's temperature is {temperature}°C");
    return Results.Ok(success.Value);
});

app.Run();

Example 2:

program.cs:

using ResultToProblem.Domain.Common;
using ResultToProblem.Domain.Enums;
using ResultToProblem.Api.Extensions;

//....

app.MapGet("/", () =>
{
    var random = new Random();
    var temperature = random.Next(-10, 40);

    if (temperature < -5)
    {
        var result = Result.Failure(
            Error.Unexpected("WEATHER_SENSOR_FAILURE", "Temperature sensor error")
        );

        return Results.Problem(result.ToProblemDetails());
    }

    var success = Result.Success($"Today's temperature is {temperature}°C");
    return Results.Ok(success.Value);
});

app.Run();

Other combinations:

Error.Conflict("DUPLICATE_ENTRY", "User already exists")
Error.NotFound("USER_NOT_FOUND", "User record not found")
Error.Validation("INVALID_INPUT", "Temperature must be above zero")

ToValidationProblemDetails() extension for validation errors:

app.MapPost("/users", (UserDTO dto) =>
{
    var errors = new Dictionary<string, string[]>();

    if (string.IsNullOrWhiteSpace(dto.Email))
        errors.Add("Email", new[] { "Email cannot be empty" });
    else if (!Regex.IsMatch(dto.Email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
        errors.Add("Email", new[] { "Email format is invalid" });

    if (string.IsNullOrWhiteSpace(dto.Name))
        errors.Add("Name", new[] { "Name is required" });
    else if (dto.Name.Length < 3)
        errors.Add("Name", new[] { "Name must be at least 3 characters" });

    if (dto.Age < 18 || dto.Age > 120)
        errors.Add("Age", new[] { "Age must be between 18 and 120" });

    if (errors.Any())
    {
        var result = Result.Failure(
            message: "Validation failed",
            code: "USER_VALIDATION_ERROR",
            type: ErrorType.Validation,
            validationErrors: errors
        );

        return Results.ValidationProblem(result.ToValidationProblemDetails().Errors);
    }

    return Results.Ok(new { Message = "User created successfully" });
});

Using a centralized validator:

UserValidator.cs:

public static class UserValidator
{
    public static Result Validate(UserDTO dto)
    {
        var errors = new Dictionary<string, string[]>();

        if (string.IsNullOrWhiteSpace(dto.Email))
            errors.Add("Email", new[] { "Email cannot be empty" });
        else if (!Regex.IsMatch(dto.Email, @"^[^@\s]+@[^@\s]+\.[^@\s]+$"))
            errors.Add("Email", new[] { "Email format is invalid" });

        if (string.IsNullOrWhiteSpace(dto.Name))
            errors.Add("Name", new[] { "Name is required" });
        else if (dto.Name.Length < 3)
            errors.Add("Name", new[] { "Name must be at least 3 characters" });

        if (dto.Age < 18 || dto.Age > 120)
            errors.Add("Age", new[] { "Age must be between 18 and 120" });

        return errors.Any()
            ? Result.Failure("Validation failed", "USER_VALIDATION_ERROR", ErrorType.Validation, errors)
            : Result.Success(dto);
    }
}

program.cs:

app.MapPost("/users", (UserDTO dto) =>
{
    var result = UserValidator.Validate(dto);
    return result.IsSuccess
        ? Results.Ok(new { Message = "User created successfully" })
        : Results.ValidationProblem(result.ToValidationProblemDetails().Errors);
});

Using a centralized validator with a middleware:

ResultMiddleware.cs:

 public class ResultMiddleware
 {
     private readonly RequestDelegate _next;

     public ResultMiddleware(RequestDelegate next)
     {
         _next = next;
     }

    public async Task InvokeAsync(HttpContext context)
    {
        // Run the pipeline
        await _next(context);

        if (!context.Items.TryGetValue("Result", out var resultObj) || resultObj is not Result result)
            return;

        if (result.IsSuccess)
        {
            context.Response.StatusCode = StatusCodes.Status200OK;
            await context.Response.WriteAsJsonAsync(result.Value);
            return;
        }

        if (result.Error?.Type == ErrorType.Validation)
        {
            var validationProblem = result.ToValidationProblemDetails();
            context.Response.StatusCode = StatusCodes.Status400BadRequest;
            await context.Response.WriteAsJsonAsync(validationProblem);
            return;
        }

        var problem = result.ToProblemDetails();
        context.Response.StatusCode = problem.Status ?? StatusCodes.Status500InternalServerError;
        await context.Response.WriteAsJsonAsync(problem);
    }
 }

program.cs:

//Middleware Register
app.UseMiddleware<ResultMiddleware>();
 
app.MapPost("/users", (HttpContext ctx, UserDTO dto) =>
{
    var result = UserValidator.Validate(dto);

    // Store the result for middleware to process
    ctx.Items["Result"] = result;

    // Endpoint doesn’t return JSON directly — middleware handles it
    return Results.Empty;
});

Using FluentValidation library:

UserFluentValidator.cs:

using FluentValidation;

 public class UserFluentValidator : AbstractValidator<UserDTO>
 {
     public UserFluentValidator()
     {
         RuleFor(x => x.Email)
             .NotEmpty().WithMessage("Email cannot be empty")
             .EmailAddress().WithMessage("Email format is invalid");

         RuleFor(x => x.Name)
             .NotEmpty().WithMessage("Name is required")
             .MinimumLength(3).WithMessage("Name must be at least 3 characters");

         RuleFor(x => x.Age)
             .InclusiveBetween(18, 120).WithMessage("Age must be between 18 and 120");
     }
 }

program.cs:

using FluentValidation;
using FluentValidation.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

//...
builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddValidatorsFromAssemblyContaining<UserFluentValidator>();

var app = builder.Build();

//...

app.MapPost("/users", async (UserDTO dto, IValidator<UserDTO> validator) =>
{
    var validationResult = await validator.ValidateAsync(dto);

    var result = validationResult.IsValid
        ? Result.Success(dto)
        : Result.Failure(Error.Validation(
            "ValidationError",
            "One or more validation errors occurred.",
            validationResult.Errors
                .GroupBy(e => e.PropertyName)
                .ToDictionary(
                    g => g.Key,
                    g => g.Select(e => e.ErrorMessage).ToArray()
                )
        ));

    if (result.IsSuccess)
    {
        return Results.Ok(new { Message = "User created successfully", User = dto });
    }

    return Results.ValidationProblem(result.ToValidationProblemDetails().Errors);
});

app.Run();

Using FluentValidation library with a middleware:

ResultMiddleware:

using ResultToProblem.Api.Extensions;
using ResultToProblem.Domain.Common;
using ResultToProblem.Domain.Enums;

public class ResultMiddleware
{
    private readonly RequestDelegate _next;

    public ResultMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // Run the pipeline
        await _next(context);

        if (!context.Items.TryGetValue("Result", out var resultObj) || resultObj is not Result result)
            return;

        if (result.IsSuccess)
        {
            context.Response.StatusCode = StatusCodes.Status200OK;
            await context.Response.WriteAsJsonAsync(result.Value);
            return;
        }

        if (result.Error?.Type == ErrorType.Validation)
        {
            var validationProblem = result.ToValidationProblemDetails();
            context.Response.StatusCode = StatusCodes.Status400BadRequest;
            await context.Response.WriteAsJsonAsync(validationProblem);
            return;
        }

        var problem = result.ToProblemDetails();
        context.Response.StatusCode = problem.Status ?? StatusCodes.Status500InternalServerError;
        await context.Response.WriteAsJsonAsync(problem);
    }
}

UserFluentValidator.cs:

using FluentValidation;

 public class UserFluentValidator : AbstractValidator<UserDTO>
 {
     public UserFluentValidator()
     {
         RuleFor(x => x.Email)
             .NotEmpty().WithMessage("Email cannot be empty")
             .EmailAddress().WithMessage("Email format is invalid");

         RuleFor(x => x.Name)
             .NotEmpty().WithMessage("Name is required")
             .MinimumLength(3).WithMessage("Name must be at least 3 characters");

         RuleFor(x => x.Age)
             .InclusiveBetween(18, 120).WithMessage("Age must be between 18 and 120");
     }
 }

program.cs:

using FluentValidation;
using FluentValidation.AspNetCore;

var builder = WebApplication.CreateBuilder(args);

//...
builder.Services.AddFluentValidationAutoValidation();
builder.Services.AddValidatorsFromAssemblyContaining<UserFluentValidator>();

var app = builder.Build();

//...

app.MapPost("/users", async (UserDTO dto, IValidator<UserDTO> validator, HttpContext context) =>
{
    var validationResult = await validator.ValidateAsync(dto);

    if (!validationResult.IsValid)
    {
        var errors = validationResult.Errors
            .GroupBy(e => e.PropertyName)
            .ToDictionary(
                g => g.Key,
                g => g.Select(e => e.ErrorMessage).ToArray()
            );

        var result = Result.Failure(Error.Validation("ValidationError", "Validation failed", errors));
        context.Items["Result"] = result;
        return; 
    }

    var success = Result.Success(dto);
    context.Items["Result"] = success;
});

app.Run();

✨ Features

• Automatically converts Result objects into ProblemDetails
• Standardized handling for common errors: NotFound, Validation, Conflict, Unexpected
• Easy-to-use extensions for minimal API endpoints
• Compatible with Clean Architecture and Domain-Driven Design

Support the Project

If you find this library useful, consider supporting its development:

Buy Me a Coffee

⚖️ License

This project is freely available under the MIT license.
You may use it without restrictions, as long as you retain the reference to the original license.