Yiisoft\Middleware\Dispatcher\MiddlewareFactory::createCallableWrapper()

Size

Total Lines	81
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes	2
Bugs	0	Features	0

3 Methods

Rating	Name	Duplication	Size	Complexity
A	MiddlewareFactory.php$0 ➔ __debugInfo()	0	10	5
A	MiddlewareFactory.php$0 ➔ process()	0	29	5
A	MiddlewareFactory.php$0 ➔ __construct()	0	19	2

<?php

declare(strict_types=1);

namespace Yiisoft\Middleware\Dispatcher;

use Closure;
use Psr\Container\ContainerInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Server\MiddlewareInterface;
use Psr\Http\Server\RequestHandlerInterface;
use ReflectionAttribute;
use ReflectionFunction;
use ReflectionParameter;
use Yiisoft\Definitions\ArrayDefinition;
use Yiisoft\Definitions\Exception\InvalidConfigException;
use Yiisoft\Definitions\Helpers\DefinitionValidator;
use Yiisoft\Injector\Injector;
use Yiisoft\Middleware\Dispatcher\Attribute\Middleware;

use function in_array;
use function is_array;
use function is_string;

/**
 * Creates a PSR-15 middleware based on the definition provided.
 *
 * @psalm-import-type ArrayDefinitionConfig from ArrayDefinition
 */
final class MiddlewareFactory
{
    private ?EventDispatcherInterface $eventDispatcher = null;

    /**
     * @param ContainerInterface $container Container to use for resolving definitions.
     */
    public function __construct(
        private ContainerInterface $container,
        private ?ParametersResolverInterface $parametersResolver = null
    ) {
    }

    public function withEventDispatcher(?EventDispatcherInterface $eventDispatcher): self
    {
        $new = clone $this;
        $new->eventDispatcher = $eventDispatcher;
        return $new;
    }

    /**
     * @param array|callable|string $middlewareDefinition Middleware definition in one of the following formats:
     *
     * - A name of PSR-15 middleware class. The middleware instance will be obtained from container and executed.
     * - A name of PSR-15 request handler class. The request handler instance will be obtained from container and executed.
     * - A name of invokable class. The invokable class instance will be obtained from container and executed.
     * - A callable with
     *   `function(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface`
     *   signature.
     * - Any callable.
     * - A controller handler action in format `[TestController::class, 'index']`. `TestController` instance will
     *   be created and `index()` method will be executed.
     * - A function returning a middleware. The middleware returned will be executed.
     *
     * For handler action and callable
     * typed parameters are automatically injected using dependency injection container.
     * Current request and handler could be obtained by type-hinting for {@see ServerRequestInterface}
     * and {@see RequestHandlerInterface}.
     *
     * @throws InvalidMiddlewareDefinitionException
     */
    public function create(array|callable|string $middlewareDefinition): MiddlewareInterface
    {
        if ($this->isMiddlewareClassDefinition($middlewareDefinition)) {
            /** @var MiddlewareInterface */
            return $this->container->get($middlewareDefinition);

$middlewareDefinition of type array is incompatible with the type string expected by parameter $id of Psr\Container\ContainerInterface::get().

        }

        if ($this->isRequestHandlerClassDefinition($middlewareDefinition)) {
            return $this->wrapCallable([$middlewareDefinition, 'handle']);
        }

        if ($this->isInvokableClassDefinition($middlewareDefinition)) {
            return $this->wrapCallable([$middlewareDefinition, '__invoke']);
        }

        if ($this->isCallableDefinition($middlewareDefinition)) {
            return $this->wrapCallable($middlewareDefinition);
        }

        if ($this->isArrayDefinition($middlewareDefinition)) {
            /**
             * @var MiddlewareInterface
             *
             * @psalm-suppress InvalidArgument Need for Psalm version 4.* only.
             */
            return ArrayDefinition::fromConfig($middlewareDefinition)->resolve($this->container);
        }

        throw new InvalidMiddlewareDefinitionException($middlewareDefinition);
    }

    /**
     * @psalm-assert-if-true class-string<MiddlewareInterface> $definition
     */
    private function isMiddlewareClassDefinition(array|callable|string $definition): bool
    {
        return is_string($definition)
            && is_subclass_of($definition, MiddlewareInterface::class);
    }

    /**
     * @psalm-assert-if-true class-string<RequestHandlerInterface> $definition
     */
    private function isRequestHandlerClassDefinition(array|callable|string $definition): bool
    {
        return is_string($definition)
            && is_subclass_of($definition, RequestHandlerInterface::class);
    }

