#27598

pending completion

Build # #27598

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/76109fd15ed8e2737d2492eca8c2915f6cbf2b16">76109fd15<a href="https://github.com/api-platform/core/commit/76109fd15ed8e2737d2492eca8c2915f6cbf2b16">">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/4ff5a59af1ef664f47e0194da55d1d4855fa8c4e">4ff5a59af</a>">4ff5a59af</a><a href="https://github.com/api-platform/core/commit/76109fd15ed8e2737d2492eca8c2915f6cbf2b16"> into fc9122c2d">fc9122c2d</a>

Run Details

126 of 126 new or added lines in 6 files covered. (100.0%)

13106 of 15715 relevant lines covered (83.4%)

15.07 hits per line

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

89.29

/src/Metadata/Property/Factory/SerializerPropertyMetadataFactory.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\Metadata\Property\Factory;

use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Util\ResourceClassInfoTrait;
use ApiPlatform\Exception\ResourceClassNotFoundException;
use ApiPlatform\Metadata\ApiProperty;
use Symfony\Component\PropertyInfo\Type;
use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface as SerializerClassMetadataFactoryInterface;

/**
 * Populates read/write and link status using serialization groups.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 * @author Teoh Han Hui <teohhanhui@gmail.com>
 */
final class SerializerPropertyMetadataFactory implements PropertyMetadataFactoryInterface
{
    use ResourceClassInfoTrait;

    private $serializerClassMetadataFactory;
    private $decorated;

    public function __construct(?ResourceMetadataFactoryInterface $resourceMetadataFactory = null, SerializerClassMetadataFactoryInterface $serializerClassMetadataFactory, PropertyMetadataFactoryInterface $decorated, ResourceClassResolverInterface $resourceClassResolver = null)
    {
        $this->resourceMetadataFactory = $resourceMetadataFactory;

        if ($resourceMetadataFactory) {
            trigger_deprecation('api-platform/core', '2.7', sprintf('Injecting a "%s" in the "%s" is deprecated and will not be possible anymore in 3.0.', ResourceMetadataFactoryInterface::class, __CLASS__));
        }

        $this->serializerClassMetadataFactory = $serializerClassMetadataFactory;
        $this->decorated = $decorated;
        $this->resourceClassResolver = $resourceClassResolver;
    }

    /**
     * {@inheritdoc}
     */
    public function create(string $resourceClass, string $property, array $options = [])
    {
        /** @var PropertyMetadata|ApiProperty */
        $propertyMetadata = $this->decorated->create($resourceClass, $property, $options);

        // BC to be removed in 3.0
        if ($propertyMetadata instanceof PropertyMetadata && null !== ($childResourceClass = $propertyMetadata->getChildInherited())) {
            $resourceClass = $childResourceClass;
        }

        try {
            [$normalizationGroups, $denormalizationGroups] = $this->getEffectiveSerializerGroups($options, $resourceClass);

            if ($normalizationGroups && !\is_array($normalizationGroups)) {
                $normalizationGroups = [$normalizationGroups];
            }

            if ($denormalizationGroups && !\is_array($denormalizationGroups)) {
                $denormalizationGroups = [$denormalizationGroups];
            }
        } catch (ResourceClassNotFoundException $e) {
            // TODO: for input/output classes, the serializer groups must be read from the actual resource class
            return $propertyMetadata;
        }

        $propertyMetadata = $this->transformReadWrite($propertyMetadata, $resourceClass, $property, $normalizationGroups, $denormalizationGroups);

        return $this->transformLinkStatus($propertyMetadata, $normalizationGroups, $denormalizationGroups);
    }

