Andi\GraphQL\Common\LazyTypeByReflectionType

Complexity

Total Complexity

23

Size/Duplication

Total Lines	106
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	__invoke()	0	11	3
A	__construct()	0	5	1
B	getTypeFromReflectionNamedType()	0	27	7
C	getTypeFromReflectionUnionType()	0	52	12

<?php

declare(strict_types=1);

namespace Andi\GraphQL\Common;

use Andi\GraphQL\Exception\CantResolveGraphQLTypeException;
use Andi\GraphQL\TypeRegistryInterface;
use GraphQL\Type\Definition as Webonyx;
use ReflectionNamedType;
use ReflectionType;
use ReflectionUnionType;
use UnhandledMatchError;

class LazyTypeByReflectionType
{
    public function __construct(
        private readonly ReflectionType $type,
        private readonly TypeRegistryInterface $typeRegistry,
        private readonly string $selfClassName,
    ) {
    }

    public function __invoke(): Webonyx\Type
    {
        if ($this->type instanceof ReflectionNamedType) {
            return $this->getTypeFromReflectionNamedType();
        }

        if ($this->type instanceof ReflectionUnionType) {
            return $this->getTypeFromReflectionUnionType();
        }

        throw new CantResolveGraphQLTypeException('Can\'t resolve GraphQL type from ReflectionType');
    }

    private function getTypeFromReflectionNamedType(): Webonyx\Type
    {
        assert($this->type instanceof ReflectionNamedType);
        if ($this->type->isBuiltin()) {
            try {
                $type = match ($this->type->getName()) {

The method getName() does not exist on ReflectionType. It seems like you code against a sub-type of ReflectionType such as ReflectionNamedType.

                    'int' => $this->typeRegistry->get(Webonyx\IntType::class),
                    'string' => $this->typeRegistry->get(Webonyx\StringType::class),
                    'bool', 'true', 'false'   => $this->typeRegistry->get(Webonyx\BooleanType::class),
                    'float' => $this->typeRegistry->get(Webonyx\FloatType::class),
                };
            } catch (UnhandledMatchError $exception) {
                $message = 'Can\'t resolve GraphQL type from ReflectionType';
                throw new CantResolveGraphQLTypeException($message, 0, $exception);
            }
        } else {
            $name = $this->type->getName();

            /** @psalm-suppress TypeDoesNotContainType */
            $type = 'self' === $name || 'static' === $name
                ? $this->typeRegistry->get($this->selfClassName)
                : $this->typeRegistry->get($name);
        }

        return !$this->type->allowsNull() && $type instanceof Webonyx\NullableType
            ? Webonyx\Type::nonNull($type)
            : $type;
    }

    /**
     * @return Webonyx\Type
     */
    private function getTypeFromReflectionUnionType(): Webonyx\Type
    {
        $names = [];
        $types = [];
        $allowsNull = false;
        assert($this->type instanceof ReflectionUnionType);
        foreach ($this->type->getTypes() as $type) {

The method getTypes() does not exist on ReflectionType. It seems like you code against a sub-type of ReflectionType such as ReflectionUnionType.

            assert($type instanceof ReflectionNamedType);
            if ($type->isBuiltin()) {
                $allowsNull = 'null' === $type->getName()
                    || throw new CantResolveGraphQLTypeException('UnionType must contains only ObjectTypes');

                continue;
            }

            $name = $type->getName();
            if ($this->typeRegistry->has($name)) {
                $gqlType = $this->typeRegistry->get($name);

                if (! $gqlType instanceof Webonyx\ObjectType) {
                    throw new CantResolveGraphQLTypeException('UnionType must contains only ObjectTypes');
                }

                $names[] = (string) $gqlType;
                $types[] = $name;
            } else {
                throw new CantResolveGraphQLTypeException(sprintf('Undefined ObjectType "%s" for UnionType', $name));
            }
        }

        sort($names);
        $name = implode('', $names) . 'UnionType';

        if ($this->typeRegistry->has($name)) {
            $existsType = $this->typeRegistry->get($name);

            return !$this->type->allowsNull() && !$allowsNull && $existsType instanceof Webonyx\NullableType
                ? Webonyx\Type::nonNull($existsType)
                : $existsType;
        }

        $unionType = new Webonyx\UnionType([
            'name'        => $name,
            'types'       => new LazyTypeIterator(fn() => $types, $this->typeRegistry),
            'resolveType' => new ResolveType($this->typeRegistry),
        ]);

        $this->typeRegistry->register($unionType);

        return $this->type->allowsNull() || $allowsNull
            ? $unionType
            : Webonyx\Type::nonNull($unionType);
    }
}