vendor/api-platform/core/src/JsonApi/Serializer/ItemNormalizer.php line 58

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