TheCodingMachine\GraphQLite\Types\JSONScalar\JSONScalarTypeMapper

Complexity

Total Complexity

14

Size/Duplication

Total Lines	78
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	1

6 Methods

Rating	Name	Duplication	Size	Complexity
A	toGraphQLInputType()	0	11	2
A	matchReturnType()	0	6	2
A	mapNameToType()	0	6	2
A	matchInputType()	0	13	5
A	toGraphQLOutputType()	0	10	2
A	__construct()	0	3	1

<?php

namespace TheCodingMachine\GraphQLite\Types\JSONScalar;

use GraphQL\Type\Definition\InputType;
use GraphQL\Type\Definition\NamedType;
use GraphQL\Type\Definition\OutputType;
use phpDocumentor\Reflection\DocBlock;
use phpDocumentor\Reflection\Type;
use ReflectionMethod;
use ReflectionProperty;
use TheCodingMachine\GraphQLite\Mappers\Root\RootTypeMapperInterface;

class JSONScalarTypeMapper implements RootTypeMapperInterface
{
    /** @var RootTypeMapperInterface */
    private $next;

    public function __construct(RootTypeMapperInterface $next)
    {
        $this->next = $next;
    }

    public function toGraphQLOutputType(
        Type $type,
        ?OutputType $subType,
        $reflector,
        DocBlock $docBlockObj
    ): OutputType {
        if ($this->matchReturnType($docBlockObj)) {
            return JSONScalarType::getInstance();
        }
        return  $this->next->toGraphQLOutputType($type, $subType, $reflector, $docBlockObj);
    }

    public function toGraphQLInputType(
        Type $type,
        ?InputType $subType,
        string $argumentName,
        $reflector,
        DocBlock $docBlockObj
    ): InputType {
        if ($this->matchInputType($argumentName, $reflector, $docBlockObj)) {
            return JSONScalarType::getInstance();
        }
        return $this->next->toGraphQLInputType($type, $subType, $argumentName, $reflector, $docBlockObj);
    }

    /**
     * @param string $typeName The name of the GraphQL type
     * @return NamedType
     */
    public function mapNameToType(string $typeName): NamedType
    {
        if ($typeName === JSONScalarType::NAME) {
            return JSONScalarType::getInstance();
        }
        return $this->next->mapNameToType($typeName);
    }

    /**
     * @param DocBlock $docBlockObj
     * @return bool
     */
    private function matchReturnType(DocBlock $docBlockObj): bool
    {
        $paramText = $docBlockObj->hasTag('return') ?
            $docBlockObj->getTagsByName('return')[0]->__toString() :
            null;
        return strpos($paramText, JSONScalarType::NAME) > 0;

It seems like $paramText can also be of type null; however, parameter $haystack of strpos() does only seem to accept string, maybe add an additional type check?

    }

    /**
     * @param string $argumentName
     * @param ReflectionMethod|ReflectionProperty $reflector
     * @param DocBlock $docBlockObj
     * @return bool
     */
    private function matchInputType(string $argumentName, $reflector, DocBlock $docBlockObj): bool
    {
        $params = $docBlockObj->getTagsByName('param');
        for ($i = 0; $i < count($params); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $paramText = $params[$i]->__toString();
            if ($reflector instanceof ReflectionMethod) {
                $refParams = $reflector->getParameters();
                if (strpos($paramText, JSONScalarType::NAME) > 0 && $refParams[$i]->getName() === $argumentName) {
                    return true;
                }
            }
        }
        return false;
    }
}