BEAR\Resource\Options\OptionsMethods

Complexity

Total Complexity

25

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getMethodExtras()	0	17	4
A	getInMap()	0	17	2
A	__construct()	0	5	1
A	getJsonSchema()	0	16	3
A	getInsFromMethodAnnotations()	0	16	4
A	getInsFromParameterAttributes()	0	20	4
A	mergeParameterMetas()	0	18	3
A	__invoke()	0	23	4

<?php

declare(strict_types=1);

namespace BEAR\Resource\Options;

use BEAR\Resource\Annotation\Embed;
use BEAR\Resource\Annotation\JsonSchema;
use BEAR\Resource\Annotation\Link;
use BEAR\Resource\ResourceObject;
use Ray\Aop\ReflectionMethod;
use Ray\Di\Di\Named;
use Ray\WebContextParam\Annotation\AbstractWebContextParam;
use Ray\WebContextParam\Annotation\CookieParam;
use Ray\WebContextParam\Annotation\EnvParam;
use Ray\WebContextParam\Annotation\FilesParam;
use Ray\WebContextParam\Annotation\FormParam;
use Ray\WebContextParam\Annotation\QueryParam;
use Ray\WebContextParam\Annotation\ServerParam;

use function array_merge;
use function array_unique;
use function array_values;
use function assert;
use function file_exists;
use function file_get_contents;
use function json_decode;

use const JSON_THROW_ON_ERROR;

/**
 * @psalm-type WebContextKey = class-string<AbstractWebContextParam>
 * @psalm-type WebContextValue = 'cookie'|'env'|'formData'|'query'|'server'|'files'
 * @psalm-type OptionParamDoc = array{description?: string, embed?: mixed, links?: mixed, request?: mixed, schema?: mixed, summary?: string}
 * @psalm-import-type OptionMethodMeta from InputParamMetaInterface
 */
final class OptionsMethods
{
    /**
     * Constants for annotation name and "in" name
     */
    private const WEB_CONTEXT_NAME = [
        CookieParam::class => 'cookie',
        EnvParam::class => 'env',
        FormParam::class => 'formData',
        QueryParam::class => 'query',
        ServerParam::class => 'server',
        FilesParam::class => 'files',
    ];

    public function __construct(
        private readonly InputParamMetaInterface $inputParamMeta,
        #[Named('json_schema_dir')]
        private readonly string $schemaDir = '',
    ) {
    }

    /** @return OptionParamDoc */

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

    public function __invoke(ResourceObject $ro, string $requestMethod): array
    {
        $method = new ReflectionMethod($ro::class, 'on' . $requestMethod);
        $ins = $this->getInMap($method);
        [$doc, $paramDoc] = (new OptionsMethodDocBolck())($method);
        $methodOption = $doc;
        $paramMetas = (new OptionsMethodRequest())($method, $paramDoc, $ins);
        $inputMetas = $this->inputParamMeta->get($method);
        $paramMetas = $this->mergeParameterMetas($paramMetas, $inputMetas);
        $schema = $this->getJsonSchema($method);
        $request = $paramMetas ? ['request' => $paramMetas] : [];
        $methodOption += $request;
        if (! empty($schema)) {
            $methodOption += ['schema' => $schema];
        }

        $extras = $this->getMethodExtras($method);
        if (! empty($extras)) {
            $methodOption += $extras;
        }

        /** @var OptionParamDoc $methodOption */
        return $methodOption;

The expression return $methodOption returns the type BEAR\Resource\Options\OptionParamDoc which is incompatible with the type-hinted return array.

    }

    /**
     * @return (Embed|Link)[][]
     * @psalm-return array{links?: non-empty-list<Link>, embed?: non-empty-list<Embed>}
     * @phpstan-return (Embed|Link)[][]
     */
    private function getMethodExtras(ReflectionMethod $method): array
    {
        $extras = [];
        $annotations = $method->getAnnotations();
        foreach ($annotations as $annotation) {
            if ($annotation instanceof Link) {
                $extras['links'][] = $annotation;
            }

            if (! ($annotation instanceof Embed)) {
                continue;
            }

            $extras['embed'][] = $annotation;
        }

        return $extras;
    }

