Spiral\Router\Traits\PipelineTrait

Complexity

Total Complexity

10

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Test Coverage

Coverage

70.37%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	makeLazyPipeline()	0	9	2
A	makePipeline()	0	9	2
A	withMiddleware()	0	19	5
A	withPipeline()	0	8	1

<?php

declare(strict_types=1);

namespace Spiral\Router\Traits;

use Psr\Container\ContainerExceptionInterface;
use Psr\Http\Server\MiddlewareInterface;
use Spiral\Core\Container\Autowire;
use Spiral\Http\LazyPipeline;
use Spiral\Http\Pipeline;
use Spiral\Router\Exception\RouteException;
use Spiral\Router\PipelineFactory;
use Spiral\Router\RouteInterface;

/**
 * @psalm-type MiddlewareType = MiddlewareInterface|class-string<MiddlewareInterface>|non-empty-string|Autowire
 */
trait PipelineTrait
{
    use ContainerTrait;

    protected Pipeline|LazyPipeline|null $pipeline = null;

    /** @psalm-var array<array-key, MiddlewareType> */
    protected array $middleware = [];

    /**
     * Associated middleware with route. New instance of route will be returned.
     *
     * Example:
     * $route->withMiddleware(new CacheMiddleware(100));
     * $route->withMiddleware(ProxyMiddleware::class);
     * $route->withMiddleware(ProxyMiddleware::class, OtherMiddleware::class);
     * $route->withMiddleware([ProxyMiddleware::class, OtherMiddleware::class]);
     *
     * @param MiddlewareType|array{0:MiddlewareType[]} ...$middleware

The type Spiral\Router\Traits\MiddlewareType was not found. Maybe you did not declare it correctly or list all dependencies?

     * @return RouteInterface|$this
     *
     * @throws RouteException
     */
    public function withMiddleware(...$middleware): RouteInterface
    {
        $route = clone $this;

        // array fallback
        if (\count($middleware) === 1 && \is_array($middleware[0])) {
            $middleware = $middleware[0];
        }

        /** @var MiddlewareType[] $middleware */
        foreach ($middleware as $item) {
            $route->middleware[] = $item;
        }

        if ($route->pipeline !== null) {
            $route->pipeline = $route->makeLazyPipeline();
        }

        return $route;
    }

    public function withPipeline(Pipeline $pipeline): static
    {
        $route = clone $this;

        $route->middleware = [$pipeline];
        $route->pipeline = $pipeline;

        return $route;
    }

    /**
     * Get associated route pipeline.
     *
     * @throws RouteException
     *
     * @deprecated Will be removed in Spiral v4.0. Use {@see makeLazyPipeline()} instead.
     */
    protected function makePipeline(): Pipeline
    {
        \assert($this->container !== null);
        try {
            return $this->container
                ->get(PipelineFactory::class)
                ->createWithMiddleware($this->middleware);
        } catch (ContainerExceptionInterface $e) {
            throw new RouteException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * Get associated route pipeline.
     *
     * @throws RouteException
     */
    protected function makeLazyPipeline(): LazyPipeline
    {
        \assert($this->container !== null);
        try {
            /** @var LazyPipeline $pipeline */
            $pipeline = $this->container->get(LazyPipeline::class);
            return $pipeline->withMiddleware(...$this->middleware);
        } catch (ContainerExceptionInterface $e) {
            throw new RouteException($e->getMessage(), $e->getCode(), $e);
        }
    }
}