mrdave1999/simpleresults

A simple library to implement the Result pattern for returning from services

simpleresults's Issues

Add support for .NET Standard 2.0

Incorrect status is obtained when deserializing the result object

Problem reproduction

public class Program
{
    public static void Main()
    {
        var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
        var json =
            """
            {
              "status": "Ok",
              "success": true,
              "message": "Operation successfully executed",
              "errors": []
            }
            """;

        Result result = JsonSerializer.Deserialize<Result>(json, options);
        Console.WriteLine(result.Status == ResultStatus.Ok); // Output: False
        Console.WriteLine(result.Status); // Output: Failure
    }
}

• The expected behavior should be True.
• The result status should not be Failure. Should be Ok in this case.

Why not use `ref struct` to represent the results?

Indicate which properties of the Result object do not return null

Comments should be added to indicate which properties do not represent a null value by default or vice versa.

Add an action filter to translate the `Result` object to `ActionResult`

Example

[TranslateResultToActionResult]
[ApiController]
[Route("[controller]")]
public class PersonController : ControllerBase
{
    private readonly PersonService _personService;
    public PersonController(PersonService personService) => _personService = personService;

    [HttpPost]
    public Result Create([FromBody]Person person)
        => _personService.Create(person);

    [HttpGet]
    public ListedResult<Person> Get() 
        => _personService.GetAll();
}

TranslateResultToActionResultAttribute inherits from ActionFilterAttribute.
See https://learn.microsoft.com/en-us/aspnet/core/mvc/controllers/filters?view=aspnetcore-7.0#action-filters

Add implicit conversion from `Result<T>` to value

Example

var data = new List<string>();
Result<List<string>> result = Result.Success(data);
// Implicit conversion.
List<string> value = result;

Add sample on the use of PagedResult

Replace ResultSet type by ListedResult

Allow endpoint filter to be used in controller actions

PR #50 only works if you use in Minimal API but in controller actions it does not work.

See https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis/min-api-filters?view=aspnetcore-8.0#register-a-filter-on-controller-actions

Add .NET 8 support for the SimpleResults.AspNetCore project

The version of the SimpleResults.AspNetCore package must be incremented.

Create nuget package in release mode

Add extension methods to the ModelStateDictionary type

These extension methods will be added to the ModelStateDictionary type:

public static class SRModelStateDictionaryExtensions
{
    public static bool IsFailed(this ModelStateDictionary modelState);
    public static Result Invalid(this ModelStateDictionary modelState);
    public static Result Invalid(this ModelStateDictionary modelState, string message);
    public static BadRequestObjectResult BadRequest(this ModelStateDictionary modelState);
    public static BadRequestObjectResult BadRequest(this ModelStateDictionary modelState, string message);
}

SRModelStateDictionaryExtensions contains methods that convert an instance of ModelStateDictionary into an instance of type Result.
The SR "prefix" is so as not to cause name conflicts.

Usage

[Route("api/[controller]")]
public class PersonController : ControllerBase
{
    [HttpPost]
    public ActionResult<Result<CreatedId>> Create([FromBody]Person person)
    {
        if (ModelState.IsFailed())
            return ModelState.BadRequest();

        // Some code..
    }
}

Why it was decided to create different extension methods called ToActionResult?

See https://mrdave1999.github.io/SimpleResults/api/SimpleResults.ResultExtensions.ToActionResult.html

Add English resource as default

Add an index to README.md

Add support for Fluent Validation

These methods can be distributed in a NuGet package:

public static class SRFluentValidationResultExtensions
{
    public static bool IsFailed(this ValidationResult result) => !result.IsValid;
    public static IEnumerable<string> AsErrors(this ValidationResult result)
        => result.Errors.Select(failure => failure.ErrorMessage);

   public static Result Invalid(this ValidationResult result) 
        => Result.Invalid(result.AsErrors());

   public static Result Invalid(this ValidationResult result, string message) 
        => Result.Invalid(message, result.AsErrors());
}

The SR "prefix" is so as not to cause name conflicts.

PD: The package was published here: https://www.nuget.org/packages/SimpleResults.FluentValidation

Generate the API Documentation with DocFX

API documentation is published here: https://mrdave1999.github.io/SimpleResults/api/SimpleResults.html

Add methods to execute explicit conversions

Methods to be added in the Result class to perform the conversion from Result to:

public Result<T> ToResult<T>(T data);
public ListedResult<T> ToListedResult<T>(IEnumerable<T> data);
public PagedResult<T> ToPagedResult<T>(IEnumerable<T> data, PagedInfo pagedInfo);

These methods can go in a file named Result.Conversions.cs.
Note: Implicit operators can call these methods.

Usage

var person = new Person { Name = "Bob" };
Result invalidResult = Result.Invalid();
Result<Person> result = invalidResult.ToResult(person);

PD: These methods have been added.

• ToResult
• ToListedResult
• ToPagedResult