    /** @return array<string, string> */
    private function getInMap(ReflectionMethod $method): array
    {
        $ins = [];
        bc_for_annotation: {
            // @codeCoverageIgnoreStart
            $annotations = $method->getAnnotations();
            $ins = $this->getInsFromMethodAnnotations($annotations, $ins);
        if ($ins) {
            return $ins;
        }
            // @codeCoverageIgnoreEnd
        }

        /** @var array<string, string> $insParam */
        $insParam = $this->getInsFromParameterAttributes($method, $ins);

        return $insParam;
    }

    /** @return array<string, mixed> */
    private function getJsonSchema(ReflectionMethod $method): array
    {
        $schema = $method->getAnnotation(JsonSchema::class);
        if (! $schema instanceof JsonSchema) {
            return [];
        }

        $schemaFile = $this->schemaDir . '/' . $schema->schema;
        if (! file_exists($schemaFile)) {
            return [];
        }

        /** @var array<string, mixed> $schema */
        $schema = (array) json_decode((string) file_get_contents($schemaFile), null, 512, JSON_THROW_ON_ERROR);

        return $schema;
    }

    /**
     * @param array<object>         $annotations
     * @param array<string, string> $ins
     *
     * @return array<string, string>
     *
     * @codeCoverageIgnore BC for annotation
     */
    public function getInsFromMethodAnnotations(array $annotations, array $ins): array
    {
        foreach ($annotations as $annotation) {
            if (! ($annotation instanceof AbstractWebContextParam)) {
                continue;
            }

            $class = $annotation::class;
            if (! isset(self::WEB_CONTEXT_NAME[$class])) {
                continue;
            }

            $ins[$annotation->param] = self::WEB_CONTEXT_NAME[$class];
        }

        return $ins;
    }

    /**
     * @param array<string, string> $ins
     *
     * @return array<string, string>
     */
    public function getInsFromParameterAttributes(ReflectionMethod $method, array $ins): array|null
    {
        $parameters = $method->getParameters();
        foreach ($parameters as $parameter) {
            $attributes = $parameter->getAttributes();
            foreach ($attributes as $attribute) {
                $instance = $attribute->newInstance();
                if (! ($instance instanceof AbstractWebContextParam)) {
                    continue;
                }

                $class = $instance::class;
                assert(isset(self::WEB_CONTEXT_NAME[$class]), 'WebContextParam annotation must be one of the known types');

                $webContextName = self::WEB_CONTEXT_NAME[$class];
                $ins[$parameter->name] = $webContextName;
            }
        }

        return $ins;
    }

    /**
     * Merge parameter metadata from OptionsMethodRequest and InputParamMeta
     *
     * @param OptionMethodMeta $regularParams
     * @param OptionMethodMeta $inputParams

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

     *
     * @return OptionMethodMeta
     */
    private function mergeParameterMetas(array $regularParams, array $inputParams): array
    {
        $regularParameters = $regularParams['parameters'] ?? [];
        $inputParameters   = $inputParams['parameters'] ?? [];

        $regularRequired = $regularParams['required'] ?? [];
        $inputRequired   = $inputParams['required'] ?? [];

        $parameters = array_merge($regularParameters, $inputParameters);
        $required = array_values(array_unique(array_merge($regularRequired, $inputRequired)));

        if ($parameters === [] && $required === []) {
            return [];

The expression return array() returns the type array which is incompatible with the documented return type BEAR\Resource\Options\OptionMethodMeta.

        }

        return [

The expression return array('parameters' => $parameters, 'required' => $required) returns the type array<string,array> which is incompatible with the documented return type BEAR\Resource\Options\OptionMethodMeta.

            'parameters' => $parameters,
            'required'   => $required,
        ];
    }
}