    /**
     * Sets readable/writable based on matching normalization/denormalization groups and property's ignorance.
     *
     * A false value is never reset as it could be unreadable/unwritable for other reasons.
     * If normalization/denormalization groups are not specified and the property is not ignored, the property is implicitly readable/writable.
     *
     * @param PropertyMetadata|ApiProperty $propertyMetadata
     * @param string[]|null                $normalizationGroups
     * @param string[]|null                $denormalizationGroups
     *
     * @return PropertyMetadata|ApiProperty $propertyMetadata
     */
    private function transformReadWrite($propertyMetadata, string $resourceClass, string $propertyName, array $normalizationGroups = null, array $denormalizationGroups = null)
    {
        $serializerAttributeMetadata = $this->getSerializerAttributeMetadata($resourceClass, $propertyName);
        $groups = $serializerAttributeMetadata ? $serializerAttributeMetadata->getGroups() : [];
        $ignored = $serializerAttributeMetadata && method_exists($serializerAttributeMetadata, 'isIgnored') ? $serializerAttributeMetadata->isIgnored() : false;

        if (false !== $propertyMetadata->isReadable()) {
            $propertyMetadata = $propertyMetadata->withReadable(!$ignored && (null === $normalizationGroups || array_intersect($normalizationGroups, $groups)));
        }

        if (false !== $propertyMetadata->isWritable()) {
            $propertyMetadata = $propertyMetadata->withWritable(!$ignored && (null === $denormalizationGroups || array_intersect($denormalizationGroups, $groups)));
        }

        return $propertyMetadata;
    }

    /**
     * Sets readableLink/writableLink based on matching normalization/denormalization groups.
     *
     * If normalization/denormalization groups are not specified,
     * set link status to false since embedding of resource must be explicitly enabled
     *
     * @param PropertyMetadata|ApiProperty $propertyMetadata
     * @param string[]|null                $normalizationGroups
     * @param string[]|null                $denormalizationGroups
     */
    private function transformLinkStatus($propertyMetadata, array $normalizationGroups = null, array $denormalizationGroups = null)
    {
        // No need to check link status if property is not readable and not writable
        if (false === $propertyMetadata->isReadable() && false === $propertyMetadata->isWritable()) {
            return $propertyMetadata;
        }

        // TODO: 3.0 support multiple types, default value of types will be [] instead of null
        $type = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getType() : ($propertyMetadata->getBuiltinTypes()[0] ?? null);

        if (null === $type) {
            return $propertyMetadata;
        }

        if (
            $type->isCollection() &&
            $collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()
        ) {
            $relatedClass = $collectionValueType->getClassName();
        } else {
            $relatedClass = $type->getClassName();
        }

        // if property is not a resource relation, don't set link status (as it would have no meaning)
        if (null === $relatedClass || !$this->isResourceClass($relatedClass)) {
            return $propertyMetadata;
        }

        // find the resource class
        // this prevents serializer groups on non-resource child class from incorrectly influencing the decision
        if (null !== $this->resourceClassResolver) {
            $relatedClass = $this->resourceClassResolver->getResourceClass(null, $relatedClass);
        }

        $relatedGroups = $this->getClassSerializerGroups($relatedClass);

        if (null === $propertyMetadata->isReadableLink()) {
            $propertyMetadata = $propertyMetadata->withReadableLink(null !== $normalizationGroups && !empty(array_intersect($normalizationGroups, $relatedGroups)));
        }

        if (null === $propertyMetadata->isWritableLink()) {
            $propertyMetadata = $propertyMetadata->withWritableLink(null !== $denormalizationGroups && !empty(array_intersect($denormalizationGroups, $relatedGroups)));
        }

        return $propertyMetadata;
    }

