feat(router): support giving back json when a request fail

composer.json

@@ -33,7 +33,7 @@
         "psr/http-factory": "^1.0",
         "psr/http-message": "^1.0|^2.0",
         "psr/log": "^3.0.0",
-        "rector/rector": "^2.1",
+        "rector/rector": "2.2.1",
         "symfony/cache": "^7.3",
         "symfony/mailer": "^7.2.6",
         "symfony/process": "^7.3",

packages/core/src/DevelopmentExceptionHandler.php

@@ -3,7 +3,9 @@
 namespace Tempest\Core;
 
 use Tempest\Container\Container;
+use Tempest\Http\ContentType;
 use Tempest\Http\Request;
+use Tempest\Router\Exceptions\JsonHttpExceptionRenderer;
 use Tempest\Router\MatchedRoute;
 use Throwable;
 use Whoops\Handler\HandlerInterface;
@@ -17,6 +19,7 @@
     public function __construct(
         private Container $container,
         private ExceptionReporter $exceptionReporter,
+        private JsonHttpExceptionRenderer $jsonHandler,
     ) {
         $this->whoops = new Run();
         $this->whoops->pushHandler($this->createHandler());
@@ -25,7 +28,14 @@ public function __construct(
     public function handle(Throwable $throwable): void
     {
         $this->exceptionReporter->report($throwable);
-        $this->whoops->handleException($throwable);
+
+        $request = $this->container->get(Request::class);
+
+        match (true) {
+            $request->accepts(ContentType::HTML, ContentType::XHTML) => $this->whoops->handleException($throwable),
+            $request->accepts(ContentType::JSON) => $this->jsonHandler->render($throwable),
+            default => $this->whoops->handleException($throwable),
+        };
     }
 
     private function createHandler(): HandlerInterface

packages/http/src/IsRequest.php

@@ -9,7 +9,6 @@
 use Tempest\Validation\SkipValidation;
 
 use function Tempest\get;
-use function Tempest\Support\Arr\every;
 use function Tempest\Support\Arr\get_by_key;
 use function Tempest\Support\Arr\has_key;
 use function Tempest\Support\str;

packages/http/src/Responses/NotAcceptable.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Tempest\Http\Responses;
+
+use Tempest\Http\IsResponse;
+use Tempest\Http\Response;
+use Tempest\Http\Status;
+
+final class NotAcceptable implements Response
+{
+    use IsResponse;
+
+    public function __construct()
+    {
+        $this->status = Status::NOT_ACCEPTABLE;
+    }
+}

packages/router/src/Exceptions/HttpExceptionHandler.php

@@ -8,8 +8,10 @@
 use Tempest\Core\ExceptionHandler;
 use Tempest\Core\ExceptionReporter;
 use Tempest\Core\Kernel;
+use Tempest\Http\ContentType;
 use Tempest\Http\GenericResponse;
 use Tempest\Http\HttpRequestFailed;
+use Tempest\Http\Request;
 use Tempest\Http\Response;
 use Tempest\Http\Session\CsrfTokenDidNotMatch;
 use Tempest\Http\Status;
@@ -26,19 +28,20 @@ public function __construct(
         private ResponseSender $responseSender,
         private Container $container,
         private ExceptionReporter $exceptionReporter,
+        private JsonHttpExceptionRenderer $jsonHandler,
     ) {}
 
     public function handle(Throwable $throwable): void
     {
+        $request = $this->container->get(Request::class);
+
         try {
             $this->exceptionReporter->report($throwable);
 
             $response = match (true) {
-                $throwable instanceof ConvertsToResponse => $throwable->toResponse(),
-                $throwable instanceof AccessWasDenied => $this->renderErrorResponse(Status::FORBIDDEN),
-                $throwable instanceof HttpRequestFailed => $this->renderErrorResponse($throwable->status, $throwable),
-                $throwable instanceof CsrfTokenDidNotMatch => $this->renderErrorResponse(Status::UNPROCESSABLE_CONTENT),
-                default => $this->renderErrorResponse(Status::INTERNAL_SERVER_ERROR),
+                $request->accepts(ContentType::HTML, ContentType::XHTML) => $this->handleHtml($throwable),
+                $request->accepts(ContentType::JSON) => $this->jsonHandler->render($throwable),
+                default => new GenericResponse(status: Status::NOT_ACCEPTABLE),
             };
 
             $this->responseSender->send($response);
@@ -47,6 +50,17 @@ public function handle(Throwable $throwable): void
         }
     }
 
+    private function handleHtml(Throwable $throwable): Response
+    {
+        return match (true) {
+            $throwable instanceof ConvertsToResponse => $throwable->toResponse(),
+            $throwable instanceof AccessWasDenied => $this->renderErrorResponse(Status::FORBIDDEN),
+            $throwable instanceof HttpRequestFailed => $this->renderErrorResponse($throwable->status, $throwable),
+            $throwable instanceof CsrfTokenDidNotMatch => $this->renderErrorResponse(Status::UNPROCESSABLE_CONTENT),
+            default => $this->renderErrorResponse(Status::INTERNAL_SERVER_ERROR),
+        };
+    }
+
     private function renderErrorResponse(Status $status, ?HttpRequestFailed $exception = null): Response
     {
         return new GenericResponse(

packages/router/src/Exceptions/JsonHttpExceptionRenderer.php

@@ -0,0 +1,94 @@
+<?php
+
+namespace Tempest\Router\Exceptions;
+
+use Tempest\Auth\Exceptions\AccessWasDenied;
+use Tempest\Container\Container;
+use Tempest\Core\AppConfig;
+use Tempest\Core\ExceptionReporter;
+use Tempest\Core\Kernel;
+use Tempest\Http\HttpRequestFailed;
+use Tempest\Http\Response;
+use Tempest\Http\Responses\Json;
+use Tempest\Http\Session\CsrfTokenDidNotMatch;
+use Tempest\Http\Status;
+use Tempest\Router\ResponseSender;
+use Tempest\Validation\Exceptions\ValidationFailed;
+use Tempest\Validation\Rule;
+use Tempest\Validation\Validator;
+use Throwable;
+
+use function Tempest\Support\arr;
+
+final readonly class JsonHttpExceptionRenderer
+{
+    public function __construct(
+        private AppConfig $appConfig,
+        private Kernel $kernel,
+        private ResponseSender $responseSender,
+        private Container $container,
+        private ExceptionReporter $exceptionReporter,
+    ) {}
+
+    public function render(Throwable $throwable): Response
+    {
+        return match (true) {
+            $throwable instanceof ConvertsToResponse => $throwable->toResponse(),
+            $throwable instanceof ValidationFailed => $this->renderValidationErrorResponse($throwable),
+            $throwable instanceof RouteBindingFailed => $this->renderErrorResponse(Status::NOT_FOUND),
+            $throwable instanceof AccessWasDenied => $this->renderErrorResponse(Status::FORBIDDEN),
+            $throwable instanceof HttpRequestFailed => $this->renderErrorResponse($throwable->status),
+            $throwable instanceof CsrfTokenDidNotMatch => $this->renderErrorResponse(Status::UNPROCESSABLE_CONTENT),
+            default => $this->renderErrorResponse(
+                Status::INTERNAL_SERVER_ERROR,
+                $this->appConfig->environment->isLocal() ? $throwable : null,
+            ),
+        };
+    }
+
+    private function renderValidationErrorResponse(ValidationFailed $exception): Response
+    {
+        $errors = arr($exception->failingRules)->map(
+            fn (array $failingRulesForField, string $field) => arr($failingRulesForField)->map(
+                fn (Rule $rule) => $this->container->get(Validator::class)->getErrorMessage($rule, $field),
+            )->toArray(),
+        );
+
+        return new Json([
+            'message' => $errors->first()[0],
+            'errors' => $errors->toArray(),
+        ])->setStatus(Status::UNPROCESSABLE_CONTENT);
+    }
+
+    private function renderErrorResponse(Status $status, ?Throwable $exception = null): Response
+    {
+        return new Json(
+            $this->appConfig->environment->isLocal() && $exception !== null
+                ? [
+                    'message' => $exception->getMessage(),
+                    'exception' => get_class($exception),
+                    'file' => $exception->getFile(),
+                    'line' => $exception->getLine(),
+                    'trace' => arr($exception->getTrace())->map(
+                        fn ($trace) => arr($trace)->removeKeys('args')->toArray(),
+                    )->toArray(),
+                ] : [
+                    'message' => static::getErrorMessage($status, $exception),
+                ],
+        )->setStatus($status);
+    }
+
+    private static function getErrorMessage(Status $status, ?Throwable $exception = null): ?string
+    {
+        return (
+            $exception?->getMessage() ?: match ($status) {
+                Status::INTERNAL_SERVER_ERROR => 'An unexpected server error occurred',
+                Status::NOT_FOUND => 'This page could not be found on the server',
+                Status::FORBIDDEN => 'You do not have permission to access this page',
+                Status::UNAUTHORIZED => 'You must be authenticated in to access this page',
+                Status::UNPROCESSABLE_CONTENT => 'The request could not be processed due to invalid data',
+                default => null,
+            }
+        );
+    }
+}

packages/router/src/HandleRouteExceptionMiddleware.php

@@ -3,12 +3,15 @@
 namespace Tempest\Router;
 
 use Tempest\Core\Priority;
+use Tempest\Http\ContentType;
 use Tempest\Http\HttpRequestFailed;
 use Tempest\Http\Request;
 use Tempest\Http\Response;
 use Tempest\Http\Responses\Invalid;
+use Tempest\Http\Responses\NotAcceptable;
 use Tempest\Http\Responses\NotFound;
 use Tempest\Router\Exceptions\ConvertsToResponse;
+use Tempest\Router\Exceptions\JsonHttpExceptionRenderer;
 use Tempest\Router\Exceptions\RouteBindingFailed;
 use Tempest\Validation\Exceptions\ValidationFailed;
 
@@ -17,6 +20,7 @@
 {
     public function __construct(
         private RouteConfig $routeConfig,
+        private JsonHttpExceptionRenderer $jsonHandler,
     ) {}
 
     public function __invoke(Request $request, HttpMiddlewareCallable $next): Response
@@ -44,9 +48,19 @@ private function forward(Request $request, HttpMiddlewareCallable $next): Respon
             return $next($request);
         } catch (ConvertsToResponse $convertsToResponse) {
             return $convertsToResponse->toResponse();
-        } catch (RouteBindingFailed) {
-            return new NotFound();
+        } catch (RouteBindingFailed $routeBindingFailed) {
+            return match (true) {
+                $request->accepts(ContentType::HTML, ContentType::XHTML) => new NotFound(),
+                $request->accepts(ContentType::JSON) => $this->jsonHandler->render($routeBindingFailed),
+                default => new NotAcceptable(),
+            };
         } catch (ValidationFailed $validationException) {
+            return match (true) {
+                $request->accepts(ContentType::HTML, ContentType::XHTML) => new Invalid($validationException->subject, $validationException->failingRules),
+                $request->accepts(ContentType::JSON) => $this->jsonHandler->render($validationException),
+                default => new NotAcceptable(),
+            };
+
             return new Invalid($validationException->subject, $validationException->failingRules);
         }
     }