#26828

Build Type

push

github

Committed by GitHub

Commit Message

<a href="https://github.com/api-platform/core/commit/<a class=hub.com/api-platform/core/commit/fb8bbd24be7e657850d1c45e932448462bd2775c">fb8bbd24b<a href="https://github.com/api-platform/core/commit/fb8bbd24be7e657850d1c45e932448462bd2775c">">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/e445091e764200c7fb7333879ab019aa07bbe0fc">e445091e7</a>">e445091e7</a><a href="https://github.com/api-platform/core/commit/fb8bbd24be7e657850d1c45e932448462bd2775c"> into 4717bd564">4717bd564</a>

Run Details

29 of 29 new or added lines in 1 file covered. (100.0%)

9620 of 11608 relevant lines covered (82.87%)

14.24 hits per line

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

44.81

/src/JsonApi/Serializer/ItemNormalizer.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\JsonApi\Serializer;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Exception\ItemNotFoundException;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
use ApiPlatform\Core\Security\ResourceAccessCheckerInterface;
use ApiPlatform\Core\Serializer\AbstractItemNormalizer;
use ApiPlatform\Core\Serializer\CacheKeyTrait;
use ApiPlatform\Core\Serializer\ContextTrait;
use ApiPlatform\Core\Util\ClassInfoTrait;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
use Symfony\Component\PropertyInfo\Type;
use Symfony\Component\Serializer\Exception\LogicException;
use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
use Symfony\Component\Serializer\Exception\RuntimeException;
use Symfony\Component\Serializer\Exception\UnexpectedValueException;
use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

/**
 * Converts between objects and array.
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 * @author Amrouche Hamza <hamza.simperfit@gmail.com>
 * @author Baptiste Meyer <baptiste.meyer@gmail.com>
 */
final class ItemNormalizer extends AbstractItemNormalizer
{
    use CacheKeyTrait;
    use ClassInfoTrait;
    use ContextTrait;

    public const FORMAT = 'jsonapi';

