BEAR\Resource\Linker

Complexity

Total Complexity

50

Size/Duplication

Total Lines	325
Duplicated Lines	0 %

Importance

Changes	6
Bugs	0	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	invokeRecursive()	0	15	3
A	annotationRel()	0	18	3
A	getResponseBody()	0	6	2
B	crawl()	0	26	7
A	isList()	0	14	3
B	processBatchLinks()	0	37	9
A	isMultiColumnMultiRowList()	0	13	4
A	nextLink()	0	20	4
A	annotationCrawl()	0	19	4
A	isMultiColumnList()	0	3	2
A	invoke()	0	6	1
A	__construct()	0	5	1
A	isSingleColumnList()	0	3	2
A	annotationLink()	0	15	3
A	getBatchResolver()	0	8	2

<?php

declare(strict_types=1);

namespace BEAR\Resource;

use BEAR\Resource\Annotation\Link;
use BEAR\Resource\Batch\BatchResolverFactoryInterface;
use BEAR\Resource\Batch\BatchResolverInterface;
use BEAR\Resource\Batch\Requests;
use BEAR\Resource\Exception\LinkQueryException;
use BEAR\Resource\Exception\LinkRelException;
use BEAR\Resource\Exception\MethodException;
use BEAR\Resource\Exception\UriException;
use Override;
use Ray\Aop\ReflectionMethod;

use function array_filter;
use function array_key_exists;
use function array_keys;
use function array_pop;
use function array_values;
use function assert;
use function count;
use function is_array;
use function is_numeric;
use function ucfirst;
use function uri_template;

/**
 * @psalm-import-type Body from Types
 * @psalm-import-type BodyOrStringList from Types
 * @psalm-import-type ObjectList from Types
 * @psalm-import-type Query from Types
 * @psalm-import-type QueryList from Types
 */
final class Linker implements LinkerInterface
{
    /**
     * memory cache for linker
     *
     * @var Query

The type BEAR\Resource\Query was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private array $cache = [];

    /** @var array<class-string<BatchResolverInterface>, BatchResolverInterface> */

The doc comment array<class-string<BatchResolverInterface>, BatchResolverInterface> at position 2 could not be parsed: Unknown type name 'class-string' at position 2 in array<class-string<BatchResolverInterface>, BatchResolverInterface>.

    private array $batchResolverCache = [];

    public function __construct(
        private readonly InvokerInterface $invoker,
        private readonly FactoryInterface $factory,
        private readonly BatchResolverFactoryInterface|null $batchResolverFactory = null,
    ) {
    }

    /**
     * {@inheritDoc}
     */
    #[Override]
    public function invoke(AbstractRequest $request)
    {
        $this->cache = [];

It seems like array() of type array is incompatible with the declared type BEAR\Resource\Query of property $cache.

        return $this->invokeRecursive($request);
    }

    /**
     * @throws LinkQueryException
     * @throws LinkRelException
     */
    private function invokeRecursive(AbstractRequest $request): ResourceObject
    {
        $this->invoker->invoke($request);
        $current = clone $request->resourceObject;
        if ($current->code >= Code::BAD_REQUEST) {
            return $current;
        }

        foreach ($request->links as $link) {
            /** @var Body $nextBody */
            $nextBody = $this->annotationLink($link, $current, $request)->body;
            $current = $this->nextLink($link, $current, $nextBody);

$nextBody of type BEAR\Resource\Body is incompatible with the type array expected by parameter $nextResource of BEAR\Resource\Linker::nextLink().

        }

        return $current;
    }

    /**
     * @param Body $nextResource

The type BEAR\Resource\Body was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @return ResourceObject
     */
    private function nextLink(LinkType $link, ResourceObject $ro, array $nextResource): ResourceObject
    {
        /** @psalm-suppress MixedAssignment */
        $nextBody = $nextResource;

        if ($link->type === LinkType::SELF_LINK) {
            $ro->body = $nextBody;

            return $ro;
        }

        if ($link->type === LinkType::NEW_LINK) {
            assert(is_array($ro->body) || $ro->body === null);
            $ro->body[$link->key] = $nextBody;

            return $ro;
        }

        // crawl
        return $ro;
    }

