Spiral\Router\CoreHandler

Complexity

Total Complexity

19

Size/Duplication

Total Lines	179
Duplicated Lines	0 %

Test Coverage

Coverage

98.86%

Importance

Changes	1
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	withVerbActions()	0	6	1
B	handle()	0	61	6
A	mapException()	0	9	1
A	__construct()	0	8	1
A	withContext()	0	8	1
A	checkValues()	0	4	2
B	wrapResponse()	0	24	7

<?php

declare(strict_types=1);

namespace Spiral\Router;

use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Psr\Http\Server\RequestHandlerInterface;
use Spiral\Core\CoreInterface;
use Spiral\Core\ScopeInterface;
use Spiral\Http\Exception\ClientException;
use Spiral\Http\Exception\ClientException\BadRequestException;
use Spiral\Http\Exception\ClientException\ForbiddenException;
use Spiral\Http\Exception\ClientException\NotFoundException;
use Spiral\Http\Exception\ClientException\ServerErrorException;
use Spiral\Http\Exception\ClientException\UnauthorizedException;
use Spiral\Http\Stream\GeneratorStream;
use Spiral\Http\Traits\JsonTrait;
use Spiral\Interceptors\Context\CallContext;
use Spiral\Interceptors\Context\Target;
use Spiral\Interceptors\Exception\TargetCallException;
use Spiral\Interceptors\HandlerInterface;
use Spiral\Router\Exception\HandlerException;
use Spiral\Telemetry\NullTracer;
use Spiral\Telemetry\TracerInterface;

final class CoreHandler implements RequestHandlerInterface
{
    use JsonTrait;

    private readonly TracerInterface $tracer;

    /** @readonly */
    private ?string $controller = null;
    /** @readonly */
    private ?string $action = null;
    /** @readonly */
    private ?bool $verbActions = null;
    /** @readonly */
    private ?array $parameters = null;

    private bool $isLegacyPipeline;

    public function __construct(
        private readonly HandlerInterface|CoreInterface $core,
        private readonly ScopeInterface $scope,
        private readonly ResponseFactoryInterface $responseFactory,
        ?TracerInterface $tracer = null
    ) {
        $this->tracer = $tracer ?? new NullTracer($scope);

The property tracer is declared read-only in Spiral\Router\CoreHandler.

        $this->isLegacyPipeline = !$core instanceof HandlerInterface;
    }

    /**
     * @mutation-free
     */
    public function withContext(string $controller, string $action, array $parameters): CoreHandler
    {
        $handler = clone $this;
        $handler->controller = $controller;
        $handler->action = $action;
        $handler->parameters = $parameters;

        return $handler;
    }

    /**
     * Disable or enable HTTP prefix for actions.
     *
     * @mutation-free
     */
    public function withVerbActions(bool $verbActions): CoreHandler
    {
        $handler = clone $this;
        $handler->verbActions = $verbActions;

        return $handler;
    }

