#27275

pending completion

Build # #27275

Build Type

push

github

Committed by

web-flow

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/f3b2c750a5f8922c6dbf8ea94608e147c5cf81f4">f3b2c750a<a href="https://github.com/api-platform/core/commit/f3b2c750a5f8922c6dbf8ea94608e147c5cf81f4">">Merge </a><a class="double-link" href="https://github.com/api-platform/core/commit/<a class="double-link" href="https://github.com/api-platform/core/commit/62232b7603a5733301eb5b1b226e6893b8d033cb">62232b760</a>">62232b760</a><a href="https://github.com/api-platform/core/commit/f3b2c750a5f8922c6dbf8ea94608e147c5cf81f4"> into cd198d20b">cd198d20b</a>

Run Details

422 of 422 new or added lines in 36 files covered. (100.0%)

10250 of 12298 relevant lines covered (83.35%)

14.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.49

/src/GraphQl/Type/TypeConverter.php

<?php

/*
 * This file is part of the API Platform project.
 *
 * (c) Kévin Dunglas <dunglas@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace ApiPlatform\Core\GraphQl\Type;

use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\Exception\ResourceClassNotFoundException;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use GraphQL\Error\SyntaxError;
use GraphQL\Language\AST\ListTypeNode;
use GraphQL\Language\AST\NamedTypeNode;
use GraphQL\Language\AST\NonNullTypeNode;
use GraphQL\Language\AST\TypeNode;
use GraphQL\Language\Parser;
use GraphQL\Type\Definition\NullableType;
use GraphQL\Type\Definition\Type as GraphQLType;
use Symfony\Component\PropertyInfo\Type;

/**
 * Converts a type to its GraphQL equivalent.
 *
 * @experimental
 *
 * @author Alan Poulain <contact@alanpoulain.eu>
 */
final class TypeConverter implements TypeConverterInterface
{
    private $typeBuilder;
    private $typesContainer;
    private $resourceMetadataFactory;

    public function __construct(TypeBuilderInterface $typeBuilder, TypesContainerInterface $typesContainer, ResourceMetadataFactoryInterface $resourceMetadataFactory)
    {
        $this->typeBuilder = $typeBuilder;
        $this->typesContainer = $typesContainer;
        $this->resourceMetadataFactory = $resourceMetadataFactory;
    }

