Merge pull request #23 from clue/global-middleware

Add support for global middleware

Author: clue

docs/api/middleware.md

@@ -36,7 +36,7 @@ $app->get(
     },
     function (Psr\Http\Message\ServerRequestInterface $request) {
         $role = $request->getAttribute('admin') ? 'admin' : 'user';
-        return new React\Http\Message\Response(200, [], "hello $role!");
+        return new React\Http\Message\Response(200, [], "Hello $role!\n");
     }
 );
 ```
@@ -58,6 +58,7 @@ like this:
 
 namespace Acme\Todo;
 
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 
 class DemoMiddleware
@@ -72,7 +73,7 @@ class DemoMiddleware
 
         // call next handler in chain
         $response = $next($request);
-        assert($response instanceof Psr\Http\Message\ResponseInterface);
+        assert($response instanceof ResponseInterface);
 
         // optionally modify response before returning to previous handler
         // $response = $response->withHeader('Content-Type', 'text/plain');
@@ -136,13 +137,14 @@ class AdminMiddleware
 namespace Acme\Todo;
 
 use Psr\Http\Message\ServerRequestInterface;
+use React\Http\Message\Response;
 
 class UserController
 {
     public function __invoke(ServerRequestInterface $request)
     {
         $role = $request->getAttribute('admin') ? 'admin' : 'user';
-        return new React\Http\Message\Response(200, [], "hello $role!");
+        return new Response(200, [], "Hello $role!\n");
     }
 }
 ```
@@ -156,7 +158,7 @@ use Acme\Todo\UserController;
 
 // …
 
-$app->get('/user/', new AdminMiddleware(), new UserController());
+$app->get('/user', new AdminMiddleware(), new UserController());
 ```
 
 For example, an HTTP `GET` request for `/user` would first call the middleware handler which then modifies this request and passes the modified request to the next controller function.
@@ -172,7 +174,7 @@ Likewise, we can add an example middleware handler that can modify the outgoing
 
 namespace Acme\Todo;
 
-use Psr\Http\Message\ResponseInterface);
+use Psr\Http\Message\ResponseInterface;
 use Psr\Http\Message\ServerRequestInterface;
 
 class ContentTypeMiddleware
@@ -194,12 +196,13 @@ class ContentTypeMiddleware
 namespace Acme\Todo;
 
 use Psr\Http\Message\ServerRequestInterface;
+use React\Http\Message\Response;
 
 class UserController
 {
     public function __invoke(ServerRequestInterface $request)
     {
-        return new React\Http\Message\Response(200, [], "Hello world!\n");
+        return new Response(200, [], "Hello world!\n");
     }
 }
 ```
@@ -213,7 +216,7 @@ use Acme\Todo\UserController;
 
 // …
 
-$app->get('/user/', new ContentTypeMiddleware(), new UserController());
+$app->get('/user', new ContentTypeMiddleware(), new UserController());
 ```
 
 For example, an HTTP `GET` request for `/user` would first call the middleware handler which passes on the request to the controller function and then modifies the response that is returned by the controller function.
@@ -242,15 +245,10 @@ As a consequence, each middleware handler can also return
 
 ## Global middleware
 
-> ℹ️ **Feature preview**
->
-> This is a feature preview, i.e. it might not have made it into the current beta.
-> Give feedback to help us prioritize.
-
-Additionally, you can also add middleware to the `App` object itself to register
-a global middleware handler for all registered routes:
+Additionally, you can also add middleware to the [`App`](app.md) object itself
+to register a global middleware handler:
 
-```php hl_lines="8"
+```php hl_lines="7"
 # app.php
 <?php
 
@@ -264,6 +262,9 @@ $app->get('/user', new UserController());
 $app->run();
 ```
 
+Any global middleware handler will always be called for all registered routes
+and also any requests that can not be routed.
+
 You can also combine global middleware handlers (think logging) with additional
 middleware handlers for individual routes (think authentication).
 Global middleware handlers will always be called before route middleware handlers.

src/App.php

