Eventuous should always return Result<TState>

[alexeyzimarev]

Follow up #270 (comment)

[alexeyzimarev]

I now changed the controller base signature to this:

public abstract class CommandHttpApiBase<TState>(IStateCommandService<TState> service, MessageMap? commandMap = null) : ControllerBase
    where TState : State<TState>, new() {

It allows using both aggregate and functional command services since both of them implement the IStateCommandService interface.

The interface itself looks like this:

public interface IStateCommandService<TState> where TState : State<TState>, new() {
    Task<Result<TState>> Handle<TCommand>(TCommand command, CancellationToken cancellationToken) where TCommand : class;
}

I think it will work for your code, the AsActionResult function remains virtual. If people don't want to use custom result, the controller can return Result<TState> directly, and the OpenAPI will be correct without any additional code.

[LockTar]

Hi @alexeyzimarev,

I think this can work. I need to test it of course. But if we use the "Users" sample from my previous comment it should look something like this?

Then it's immediately somewhat documented :-)

Out of the box (no custom result):

[Authorize]
[Route("/users")]
public class UsersCommandApi
{
    public UsersCommandApi(CommandHttpApiBase<User> service) { }

    // Actions here...
}

With custom result:

[Authorize]
[Route("/users")]
public class UsersCommandApi
{
    public UsersCommandApi(UserCommandService service) { }

    [HttpPost]
    [Route("add")]
    [SwaggerResponse((int)HttpStatusCode.OK, "OK", typeof(UserResult))]
    [SwaggerResponse((int)HttpStatusCode.BadRequest, "Bad Request", typeof(ValidationProblemDetailsException))]
    public Task<ActionResult<CustomUserResult>> AddUser(
        [FromBody] AddUserCommand cmd, CancellationToken cancellationToken
    )
    {
        return Handle(cmd, cancellationToken);
    }
}

public class CustomUserResult
{
    public string CustomName { get; set; }
    public string CustomEmail { get; set; }
}

// implement interface IStateCommandService<User>
public class UserCommandService : IStateCommandService<User>
{
    public Task<Result<User>> Handle<TCommand>(TCommand command, CancellationToken cancellationToken) where TCommand : class
    {
        // handle command here...
    }

    protected override ActionResult AsActionResult(Result result)
    {
        // If result is ErrorResult, map it to an error response
        // MapValidationExceptionAsValidationProblemDetails is a method that maps a validation exception to a validation problem details response
        // else, map it to a success response of the type CustomUserResult

        // Removed for brevity
    }

    private BadRequestObjectResult MapValidationExceptionAsValidationProblemDetails(ErrorResult error)
    {
        // Map validation exception to a validation problem details response

        // Removed for brevity
    }
}