    /**
     * Annotation link
     *
     * @throws MethodException
     * @throws LinkRelException
     * @throws Exception\LinkQueryException
     */
    private function annotationLink(LinkType $link, ResourceObject $current, AbstractRequest $request): ResourceObject
    {
        if (! is_array($current->body)) {
            throw new Exception\LinkQueryException('Only array is allowed for link in ' . $current::class, 500);
        }

        $classMethod = 'on' . ucfirst($request->method);
        /** @var list<Link> $annotations */
        $annotations = (new ReflectionMethod($current::class, $classMethod))->getAnnotations();
        if ($link->type === LinkType::CRAWL_LINK) {
            return $this->annotationCrawl($annotations, $link, $current);

$annotations of type BEAR\Resource\list is incompatible with the type array expected by parameter $annotations of BEAR\Resource\Linker::annotationCrawl().

        }

        /* @noinspection ExceptionsAnnotatingAndHandlingInspection */
        return $this->annotationRel($annotations, $link, $current);

$annotations of type BEAR\Resource\list is incompatible with the type array expected by parameter $annotations of BEAR\Resource\Linker::annotationRel().

    }

    /**
     * Annotation link (new, self)
     *
     * @param Link[] $annotations
     *
     * @throws UriException
     * @throws MethodException
     * @throws Exception\LinkQueryException
     * @throws Exception\LinkRelException
     */
    private function annotationRel(array $annotations, LinkType $link, ResourceObject $current): ResourceObject
    {
        /* @noinspection LoopWhichDoesNotLoopInspection */
        foreach ($annotations as $annotation) {
            if ($annotation->rel !== $link->key) {
                continue;
            }

            $uri = uri_template($annotation->href, (array) $current->body);
            $rel = $this->factory->newInstance($uri);
            /* @noinspection UnnecessaryParenthesesInspection */
            $query = (new Uri($uri))->query;
            $request = new Request($this->invoker, $rel, Request::GET, $query);

$query of type BEAR\Resource\Query is incompatible with the type array expected by parameter $query of BEAR\Resource\Request::__construct().

            return $this->invoker->invoke($request);
        }

        throw new LinkRelException("rel:{$link->key} class:" . $current::class, 500);
    }

    /**
     * Link annotation crawl
     *
     * @param ObjectList $annotations

The type BEAR\Resource\ObjectList was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @throws MethodException
     */
    private function annotationCrawl(array $annotations, LinkType $link, ResourceObject $current): ResourceObject
    {
        $isList = $this->isList($current->body);
        /** @var QueryList $bodyList */
        $bodyList = $isList ? (array) $current->body : [$current->body];

        // Process batch links first
        $this->processBatchLinks($annotations, $link, $bodyList);

$bodyList of type BEAR\Resource\QueryList is incompatible with the type array expected by parameter $bodyList of BEAR\Resource\Linker::processBatchLinks().

        // Process non-batch links
        foreach ($bodyList as &$body) {
            $this->crawl($annotations, $link, $body);
        }

        unset($body);
        /** @psalm-suppress PossiblyUndefinedArrayOffset */
        $current->body = $isList ? $bodyList : $bodyList[0];

        return $current;
    }

    /**
     * Process batch-enabled links
     *
     * @param ObjectList $annotations
     * @param QueryList  $bodyList

The type BEAR\Resource\QueryList was not found. Maybe you did not declare it correctly or list all dependencies?

     *
     * @param-out QueryList $bodyList
     */
    private function processBatchLinks(array $annotations, LinkType $link, array &$bodyList): void
    {
        if ($this->batchResolverFactory === null) {
            return;
        }

        // Group URIs by batch resolver class
        /** @var array<class-string<BatchResolverInterface>, array{annotation: Link, uris: array<int, string>}> $batchGroups */
        $batchGroups = [];

        foreach ($annotations as $annotation) {
            if (! $annotation instanceof Link || $annotation->crawl !== $link->key) {
                continue;
            }

            if ($annotation->batch === null) {
                continue;
            }

            /** @var class-string<BatchResolverInterface> $batchClass */
            $batchClass = $annotation->batch;
            $batchGroups[$batchClass] = ['annotation' => $annotation, 'uris' => []];

            foreach ($bodyList as $index => $body) {
                $uri = uri_template($annotation->href, $body);
                $batchGroups[$batchClass]['uris'][$index] = $uri;
            }
        }

        // Execute batch resolvers and distribute results
        foreach ($batchGroups as $batchClass => $group) {
            $resolver = $this->getBatchResolver($batchClass);
            $requests = new Requests(array_values($group['uris']));
            $results = $resolver($requests);

            foreach ($group['uris'] as $index => $uri) {
                $bodyList[$index][$group['annotation']->rel] = $results->get($uri);
            }
        }
    }

