#27939

pending completion

Build # #27939

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/d1178b4fb4780ff96aa3f8d353d2eb4d7ff19622">d1178b4fb<a href="https://github.com/api-platform/core/commit/d1178b4fb4780ff96aa3f8d353d2eb4d7ff19622">">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/1ce8d5cdb70f8f6518f12b35acbe1940fc6e8b6f">1ce8d5cdb</a>">1ce8d5cdb</a><a href="https://github.com/api-platform/core/commit/d1178b4fb4780ff96aa3f8d353d2eb4d7ff19622"> into 0d37caaf9">0d37caaf9</a>

Run Details

9760 of 11681 relevant lines covered (83.55%)

14.83 hits per line

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

92.86

/src/GraphQl/Type/TypeBuilder.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\DataProvider\Pagination;
use ApiPlatform\Core\GraphQl\Serializer\ItemNormalizer;
use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
use GraphQL\Type\Definition\InputObjectType;
use GraphQL\Type\Definition\InterfaceType;
use GraphQL\Type\Definition\NonNull;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Type\Definition\Type as GraphQLType;
use Psr\Container\ContainerInterface;
use Symfony\Component\PropertyInfo\Type;

/**
 * Builds the GraphQL types.
 *
 * @experimental
 *
 * @author Alan Poulain <contact@alanpoulain.eu>
 */
final class TypeBuilder implements TypeBuilderInterface
{
    private $typesContainer;
    private $defaultFieldResolver;
    private $fieldsBuilderLocator;
    private $pagination;

    public function __construct(TypesContainerInterface $typesContainer, callable $defaultFieldResolver, ContainerInterface $fieldsBuilderLocator, Pagination $pagination)
    {
        $this->typesContainer = $typesContainer;
        $this->defaultFieldResolver = $defaultFieldResolver;
        $this->fieldsBuilderLocator = $fieldsBuilderLocator;
        $this->pagination = $pagination;
    }