    private $componentsCache = [];

    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor, ?NameConverterInterface $nameConverter, ResourceMetadataFactoryInterface $resourceMetadataFactory, array $defaultContext = [], iterable $dataTransformers = [], ResourceAccessCheckerInterface $resourceAccessChecker = null)
    {
        parent::__construct($propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, $propertyAccessor, $nameConverter, null, null, false, $defaultContext, $dataTransformers, $resourceMetadataFactory, $resourceAccessChecker);
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null): bool
    {
        return self::FORMAT === $format && parent::supportsNormalization($data, $format);
    }

    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        if (null !== $this->getOutputClass($this->getObjectClass($object), $context)) {
            return parent::normalize($object, $format, $context);
        }

        if (!isset($context['cache_key'])) {
            $context['cache_key'] = $this->getCacheKey($format, $context);
        }

        $resourceClass = $this->resourceClassResolver->getResourceClass($object, $context['resource_class'] ?? null);
        $context = $this->initContext($resourceClass, $context);
        $iri = $this->iriConverter->getIriFromItem($object);
        $context['iri'] = $iri;
        $context['api_normalize'] = true;

        $data = parent::normalize($object, $format, $context);
        if (!\is_array($data)) {
            return $data;
        }

        $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);

        // Get and populate relations
        $allRelationshipsData = $this->getComponents($object, $format, $context)['relationships'];
        $populatedRelationContext = $context;
        $relationshipsData = $this->getPopulatedRelations($object, $format, $populatedRelationContext, $allRelationshipsData);

        // Do not include primary resources
        $context['api_included_resources'] = [$resourceMetadata->getShortName() => [$context['iri']]];

        $includedResourcesData = $this->getRelatedResources($object, $format, $context, $allRelationshipsData);

        $resourceData = [
            'id' => $context['iri'],
            'type' => $resourceMetadata->getShortName(),
        ];

        if ($data) {
            $resourceData['attributes'] = $data;
        }

        if ($relationshipsData) {
            $resourceData['relationships'] = $relationshipsData;
        }

        $document = ['data' => $resourceData];

        if ($includedResourcesData) {
            $document['included'] = $includedResourcesData;
        }

        return $document;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization($data, $type, $format = null): bool
    {
        return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format);
    }

    /**
     * {@inheritdoc}
     *
     * @throws NotNormalizableValueException
     */
    public function denormalize($data, $class, $format = null, array $context = [])
    {
        // Avoid issues with proxies if we populated the object
        if (!isset($context[self::OBJECT_TO_POPULATE]) && isset($data['data']['id'])) {
            if (true !== ($context['api_allow_update'] ?? true)) {
                throw new NotNormalizableValueException('Update is not allowed for this operation.');
            }

            $context[self::OBJECT_TO_POPULATE] = $this->iriConverter->getItemFromIri(
                $data['data']['id'],
                $context + ['fetch_data' => false]
            );
        }

        // Merge attributes and relationships, into format expected by the parent normalizer
        $dataToDenormalize = array_merge(
            $data['data']['attributes'] ?? [],
            $data['data']['relationships'] ?? []
        );

        return parent::denormalize(
            $dataToDenormalize,
            $class,
            $format,
            $context
        );
    }

    /**
     * {@inheritdoc}
     */
    protected function getAttributes($object, $format = null, array $context = []): array
    {
        return $this->getComponents($object, $format, $context)['attributes'];
    }

    /**
     * {@inheritdoc}
     */
    protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []): void
    {
        parent::setAttributeValue($object, $attribute, \is_array($value) && \array_key_exists('data', $value) ? $value['data'] : $value, $format, $context);
    }

    /**
     * {@inheritdoc}
     *
     * @see http://jsonapi.org/format/#document-resource-object-linkage
     *
     * @throws RuntimeException
     * @throws NotNormalizableValueException
     */
    protected function denormalizeRelation(string $attributeName, PropertyMetadata $propertyMetadata, string $className, $value, ?string $format, array $context)
    {
        if (!\is_array($value) || !isset($value['id'], $value['type'])) {
            throw new NotNormalizableValueException('Only resource linkage supported currently, see: http://jsonapi.org/format/#document-resource-object-linkage.');
        }

        try {
            return $this->iriConverter->getItemFromIri($value['id'], $context + ['fetch_data' => true]);
        } catch (ItemNotFoundException $e) {
            throw new RuntimeException($e->getMessage(), $e->getCode(), $e);
        }
    }

    /**
     * {@inheritdoc}
     *
     * @see http://jsonapi.org/format/#document-resource-object-linkage
     */
    protected function normalizeRelation(PropertyMetadata $propertyMetadata, $relatedObject, string $resourceClass, ?string $format, array $context)
    {
        if (null !== $relatedObject) {
            $iri = $this->iriConverter->getIriFromItem($relatedObject);
            $context['iri'] = $iri;

            if (isset($context['resources'])) {
                $context['resources'][$iri] = $iri;
            }
        }

        if (null === $relatedObject || isset($context['api_included'])) {
            if (!$this->serializer instanceof NormalizerInterface) {
                throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));
            }

            $normalizedRelatedObject = $this->serializer->normalize($relatedObject, $format, $context);
            // @phpstan-ignore-next-line throwing an explicit exception helps debugging
            if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {
                throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');
            }

            return $normalizedRelatedObject;
        }

        return [
            'data' => [
                'type' => $this->resourceMetadataFactory->create($resourceClass)->getShortName(),
                'id' => $iri,
            ],
        ];
    }

    /**
     * {@inheritdoc}
     */
    protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = []): bool
    {
        return preg_match('/^\\w[-\\w_]*$/', $attribute) && parent::isAllowedAttribute($classOrObject, $attribute, $format, $context);
    }

    /**
     * Gets JSON API components of the resource: attributes, relationships, meta and links.
     *
     * @param object $object
     */
    private function getComponents($object, ?string $format, array $context): array
    {
        $cacheKey = $this->getObjectClass($object).'-'.$context['cache_key'];

        if (isset($this->componentsCache[$cacheKey])) {
            return $this->componentsCache[$cacheKey];
        }

        $attributes = parent::getAttributes($object, $format, $context);

        $options = $this->getFactoryOptions($context);

        $components = [
            'links' => [],
            'relationships' => [],
            'attributes' => [],
            'meta' => [],
        ];

        foreach ($attributes as $attribute) {
            $propertyMetadata = $this
                ->propertyMetadataFactory
                ->create($context['resource_class'], $attribute, $options);

            $type = $propertyMetadata->getType();
            $isOne = $isMany = false;

            if (null !== $type) {
                if ($type->isCollection()) {
                    $collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType();
                    $isMany = ($collectionValueType && $className = $collectionValueType->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
                } else {
                    $isOne = ($className = $type->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
                }
            }

            if (!isset($className) || !$isOne && !$isMany) {
                $components['attributes'][] = $attribute;

                continue;
            }

            $relation = [
                'name' => $attribute,
                'type' => $this->resourceMetadataFactory->create($className)->getShortName(),
                'cardinality' => $isOne ? 'one' : 'many',
            ];

            $components['relationships'][] = $relation;
        }

        if (false !== $context['cache_key']) {
            $this->componentsCache[$cacheKey] = $components;
        }

        return $components;
    }

    /**
     * Populates relationships keys.
     *
     * @param object $object
     *
     * @throws UnexpectedValueException
     */
    private function getPopulatedRelations($object, ?string $format, array $context, array $relationships): array
    {
        $data = [];

        if (!isset($context['resource_class'])) {
            return $data;
        }

        unset($context['api_included']);
        foreach ($relationships as $relationshipDataArray) {
            $relationshipName = $relationshipDataArray['name'];

            $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $context);

            if ($this->nameConverter) {
                $relationshipName = $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context);
            }

            if (!$attributeValue) {
                continue;
            }

            $data[$relationshipName] = [
                'data' => [],
            ];

            // Many to one relationship
            if ('one' === $relationshipDataArray['cardinality']) {
                unset($attributeValue['data']['attributes']);
                $data[$relationshipName] = $attributeValue;

                continue;
            }

            // Many to many relationship
            foreach ($attributeValue as $attributeValueElement) {
                if (!isset($attributeValueElement['data'])) {
                    throw new UnexpectedValueException(sprintf('The JSON API attribute \'%s\' must contain a "data" key.', $relationshipName));
                }
                unset($attributeValueElement['data']['attributes']);
                $data[$relationshipName]['data'][] = $attributeValueElement['data'];
            }
        }

        return $data;
    }

    /**
     * Populates included keys.
     */
    private function getRelatedResources($object, ?string $format, array $context, array $relationships): array
    {
        if (!isset($context['api_included'])) {
            return [];
        }

        $included = [];
        foreach ($relationships as $relationshipDataArray) {
            $relationshipName = $relationshipDataArray['name'];

            if (!$this->shouldIncludeRelation($relationshipName, $context)) {
                continue;
            }

            $relationContext = $context;
            $relationContext['api_included'] = [];
            if ($this->hasIncludedNestedResources($relationshipName, $context)) {
                $relationContext['api_included'] = $this->getIncludedNestedResources($relationshipName, $context);
            }
            $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $relationContext);

            if (!$attributeValue) {
                continue;
            }

            // Many to many relationship
            $attributeValues = $attributeValue;
            // Many to one relationship
            if ('one' === $relationshipDataArray['cardinality']) {
                $attributeValues = [$attributeValue];
            }

            foreach ($attributeValues as $attributeValueElement) {
                if (isset($attributeValueElement['data'])) {
                    $this->addIncluded($attributeValueElement['data'], $included, $context);
                    if (isset($attributeValueElement['included']) && \is_array($attributeValueElement['included'])) {
                        foreach ($attributeValueElement['included'] as $include) {
                            $this->addIncluded($include, $included, $context);
                        }
                    }
                }
            }
        }

        return $included;
    }

    /**
     * Add data to included array if it's not already included.
     */
    private function addIncluded(array $data, array &$included, array &$context): void
    {
        if (isset($data['id'], $data['type'])) {
            if (!isset($context['api_included_resources'][$data['type']])) {
                $context['api_included_resources'][$data['type']] = [];
            }
            if (!\in_array($data['id'], $context['api_included_resources'][$data['type']], true)) {
                $included[] = $data;
                // Track already included resources
                $context['api_included_resources'][$data['type']][] = $data['id'];
            }
        }
    }

    /**
     * Figures out if the relationship is in the api_included hash or has included nested resources (path).
     */
    private function shouldIncludeRelation(string $relationshipName, array $context): bool
    {
        $normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;

        return \in_array($normalizedName, $context['api_included'], true) || $this->hasIncludedNestedResources($relationshipName, $context);
    }

    /**
     * Returns true if the relationship has included nested resources (path).
     */
    private function hasIncludedNestedResources(string $relationshipName, array $context): bool
    {
        $nested = $this->getIncludedNestedResources($relationshipName, $context);

        return \count($nested) > 0;
    }

    /**
     * Returns the names of the nested resources from a path relationship.
     */
    private function getIncludedNestedResources(string $relationshipName, array $context): array
    {
        $normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;

        $filtered = array_filter($context['api_included'], static function (string $included) use ($normalizedName) {
            return 0 === strpos($included, $normalizedName.'.');
        });

        return array_map(static function (string $nested) {
            return substr($nested, strpos($nested, '.') + 1);
        }, $filtered);
    }
}

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\JsonApi\Serializer;
15
16	use ApiPlatform\Core\Api\IriConverterInterface;
17	use ApiPlatform\Core\Api\ResourceClassResolverInterface;
18	use ApiPlatform\Core\Exception\ItemNotFoundException;
19	use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
20	use ApiPlatform\Core\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
21	use ApiPlatform\Core\Metadata\Property\PropertyMetadata;
22	use ApiPlatform\Core\Metadata\Resource\Factory\ResourceMetadataFactoryInterface;
23	use ApiPlatform\Core\Security\ResourceAccessCheckerInterface;
24	use ApiPlatform\Core\Serializer\AbstractItemNormalizer;
25	use ApiPlatform\Core\Serializer\CacheKeyTrait;
26	use ApiPlatform\Core\Serializer\ContextTrait;
27	use ApiPlatform\Core\Util\ClassInfoTrait;
28	use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
29	use Symfony\Component\PropertyInfo\Type;
30	use Symfony\Component\Serializer\Exception\LogicException;
31	use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
32	use Symfony\Component\Serializer\Exception\RuntimeException;
33	use Symfony\Component\Serializer\Exception\UnexpectedValueException;
34	use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
35	use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
36
37	/**
38	* Converts between objects and array.
39	*
40	* @author Kévin Dunglas <dunglas@gmail.com>
41	* @author Amrouche Hamza <hamza.simperfit@gmail.com>
42	* @author Baptiste Meyer <baptiste.meyer@gmail.com>
43	*/
44	final class ItemNormalizer extends AbstractItemNormalizer
45	{
46	use CacheKeyTrait;
47	use ClassInfoTrait;
48	use ContextTrait;
49
50	public const FORMAT = 'jsonapi';
51
52	private $componentsCache = [];
53
54	public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor, ?NameConverterInterface $nameConverter, ResourceMetadataFactoryInterface $resourceMetadataFactory, array $defaultContext = [], iterable $dataTransformers = [], ResourceAccessCheckerInterface $resourceAccessChecker = null)
55	{
56	parent::__construct($propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, $propertyAccessor, $nameConverter, null, null, false, $defaultContext, $dataTransformers, $resourceMetadataFactory, $resourceAccessChecker);	41✔
57	}	41✔
58
59	/**
60	* {@inheritdoc}
61	*/
62	public function supportsNormalization($data, $format = null): bool
63	{
64	return self::FORMAT === $format && parent::supportsNormalization($data, $format);	17✔
65	}
66
67	/**
68	* {@inheritdoc}
69	*/
70	public function normalize($object, $format = null, array $context = [])
71	{
72	if (null !== $this->getOutputClass($this->getObjectClass($object), $context)) {	4✔
73	return parent::normalize($object, $format, $context);	×
74	}
75
76	if (!isset($context['cache_key'])) {	4✔
77	$context['cache_key'] = $this->getCacheKey($format, $context);	4✔
78	}
79
80	$resourceClass = $this->resourceClassResolver->getResourceClass($object, $context['resource_class'] ?? null);	4✔
81	$context = $this->initContext($resourceClass, $context);	4✔
82	$iri = $this->iriConverter->getIriFromItem($object);	4✔
83	$context['iri'] = $iri;	4✔
84	$context['api_normalize'] = true;	4✔
85
86	$data = parent::normalize($object, $format, $context);	4✔
87	if (!\is_array($data)) {	3✔
88	return $data;	1✔
89	}
90
91	$resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);	2✔
92
93	// Get and populate relations
94	$allRelationshipsData = $this->getComponents($object, $format, $context)['relationships'];	2✔
95	$populatedRelationContext = $context;	2✔
96	$relationshipsData = $this->getPopulatedRelations($object, $format, $populatedRelationContext, $allRelationshipsData);	2✔
97
98	// Do not include primary resources
99	$context['api_included_resources'] = [$resourceMetadata->getShortName() => [$context['iri']]];	2✔
100
101	$includedResourcesData = $this->getRelatedResources($object, $format, $context, $allRelationshipsData);	2✔
102
103	$resourceData = [
104	'id' => $context['iri'],	2✔
105	'type' => $resourceMetadata->getShortName(),	2✔
106	];
107
108	if ($data) {	2✔
109	$resourceData['attributes'] = $data;	2✔
110	}
111
112	if ($relationshipsData) {	2✔
113	$resourceData['relationships'] = $relationshipsData;	×
114	}
115
116	$document = ['data' => $resourceData];	2✔
117
118	if ($includedResourcesData) {	2✔
119	$document['included'] = $includedResourcesData;	×
120	}
121
122	return $document;	2✔
123	}
124
125	/**
126	* {@inheritdoc}
127	*/
128	public function supportsDenormalization($data, $type, $format = null): bool
129	{
130	return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format);	5✔
131	}
132
133	/**
134	* {@inheritdoc}
135	*
136	* @throws NotNormalizableValueException
137	*/
138	public function denormalize($data, $class, $format = null, array $context = [])
139	{
140	// Avoid issues with proxies if we populated the object
141	if (!isset($context[self::OBJECT_TO_POPULATE]) && isset($data['data']['id'])) {	5✔
142	if (true !== ($context['api_allow_update'] ?? true)) {	1✔
143	throw new NotNormalizableValueException('Update is not allowed for this operation.');	1✔
144	}
145
146	$context[self::OBJECT_TO_POPULATE] = $this->iriConverter->getItemFromIri(	×
147	$data['data']['id'],	×
148	$context + ['fetch_data' => false]	×
149	);
150	}
151
152	// Merge attributes and relationships, into format expected by the parent normalizer
153	$dataToDenormalize = array_merge(	4✔
154	$data['data']['attributes'] ?? [],	4✔
155	$data['data']['relationships'] ?? []	4✔
156	);
157
158	return parent::denormalize(	4✔
159	$dataToDenormalize,	4✔
160	$class,
161	$format,
162	$context
163	);
164	}
165
166	/**
167	* {@inheritdoc}
168	*/
169	protected function getAttributes($object, $format = null, array $context = []): array
170	{
171	return $this->getComponents($object, $format, $context)['attributes'];	3✔
172	}
173
174	/**
175	* {@inheritdoc}
176	*/
177	protected function setAttributeValue($object, $attribute, $value, $format = null, array $context = []): void
178	{
179	parent::setAttributeValue($object, $attribute, \is_array($value) && \array_key_exists('data', $value) ? $value['data'] : $value, $format, $context);	4✔
180	}	1✔
181
182	/**
183	* {@inheritdoc}
184	*
185	* @see http://jsonapi.org/format/#document-resource-object-linkage
186	*
187	* @throws RuntimeException
188	* @throws NotNormalizableValueException
189	*/
190	protected function denormalizeRelation(string $attributeName, PropertyMetadata $propertyMetadata, string $className, $value, ?string $format, array $context)
191	{
192	if (!\is_array($value) \|\| !isset($value['id'], $value['type'])) {	2✔
193	throw new NotNormalizableValueException('Only resource linkage supported currently, see: http://jsonapi.org/format/#document-resource-object-linkage.');	1✔
194	}
195
196	try {
197	return $this->iriConverter->getItemFromIri($value['id'], $context + ['fetch_data' => true]);	1✔
198	} catch (ItemNotFoundException $e) {	×
199	throw new RuntimeException($e->getMessage(), $e->getCode(), $e);	×
200	}
201	}
202
203	/**
204	* {@inheritdoc}
205	*
206	* @see http://jsonapi.org/format/#document-resource-object-linkage
207	*/
208	protected function normalizeRelation(PropertyMetadata $propertyMetadata, $relatedObject, string $resourceClass, ?string $format, array $context)
209	{
210	if (null !== $relatedObject) {	×
211	$iri = $this->iriConverter->getIriFromItem($relatedObject);	×
212	$context['iri'] = $iri;	×
213
214	if (isset($context['resources'])) {	×
215	$context['resources'][$iri] = $iri;	×
216	}
217	}
218
219	if (null === $relatedObject \|\| isset($context['api_included'])) {	×
220	if (!$this->serializer instanceof NormalizerInterface) {	×
221	throw new LogicException(sprintf('The injected serializer must be an instance of "%s".', NormalizerInterface::class));	×
222	}
223
224	$normalizedRelatedObject = $this->serializer->normalize($relatedObject, $format, $context);	×
225	// @phpstan-ignore-next-line throwing an explicit exception helps debugging
226	if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {	×
227	throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');	×
228	}
229
230	return $normalizedRelatedObject;	×
231	}
232
233	return [
234	'data' => [
235	'type' => $this->resourceMetadataFactory->create($resourceClass)->getShortName(),	×
236	'id' => $iri,	×
237	],
238	];
239	}
240
241	/**
242	* {@inheritdoc}
243	*/
244	protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = []): bool
245	{
246	return preg_match('/^\\w[-\\w_]*$/', $attribute) && parent::isAllowedAttribute($classOrObject, $attribute, $format, $context);	7✔
247	}
248
249	/**
250	* Gets JSON API components of the resource: attributes, relationships, meta and links.
251	*
252	* @param object $object
253	*/
254	private function getComponents($object, ?string $format, array $context): array
255	{
256	$cacheKey = $this->getObjectClass($object).'-'.$context['cache_key'];	3✔
257
258	if (isset($this->componentsCache[$cacheKey])) {	3✔
259	return $this->componentsCache[$cacheKey];	2✔
260	}
261
262	$attributes = parent::getAttributes($object, $format, $context);	3✔
263
264	$options = $this->getFactoryOptions($context);	3✔
265
266	$components = [
267	'links' => [],	3✔
268	'relationships' => [],
269	'attributes' => [],
270	'meta' => [],
271	];
272
273	foreach ($attributes as $attribute) {	3✔
274	$propertyMetadata = $this
275	->propertyMetadataFactory	3✔
276	->create($context['resource_class'], $attribute, $options);	3✔
277
278	$type = $propertyMetadata->getType();	3✔
279	$isOne = $isMany = false;	3✔
280
281	if (null !== $type) {	3✔
282	if ($type->isCollection()) {	×
283	$collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType();	×
284	$isMany = ($collectionValueType && $className = $collectionValueType->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;	×
285	} else {
286	$isOne = ($className = $type->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;	×
287	}
288	}
289
290	if (!isset($className) \|\| !$isOne && !$isMany) {	3✔
291	$components['attributes'][] = $attribute;	3✔
292
293	continue;	3✔
294	}
295
296	$relation = [
297	'name' => $attribute,	×
298	'type' => $this->resourceMetadataFactory->create($className)->getShortName(),	×
299	'cardinality' => $isOne ? 'one' : 'many',	×
300	];
301
302	$components['relationships'][] = $relation;	×
303	}
304
305	if (false !== $context['cache_key']) {	3✔
306	$this->componentsCache[$cacheKey] = $components;	3✔
307	}
308
309	return $components;	3✔
310	}
311
312	/**
313	* Populates relationships keys.
314	*
315	* @param object $object
316	*
317	* @throws UnexpectedValueException
318	*/
319	private function getPopulatedRelations($object, ?string $format, array $context, array $relationships): array
320	{
321	$data = [];	2✔
322
323	if (!isset($context['resource_class'])) {	2✔
324	return $data;	×
325	}
326
327	unset($context['api_included']);	2✔
328	foreach ($relationships as $relationshipDataArray) {	2✔
329	$relationshipName = $relationshipDataArray['name'];	×
330
331	$attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $context);	×
332
333	if ($this->nameConverter) {	×
334	$relationshipName = $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context);	×
335	}
336
337	if (!$attributeValue) {	×
338	continue;	×
339	}
340
341	$data[$relationshipName] = [	×
342	'data' => [],
343	];
344
345	// Many to one relationship
346	if ('one' === $relationshipDataArray['cardinality']) {	×
347	unset($attributeValue['data']['attributes']);	×
348	$data[$relationshipName] = $attributeValue;	×
349
350	continue;	×
351	}
352
353	// Many to many relationship
354	foreach ($attributeValue as $attributeValueElement) {	×
355	if (!isset($attributeValueElement['data'])) {	×
356	throw new UnexpectedValueException(sprintf('The JSON API attribute \'%s\' must contain a "data" key.', $relationshipName));	×
357	}
358	unset($attributeValueElement['data']['attributes']);	×
359	$data[$relationshipName]['data'][] = $attributeValueElement['data'];	×
360	}
361	}
362
363	return $data;	2✔
364	}
365
366	/**
367	* Populates included keys.
368	*/
369	private function getRelatedResources($object, ?string $format, array $context, array $relationships): array
370	{
371	if (!isset($context['api_included'])) {	2✔
372	return [];	2✔
373	}
374
375	$included = [];	×
376	foreach ($relationships as $relationshipDataArray) {	×
377	$relationshipName = $relationshipDataArray['name'];	×
378
379	if (!$this->shouldIncludeRelation($relationshipName, $context)) {	×
380	continue;	×
381	}
382
383	$relationContext = $context;	×
384	$relationContext['api_included'] = [];	×
385	if ($this->hasIncludedNestedResources($relationshipName, $context)) {	×
386	$relationContext['api_included'] = $this->getIncludedNestedResources($relationshipName, $context);	×
387	}
388	$attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $relationContext);	×
389
390	if (!$attributeValue) {	×
391	continue;	×
392	}
393
394	// Many to many relationship
395	$attributeValues = $attributeValue;	×
396	// Many to one relationship
397	if ('one' === $relationshipDataArray['cardinality']) {	×
398	$attributeValues = [$attributeValue];	×
399	}
400
401	foreach ($attributeValues as $attributeValueElement) {	×
402	if (isset($attributeValueElement['data'])) {	×
403	$this->addIncluded($attributeValueElement['data'], $included, $context);	×
404	if (isset($attributeValueElement['included']) && \is_array($attributeValueElement['included'])) {	×
405	foreach ($attributeValueElement['included'] as $include) {	×
406	$this->addIncluded($include, $included, $context);	×
407	}
408	}
409	}
410	}
411	}
412
413	return $included;	×
414	}
415
416	/**
417	* Add data to included array if it's not already included.
418	*/
419	private function addIncluded(array $data, array &$included, array &$context): void
420	{
421	if (isset($data['id'], $data['type'])) {	×
422	if (!isset($context['api_included_resources'][$data['type']])) {	×
423	$context['api_included_resources'][$data['type']] = [];	×
424	}
425	if (!\in_array($data['id'], $context['api_included_resources'][$data['type']], true)) {	×
426	$included[] = $data;	×
427	// Track already included resources
428	$context['api_included_resources'][$data['type']][] = $data['id'];	×
429	}
430	}
431	}	×
432
433	/**
434	* Figures out if the relationship is in the api_included hash or has included nested resources (path).
435	*/
436	private function shouldIncludeRelation(string $relationshipName, array $context): bool
437	{
438	$normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;	×
439
440	return \in_array($normalizedName, $context['api_included'], true) \|\| $this->hasIncludedNestedResources($relationshipName, $context);	×
441	}
442
443	/**
444	* Returns true if the relationship has included nested resources (path).
445	*/
446	private function hasIncludedNestedResources(string $relationshipName, array $context): bool
447	{
448	$nested = $this->getIncludedNestedResources($relationshipName, $context);	×
449
450	return \count($nested) > 0;	×
451	}
452
453	/**
454	* Returns the names of the nested resources from a path relationship.
455	*/
456	private function getIncludedNestedResources(string $relationshipName, array $context): array
457	{
458	$normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;	×
459
460	$filtered = array_filter($context['api_included'], static function (string $included) use ($normalizedName) {
461	return 0 === strpos($included, $normalizedName.'.');	×
462	});	×
463
464	return array_map(static function (string $nested) {
465	return substr($nested, strpos($nested, '.') + 1);	×
466	}, $filtered);	×
467	}
468	}

api-platform / core / #26828

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