Ynlo\GraphQLBundle\Definition\Loader\Annotation\FieldConnectionAnnotationParser

Complexity

Total Complexity

12

Size/Duplication

Total Lines	100
Duplicated Lines	24 %

Test Coverage

Coverage

10%

Importance

Changes

0

3 Methods

Rating	Name	Duplication	Size	Complexity
C	parse()	24	67	10
A	__construct()	0	3	1
A	supports()	0	3	1

<?php
/*******************************************************************************
 *  This file is part of the GraphQL Bundle package.
 *
 *  (c) YnloUltratech <support@ynloultratech.com>
 *
 *  For the full copyright and license information, please view the LICENSE
 *  file that was distributed with this source code.
 ******************************************************************************/

namespace Ynlo\GraphQLBundle\Definition\Loader\Annotation;

use Ynlo\GraphQLBundle\Annotation;
use Ynlo\GraphQLBundle\Definition\ArgumentDefinition;
use Ynlo\GraphQLBundle\Definition\ConnectionDefinitionBuilder;
use Ynlo\GraphQLBundle\Definition\FieldDefinition;
use Ynlo\GraphQLBundle\Definition\Registry\DefinitionManager;
use Ynlo\GraphQLBundle\Util\TypeUtil;

/**
 * Resolve field of types queries using naming conventions
 */
class FieldConnectionAnnotationParser implements AnnotationParserInterface
{
    use AnnotationReaderAwareTrait;

    /**
     * @var ConnectionDefinitionBuilder
     */
    protected $connectionBuilder;

    /**
     * @var DefinitionManager
     */
    protected $definitionManager;

    /**
     * @param ConnectionDefinitionBuilder $connectionBuilder
     */
    public function __construct(ConnectionDefinitionBuilder $connectionBuilder)
    {
        $this->connectionBuilder = $connectionBuilder;
    }

    /**
     * {@inheritdoc}
     */
    public function supports($annotation): bool
    {
        return $annotation instanceof Annotation\Field;
    }

    /**
     * {@inheritdoc}
     */
    public function parse($annotation, \ReflectionClass $refClass, DefinitionManager $definitionManager)
    {
        $this->definitionManager = $definitionManager;

        /** @var Annotation\Field $annotation */
        $field = new FieldDefinition();

        if (!$refClass->hasMethod('__invoke')) {
            throw new \LogicException(sprintf('The class %s should have "__invoke" method to resolve field valued', $refClass->getName()));
        }

        if ($annotation->name) {
            $field->setName($annotation->name);
        } else {
            preg_match('/\w+$/', $refClass->getName(), $matches);
            $field->setName(lcfirst($matches[0] ?? ''));
        }

        $objectType = null;

The assignment to $objectType is dead and can be removed.

        preg_match('/(\w+)\\\\Field\\\\(\w+)$/', $refClass->getName(), $matches);
        if (!isset($matches[1]) || !$definitionManager->hasType($matches[1])) {

This code seems to be duplicated across your project.

            $error = sprintf('Can`t resolve a valid object type for field "%s"', $refClass->getName());
            throw new \RuntimeException($error);
        }

        $objectDefinition = $definitionManager->getType($matches[1]);
        if ($objectDefinition->hasField($field->getName())) {
            $field = $objectDefinition->getField($field->getName());
        } else {
            $objectDefinition->addField($field);
        }

        $argAnnotations = $this->reader->getClassAnnotations($refClass);
        foreach ($argAnnotations as $argAnnotation) {

This code seems to be duplicated across your project.

            if ($argAnnotation instanceof Annotation\Argument) {
                $arg = new ArgumentDefinition();
                $arg->setName($argAnnotation->name);
                $arg->setDescription($argAnnotation->description);
                $arg->setInternalName($argAnnotation->internalName);
                $arg->setDefaultValue($argAnnotation->defaultValue);
                $arg->setType(TypeUtil::normalize($argAnnotation->type));
                $arg->setList(TypeUtil::isTypeList($argAnnotation->type));
                $arg->setNonNullList(TypeUtil::isTypeNonNullList($argAnnotation->type));
                $arg->setNonNull(TypeUtil::isTypeNonNull($argAnnotation->type));
                $field->addArgument($arg);
            }
        }

        $field->setDeprecationReason($annotation->deprecationReason ?? $field->getDeprecationReason());
        $field->setDescription($annotation->description ?? $field->getDescription());
        $field->setType(TypeUtil::normalize($annotation->type) ?? $field->getType());

        if ($annotation->type) {
            $field->setList(TypeUtil::isTypeList($annotation->type));
            $field->setNonNull(TypeUtil::isTypeNonNull($annotation->type));
            $field->setNonNullList(TypeUtil::isTypeNonNullList($annotation->type));
        }

        $field->setResolver($refClass->getName());

        /** @var Annotation\Connection $connection */
        if ($connection = $this->reader->getClassAnnotation($refClass, Annotation\Connection::class)) {

This code seems to be duplicated across your project.

            $this->connectionBuilder->setEndpoint($this->definitionManager->getEndpoint());
            $this->connectionBuilder->setLimit($connection->limit);
            $this->connectionBuilder->setParentField($connection->parentField);
            $this->connectionBuilder->build($field, $field->getType());
            $field->setResolver($refClass->getName());
        }
    }
}