proposal-system/api/src/ProposalSystem.Api/Middleware/GlobalExceptionHandler.cs

using System.Net;
using System.Text.Json;
using FluentValidation;
using Microsoft.AspNetCore.Mvc;
using ProposalSystem.Application.Common;

namespace ProposalSystem.Api.Middleware;

public class GlobalExceptionHandler : IMiddleware
{
    private readonly ILogger<GlobalExceptionHandler> _logger;

    public GlobalExceptionHandler(ILogger<GlobalExceptionHandler> logger)
    {
        _logger = logger;
    }

    public async Task InvokeAsync(HttpContext context, RequestDelegate next)
    {
        try
        {
            await next(context);
        }
        catch (Exception ex)
        {
            await HandleExceptionAsync(context, ex);
        }
    }

    private static ProblemDetails MakeProblem(int status, string title, string detail, string code)
    {
        var problem = new ProblemDetails
        {
            Status = status,
            Title = title,
            Detail = detail,
        };
        problem.Extensions["code"] = code; // serialized top-level via [JsonExtensionData]
        return problem;
    }

    private async Task HandleExceptionAsync(HttpContext context, Exception exception)
    {
        // Every response carries a machine-readable "code" extension (SHOC
        // error-code vocabulary convention) so clients branch on codes, not
        // on human-readable text.
        var (statusCode, problemDetails) = exception switch
        {
            ValidationException validationEx => (
                HttpStatusCode.BadRequest,
                MakeProblem(400, "Validation Error",
                    string.Join("; ", validationEx.Errors.Select(e => e.ErrorMessage)),
                    "ValidationFailed")
            ),
            BusinessRuleException businessEx => (
                HttpStatusCode.UnprocessableEntity,
                MakeProblem(422, "Business Rule Violation", businessEx.Message, businessEx.Code)
            ),
            KeyNotFoundException => (
                HttpStatusCode.NotFound,
                MakeProblem(404, "Not Found", "The requested resource was not found", "NotFound")
            ),
            UnauthorizedAccessException => (
                HttpStatusCode.Unauthorized,
                MakeProblem(401, "Unauthorized", "Authentication required", "Unauthorized")
            ),
            InvalidOperationException => (
                HttpStatusCode.BadRequest,
                MakeProblem(400, "Invalid Operation",
                    "The requested operation is not valid for the current state",
                    "InvalidStateTransition")
            ),
            _ => (
                HttpStatusCode.InternalServerError,
                MakeProblem(500, "Internal Server Error", "An unexpected error occurred", "InternalError")
            ),
        };

        _logger.LogError(exception, "Exception on {Method} {Path}: {Status}",
            context.Request.Method, context.Request.Path, (int)statusCode);

        context.Response.StatusCode = (int)statusCode;
        context.Response.ContentType = "application/problem+json";

        await context.Response.WriteAsync(
            JsonSerializer.Serialize(problemDetails, new JsonSerializerOptions
            {
                PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
            }));
    }
}