    /**
     * @psalm-assert-if-true class-string|object $definition
     */
    private function isInvokableClassDefinition(array|callable|string $definition): bool
    {
        /**
         * @psalm-suppress ArgumentTypeCoercion `method_exists()` allow use any string as first argument and returns
         * false if it not class name.
         */
        return is_string($definition) && method_exists($definition, '__invoke');
    }

    /**
     * @psalm-assert-if-true array{0:class-string, 1:non-empty-string}|callable $definition
     */
    private function isCallableDefinition(array|callable|string $definition): bool
    {
        if (is_callable($definition)) {
            return true;
        }

        return is_array($definition)
            && array_keys($definition) === [0, 1]
            && is_string($definition[0])
            && is_string($definition[1])
            && in_array(
                $definition[1],
                class_exists($definition[0]) ? get_class_methods($definition[0]) : [],
                true
            );
    }

    /**
     * @psalm-assert-if-true ArrayDefinitionConfig $definition
     */
    private function isArrayDefinition(array|callable|string $definition): bool
    {
        if (!is_array($definition)) {

The condition is_array($definition) is always true.

            return false;
        }

        try {
            DefinitionValidator::validateArrayDefinition($definition);
        } catch (InvalidConfigException) {
            return false;
        }

        return is_subclass_of((string) ($definition['class'] ?? ''), MiddlewareInterface::class);
    }

    /**
     * @param array{0:class-string, 1:non-empty-string}|callable $callable

The doc comment array{0:class-string, 1:non-empty-string}|callable at position 4 could not be parsed: Unknown type name 'class-string' at position 4 in array{0:class-string, 1:non-empty-string}|callable.

     */
    private function wrapCallable(array|callable $callable): MiddlewareInterface
    {
        if (is_callable($callable)) {
            return $this->createCallableWrapper($callable);
        }

        return $this->createCallableWrapper([$this->container->get($callable[0]), $callable[1]]);
    }

    private function createCallableWrapper(callable $callback): MiddlewareInterface
    {
        return new class (
            $callback,
            $this->container,
            $this,
            $this->eventDispatcher,
            $this->parametersResolver,
        ) implements MiddlewareInterface {
            /** @var callable */
            private $callback;
            /**
             * @var ReflectionParameter[]
             * @psalm-var array<string,ReflectionParameter>
             */
            private array $callableParameters = [];
            public array $middlewares;

            public function __construct(
                callable $callback,
                private ContainerInterface $container,
                private MiddlewareFactory $middlewareFactory,
                private ?EventDispatcherInterface $eventDispatcher,
                private ?ParametersResolverInterface $parametersResolver
            ) {
                $this->callback = $callback;
                $callback = Closure::fromCallable($callback);

                $reflectionFunction = new ReflectionFunction($callback);

                $this->middlewares = array_map(
                    static fn (ReflectionAttribute $attribute) => $attribute->newInstance()->definition,
                    $reflectionFunction->getAttributes(Middleware::class)
                );
                $callableParameters = $reflectionFunction->getParameters();
                foreach ($callableParameters as $parameter) {
                    $this->callableParameters[$parameter->getName()] = $parameter;
                }
            }

            public function process(
                ServerRequestInterface $request,
                RequestHandlerInterface $handler
            ): ResponseInterface {
                $parameters = [$request, $handler];
                if ($this->parametersResolver !== null) {
                    $parameters = array_merge(
                        $parameters,
                        $this->parametersResolver->resolve($this->callableParameters, $request)
                    );
                }

                if ($this->middlewares !== []) {
                    $middlewares = [...$this->middlewares, fn() => ($this->callback)()];
                    $middlewareDispatcher = new MiddlewareDispatcher($this->middlewareFactory, $this->eventDispatcher);
                    $middlewareDispatcher = $middlewareDispatcher->withMiddlewares($middlewares);
                    $response = $middlewareDispatcher->dispatch($request, $handler);
                } else {
                    /** @var MiddlewareInterface|mixed|ResponseInterface $response */
                    $response = (new Injector($this->container))->invoke($this->callback, $parameters);
                }
                if ($response instanceof ResponseInterface) {
                    return $response;
                }
                if ($response instanceof MiddlewareInterface) {
                    return $response->process($request, $handler);
                }

                throw new InvalidMiddlewareDefinitionException($this->callback);
            }

            public function __debugInfo(): array
            {
                if (is_array($this->callback)
                    && isset($this->callback[0], $this->callback[1])
                    && is_object($this->callback[0])
                    && is_string($this->callback[1])
                ) {
                    return ['callback' => [$this->callback[0]::class, $this->callback[1]]];
                }
                return ['callback' => $this->callback];
            }
        };
    }
}