    /**
     * Get or create a batch resolver instance
     *
     * @param class-string<BatchResolverInterface> $class

The doc comment class-string<BatchResolverInterface> at position 0 could not be parsed: Unknown type name 'class-string' at position 0 in class-string<BatchResolverInterface>.

     */
    private function getBatchResolver(string $class): BatchResolverInterface
    {
        if (! isset($this->batchResolverCache[$class])) {
            assert($this->batchResolverFactory !== null);
            $this->batchResolverCache[$class] = $this->batchResolverFactory->create($class);
        }

        return $this->batchResolverCache[$class];
    }

    /**
     * @param ObjectList $annotations
     * @param Body       $body
     *
     * @throws LinkQueryException
     * @throws MethodException
     * @throws LinkRelException
     * @throws UriException
     *
     * @param-out Body $body
     */
    private function crawl(array $annotations, LinkType $link, array &$body): void
    {
        foreach ($annotations as $annotation) {
            if (! $annotation instanceof Link || $annotation->crawl !== $link->key) {
                continue;
            }

            // Skip batch-enabled links (already processed by processBatchLinks)
            if ($annotation->batch !== null && $this->batchResolverFactory !== null) {
                continue;
            }

            $uri = uri_template($annotation->href, $body);
            $rel = $this->factory->newInstance($uri);
            /* @noinspection UnnecessaryParenthesesInspection */
            $query = (new Uri($uri))->query;
            $request = new Request($this->invoker, $rel, Request::GET, $query, [$link], $this);

$query of type BEAR\Resource\Query is incompatible with the type array expected by parameter $query of BEAR\Resource\Request::__construct().

            $hash = $request->hash();
            if (array_key_exists($hash, $this->cache)) {
                /** @var Body $cachedResponse */
                $cachedResponse = $this->cache[$hash];
                $body[$annotation->rel] = $cachedResponse;
                continue;
            }

            $this->cache[$hash] = $body[$annotation->rel] = $this->getResponseBody($request);
        }
    }

    /** @return Body|null */
    private function getResponseBody(Request $request): array|null
    {
        $body = $this->invokeRecursive($request)->body;
        assert(is_array($body) || $body === null);

        return $body;
    }

    private function isList(mixed $value): bool
    {
        assert(is_array($value));
        /** @var BodyOrStringList $list */
        $list = $value;
        /** @var Body $firstRow */
        $firstRow = array_pop($list);

$list of type BEAR\Resource\BodyOrStringList is incompatible with the type array expected by parameter $array of array_pop().

        /** @var Query|string $firstRow */
        $keys = array_keys((array) $firstRow);
        $isMultiColumnMultiRowList = $this->isMultiColumnMultiRowList($keys, $list);
        $isMultiColumnList = $this->isMultiColumnList($value, $firstRow);
        $isSingleColumnList = $this->isSingleColumnList($value, $keys, $list);

        return $isSingleColumnList || $isMultiColumnMultiRowList || $isMultiColumnList;
    }

    /**
     * @param list<array-key>  $keys

The type BEAR\Resource\list was not found. Maybe you did not declare it correctly or list all dependencies?

     * @param BodyOrStringList $list

The type BEAR\Resource\BodyOrStringList was not found. Maybe you did not declare it correctly or list all dependencies?

     */
    private function isMultiColumnMultiRowList(array $keys, array $list): bool
    {
        if ($keys === [0 => 0]) {
            return false;
        }

        foreach ($list as $item) {
            if ($keys !== array_keys((array) $item)) {
                return false;
            }
        }

        return true;
    }

    /**
     * @param Body $value
     * @psalm-param Query|scalar $firstRow
     */
    private function isMultiColumnList(array $value, mixed $firstRow): bool
    {
        return is_array($firstRow) && array_filter(array_keys($value), is_numeric(...)) === array_keys($value);

The type is_numeric was not found. Maybe you did not declare it correctly or list all dependencies?

    }

    /**
     * @param Body            $value
     * @param list<array-key> $keys
     * @param Body            $list
     */
    private function isSingleColumnList(array $value, array $keys, array $list): bool
    {
        return (count($value) === 1) && $keys === array_keys($list);
    }
}