    /**
     * Gets the effective serializer groups used in normalization/denormalization.
     *
     * Groups are extracted in the following order:
     *
     * - From the "serializer_groups" key of the $options array.
     * - From metadata of the given operation ("collection_operation_name" and "item_operation_name" keys).
     * - From metadata of the current resource.
     *
     * @throws ResourceClassNotFoundException
     *
     * @return (string[]|null|string)[]
     */
    private function getEffectiveSerializerGroups(array $options, string $resourceClass): array
    {
        if (isset($options['serializer_groups'])) {
            $groups = (array) $options['serializer_groups'];

            return [$groups, $groups];
        }

        if (\array_key_exists('normalization_groups', $options) && \array_key_exists('denormalization_groups', $options)) {
            return [$options['normalization_groups'] ?? null, $options['denormalization_groups'] ?? null];
        }

        // To avoid an injection recursion between PropertyMetadataFactory and ResourceMetadataFactory we ask for groups when an operation name is given in the context.
        // This can be removed in 3.0 it must be an exception instead of a deprecation as `operation_name` means we use the new metadata system which isn't compatible
        if (isset($options['operation_name'])) {
            throw new \RuntimeException('You should specify "normalization_groups" and/or "denormalization_groups" when using the SerializerPropertyMetadataFactory.');
        }

        // TODO: 3.0 remove this code
        if ($this->resourceMetadataFactory) {
            $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
            if (isset($options['collection_operation_name'])) {
                $normalizationContext = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], 'normalization_context', null, true);
                $denormalizationContext = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], 'denormalization_context', null, true);
            } elseif (isset($options['item_operation_name'])) {
                $normalizationContext = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], 'normalization_context', null, true);
                $denormalizationContext = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], 'denormalization_context', null, true);
            } elseif (isset($options['graphql_operation_name'])) {
                $normalizationContext = $resourceMetadata->getGraphqlAttribute($options['graphql_operation_name'], 'normalization_context', null, true);
                $denormalizationContext = $resourceMetadata->getGraphqlAttribute($options['graphql_operation_name'], 'denormalization_context', null, true);
            } else {
                $normalizationContext = $resourceMetadata->getAttribute('normalization_context');
                $denormalizationContext = $resourceMetadata->getAttribute('denormalization_context');
            }

            return [
                isset($normalizationContext['groups']) ? (array) $normalizationContext['groups'] : null,
                isset($denormalizationContext['groups']) ? (array) $denormalizationContext['groups'] : null,
            ];
        }

        return [null, null];
    }

    private function getSerializerAttributeMetadata(string $class, string $attribute): ?AttributeMetadataInterface
    {
        $serializerClassMetadata = $this->serializerClassMetadataFactory->getMetadataFor($class);

        foreach ($serializerClassMetadata->getAttributesMetadata() as $serializerAttributeMetadata) {
            if ($attribute === $serializerAttributeMetadata->getName()) {
                return $serializerAttributeMetadata;
            }
        }

        return null;
    }

    /**
     * Gets all serializer groups used in a class.
     *
     * @return string[]
     */
    private function getClassSerializerGroups(string $class): array
    {
        //TODO: 3.0 remove
        if ($this->resourceMetadataFactory) {
            $resourceMetadata = $this->resourceMetadataFactory->create($class);
            if ($outputClass = $resourceMetadata->getAttribute('output')['class'] ?? null) {
                trigger_deprecation('api-platform/core', '2.7', 'We found a property class that is a resource with a different output. You should instead use an output at a higher level or type the property to that class directly if you want to keep the behavior.');
                $class = $outputClass;
            }
        }

        $serializerClassMetadata = $this->serializerClassMetadataFactory->getMetadataFor($class);

        $groups = [];
        foreach ($serializerClassMetadata->getAttributesMetadata() as $serializerAttributeMetadata) {
            $groups = array_merge($groups, $serializerAttributeMetadata->getGroups());
        }

        return array_unique($groups);
    }
}

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\Metadata\Property\Factory;
15
16	use ApiPlatform\Core\Api\ResourceClassResolverInterface;
17	use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
18	use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
19	use ApiPlatform\Core\Util\ResourceClassInfoTrait;
20	use ApiPlatform\Exception\ResourceClassNotFoundException;
21	use ApiPlatform\Metadata\ApiProperty;
22	use Symfony\Component\PropertyInfo\Type;
23	use Symfony\Component\Serializer\Mapping\AttributeMetadataInterface;
24	use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface as SerializerClassMetadataFactoryInterface;
25
26	/**
27	* Populates read/write and link status using serialization groups.
28	*
29	* @author Kévin Dunglas <dunglas@gmail.com>
30	* @author Teoh Han Hui <teohhanhui@gmail.com>
31	*/
32	final class SerializerPropertyMetadataFactory implements PropertyMetadataFactoryInterface
33	{
34	use ResourceClassInfoTrait;
35
36	private $serializerClassMetadataFactory;
37	private $decorated;
38
39	public function __construct(?ResourceMetadataFactoryInterface $resourceMetadataFactory = null, SerializerClassMetadataFactoryInterface $serializerClassMetadataFactory, PropertyMetadataFactoryInterface $decorated, ResourceClassResolverInterface $resourceClassResolver = null)
40	{
41	$this->resourceMetadataFactory = $resourceMetadataFactory;	46✔
42
43	if ($resourceMetadataFactory) {	46✔
44	trigger_deprecation('api-platform/core', '2.7', sprintf('Injecting a "%s" in the "%s" is deprecated and will not be possible anymore in 3.0.', ResourceMetadataFactoryInterface::class, __CLASS__));	5✔
45	}
46
47	$this->serializerClassMetadataFactory = $serializerClassMetadataFactory;	46✔
48	$this->decorated = $decorated;	46✔
49	$this->resourceClassResolver = $resourceClassResolver;	46✔
50	}	46✔
51
52	/**
53	* {@inheritdoc}
54	*/
55	public function create(string $resourceClass, string $property, array $options = [])
56	{
57	/** @var PropertyMetadata\|ApiProperty */
58	$propertyMetadata = $this->decorated->create($resourceClass, $property, $options);	18✔
59
60	// BC to be removed in 3.0
61	if ($propertyMetadata instanceof PropertyMetadata && null !== ($childResourceClass = $propertyMetadata->getChildInherited())) {	18✔
62	$resourceClass = $childResourceClass;	1✔
63	}
64
65	try {
66	[$normalizationGroups, $denormalizationGroups] = $this->getEffectiveSerializerGroups($options, $resourceClass);	18✔
67
68	if ($normalizationGroups && !\is_array($normalizationGroups)) {	18✔
69	$normalizationGroups = [$normalizationGroups];	1✔
70	}
71
72	if ($denormalizationGroups && !\is_array($denormalizationGroups)) {	18✔
73	$denormalizationGroups = [$denormalizationGroups];	18✔
74	}
75	} catch (ResourceClassNotFoundException $e) {	×
76	// TODO: for input/output classes, the serializer groups must be read from the actual resource class
77	return $propertyMetadata;	×
78	}
79
80	$propertyMetadata = $this->transformReadWrite($propertyMetadata, $resourceClass, $property, $normalizationGroups, $denormalizationGroups);	18✔
81
82	return $this->transformLinkStatus($propertyMetadata, $normalizationGroups, $denormalizationGroups);	18✔
83	}
84
85	/**
86	* Sets readable/writable based on matching normalization/denormalization groups and property's ignorance.
87	*
88	* A false value is never reset as it could be unreadable/unwritable for other reasons.
89	* If normalization/denormalization groups are not specified and the property is not ignored, the property is implicitly readable/writable.
90	*
91	* @param PropertyMetadata\|ApiProperty $propertyMetadata
92	* @param string[]\|null $normalizationGroups
93	* @param string[]\|null $denormalizationGroups
94	*
95	* @return PropertyMetadata\|ApiProperty $propertyMetadata
96	*/
97	private function transformReadWrite($propertyMetadata, string $resourceClass, string $propertyName, array $normalizationGroups = null, array $denormalizationGroups = null)
98	{
99	$serializerAttributeMetadata = $this->getSerializerAttributeMetadata($resourceClass, $propertyName);	18✔
100	$groups = $serializerAttributeMetadata ? $serializerAttributeMetadata->getGroups() : [];	18✔
101	$ignored = $serializerAttributeMetadata && method_exists($serializerAttributeMetadata, 'isIgnored') ? $serializerAttributeMetadata->isIgnored() : false;	18✔
102
103	if (false !== $propertyMetadata->isReadable()) {	18✔
104	$propertyMetadata = $propertyMetadata->withReadable(!$ignored && (null === $normalizationGroups \|\| array_intersect($normalizationGroups, $groups)));	18✔
105	}
106
107	if (false !== $propertyMetadata->isWritable()) {	18✔
108	$propertyMetadata = $propertyMetadata->withWritable(!$ignored && (null === $denormalizationGroups \|\| array_intersect($denormalizationGroups, $groups)));	16✔
109	}
110
111	return $propertyMetadata;	18✔
112	}
113
114	/**
115	* Sets readableLink/writableLink based on matching normalization/denormalization groups.
116	*
117	* If normalization/denormalization groups are not specified,
118	* set link status to false since embedding of resource must be explicitly enabled
119	*
120	* @param PropertyMetadata\|ApiProperty $propertyMetadata
121	* @param string[]\|null $normalizationGroups
122	* @param string[]\|null $denormalizationGroups
123	*/
124	private function transformLinkStatus($propertyMetadata, array $normalizationGroups = null, array $denormalizationGroups = null)
125	{
126	// No need to check link status if property is not readable and not writable
127	if (false === $propertyMetadata->isReadable() && false === $propertyMetadata->isWritable()) {	18✔
128	return $propertyMetadata;	10✔
129	}
130
131	// TODO: 3.0 support multiple types, default value of types will be [] instead of null
132	$type = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getType() : ($propertyMetadata->getBuiltinTypes()[0] ?? null);	16✔
133
134	if (null === $type) {	16✔
135	return $propertyMetadata;	3✔
136	}
137
138	if (
139	$type->isCollection() &&	16✔
140	$collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType()	16✔
141	) {
142	$relatedClass = $collectionValueType->getClassName();	7✔
143	} else {
144	$relatedClass = $type->getClassName();	16✔
145	}
146
147	// if property is not a resource relation, don't set link status (as it would have no meaning)
148	if (null === $relatedClass \|\| !$this->isResourceClass($relatedClass)) {	16✔
149	return $propertyMetadata;	16✔
150	}
151
152	// find the resource class
153	// this prevents serializer groups on non-resource child class from incorrectly influencing the decision
154	if (null !== $this->resourceClassResolver) {	12✔
155	$relatedClass = $this->resourceClassResolver->getResourceClass(null, $relatedClass);	12✔
156	}
157
158	$relatedGroups = $this->getClassSerializerGroups($relatedClass);	12✔
159
160	if (null === $propertyMetadata->isReadableLink()) {	12✔
161	$propertyMetadata = $propertyMetadata->withReadableLink(null !== $normalizationGroups && !empty(array_intersect($normalizationGroups, $relatedGroups)));	12✔
162	}
163
164	if (null === $propertyMetadata->isWritableLink()) {	12✔
165	$propertyMetadata = $propertyMetadata->withWritableLink(null !== $denormalizationGroups && !empty(array_intersect($denormalizationGroups, $relatedGroups)));	12✔
166	}
167
168	return $propertyMetadata;	12✔
169	}
170
171	/**
172	* Gets the effective serializer groups used in normalization/denormalization.
173	*
174	* Groups are extracted in the following order:
175	*
176	* - From the "serializer_groups" key of the $options array.
177	* - From metadata of the given operation ("collection_operation_name" and "item_operation_name" keys).
178	* - From metadata of the current resource.
179	*
180	* @throws ResourceClassNotFoundException
181	*
182	* @return (string[]\|null\|string)[]
183	*/
184	private function getEffectiveSerializerGroups(array $options, string $resourceClass): array
185	{
186	if (isset($options['serializer_groups'])) {	18✔
187	$groups = (array) $options['serializer_groups'];	2✔
188
189	return [$groups, $groups];	2✔
190	}
191
192	if (\array_key_exists('normalization_groups', $options) && \array_key_exists('denormalization_groups', $options)) {	18✔
193	return [$options['normalization_groups'] ?? null, $options['denormalization_groups'] ?? null];	13✔
194	}
195
196	// To avoid an injection recursion between PropertyMetadataFactory and ResourceMetadataFactory we ask for groups when an operation name is given in the context.
197	// This can be removed in 3.0 it must be an exception instead of a deprecation as `operation_name` means we use the new metadata system which isn't compatible
198	if (isset($options['operation_name'])) {	6✔
199	throw new \RuntimeException('You should specify "normalization_groups" and/or "denormalization_groups" when using the SerializerPropertyMetadataFactory.');	×
200	}
201
202	// TODO: 3.0 remove this code
203	if ($this->resourceMetadataFactory) {	6✔
204	$resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);	4✔
205	if (isset($options['collection_operation_name'])) {	4✔
206	$normalizationContext = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], 'normalization_context', null, true);	×
207	$denormalizationContext = $resourceMetadata->getCollectionOperationAttribute($options['collection_operation_name'], 'denormalization_context', null, true);	×
208	} elseif (isset($options['item_operation_name'])) {	4✔
209	$normalizationContext = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], 'normalization_context', null, true);	×
210	$denormalizationContext = $resourceMetadata->getItemOperationAttribute($options['item_operation_name'], 'denormalization_context', null, true);	×
211	} elseif (isset($options['graphql_operation_name'])) {	4✔
212	$normalizationContext = $resourceMetadata->getGraphqlAttribute($options['graphql_operation_name'], 'normalization_context', null, true);	×
213	$denormalizationContext = $resourceMetadata->getGraphqlAttribute($options['graphql_operation_name'], 'denormalization_context', null, true);	×
214	} else {
215	$normalizationContext = $resourceMetadata->getAttribute('normalization_context');	4✔
216	$denormalizationContext = $resourceMetadata->getAttribute('denormalization_context');	4✔
217	}
218
219	return [
220	isset($normalizationContext['groups']) ? (array) $normalizationContext['groups'] : null,	4✔
221	isset($denormalizationContext['groups']) ? (array) $denormalizationContext['groups'] : null,	4✔
222	];
223	}
224
225	return [null, null];	2✔
226	}
227
228	private function getSerializerAttributeMetadata(string $class, string $attribute): ?AttributeMetadataInterface
229	{
230	$serializerClassMetadata = $this->serializerClassMetadataFactory->getMetadataFor($class);	18✔
231
232	foreach ($serializerClassMetadata->getAttributesMetadata() as $serializerAttributeMetadata) {	18✔
233	if ($attribute === $serializerAttributeMetadata->getName()) {	17✔
234	return $serializerAttributeMetadata;	17✔
235	}
236	}
237
238	return null;	1✔
239	}
240
241	/**
242	* Gets all serializer groups used in a class.
243	*
244	* @return string[]
245	*/
246	private function getClassSerializerGroups(string $class): array
247	{
248	//TODO: 3.0 remove
249	if ($this->resourceMetadataFactory) {	12✔
250	$resourceMetadata = $this->resourceMetadataFactory->create($class);	3✔
251	if ($outputClass = $resourceMetadata->getAttribute('output')['class'] ?? null) {	3✔
252	trigger_deprecation('api-platform/core', '2.7', 'We found a property class that is a resource with a different output. You should instead use an output at a higher level or type the property to that class directly if you want to keep the behavior.');	1✔
253	$class = $outputClass;	1✔
254	}
255	}
256
257	$serializerClassMetadata = $this->serializerClassMetadataFactory->getMetadataFor($class);	12✔
258
259	$groups = [];	12✔
260	foreach ($serializerClassMetadata->getAttributesMetadata() as $serializerAttributeMetadata) {	12✔
261	$groups = array_merge($groups, $serializerAttributeMetadata->getGroups());	12✔
262	}
263
264	return array_unique($groups);	12✔
265	}
266	}

api-platform / core / #27598

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