[3.x] Exception handling via Inertia::handleExceptionsUsing() (#823)

* Exception handling via `Inertia::handleExceptionsUsing()`

* Added `usingMiddleware` method

Author: pascalbaljet

src/ExceptionResponse.php

@@ -0,0 +1,165 @@
+<?php
+
+namespace Inertia;
+
+use Illuminate\Contracts\Http\Kernel as KernelContract;
+use Illuminate\Contracts\Support\Responsable;
+use Illuminate\Http\Request;
+use Illuminate\Routing\Router;
+use Symfony\Component\HttpFoundation\Response;
+use Throwable;
+
+class ExceptionResponse implements Responsable
+{
+    protected ?string $component = null;
+
+    /** @var array<string, mixed> */
+    protected array $props = [];
+
+    protected bool $includeSharedData = false;
+
+    protected ?string $rootView = null;
+
+    /** @var class-string<Middleware>|null */
+    protected ?string $middlewareClass = null;
+
+    public function __construct(
+        public readonly Throwable $exception,
+        public readonly Request $request,
+        public readonly Response $response,
+        protected readonly Router $router,
+        protected readonly KernelContract $kernel,
+    ) {}
+
+    /**
+     * @param  array<string, mixed>  $props
+     */
+    public function render(string $component, array $props = []): static
+    {
+        $this->component = $component;
+        $this->props = $props;
+
+        return $this;
+    }
+
+    /**
+     * @param  class-string<Middleware>  $middlewareClass
+     */
+    public function usingMiddleware(string $middlewareClass): static
+    {
+        $this->middlewareClass = $middlewareClass;
+
+        return $this;
+    }
+
+    public function withSharedData(): static
+    {
+        $this->includeSharedData = true;
+
+        return $this;
+    }
+
+    public function rootView(string $rootView): static
+    {
+        $this->rootView = $rootView;
+
+        return $this;
+    }
+
+    public function statusCode(): int
+    {
+        return $this->response->getStatusCode();
+    }
+
+    /**
+     * @param  \Illuminate\Http\Request  $request
+     */
+    public function toResponse($request): Response
+    {
+        if ($this->component === null) {
+            return $this->response;
+        }
+
+        $middleware = $this->resolveMiddleware();
+
+        if ($middleware) {
+            Inertia::version(fn () => $middleware->version($this->request));
+            Inertia::setRootView($this->rootView ?? $middleware->rootView($this->request));
+        } elseif ($this->rootView) {
+            Inertia::setRootView($this->rootView);
+        }
+
+        if ($this->includeSharedData && $middleware) {
+            Inertia::share($middleware->share($this->request));
+
+            foreach ($middleware->shareOnce($this->request) as $key => $value) {
+                if ($value instanceof OnceProp) {
+                    Inertia::share($key, $value);
+                } else {
+                    Inertia::shareOnce($key, $value);
+                }
+            }
+        }
+
+        return Inertia::render($this->component, $this->props)
+            ->toResponse($this->request)
+            ->setStatusCode($this->response->getStatusCode());
+    }
+
+    protected function resolveMiddleware(): ?Middleware
+    {
+        if ($this->middlewareClass) {
+            return app($this->middlewareClass);
+        }
+
+        $class = $this->resolveMiddlewareFromRoute() ?? $this->resolveMiddlewareFromKernel();
+
+        if ($class) {
+            return app($class);
+        }
+
+        return null;
+    }
+
+    /**
+     * @return class-string<Middleware>|null
+     */
+    protected function resolveMiddlewareFromRoute(): ?string
+    {
+        $route = $this->request->route();
+
+        if (! $route) {
+            return null;
+        }
+
+        foreach ($this->router->gatherRouteMiddleware($route) as $middleware) {
+            if (! is_string($middleware)) {
+                continue;
+            }
+
+            $class = head(explode(':', $middleware));
+
+            if (is_a($class, Middleware::class, true)) {
+                return $class;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * @return class-string<Middleware>|null
+     */
+    protected function resolveMiddlewareFromKernel(): ?string
+    {
+        foreach ($this->kernel->getMiddlewareGroups() as $group) {
+            foreach ($group as $middleware) {
+                if (is_string($middleware) && is_a($middleware, Middleware::class, true)) {
+                    return $middleware;
+                }
+            }
+        }
+
+        return null;
+    }
+}

src/Inertia.php

@@ -24,6 +24,7 @@
  * @method static \Inertia\Response render(string $component, array<array-key, mixed>|\Illuminate\Contracts\Support\Arrayable<array-key, mixed>|\Inertia\ProvidesInertiaProperties $props = [])
  * @method static \Illuminate\Http\RedirectResponse back(int $status = 302, array<string, string> $headers = [], mixed $fallback = false)
  * @method static \Symfony\Component\HttpFoundation\Response location(string|\Symfony\Component\HttpFoundation\RedirectResponse $url)
+ * @method static void handleExceptionsUsing(callable $callback)
  * @method static \Inertia\ResponseFactory flash(string|array<string, mixed> $key, mixed $value = null)
  * @method static array<string, mixed> getFlashed(?\Illuminate\Http\Request $request = null)
  * @method static void withoutSsr(array<int, string>|string $paths)

src/ResponseFactory.php

@@ -4,8 +4,11 @@
 
 use BackedEnum;
 use Closure;
+use Illuminate\Contracts\Debug\ExceptionHandler;
+use Illuminate\Contracts\Http\Kernel;
 use Illuminate\Contracts\Support\Arrayable;
 use Illuminate\Http\Request as HttpRequest;
+use Illuminate\Routing\Router;
 use Illuminate\Support\Arr;
 use Illuminate\Support\Facades\App;
 use Illuminate\Support\Facades\Redirect;
@@ -334,6 +337,31 @@ public function location($url): SymfonyResponse
         return $url instanceof RedirectResponse ? $url : Redirect::away($url);
     }
 
+    /**
+     * Register a callback to handle HTTP exceptions for Inertia requests.
+     */
+    public function handleExceptionsUsing(callable $callback): void
+    {
+        /** @var \Illuminate\Foundation\Exceptions\Handler $handler */
+        $handler = app(ExceptionHandler::class);
+
+        $handler->respondUsing(function ($response, $e, $request) use ($callback) {
+            $result = $callback(new ExceptionResponse(
+                $e,
+                $request,
+                $response,
+                app(Router::class),
+                app(Kernel::class),
+            ));
+
+            if ($result instanceof ExceptionResponse) {
+                return $result->toResponse($request);
+            }
+
+            return $result ?? $response;
+        });
+    }
+
     /**
      * Flash data to be included with the next response. Unlike regular props,
      * flash data is not persisted in the browser's history state, making it