Add implicit conversion from value to `Result<T>`

Example

var value = new List<string>();
// Implicit conversion.
Result<List<string>> result = value;

Translate from Result object to an implementation of IResult

The result types must be translated into an implementation of Microsoft.AspNetCore.Http.IResult.
It also adds support for Minimal APIs.

Add integration tests to aspnetcore example

Why are exceptions used for unexpected errors or exceptional situations?

Add a result when multiple resources are successfully obtained

Add overloading methods with a single parameter of type `IEnumerable` to `Result` type

Samples

• Result Failure(IEnumerable<string> errors);
• Result Invalid(IEnumerable<string> errors);
• Result NotFound(IEnumerable<string> errors);
• Result Unauthorized(IEnumerable<string> errors);
• Result Conflict(IEnumerable<string> errors);
• Result CriticalError(IEnumerable<string> errors);

Overload to allow Exceptions

More of a question, than a request.
What would be your opinion on adding an overload on the ErrorResult to accept to Exception (and maybe even a String,Exception)

Something like this:

try
{
    var state = await domainEventHandler.Handle(domainEvent, domainEventMetaData,cancellationToken);
    return new Result.Success(state);
}
catch(Exception e)
{
    return new ErrorResult(e);
}

Add an endpoint filter to translate the Result object to IResult

The filter only converts the Result object to an implementation of Microsoft.AspNetCore.Http.IResult.

Example

public static class PersonEndpoint
{
    public static void AddRoutes(this WebApplication app)
    {
        var personGroup = app
            .MapGroup("/Person")
            .WithTags("Person")
            .AddEndpointFilter<TranslateResultToHttpResultFilter>();

        personGroup
            .MapPost("/", ([FromBody]Person person, PersonService service) => service.Create(person))
            .Produces<Result>();

        personGroup
            .MapGet("/", (PersonService service) => service.GetAll())
            .Produces<ListedResult<Person>>();
    }
}

TranslateResultToHttpResultFilter must implement the IEndpointFilter interface.

The detail to take into consideration is that IEndpointFilter is only available as of ASP.NET Core 7.0. This means that the custom filter should be compiled for specific frameworks such as .NET 7, 8 or higher.

As the SimpleResults.AspNetCore project has multiple target frameworks, the preprocessor symbols could be used as NET7_0_OR_GREATER. See https://learn.microsoft.com/en-us/dotnet/core/tutorials/libraries#preprocessor-symbols

Add support for paginating a result

Change error message format when validation fails from Fluent Validation

Currently the SRFluentValidationResultExtensions.AsErrors method will return an error message like this:

'Name' must not be empty.
'First Name' must not be empty.

It would be good to change it to a more specific format like this one:

'Name' property failed validation. Error was: 'Name' must not be empty.

The template would look like this in English:

'{0}' property failed validation. Error was: {1}

And in Spanish:

Propiedad '{0}' falló en la validación. El error fue: {1}

Add sample about native AOT

See https://learn.microsoft.com/en-us/dotnet/core/deploying/native-aot

Add a result operation to represent the file contents

New types to be added:

public class StreamFileContent
{
    public StreamFileContent(Stream content) => Content = content;
    public Stream Content { get; }
    public string ContentType { get; init; } = string.Empty;
    public string FileName { get; init; } = string.Empty;
}

public class ByteArrayFileContent
{
    public ByteArrayFileContent(byte[] content) => Content = content;
    public byte[] Content { get; }
    public string ContentType { get; init; } = string.Empty;
    public string FileName { get; init; } = string.Empty;
}

These types represent the content of a file.

Two methods are added to the Result type:

public static Result<StreamFileContent> File(StreamFileContent fileContent);
public static Result<ByteArrayFileContent> File(ByteArrayFileContent fileContent);

Usage

public class DownloadProformaInvoiceUseCase(
    IHtmlTemplateLoader htmlTemplateLoader,
    IHtmlConverter htmlConverter,
    DownloadProformaInvoiceValidator validator)
{
    public async Task<Result<ByteArrayFileContent>> DownloadAsPdfAsync(DownloadProformaInvoiceRequest request)
    {
        ValidationResult result = validator.Validate(request);
        if (result.IsFailed())
            return Result.Invalid(result.AsErrors());

        var html = await htmlTemplateLoader
            .LoadAsync("./Templates/ProformaInvoice.html", request.MapToObject());

        byte[] fileContents = htmlConverter.ConvertToPdf(html, new MemoryStream());
        var byteArrayFileContent = new ByteArrayFileContent(fileContents)
        {
            ContentType = "application/pdf",
            FileName = "Report.pdf"
        };
        return Result.File(byteArrayFileContent);
    }
}

If the result is successful, Result<ByteArrayFileContent> should be translated to an object like FileContentResult or FileStreamResult (these are types used in MVC controllers).

Support should also be added for Minimal APIs. See, FileContentHttpResult and FileStreamHttpResult.