Fix #61: Add support callable middlewares like [$instance, 'method'] and $invokeable

src/MiddlewareFactory.php

@@ -44,8 +44,9 @@ public function __construct(
      * - A callable with
      *   `function(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface`
      *   signature.
-     * - A controller handler action in format `[TestController::class, 'index']`. `TestController` instance will
-     *   be created and `index()` method will be executed.
+     * - Any callable.
+     * - A controller handler action in format `[TestController::class, 'index']` or `[new TestController(), 'index']`.
+     *   `TestController` instance will be created if it is not an instance and `index()` method will be executed.
      * - A function returning a middleware. The middleware returned will be executed.
      *
      * For handler action and callable
@@ -87,21 +88,21 @@ private function isMiddlewareClassDefinition(array|callable|string $definition):
     }
 
     /**
-     * @psalm-assert-if-true array{0:class-string, 1:non-empty-string}|Closure $definition
+     * @psalm-assert-if-true array{0:class-string|object, 1:non-empty-string}|callable-object|callable-string|Closure $definition
      */
     private function isCallableDefinition(array|callable|string $definition): bool
     {
-        if ($definition instanceof Closure) {
+        if (is_callable($definition)) {
             return true;
         }
 
         return is_array($definition)
             && array_keys($definition) === [0, 1]
-            && is_string($definition[0])
+            && (is_string($definition[0]) || is_object($definition[0]))
             && is_string($definition[1])
             && in_array(
                 $definition[1],
-                class_exists($definition[0]) ? get_class_methods($definition[0]) : [],
+                is_object($definition[0]) || class_exists($definition[0]) ? get_class_methods($definition[0]) : [],
                 true
             );
     }
@@ -125,9 +126,9 @@ private function isArrayDefinition(array|callable|string $definition): bool
     }
 
     /**
-     * @param array{0:class-string, 1:non-empty-string}|Closure $callable
+     * @param array{0:class-string|object, 1:non-empty-string}|callable-object|callable-string|Closure $callable
      */
-    private function wrapCallable(array|Closure $callable): MiddlewareInterface
+    private function wrapCallable(array|callable $callable): MiddlewareInterface
     {
         if (is_array($callable)) {
             return $this->createActionWrapper($callable[0], $callable[1]);
@@ -184,17 +185,17 @@ private function getCallableParameters(): array
     }
 
     /**
-     * @param class-string $class
+     * @param class-string|object $class
      * @param non-empty-string $method
      */
-    private function createActionWrapper(string $class, string $method): MiddlewareInterface
+    private function createActionWrapper(string|object $class, string $method): MiddlewareInterface
     {
         return new class ($this->container, $this->parametersResolver, $class, $method) implements MiddlewareInterface {
             public function __construct(
                 private ContainerInterface $container,
                 private ?ParametersResolverInterface $parametersResolver,
-                /** @var class-string */
-                private string $class,
+                /** @var class-string|object */
+                private string|object $class,
                 /** @var non-empty-string */
                 private string $method
             ) {
@@ -204,8 +205,12 @@ public function process(
                 ServerRequestInterface $request,
                 RequestHandlerInterface $handler
             ): ResponseInterface {
-                /** @var mixed $controller */
-                $controller = $this->container->get($this->class);
+                if (is_string($this->class)) {
+                    /** @var mixed $controller */
+                    $controller = $this->container->get($this->class);
+                } else {
+                    $controller = $this->class;
+                }
                 $parameters = [$request, $handler];
                 if ($this->parametersResolver !== null) {
                     $parameters = array_merge(

tests/MiddlewareFactoryTest.php

@@ -15,6 +15,7 @@
 use Yiisoft\Middleware\Dispatcher\InvalidMiddlewareDefinitionException;
 use Yiisoft\Middleware\Dispatcher\MiddlewareFactory;
 use Yiisoft\Middleware\Dispatcher\ParametersResolverInterface;
+use Yiisoft\Middleware\Dispatcher\Tests\Support\InvokeableAction;
 use Yiisoft\Middleware\Dispatcher\Tests\Support\SimpleParametersResolver;
 use Yiisoft\Middleware\Dispatcher\Tests\Support\UseParamsController;
 use Yiisoft\Middleware\Dispatcher\Tests\Support\UseParamsMiddleware;
@@ -110,6 +111,45 @@ public function testCreateFromClosureWithResolver(): void
         );
     }
 
+    public function testCreateCallableFromArrayWithInstance(): void
+    {
+        $container = $this->getContainer();
+        $controller = new TestController();
+        $middleware = $this
+            ->getMiddlewareFactory($container)
+            ->create([$controller, 'index']);
+        self::assertSame(
+            'yii',
+            $middleware
+                ->process(
+                    $this->createMock(ServerRequestInterface::class),
+                    $this->createMock(RequestHandlerInterface::class)
+                )
+                ->getHeaderLine('test')
+        );
+        self::assertSame(
+            [$controller, 'index'],
+            $middleware->__debugInfo()['callback']
+        );
+    }
+
+    public function testCreateCallableObject(): void
+    {
+        $container = $this->getContainer();
+        $middleware = $this
+            ->getMiddlewareFactory($container)
+            ->create(new InvokeableAction());
+        self::assertSame(
+            'yii',
+            $middleware
+                ->process(
+                    $this->createMock(ServerRequestInterface::class),
+                    $this->createMock(RequestHandlerInterface::class)
+                )
+                ->getHeaderLine('test')
+        );
+    }
+
     public function testCreateFromClosureMiddleware(): void
     {
         $container = $this->getContainer([TestController::class => new TestController()]);
@@ -259,14 +299,6 @@ public function testInvalidMiddlewareWithWrongArrayType(): void
             ->create(['class' => TestController::class, 'index']);
     }
 
-    public function testInvalidMiddlewareWithWrongArrayWithInstance(): void
-    {
-        $this->expectException(InvalidMiddlewareDefinitionException::class);
-        $this
-            ->getMiddlewareFactory()
-            ->create([new TestController(), 'index']);
-    }
-
     public function testInvalidMiddlewareWithWrongArrayWithIntItems(): void
     {
         $this->expectException(InvalidMiddlewareDefinitionException::class);

tests/Support/InvokeableAction.php

@@ -0,0 +1,16 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Yiisoft\Middleware\Dispatcher\Tests\Support;
+
+use Nyholm\Psr7\Response;
+use Psr\Http\Message\ResponseInterface;
+
+final class InvokeableAction
+{
+    public function __invoke(): ResponseInterface
+    {
+        return new Response(200, ['test' => 'yii']);
+    }
+}