@@ -21,15 +21,45 @@
 class App
 {
     private $loop;
+    private $middleware;
     private $router;
     private $routeDispatcher;
 
-    public function __construct(LoopInterface $loop = null)
+    /**
+     * Instantiate new X application
+     *
+     * ```php
+     * // instantiate
+     * $app = new App();
+     *
+     * // instantiate with global middleware
+     * $app = new App($middleware);
+     * $app = new App($middleware1, $middleware2);
+     *
+     * // instantiate with optional $loop
+     * $app = new App($loop);
+     * $app = new App($loop, $middleware);
+     * $app = new App($loop, $middleware1, $middleware2);
+     *
+     * // invalid $loop argument
+     * $app = new App(null);
+     * $app = new App(null, $middleware);
+     * ```
+     *
+     * @param callable|LoopInterface|null $loop
+     * @param callable ...$middleware
+     * @throws \TypeError if given $loop argument is invalid
+     */
+    public function __construct($loop = null, callable ...$middleware)
     {
-        if ($loop === null) {
-            $loop = Loop::get();
+        if (\is_callable($loop)) {
+            \array_unshift($middleware, $loop);
+            $loop = null;
+        } elseif (\func_num_args() !== 0 && !$loop instanceof LoopInterface) {
+            throw new \TypeError('Argument 1 ($loop) must be callable|' . LoopInterface::class . ', ' . $this->describeType($loop) . ' given');
         }
-        $this->loop = $loop;
+        $this->loop = $loop ?? Loop::get();
+        $this->middleware = $middleware;
         $this->router = new RouteCollector(new RouteParser(), new RouteGenerator());
     }
 
@@ -315,6 +345,45 @@ private function sendResponse(ServerRequestInterface $request, ResponseInterface
      *     turned into a valid error response before returning.
      */
     private function handleRequest(ServerRequestInterface $request)
+    {
+        $handler = function (ServerRequestInterface $request) {
+            return $this->routeRequest($request);
+        };
+        if ($this->middleware) {
+            $handler = new MiddlewareHandler(array_merge($this->middleware, [$handler]));
+        }
+
+        try {
+            $response = $handler($request);
+        } catch (\Throwable $e) {
+            return $this->errorHandlerException($e);
+        }
+
+        if ($response instanceof \Generator) {
+            $response = $this->coroutine($response);
+        }
+
+        if ($response instanceof ResponseInterface) {
+            return $response;
+        } elseif ($response instanceof PromiseInterface) {
+            return $response->then(function ($response) {
+                if (!$response instanceof ResponseInterface) {
+                    return $this->errorHandlerResponse($response);
+                }
+                return $response;
+            }, function ($e) {
+                if ($e instanceof \Throwable) {
+                    return $this->errorHandlerException($e);
+                } else {
+                    return $this->errorHandlerResponse(\React\Promise\reject($e));
+                }
+            });
+        } else {
+            return $this->errorHandlerResponse($response);
+        }
+    }
+
+    private function routeRequest(ServerRequestInterface $request)
     {
         if (\strpos($request->getRequestTarget(), '://') !== false || $request->getMethod() === 'CONNECT') {
             return $this->errorProxy($request);
@@ -342,34 +411,7 @@ private function handleRequest(ServerRequestInterface $request)
                     $request = $request->withAttribute($key, rawurldecode($value));
                 }
 
-                try {
-                    $response = $handler($request);
-                } catch (\Throwable $e) {
-                    return $this->errorHandlerException($e);
-                }
-
-                if ($response instanceof \Generator) {
-                    $response = $this->coroutine($response);
-                }
-
-                if ($response instanceof ResponseInterface) {
-                    return $response;
-                } elseif ($response instanceof PromiseInterface) {
-                    return $response->then(function ($response) {
-                        if (!$response instanceof ResponseInterface) {
-                            return $this->errorHandlerResponse($response);
-                        }
-                        return $response;
-                    }, function ($e) {
-                        if ($e instanceof \Throwable) {
-                            return $this->errorHandlerException($e);
-                        } else {
-                            return $this->errorHandlerResponse(\React\Promise\reject($e));
-                        }
-                    });
-                } else {
-                    return $this->errorHandlerResponse($response);
-                }
+                return $handler($request);
         }
     } // @codeCoverageIgnore