    /**
     * {@inheritdoc}
     */
    public function getResourceObjectType(?string $resourceClass, ResourceMetadata $resourceMetadata, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, bool $wrapped = false, int $depth = 0): GraphQLType
    {
        $shortName = $resourceMetadata->getShortName();

        if (null !== $mutationName) {
            $shortName = $mutationName.ucfirst($shortName);
        }
        if (null !== $subscriptionName) {
            $shortName = $subscriptionName.ucfirst($shortName).'Subscription';
        }
        if ($input) {
            $shortName .= 'Input';
        } elseif (null !== $mutationName || null !== $subscriptionName) {
            if ($depth > 0) {
                $shortName .= 'Nested';
            }
            $shortName .= 'Payload';
        }
        if (('item_query' === $queryName || 'collection_query' === $queryName)
            && $resourceMetadata->getGraphqlAttribute('item_query', 'normalization_context', [], true) !== $resourceMetadata->getGraphqlAttribute('collection_query', 'normalization_context', [], true)) {
            if ('item_query' === $queryName) {
                $shortName .= 'Item';
            }
            if ('collection_query' === $queryName) {
                $shortName .= 'Collection';
            }
        }
        if ($wrapped && (null !== $mutationName || null !== $subscriptionName)) {
            $shortName .= 'Data';
        }

        if ($this->typesContainer->has($shortName)) {
            $resourceObjectType = $this->typesContainer->get($shortName);
            if (!($resourceObjectType instanceof ObjectType || $resourceObjectType instanceof NonNull)) {
                throw new \LogicException(sprintf('Expected GraphQL type "%s" to be %s.', $shortName, implode('|', [ObjectType::class, NonNull::class])));
            }

            return $resourceObjectType;
        }

        $ioMetadata = $resourceMetadata->getGraphqlAttribute($subscriptionName ?? $mutationName ?? $queryName, $input ? 'input' : 'output', null, true);
        if (null !== $ioMetadata && \array_key_exists('class', $ioMetadata) && null !== $ioMetadata['class']) {
            $resourceClass = $ioMetadata['class'];
        }

        $wrapData = !$wrapped && (null !== $mutationName || null !== $subscriptionName) && !$input && $depth < 1;

        $configuration = [
            'name' => $shortName,
            'description' => $resourceMetadata->getDescription(),
            'resolveField' => $this->defaultFieldResolver,
            'fields' => function () use ($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, $wrapData, $depth, $ioMetadata) {
                if ($wrapData) {
                    $queryNormalizationContext = $resourceMetadata->getGraphqlAttribute($queryName ?? '', 'normalization_context', [], true);
                    $mutationNormalizationContext = $resourceMetadata->getGraphqlAttribute($mutationName ?? $subscriptionName ?? '', 'normalization_context', [], true);
                    // Use a new type for the wrapped object only if there is a specific normalization context for the mutation or the subscription.
                    // If not, use the query type in order to ensure the client cache could be used.
                    $useWrappedType = $queryNormalizationContext !== $mutationNormalizationContext;

                    $fields = [
                        lcfirst($resourceMetadata->getShortName()) => $useWrappedType ?
                            $this->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, true, $depth) :
                            $this->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName ?? 'item_query', null, null, true, $depth),
                    ];

                    if (null !== $subscriptionName) {
                        $fields['clientSubscriptionId'] = GraphQLType::string();
                        if ($resourceMetadata->getAttribute('mercure', false)) {
                            $fields['mercureUrl'] = GraphQLType::string();
                        }

                        return $fields;
                    }

                    return $fields + ['clientMutationId' => GraphQLType::string()];
                }

                $fieldsBuilder = $this->fieldsBuilderLocator->get('api_platform.graphql.fields_builder');
                $fields = $fieldsBuilder->getResourceObjectTypeFields($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, $depth, $ioMetadata);

                if ($input && null !== $mutationName && null !== $mutationArgs = $resourceMetadata->getGraphql()[$mutationName]['args'] ?? null) {
                    return $fieldsBuilder->resolveResourceArgs($mutationArgs, $mutationName, $resourceMetadata->getShortName()) + ['clientMutationId' => $fields['clientMutationId']];
                }

                return $fields;
            },
            'interfaces' => $wrapData ? [] : [$this->getNodeInterface()],
        ];

        $resourceObjectType = $input ? GraphQLType::nonNull(new InputObjectType($configuration)) : new ObjectType($configuration);
        $this->typesContainer->set($shortName, $resourceObjectType);

        return $resourceObjectType;
    }

    /**
     * {@inheritdoc}
     */
    public function getNodeInterface(): InterfaceType
    {
        if ($this->typesContainer->has('Node')) {
            $nodeInterface = $this->typesContainer->get('Node');
            if (!$nodeInterface instanceof InterfaceType) {
                throw new \LogicException(sprintf('Expected GraphQL type "Node" to be %s.', InterfaceType::class));
            }

            return $nodeInterface;
        }

        $nodeInterface = new InterfaceType([
            'name' => 'Node',
            'description' => 'A node, according to the Relay specification.',
            'fields' => [
                'id' => [
                    'type' => GraphQLType::nonNull(GraphQLType::id()),
                    'description' => 'The id of this node.',
                ],
            ],
            'resolveType' => function ($value) {
                if (!isset($value[ItemNormalizer::ITEM_RESOURCE_CLASS_KEY])) {
                    return null;
                }

                $shortName = (new \ReflectionClass($value[ItemNormalizer::ITEM_RESOURCE_CLASS_KEY]))->getShortName();

                return $this->typesContainer->has($shortName) ? $this->typesContainer->get($shortName) : null;
            },
        ]);

        $this->typesContainer->set('Node', $nodeInterface);

        return $nodeInterface;
    }

    /**
     * {@inheritdoc}
     */
    public function getResourcePaginatedCollectionType(GraphQLType $resourceType, string $resourceClass, string $operationName): GraphQLType
    {
        $shortName = $resourceType->name;

        if ($this->typesContainer->has("{$shortName}Connection")) {
            return $this->typesContainer->get("{$shortName}Connection");
        }

        $paginationType = $this->pagination->getGraphQlPaginationType($resourceClass, $operationName);

        $fields = 'cursor' === $paginationType ?
            $this->getCursorBasedPaginationFields($resourceType) :
            $this->getPageBasedPaginationFields($resourceType);

        $configuration = [
            'name' => "{$shortName}Connection",
            'description' => "Connection for $shortName.",
            'fields' => $fields,
        ];

        $resourcePaginatedCollectionType = new ObjectType($configuration);
        $this->typesContainer->set("{$shortName}Connection", $resourcePaginatedCollectionType);

        return $resourcePaginatedCollectionType;
    }

    /**
     * {@inheritdoc}
     */
    public function isCollection(Type $type): bool
    {
        return $type->isCollection() && ($collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()) && null !== $collectionValueType->getClassName();
    }

    private function getCursorBasedPaginationFields(GraphQLType $resourceType): array
    {
        $shortName = $resourceType->name;

        $edgeObjectTypeConfiguration = [
            'name' => "{$shortName}Edge",
            'description' => "Edge of $shortName.",
            'fields' => [
                'node' => $resourceType,
                'cursor' => GraphQLType::nonNull(GraphQLType::string()),
            ],
        ];
        $edgeObjectType = new ObjectType($edgeObjectTypeConfiguration);
        $this->typesContainer->set("{$shortName}Edge", $edgeObjectType);

        $pageInfoObjectTypeConfiguration = [
            'name' => "{$shortName}PageInfo",
            'description' => 'Information about the current page.',
            'fields' => [
                'endCursor' => GraphQLType::string(),
                'startCursor' => GraphQLType::string(),
                'hasNextPage' => GraphQLType::nonNull(GraphQLType::boolean()),
                'hasPreviousPage' => GraphQLType::nonNull(GraphQLType::boolean()),
            ],
        ];
        $pageInfoObjectType = new ObjectType($pageInfoObjectTypeConfiguration);
        $this->typesContainer->set("{$shortName}PageInfo", $pageInfoObjectType);

        return [
            'edges' => GraphQLType::listOf($edgeObjectType),
            'pageInfo' => GraphQLType::nonNull($pageInfoObjectType),
            'totalCount' => GraphQLType::nonNull(GraphQLType::int()),
        ];
    }

    private function getPageBasedPaginationFields(GraphQLType $resourceType): array
    {
        $shortName = $resourceType->name;

        $paginationInfoObjectTypeConfiguration = [
            'name' => "{$shortName}PaginationInfo",
            'description' => 'Information about the pagination.',
            'fields' => [
                'itemsPerPage' => GraphQLType::nonNull(GraphQLType::int()),
                'lastPage' => GraphQLType::nonNull(GraphQLType::int()),
                'totalCount' => GraphQLType::nonNull(GraphQLType::int()),
            ],
        ];
        $paginationInfoObjectType = new ObjectType($paginationInfoObjectTypeConfiguration);
        $this->typesContainer->set("{$shortName}PaginationInfo", $paginationInfoObjectType);

        return [
            'collection' => GraphQLType::listOf($resourceType),
            'paginationInfo' => GraphQLType::nonNull($paginationInfoObjectType),
        ];
    }
}

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\DataProvider\Pagination;
17	use ApiPlatform\Core\GraphQl\Serializer\ItemNormalizer;
18	use ApiPlatform\Core\Metadata\Resource\ResourceMetadata;
19	use GraphQL\Type\Definition\InputObjectType;
20	use GraphQL\Type\Definition\InterfaceType;
21	use GraphQL\Type\Definition\NonNull;
22	use GraphQL\Type\Definition\ObjectType;
23	use GraphQL\Type\Definition\Type as GraphQLType;
24	use Psr\Container\ContainerInterface;
25	use Symfony\Component\PropertyInfo\Type;
26
27	/**
28	* Builds the GraphQL types.
29	*
30	* @experimental
31	*
32	* @author Alan Poulain <contact@alanpoulain.eu>
33	*/
34	final class TypeBuilder implements TypeBuilderInterface
35	{
36	private $typesContainer;
37	private $defaultFieldResolver;
38	private $fieldsBuilderLocator;
39	private $pagination;
40
41	public function __construct(TypesContainerInterface $typesContainer, callable $defaultFieldResolver, ContainerInterface $fieldsBuilderLocator, Pagination $pagination)
42	{
43	$this->typesContainer = $typesContainer;	25✔
44	$this->defaultFieldResolver = $defaultFieldResolver;	25✔
45	$this->fieldsBuilderLocator = $fieldsBuilderLocator;	25✔
46	$this->pagination = $pagination;	25✔
47	}	25✔
48
49	/**
50	* {@inheritdoc}
51	*/
52	public function getResourceObjectType(?string $resourceClass, ResourceMetadata $resourceMetadata, bool $input, ?string $queryName, ?string $mutationName, ?string $subscriptionName, bool $wrapped = false, int $depth = 0): GraphQLType
53	{
54	$shortName = $resourceMetadata->getShortName();	13✔
55
56	if (null !== $mutationName) {	13✔
57	$shortName = $mutationName.ucfirst($shortName);	5✔
58	}
59	if (null !== $subscriptionName) {	13✔
60	$shortName = $subscriptionName.ucfirst($shortName).'Subscription';	3✔
61	}
62	if ($input) {	13✔
63	$shortName .= 'Input';	2✔
64	} elseif (null !== $mutationName \|\| null !== $subscriptionName) {	11✔
65	if ($depth > 0) {	6✔
66	$shortName .= 'Nested';	2✔
67	}
68	$shortName .= 'Payload';	6✔
69	}
70	if (('item_query' === $queryName \|\| 'collection_query' === $queryName)	13✔
71	&& $resourceMetadata->getGraphqlAttribute('item_query', 'normalization_context', [], true) !== $resourceMetadata->getGraphqlAttribute('collection_query', 'normalization_context', [], true)) {	13✔
72	if ('item_query' === $queryName) {	2✔
73	$shortName .= 'Item';	1✔
74	}
75	if ('collection_query' === $queryName) {	2✔
76	$shortName .= 'Collection';	1✔
77	}
78	}
79	if ($wrapped && (null !== $mutationName \|\| null !== $subscriptionName)) {	13✔
80	$shortName .= 'Data';	2✔
81	}
82
83	if ($this->typesContainer->has($shortName)) {	13✔
84	$resourceObjectType = $this->typesContainer->get($shortName);	×
85	if (!($resourceObjectType instanceof ObjectType \|\| $resourceObjectType instanceof NonNull)) {	×
86	throw new \LogicException(sprintf('Expected GraphQL type "%s" to be %s.', $shortName, implode('\|', [ObjectType::class, NonNull::class])));	×
87	}
88
89	return $resourceObjectType;	×
90	}
91
92	$ioMetadata = $resourceMetadata->getGraphqlAttribute($subscriptionName ?? $mutationName ?? $queryName, $input ? 'input' : 'output', null, true);	13✔
93	if (null !== $ioMetadata && \array_key_exists('class', $ioMetadata) && null !== $ioMetadata['class']) {	13✔
94	$resourceClass = $ioMetadata['class'];	1✔
95	}
96
97	$wrapData = !$wrapped && (null !== $mutationName \|\| null !== $subscriptionName) && !$input && $depth < 1;	13✔
98
99	$configuration = [	13✔
100	'name' => $shortName,	13✔
101	'description' => $resourceMetadata->getDescription(),	13✔
102	'resolveField' => $this->defaultFieldResolver,	13✔
103	'fields' => function () use ($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, $wrapData, $depth, $ioMetadata) {	13✔
104	if ($wrapData) {	10✔
105	$queryNormalizationContext = $resourceMetadata->getGraphqlAttribute($queryName ?? '', 'normalization_context', [], true);	4✔
106	$mutationNormalizationContext = $resourceMetadata->getGraphqlAttribute($mutationName ?? $subscriptionName ?? '', 'normalization_context', [], true);	4✔
107	// Use a new type for the wrapped object only if there is a specific normalization context for the mutation or the subscription.
108	// If not, use the query type in order to ensure the client cache could be used.
109	$useWrappedType = $queryNormalizationContext !== $mutationNormalizationContext;	4✔
110
111	$fields = [	4✔
112	lcfirst($resourceMetadata->getShortName()) => $useWrappedType ?	4✔
113	$this->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, true, $depth) :	2✔
114	$this->getResourceObjectType($resourceClass, $resourceMetadata, $input, $queryName ?? 'item_query', null, null, true, $depth),	4✔
115	];
116
117	if (null !== $subscriptionName) {	4✔
118	$fields['clientSubscriptionId'] = GraphQLType::string();	2✔
119	if ($resourceMetadata->getAttribute('mercure', false)) {	2✔
120	$fields['mercureUrl'] = GraphQLType::string();	1✔
121	}
122
123	return $fields;	2✔
124	}
125
126	return $fields + ['clientMutationId' => GraphQLType::string()];	2✔
127	}
128
129	$fieldsBuilder = $this->fieldsBuilderLocator->get('api_platform.graphql.fields_builder');	8✔
130	$fields = $fieldsBuilder->getResourceObjectTypeFields($resourceClass, $resourceMetadata, $input, $queryName, $mutationName, $subscriptionName, $depth, $ioMetadata);	8✔
131
132	if ($input && null !== $mutationName && null !== $mutationArgs = $resourceMetadata->getGraphql()[$mutationName]['args'] ?? null) {	8✔
133	return $fieldsBuilder->resolveResourceArgs($mutationArgs, $mutationName, $resourceMetadata->getShortName()) + ['clientMutationId' => $fields['clientMutationId']];	1✔
134	}
135
136	return $fields;	7✔
137	},	13✔
138	'interfaces' => $wrapData ? [] : [$this->getNodeInterface()],	13✔
139	];
140
141	$resourceObjectType = $input ? GraphQLType::nonNull(new InputObjectType($configuration)) : new ObjectType($configuration);	13✔
142	$this->typesContainer->set($shortName, $resourceObjectType);	13✔
143
144	return $resourceObjectType;	13✔
145	}
146
147	/**
148	* {@inheritdoc}
149	*/
150	public function getNodeInterface(): InterfaceType
151	{
152	if ($this->typesContainer->has('Node')) {	14✔
153	$nodeInterface = $this->typesContainer->get('Node');	×
154	if (!$nodeInterface instanceof InterfaceType) {	×
155	throw new \LogicException(sprintf('Expected GraphQL type "Node" to be %s.', InterfaceType::class));	×
156	}
157
158	return $nodeInterface;	×
159	}
160
161	$nodeInterface = new InterfaceType([	14✔
162	'name' => 'Node',	14✔
163	'description' => 'A node, according to the Relay specification.',	14✔
164	'fields' => [
165	'id' => [
166	'type' => GraphQLType::nonNull(GraphQLType::id()),	14✔
167	'description' => 'The id of this node.',	14✔
168	],
169	],
170	'resolveType' => function ($value) {	14✔
171	if (!isset($value[ItemNormalizer::ITEM_RESOURCE_CLASS_KEY])) {	1✔
172	return null;	1✔
173	}
174
175	$shortName = (new \ReflectionClass($value[ItemNormalizer::ITEM_RESOURCE_CLASS_KEY]))->getShortName();	1✔
176
177	return $this->typesContainer->has($shortName) ? $this->typesContainer->get($shortName) : null;	1✔
178	},	14✔
179	]);
180
181	$this->typesContainer->set('Node', $nodeInterface);	14✔
182
183	return $nodeInterface;	14✔
184	}
185
186	/**
187	* {@inheritdoc}
188	*/
189	public function getResourcePaginatedCollectionType(GraphQLType $resourceType, string $resourceClass, string $operationName): GraphQLType
190	{
191	$shortName = $resourceType->name;	2✔
192
193	if ($this->typesContainer->has("{$shortName}Connection")) {	2✔
194	return $this->typesContainer->get("{$shortName}Connection");	×
195	}
196
197	$paginationType = $this->pagination->getGraphQlPaginationType($resourceClass, $operationName);	2✔
198
199	$fields = 'cursor' === $paginationType ?	2✔
200	$this->getCursorBasedPaginationFields($resourceType) :	1✔
201	$this->getPageBasedPaginationFields($resourceType);	1✔
202
203	$configuration = [	2✔
204	'name' => "{$shortName}Connection",	2✔
205	'description' => "Connection for $shortName.",	2✔
206	'fields' => $fields,	2✔
207	];
208
209	$resourcePaginatedCollectionType = new ObjectType($configuration);	2✔
210	$this->typesContainer->set("{$shortName}Connection", $resourcePaginatedCollectionType);	2✔
211
212	return $resourcePaginatedCollectionType;	2✔
213	}
214
215	/**
216	* {@inheritdoc}
217	*/
218	public function isCollection(Type $type): bool
219	{
220	return $type->isCollection() && ($collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()) && null !== $collectionValueType->getClassName();	9✔
221	}
222
223	private function getCursorBasedPaginationFields(GraphQLType $resourceType): array
224	{
225	$shortName = $resourceType->name;	1✔
226
227	$edgeObjectTypeConfiguration = [	1✔
228	'name' => "{$shortName}Edge",	1✔
229	'description' => "Edge of $shortName.",	1✔
230	'fields' => [
231	'node' => $resourceType,	1✔
232	'cursor' => GraphQLType::nonNull(GraphQLType::string()),	1✔
233	],
234	];
235	$edgeObjectType = new ObjectType($edgeObjectTypeConfiguration);	1✔
236	$this->typesContainer->set("{$shortName}Edge", $edgeObjectType);	1✔
237
238	$pageInfoObjectTypeConfiguration = [	1✔
239	'name' => "{$shortName}PageInfo",	1✔
240	'description' => 'Information about the current page.',	1✔
241	'fields' => [
242	'endCursor' => GraphQLType::string(),	1✔
243	'startCursor' => GraphQLType::string(),	1✔
244	'hasNextPage' => GraphQLType::nonNull(GraphQLType::boolean()),	1✔
245	'hasPreviousPage' => GraphQLType::nonNull(GraphQLType::boolean()),	1✔
246	],
247	];
248	$pageInfoObjectType = new ObjectType($pageInfoObjectTypeConfiguration);	1✔
249	$this->typesContainer->set("{$shortName}PageInfo", $pageInfoObjectType);	1✔
250
251	return [
252	'edges' => GraphQLType::listOf($edgeObjectType),	1✔
253	'pageInfo' => GraphQLType::nonNull($pageInfoObjectType),	1✔
254	'totalCount' => GraphQLType::nonNull(GraphQLType::int()),	1✔
255	];
256	}
257
258	private function getPageBasedPaginationFields(GraphQLType $resourceType): array
259	{
260	$shortName = $resourceType->name;	1✔
261
262	$paginationInfoObjectTypeConfiguration = [	1✔
263	'name' => "{$shortName}PaginationInfo",	1✔
264	'description' => 'Information about the pagination.',	1✔
265	'fields' => [
266	'itemsPerPage' => GraphQLType::nonNull(GraphQLType::int()),	1✔
267	'lastPage' => GraphQLType::nonNull(GraphQLType::int()),	1✔
268	'totalCount' => GraphQLType::nonNull(GraphQLType::int()),	1✔
269	],
270	];
271	$paginationInfoObjectType = new ObjectType($paginationInfoObjectTypeConfiguration);	1✔
272	$this->typesContainer->set("{$shortName}PaginationInfo", $paginationInfoObjectType);	1✔
273
274	return [
275	'collection' => GraphQLType::listOf($resourceType),	1✔
276	'paginationInfo' => GraphQLType::nonNull($paginationInfoObjectType),	1✔
277	];
278	}
279	}

api-platform / core / #27939

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