15133993414

Committed 20 May 2025 09:30AM UTC coverage: 26.313% (-1.2%) from 27.493%

Build # 15133993414

Build Type

Pull #7161

github

Committed by

web-flow

Commit Message

Merge e2c03d45f into 5459ba375

Pull Request Pull Request #7161: fix(metadata): infer parameter string type from schema

Run Details

0 of 2 new or added lines in 1 file covered. (0.0%)

11019 existing lines in 363 files now uncovered.

12898 of 49018 relevant lines covered (26.31%)

34.33 hits per line

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

87.02

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

use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\Exception\ItemNotFoundException;
use ApiPlatform\Metadata\IriConverterInterface;
use ApiPlatform\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use ApiPlatform\Metadata\Property\Factory\PropertyNameCollectionFactoryInterface;
use ApiPlatform\Metadata\Resource\Factory\ResourceMetadataCollectionFactoryInterface;
use ApiPlatform\Metadata\ResourceAccessCheckerInterface;
use ApiPlatform\Metadata\ResourceClassResolverInterface;
use ApiPlatform\Metadata\UrlGeneratorInterface;
use ApiPlatform\Metadata\Util\ClassInfoTrait;
use ApiPlatform\Serializer\AbstractItemNormalizer;
use ApiPlatform\Serializer\CacheKeyTrait;
use ApiPlatform\Serializer\ContextTrait;
use ApiPlatform\Serializer\TagCollectorInterface;
use Symfony\Component\ErrorHandler\Exception\FlattenException;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
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\Mapping\Factory\ClassMetadataFactoryInterface;
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 array $componentsCache = [];

    public function __construct(PropertyNameCollectionFactoryInterface $propertyNameCollectionFactory, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver, ?PropertyAccessorInterface $propertyAccessor = null, ?NameConverterInterface $nameConverter = null, ?ClassMetadataFactoryInterface $classMetadataFactory = null, array $defaultContext = [], ?ResourceMetadataCollectionFactoryInterface $resourceMetadataCollectionFactory = null, ?ResourceAccessCheckerInterface $resourceAccessChecker = null, protected ?TagCollectorInterface $tagCollector = null)
    {
        parent::__construct($propertyNameCollectionFactory, $propertyMetadataFactory, $iriConverter, $resourceClassResolver, $propertyAccessor, $nameConverter, $classMetadataFactory, $defaultContext, $resourceMetadataCollectionFactory, $resourceAccessChecker, $tagCollector);
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
    {
        return self::FORMAT === $format && parent::supportsNormalization($data, $format, $context) && !($data instanceof \Exception || $data instanceof FlattenException);
    }

    public function getSupportedTypes($format): array
    {
        return self::FORMAT === $format ? parent::getSupportedTypes($format) : [];
    }

    /**
     * {@inheritdoc}
     */
    public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
    {
        $resourceClass = $this->getObjectClass($object);
        if ($this->getOutputClass($context)) {
            return parent::normalize($object, $format, $context);
        }

        $previousResourceClass = $context['resource_class'] ?? null;
        if ($this->resourceClassResolver->isResourceClass($resourceClass) && (null === $previousResourceClass || $this->resourceClassResolver->isResourceClass($previousResourceClass))) {
            $resourceClass = $this->resourceClassResolver->getResourceClass($object, $previousResourceClass);
        }

        if (($operation = $context['operation'] ?? null) && method_exists($operation, 'getItemUriTemplate')) {
            $context['item_uri_template'] = $operation->getItemUriTemplate();
        }

        $context = $this->initContext($resourceClass, $context);

        $iri = $context['iri'] ??= $this->iriConverter->getIriFromResource($object, UrlGeneratorInterface::ABS_PATH, $context['operation'] ?? null, $context);
        $context['object'] = $object;
        $context['format'] = $format;
        $context['api_normalize'] = true;

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

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

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

        // Do not include primary resources
        $context['api_included_resources'] = [$context['iri']];

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

        $resourceData = [
            'id' => $context['iri'],
            'type' => $this->getResourceShortName($resourceClass),
        ];

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

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

        $document = [];

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

        $document['data'] = $resourceData;

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

        return $document;
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
    {
        return self::FORMAT === $format && parent::supportsDenormalization($data, $type, $format, $context);
    }

    /**
     * {@inheritdoc}
     *
     * @throws NotNormalizableValueException
     */
    public function denormalize(mixed $data, string $class, ?string $format = null, array $context = []): mixed
    {
        // 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->getResourceFromIri(
                $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 $object, ?string $format = null, array $context = []): array
    {
        return $this->getComponents($object, $format, $context)['attributes'];
    }

    /**
     * {@inheritdoc}
     */
    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $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 UnexpectedValueException
     */
    protected function denormalizeRelation(string $attributeName, ApiProperty $propertyMetadata, string $className, mixed $value, ?string $format, array $context): ?object
    {
        if (!\is_array($value) || !isset($value['id'], $value['type'])) {
            throw new UnexpectedValueException('Only resource linkage supported currently, see: http://jsonapi.org/format/#document-resource-object-linkage.');
        }

        try {
            return $this->iriConverter->getResourceFromIri($value['id'], $context + ['fetch_data' => true]);
        } catch (ItemNotFoundException $e) {
            if (!isset($context['not_normalizable_value_exceptions'])) {
                throw new RuntimeException($e->getMessage(), $e->getCode(), $e);
            }
            $context['not_normalizable_value_exceptions'][] = NotNormalizableValueException::createForUnexpectedDataType(
                $e->getMessage(),
                $value,
                [$className],
                $context['deserialization_path'] ?? null,
                true,
                $e->getCode(),
                $e
            );

            return null;
        }
    }

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

            if (!$this->tagCollector && 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);
            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;
        }

        $context['data'] = [
            'data' => [
                'type' => $this->getResourceShortName($resourceClass),
                'id' => $iri,
            ],
        ];

        $context['iri'] = $iri;
        $context['object'] = $relatedObject;
        unset($context['property_metadata']);
        unset($context['api_attribute']);

        if ($this->tagCollector) {
            $this->tagCollector->collect($context);
        }

        return $context['data'];
    }

    /**
     * {@inheritdoc}
     */
    protected function isAllowedAttribute(object|string $classOrObject, string $attribute, ?string $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.
     */
    private function getComponents(object $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);

            $types = $propertyMetadata->getBuiltinTypes() ?? [];

            // prevent declaring $attribute as attribute if it's already declared as relationship
            $isRelationship = false;

            foreach ($types as $type) {
                $isOne = $isMany = false;

                if ($type->isCollection()) {
                    $collectionValueType = $type->getCollectionValueTypes()[0] ?? null;
                    $isMany = $collectionValueType && ($className = $collectionValueType->getClassName()) && $this->resourceClassResolver->isResourceClass($className);
                } else {
                    $isOne = ($className = $type->getClassName()) && $this->resourceClassResolver->isResourceClass($className);
                }

                if (!isset($className) || !$isOne && !$isMany) {
                    // don't declare it as an attribute too quick: maybe the next type is a valid resource
                    continue;
                }

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

                // if we specify the uriTemplate, generates its value for link definition
                // @see ApiPlatform\Serializer\AbstractItemNormalizer:getAttributeValue logic for intentional duplicate content
                if ($itemUriTemplate = $propertyMetadata->getUriTemplate()) {
                    $attributeValue = $this->propertyAccessor->getValue($object, $attribute);
                    $resourceClass = $this->resourceClassResolver->getResourceClass($attributeValue, $className);
                    $childContext = $this->createChildContext($context, $attribute, $format);
                    unset($childContext['iri'], $childContext['uri_variables'], $childContext['resource_class'], $childContext['operation']);

                    $operation = $this->resourceMetadataCollectionFactory->create($resourceClass)->getOperation(
                        operationName: $itemUriTemplate,
                        httpOperation: true
                    );

                    $components['links'][$attribute] = $this->iriConverter->getIriFromResource($object, UrlGeneratorInterface::ABS_PATH, $operation, $childContext);
                }

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

            // if all types are not relationships, declare it as an attribute
            if (!$isRelationship) {
                $components['attributes'][] = $attribute;
            }
        }

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

        return $components;
    }

    /**
     * Populates relationships keys.
     *
     * @throws UnexpectedValueException
     */
    private function getPopulatedRelations(object $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);
            }

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

            if (!$attributeValue) {
                continue;
            }

            // 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 $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'] = $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']) && !\in_array($data['id'], $context['api_included_resources'], true)) {
            $included[] = $data;
            // Track already included resources
            $context['api_included_resources'][] = $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) || \count($this->getIncludedNestedResources($relationshipName, $context)) > 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 fn (string $included): bool => str_starts_with($included, $normalizedName.'.'));

        return array_map(static fn (string $nested): string => substr($nested, strpos($nested, '.') + 1), $filtered);
    }

    // TODO: this code is similar to the one used in JsonLd
    private function getResourceShortName(string $resourceClass): string
    {
        if ($this->resourceClassResolver->isResourceClass($resourceClass)) {
            $resourceMetadata = $this->resourceMetadataCollectionFactory->create($resourceClass);

            return $resourceMetadata->getOperation()->getShortName();
        }

        return (new \ReflectionClass($resourceClass))->getShortName();
    }
}

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

api-platform / core / 15133993414

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