    /**
     * {@inheritdoc}
     */
    public function convertType(Type $type, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, string $resourceClass, string $rootResource, ?string $property, int $depth)
    {
        switch ($type->getBuiltinType()) {
            case Type::BUILTIN_TYPE_BOOL:
                return GraphQLType::boolean();
            case Type::BUILTIN_TYPE_INT:
                return GraphQLType::int();
            case Type::BUILTIN_TYPE_FLOAT:
                return GraphQLType::float();
            case Type::BUILTIN_TYPE_STRING:
                return GraphQLType::string();
            case Type::BUILTIN_TYPE_ARRAY:
            case Type::BUILTIN_TYPE_ITERABLE:
                if ($resourceType = $this->getResourceType($type, $input, $queryName, $mutationName, $subscriptionName, $depth)) {
                    return $resourceType;
                }

                return 'Iterable';
            case Type::BUILTIN_TYPE_OBJECT:
                if ($input && $depth > 0) {
                    return GraphQLType::string();
                }

                if (is_a($type->getClassName(), \DateTimeInterface::class, true)) {
                    return GraphQLType::string();
                }

                return $this->getResourceType($type, $input, $queryName, $mutationName, $subscriptionName, $depth);
            default:
                return null;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function resolveType(string $type): ?GraphQLType
    {
        try {
            $astTypeNode = Parser::parseType($type);
        } catch (SyntaxError $e) {
            throw new InvalidArgumentException(sprintf('"%s" is not a valid GraphQL type.', $type), 0, $e);
        }

        if ($graphQlType = $this->resolveAstTypeNode($astTypeNode, $type)) {
            return $graphQlType;
        }

        throw new InvalidArgumentException(sprintf('The type "%s" was not resolved.', $type));
    }

    private function getResourceType(Type $type, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, int $depth): ?GraphQLType
    {
        if (
            $this->typeBuilder->isCollection($type) &&
            $collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()
        ) {
            $resourceClass = $collectionValueType->getClassName();
        } else {
            $resourceClass = $type->getClassName();
        }

        if (null === $resourceClass) {
            return null;
        }

        try {
            $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
            if (null === $resourceMetadata->getGraphql()) {
                return null;
            }
            if ('Node' === $resourceMetadata->getShortName()) {
                throw new \UnexpectedValueException('A "Node" resource cannot be used with GraphQL because the type is already used by the Relay specification.');
            }
        } catch (ResourceClassNotFoundException $e) {
            // Skip objects that are not resources for now
            return null;
        }

        return $this->typeBuilder->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, false, $depth);
    }

    private function resolveAstTypeNode(TypeNode $astTypeNode, string $fromType): ?GraphQLType
    {
        if ($astTypeNode instanceof NonNullTypeNode) {
            /** @var NullableType|null $nullableAstTypeNode */
            $nullableAstTypeNode = $this->resolveNullableAstTypeNode($astTypeNode->type, $fromType);

            return $nullableAstTypeNode ? GraphQLType::nonNull($nullableAstTypeNode) : null;
        }

        return $this->resolveNullableAstTypeNode($astTypeNode, $fromType);
    }

    private function resolveNullableAstTypeNode(TypeNode $astTypeNode, string $fromType): ?GraphQLType
    {
        if ($astTypeNode instanceof ListTypeNode) {
            /** @var TypeNode $astTypeNodeElement */
            $astTypeNodeElement = $astTypeNode->type;

            return GraphQLType::listOf($this->resolveAstTypeNode($astTypeNodeElement, $fromType));
        }

        if (!$astTypeNode instanceof NamedTypeNode) {
            return null;
        }

        $typeName = $astTypeNode->name->value;

        switch ($typeName) {
            case GraphQLType::STRING:
                return GraphQLType::string();
            case GraphQLType::INT:
                return GraphQLType::int();
            case GraphQLType::BOOLEAN:
                return GraphQLType::boolean();
            case GraphQLType::FLOAT:
                return GraphQLType::float();
            case GraphQLType::ID:
                return GraphQLType::id();
            default:
                if ($this->typesContainer->has($typeName)) {
                    return $this->typesContainer->get($typeName);
                }

                return null;
        }
    }
}

1	<?php
2
3	/*
4	* This file is part of the API Platform project.
5	*
6	* (c) Kévin Dunglas <dunglas@gmail.com>
7	*
8	* For the full copyright and license information, please view the LICENSE
9	* file that was distributed with this source code.
10	*/
11
12	declare(strict_types=1);
13
14	namespace ApiPlatform\Core\GraphQl\Type;
15
16	use ApiPlatform\Core\Exception\InvalidArgumentException;
17	use ApiPlatform\Core\Exception\ResourceClassNotFoundException;
18	use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
19	use GraphQL\Error\SyntaxError;
20	use GraphQL\Language\AST\ListTypeNode;
21	use GraphQL\Language\AST\NamedTypeNode;
22	use GraphQL\Language\AST\NonNullTypeNode;
23	use GraphQL\Language\AST\TypeNode;
24	use GraphQL\Language\Parser;
25	use GraphQL\Type\Definition\NullableType;
26	use GraphQL\Type\Definition\Type as GraphQLType;
27	use Symfony\Component\PropertyInfo\Type;
28
29	/**
30	* Converts a type to its GraphQL equivalent.
31	*
32	* @experimental
33	*
34	* @author Alan Poulain <contact@alanpoulain.eu>
35	*/
36	final class TypeConverter implements TypeConverterInterface
37	{
38	private $typeBuilder;
39	private $typesContainer;
40	private $resourceMetadataFactory;
41
42	public function __construct(TypeBuilderInterface $typeBuilder, TypesContainerInterface $typesContainer, ResourceMetadataFactoryInterface $resourceMetadataFactory)
43	{
44	$this->typeBuilder = $typeBuilder;	30✔
45	$this->typesContainer = $typesContainer;	30✔
46	$this->resourceMetadataFactory = $resourceMetadataFactory;	30✔
47	}	30✔
48
49	/**
50	* {@inheritdoc}
51	*/
52	public function convertType(Type $type, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, string $resourceClass, string $rootResource, ?string $property, int $depth)
53	{
54	switch ($type->getBuiltinType()) {	17✔
55	case Type::BUILTIN_TYPE_BOOL:
56	return GraphQLType::boolean();	1✔
57	case Type::BUILTIN_TYPE_INT:
58	return GraphQLType::int();	1✔
59	case Type::BUILTIN_TYPE_FLOAT:
60	return GraphQLType::float();	1✔
61	case Type::BUILTIN_TYPE_STRING:
62	return GraphQLType::string();	1✔
63	case Type::BUILTIN_TYPE_ARRAY:
64	case Type::BUILTIN_TYPE_ITERABLE:
65	if ($resourceType = $this->getResourceType($type, $input, $queryName, $mutationName, $subscriptionName, $depth)) {	3✔
66	return $resourceType;	1✔
67	}
68
69	return 'Iterable';	2✔
70	case Type::BUILTIN_TYPE_OBJECT:
71	if ($input && $depth > 0) {	7✔
72	return GraphQLType::string();	1✔
73	}
74
75	if (is_a($type->getClassName(), \DateTimeInterface::class, true)) {	6✔
76	return GraphQLType::string();	1✔
77	}
78
79	return $this->getResourceType($type, $input, $queryName, $mutationName, $subscriptionName, $depth);	5✔
80	default:
81	return null;	3✔
82	}
83	}
84
85	/**
86	* {@inheritdoc}
87	*/
88	public function resolveType(string $type): ?GraphQLType
89	{
90	try {
91	$astTypeNode = Parser::parseType($type);	13✔
92	} catch (SyntaxError $e) {	1✔
93	throw new InvalidArgumentException(sprintf('"%s" is not a valid GraphQL type.', $type), 0, $e);	1✔
94	}
95
96	if ($graphQlType = $this->resolveAstTypeNode($astTypeNode, $type)) {	12✔
97	return $graphQlType;	10✔
98	}
99
100	throw new InvalidArgumentException(sprintf('The type "%s" was not resolved.', $type));	2✔
101	}
102
103	private function getResourceType(Type $type, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, int $depth): ?GraphQLType
104	{
105	if (
106	$this->typeBuilder->isCollection($type) &&	8✔
107	$collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()	8✔
108	) {
109	$resourceClass = $collectionValueType->getClassName();	2✔
110	} else {
111	$resourceClass = $type->getClassName();	6✔
112	}
113
114	if (null === $resourceClass) {	8✔
115	return null;	3✔
116	}
117
118	try {
119	$resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);	5✔
120	if (null === $resourceMetadata->getGraphql()) {	4✔
121	return null;	1✔
122	}
123	if ('Node' === $resourceMetadata->getShortName()) {	3✔
124	throw new \UnexpectedValueException('A "Node" resource cannot be used with GraphQL because the type is already used by the Relay specification.');	3✔
125	}
126	} catch (ResourceClassNotFoundException $e) {	2✔
127	// Skip objects that are not resources for now
128	return null;	1✔
129	}
130
131	return $this->typeBuilder->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, false, $depth);	2✔
132	}
133
134	private function resolveAstTypeNode(TypeNode $astTypeNode, string $fromType): ?GraphQLType
135	{
136	if ($astTypeNode instanceof NonNullTypeNode) {	12✔
137	/** @var NullableType\|null $nullableAstTypeNode */
138	$nullableAstTypeNode = $this->resolveNullableAstTypeNode($astTypeNode->type, $fromType);	6✔
139
140	return $nullableAstTypeNode ? GraphQLType::nonNull($nullableAstTypeNode) : null;	6✔
141	}
142
143	return $this->resolveNullableAstTypeNode($astTypeNode, $fromType);	8✔
144	}
145
146	private function resolveNullableAstTypeNode(TypeNode $astTypeNode, string $fromType): ?GraphQLType
147	{
148	if ($astTypeNode instanceof ListTypeNode) {	12✔
149	/** @var TypeNode $astTypeNodeElement */
150	$astTypeNodeElement = $astTypeNode->type;	4✔
151
152	return GraphQLType::listOf($this->resolveAstTypeNode($astTypeNodeElement, $fromType));	4✔
153	}
154
155	if (!$astTypeNode instanceof NamedTypeNode) {	12✔
156	return null;	×
157	}
158
159	$typeName = $astTypeNode->name->value;	12✔
160
161	switch ($typeName) {	12✔
162	case GraphQLType::STRING:
163	return GraphQLType::string();	2✔
164	case GraphQLType::INT:
165	return GraphQLType::int();	2✔
166	case GraphQLType::BOOLEAN:
167	return GraphQLType::boolean();	2✔
168	case GraphQLType::FLOAT:
169	return GraphQLType::float();	2✔
170	case GraphQLType::ID:
171	return GraphQLType::id();	×
172	default:
173	if ($this->typesContainer->has($typeName)) {	4✔
174	return $this->typesContainer->get($typeName);	2✔
175	}
176
177	return null;	2✔
178	}
179	}
180	}

api-platform / core / #27275

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous