Results pattern with a Post-Processor doing the response sending.

Program.cs

var bld = WebApplication.CreateBuilder(args);
bld.Services
   .AddFastEndpoints()
   .SwaggerDocument();

var app = bld.Build();
app.UseFastEndpoints()
   .UseSwaggerGen();
app.Run();

sealed class Request
{
    public bool IsHappyPath { get; set; }
}

sealed class Response
{
    public string Message { get; set; }
}

sealed class TestEndpoint : Endpoint<Request, Result<Response>> //set response type to ardalis Result<T>
{
    public override void Configure()
    {
        Get("test/{IsHappyPath}");
        AllowAnonymous();
        DontAutoSendResponse();            //disable auto send to allow post-processor to handle sending
        PostProcessor<ResponseSender>();   //register post processor
        Description(
            x => x.Produces<Response>(200) //override swagger response type for 200 ok
                  .Produces<ErrorResponse>(400));
    }

    public override Task<Result<Response>> ExecuteAsync(Request r, CancellationToken ct)
        => Task.FromResult(HelloService.SayHello(r.IsHappyPath)); //return a Result<T>
}

sealed class ResponseSender : IPostProcessor<Request, Result<Response>>
{
    public async Task PostProcessAsync(IPostProcessorContext<Request, Result<Response>> ctx, CancellationToken ct)
    {
        if (!ctx.HttpContext.ResponseStarted())
        {
            var result = ctx.Response!;

            switch (result.Status)
            {
                case ResultStatus.Ok:
                    await ctx.HttpContext.Response.SendAsync(result.GetValue());

                    break;

                case ResultStatus.Invalid:
                    var failures = result.ValidationErrors.Select(e => new ValidationFailure(e.Identifier, e.ErrorMessage)).ToList();
                    await ctx.HttpContext.Response.SendErrorsAsync(failures);

                    break;
            }
        }
    }
}

sealed class HelloService
{
    public static Result<Response> SayHello(bool isHappyPath)
    {
        if (!isHappyPath)
        {
            return Result<Response>.Invalid(
                new List<ValidationError>
                {
                    new()
                    {
                        Identifier = nameof(Request.IsHappyPath),
                        ErrorMessage = "I am unhappy!"
                    }
                });
        }

        return Result<Response>.Success(new() { Message = "hello world..." });
    }
}

Reason to go on that path is to avoid putting DontSend... and PostProcessor on each endpoint

in that case, i think the cleanest solution would be to use a global post processor and avoid subclassing the endpoint class.

sealed class GlobalResponseSender : IGlobalPostProcessor
{
    public async Task PostProcessAsync(IPostProcessorContext ctx, CancellationToken ct)
    {
        if (!ctx.HttpContext.ResponseStarted())
        {
            var result = (IResult)ctx.Response!; //cast is necessary since we don't know what the actual response dto type is

            switch (result.Status)
            {
                case ResultStatus.Ok:
                    await ctx.HttpContext.Response.SendAsync(result.GetValue());

                    break;

                case ResultStatus.Invalid:
                    var failures = result.ValidationErrors.Select(e => new ValidationFailure(e.Identifier, e.ErrorMessage)).ToList();
                    await ctx.HttpContext.Response.SendErrorsAsync(failures);

                    break;
            }
        }
    }
}

register it like so:

app.UseFastEndpoints(
       c => c.Endpoints.Configurator =
                ep =>
                {
                    ep.DontAutoSendResponse();
                    ep.PostProcessor<GlobalResponseSender>(Order.Before);
                })

{Edit: Hold up on this, I might have this wrong...}

I am using the example as above and it works perfectly for me. But I have a couple of endpoints (OAuth related, of course) that I need to do a Redirect back to my client as the endpoint is being called by the OAuth provider. I guess the question is how could I avoid using the GlobalResponseSender when I don't want/need it?

I don't want to create a fork of Result and there is no StatusCode value for a redirect in their package. This is what the endpoint looks like:

 public override void Configure()
{
  Get(OAuthCallbackRequest.RouteTemplate);
}
public override async Task HandleAsync(OAuthCallbackRequest request, CancellationToken ct = default)
{
  var options = AcuityAuthOptions.Value;

  if (!TryValidateOAuthResponseAsync(request, options, out var invalidResponseRoute))
  {
    await SendRedirectAsync(invalidResponseRoute, allowRemoteRedirects: true);
    return;
  }

  var oauthStateValuesResult = await GetStateValuesAsync(options, request);
  if (!oauthStateValuesResult.IsSuccess)
  {
    var invalidStateRoute = CreateInvalidStateValuesRoute(options);
    await SendRedirectAsync(invalidStateRoute, allowRemoteRedirects: true);
    return;
  }

  // because this is a redirect from the user's client browser the cookie will still be present and we can get the user.
  var userId = User.GetUserId();
  var command = request.ToCommand(oauthStateValuesResult.Value, userId, ComposeOAuthCallbackToServerUri());
  var result = await mediator.Send(command, ct);

  var claims = command.OAuthStateValues ?? [];

  var route = CreateResponseRoute(
    errors: result.Errors.ToArray(),
    uriBase: GetResultUri(claims),
    uriPath: options.AuthorizationResultClientPath,
    originPage: GetClientOriginUri(claims),
    success: result.IsSuccess);

  await SendRedirectAsync(route, allowRemoteRedirects: true);
  return;
}

Is there a way to make the two work at the same time? TIA

@nhwilly
since you wrote {Edit: Hold up on this, I might have this wrong...}, i didn't read your code.
if you need further assitance regarding this, don't hesitate to create a new gh issue or discord post with a "simplified" repro ;-)