    /**
     * @psalm-suppress UnusedVariable
     * @throws \Throwable
     */
    public function handle(Request $request): Response
    {
        $this->checkValues();
        $controller = $this->controller;
        $parameters = $this->parameters;

        $outputLevel = \ob_get_level();
        \ob_start();

        $result = null;
        $output = '';

        $response = $this->responseFactory->createResponse(200);
        try {
            $action = $this->verbActions
                ? \strtolower($request->getMethod()) . \ucfirst($this->action)

It seems like $this->action can also be of type null; however, parameter $string of ucfirst() does only seem to accept string, maybe add an additional type check?

                : $this->action;

            // run the core withing PSR-7 Request/Response scope
            $result = $this->scope->runScope(
                [
                    Request::class  => $request,
                    Response::class => $response,
                ],
                fn (): mixed => $this->tracer->trace(
                    name: 'Controller [' . $controller . ':' . $action . ']',
                    callback: $this->isLegacyPipeline
                        ? fn (): mixed => $this->core->callAction(

The method callAction() does not exist on Spiral\Interceptors\HandlerInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Spiral\Interceptors\Handler\ReflectionHandler or Spiral\Interceptors\Handler\InterceptorPipeline. Are you sure you never get one of those?

                            controller: $controller,

It seems like $controller can also be of type null; however, parameter $controller of Spiral\Core\CoreInterface::callAction() does only seem to accept string, maybe add an additional type check?

                            action: $action,

It seems like $action can also be of type null; however, parameter $action of Spiral\Core\CoreInterface::callAction() does only seem to accept string, maybe add an additional type check?

                            parameters: $parameters,

It seems like $parameters can also be of type null; however, parameter $parameters of Spiral\Core\CoreInterface::callAction() does only seem to accept array, maybe add an additional type check?

                        )
                        : fn (): mixed => $this->core->handle(

The method handle() does not exist on Spiral\Core\CoreInterface. It seems like you code against a sub-type of said class. However, the method does not exist in Spiral\Console\CommandCore or Spiral\Events\Interceptor\Core. Are you sure you never get one of those?

                            new CallContext(
                                Target::fromPair($controller, $action),

It seems like $action can also be of type null; however, parameter $action of Spiral\Interceptors\Context\Target::fromPair() does only seem to accept string, maybe add an additional type check?

It seems like $controller can also be of type null; however, parameter $controller of Spiral\Interceptors\Context\Target::fromPair() does only seem to accept string, maybe add an additional type check?

                                $parameters,

It seems like $parameters can also be of type null; however, parameter $arguments of Spiral\Interceptors\Context\CallContext::__construct() does only seem to accept array, maybe add an additional type check?

                            ),
                        ),
                    attributes: [
                        'route.controller' => $this->controller,
                        'route.action' => $action,
                        'route.parameters' => \array_keys($parameters),

It seems like $parameters can also be of type null; however, parameter $array of array_keys() does only seem to accept array, maybe add an additional type check?

                    ]
                )
            );
        } catch (TargetCallException $e) {
            \ob_get_clean();
            throw $this->mapException($e);
        } catch (\Throwable $e) {
            \ob_get_clean();
            throw $e;
        } finally {
            while (\ob_get_level() > $outputLevel + 1) {
                $output = \ob_get_clean() . $output;
            }
        }

        return $this->wrapResponse(
            $response,
            $result,
            \ob_get_clean() . $output,
        );
    }

    /**
     * Convert endpoint result into valid response.
     *
     * @param Response $response Initial pipeline response.
     * @param mixed    $result   Generated endpoint output.
     * @param string   $output   Buffer output.
     */
    private function wrapResponse(Response $response, mixed $result = null, string $output = ''): Response
    {
        if ($result instanceof Response) {
            if ($output !== '' && $result->getBody()->isWritable()) {
                $result->getBody()->write($output);
            }

            return $result;
        }

        if ($result instanceof \Generator) {
            return $response->withBody(new GeneratorStream($result));
        }

        if (\is_array($result) || $result instanceof \JsonSerializable) {
            $response = $this->writeJson($response, $result);
        } else {
            $response->getBody()->write((string)$result);
        }

        //Always glue buffered output
        $response->getBody()->write($output);

        return $response;
    }

    /**
     * Converts core specific ControllerException into HTTP ClientException.
     */
    private function mapException(TargetCallException $exception): ClientException
    {
        return match ($exception->getCode()) {
            TargetCallException::BAD_ACTION,
            TargetCallException::NOT_FOUND => new NotFoundException('Not found', $exception),
            TargetCallException::FORBIDDEN => new ForbiddenException('Forbidden', $exception),
            TargetCallException::UNAUTHORIZED => new UnauthorizedException('Unauthorized', $exception),
            TargetCallException::INVALID_CONTROLLER => new ServerErrorException('Server error', $exception),
            default => new BadRequestException('Bad request', $exception),
        };
    }

    /**
     * @psalm-assert !null $this->controller
     * @psalm-assert !null $this->action
     * @psalm-assert !null $this->parameters
     * @mutation-free
     */
    private function checkValues(): void
    {
        if ($this->controller === null) {
            throw new HandlerException('Controller and action pair are not set.');
        }
    }
}