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 <[email protected]>
  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 <[email protected]>
  43.  * @author Amrouche Hamza <[email protected]>
  44.  * @author Baptiste Meyer <[email protected]>
  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 ($this->resourceClassResolver->isResourceClass($resourceClass)) {
  82.             $resourceClass = $this->resourceClassResolver->getResourceClass($object, $context['resource_class'] ?? null);
  83.         }
  85.         $context = $this->initContext($resourceClass, $context);
  86.         $iri = $this->iriConverter instanceof LegacyIriConverterInterface ? $this->iriConverter->getIriFromItem($object) : $this->iriConverter->getIriFromResource($object, UrlGeneratorInterface::ABS_PATH, $context['operation'] ?? null, $context);
  87.         $context['iri'] = $iri;
  88.         $context['api_normalize'] = true;
  90.         if (!isset($context['cache_key'])) {
  91.             $context['cache_key'] = $this->getCacheKey($format, $context);
  92.         }
  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.             if (!\is_string($normalizedRelatedObject) && !\is_array($normalizedRelatedObject) && !$normalizedRelatedObject instanceof \ArrayObject && null !== $normalizedRelatedObject) {
  241.                 throw new UnexpectedValueException('Expected normalized relation to be an IRI, array, \ArrayObject or null');
  242.             }
  244.             return $normalizedRelatedObject;
  245.         }
  247.         return [
  248.             'data' => [
  249.                 'type' => $this->getResourceShortName($resourceClass),
  250.                 'id' => $iri,
  251.             ],
  252.         ];
  253.     }
  255.     /**
  256.      * {@inheritdoc}
  257.      */
  258.     protected function isAllowedAttribute($classOrObject, $attribute, $format = null, array $context = []): bool
  259.     {
  260.         return preg_match('/^\\w[-\\w_]*$/', $attribute) && parent::isAllowedAttribute($classOrObject, $attribute, $format, $context);
  261.     }
  263.     /**
  264.      * Gets JSON API components of the resource: attributes, relationships, meta and links.
  265.      *
  266.      * @param object $object
  267.      */
  268.     private function getComponents($object, ?string $format, array $context): array
  269.     {
  270.         $cacheKey = $this->getObjectClass($object).'-'.$context['cache_key'];
  272.         if (isset($this->componentsCache[$cacheKey])) {
  273.             return $this->componentsCache[$cacheKey];
  274.         }
  276.         $attributes = parent::getAttributes($object, $format, $context);
  278.         $options = $this->getFactoryOptions($context);
  280.         $components = [
  281.             'links' => [],
  282.             'relationships' => [],
  283.             'attributes' => [],
  284.             'meta' => [],
  285.         ];
  287.         foreach ($attributes as $attribute) {
  288.             /** @var ApiProperty|PropertyMetadata */
  289.             $propertyMetadata = $this
  290.                 ->propertyMetadataFactory
  291.                 ->create($context['resource_class'], $attribute, $options);
  293.             // TODO: 3.0 support multiple types, default value of types will be [] instead of null
  294.             $type = $propertyMetadata instanceof PropertyMetadata ? $propertyMetadata->getType() : ($propertyMetadata->getBuiltinTypes()[0] ?? null);
  295.             $isOne = $isMany = false;
  297.             if (null !== $type) {
  298.                 if ($type->isCollection()) {
  299.                     $collectionValueType = method_exists(Type::class, 'getCollectionValueTypes') ? ($type->getCollectionValueTypes()[0] ?? null) : $type->getCollectionValueType();
  300.                     $isMany = ($collectionValueType && $className = $collectionValueType->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
  301.                 } else {
  302.                     $isOne = ($className = $type->getClassName()) ? $this->resourceClassResolver->isResourceClass($className) : false;
  303.                 }
  304.             }
  306.             if (!isset($className) || !$isOne && !$isMany) {
  307.                 $components['attributes'][] = $attribute;
  309.                 continue;
  310.             }
  312.             $relation = [
  313.                 'name' => $attribute,
  314.                 'type' => $this->getResourceShortName($className),
  315.                 'cardinality' => $isOne ? 'one' : 'many',
  316.             ];
  318.             $components['relationships'][] = $relation;
  319.         }
  321.         if (false !== $context['cache_key']) {
  322.             $this->componentsCache[$cacheKey] = $components;
  323.         }
  325.         return $components;
  326.     }
  328.     /**
  329.      * Populates relationships keys.
  330.      *
  331.      * @param object $object
  332.      *
  333.      * @throws UnexpectedValueException
  334.      */
  335.     private function getPopulatedRelations($object, ?string $format, array $context, array $relationships): array
  336.     {
  337.         $data = [];
  339.         if (!isset($context['resource_class'])) {
  340.             return $data;
  341.         }
  343.         unset($context['api_included']);
  344.         foreach ($relationships as $relationshipDataArray) {
  345.             $relationshipName = $relationshipDataArray['name'];
  347.             $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $context);
  349.             if ($this->nameConverter) {
  350.                 $relationshipName = $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context);
  351.             }
  353.             if (!$attributeValue) {
  354.                 continue;
  355.             }
  357.             $data[$relationshipName] = [
  358.                 'data' => [],
  359.             ];
  361.             // Many to one relationship
  362.             if ('one' === $relationshipDataArray['cardinality']) {
  363.                 unset($attributeValue['data']['attributes']);
  364.                 $data[$relationshipName] = $attributeValue;
  366.                 continue;
  367.             }
  369.             // Many to many relationship
  370.             foreach ($attributeValue as $attributeValueElement) {
  371.                 if (!isset($attributeValueElement['data'])) {
  372.                     throw new UnexpectedValueException(sprintf('The JSON API attribute \'%s\' must contain a "data" key.', $relationshipName));
  373.                 }
  374.                 unset($attributeValueElement['data']['attributes']);
  375.                 $data[$relationshipName]['data'][] = $attributeValueElement['data'];
  376.             }
  377.         }
  379.         return $data;
  380.     }
  382.     /**
  383.      * Populates included keys.
  384.      *
  385.      * @param mixed $object
  386.      */
  387.     private function getRelatedResources($object, ?string $format, array $context, array $relationships): array
  388.     {
  389.         if (!isset($context['api_included'])) {
  390.             return [];
  391.         }
  393.         $included = [];
  394.         foreach ($relationships as $relationshipDataArray) {
  395.             $relationshipName = $relationshipDataArray['name'];
  397.             if (!$this->shouldIncludeRelation($relationshipName, $context)) {
  398.                 continue;
  399.             }
  401.             $relationContext = $context;
  402.             $relationContext['api_included'] = $this->getIncludedNestedResources($relationshipName, $context);
  404.             $attributeValue = $this->getAttributeValue($object, $relationshipName, $format, $relationContext);
  406.             if (!$attributeValue) {
  407.                 continue;
  408.             }
  410.             // Many to many relationship
  411.             $attributeValues = $attributeValue;
  412.             // Many to one relationship
  413.             if ('one' === $relationshipDataArray['cardinality']) {
  414.                 $attributeValues = [$attributeValue];
  415.             }
  417.             foreach ($attributeValues as $attributeValueElement) {
  418.                 if (isset($attributeValueElement['data'])) {
  419.                     $this->addIncluded($attributeValueElement['data'], $included, $context);
  420.                     if (isset($attributeValueElement['included']) && \is_array($attributeValueElement['included'])) {
  421.                         foreach ($attributeValueElement['included'] as $include) {
  422.                             $this->addIncluded($include, $included, $context);
  423.                         }
  424.                     }
  425.                 }
  426.             }
  427.         }
  429.         return $included;
  430.     }
  432.     /**
  433.      * Add data to included array if it's not already included.
  434.      */
  435.     private function addIncluded(array $data, array &$included, array &$context): void
  436.     {
  437.         if (isset($data['id']) && !\in_array($data['id'], $context['api_included_resources'], true)) {
  438.             $included[] = $data;
  439.             // Track already included resources
  440.             $context['api_included_resources'][] = $data['id'];
  441.         }
  442.     }
  444.     /**
  445.      * Figures out if the relationship is in the api_included hash or has included nested resources (path).
  446.      */
  447.     private function shouldIncludeRelation(string $relationshipName, array $context): bool
  448.     {
  449.         $normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;
  451.         return \in_array($normalizedName, $context['api_included'], true) || \count($this->getIncludedNestedResources($relationshipName, $context)) > 0;
  452.     }
  454.     /**
  455.      * Returns the names of the nested resources from a path relationship.
  456.      */
  457.     private function getIncludedNestedResources(string $relationshipName, array $context): array
  458.     {
  459.         $normalizedName = $this->nameConverter ? $this->nameConverter->normalize($relationshipName, $context['resource_class'], self::FORMAT, $context) : $relationshipName;
  461.         $filtered = array_filter($context['api_included'] ?? [], static function (string $included) use ($normalizedName) {
  462.             return 0 === strpos($included, $normalizedName.'.');
  463.         });
  465.         return array_map(static function (string $nested) {
  466.             return substr($nested, strpos($nested, '.') + 1);
  467.         }, $filtered);
  468.     }
  470.     // TODO: 3.0 remove
  471.     private function getResourceShortName(string $resourceClass): string
  472.     {
  473.         /** @var ResourceMetadata|ResourceMetadataCollection */
  474.         $resourceMetadata = $this->resourceMetadataFactory->create($resourceClass);
  476.         if ($resourceMetadata instanceof ResourceMetadata) {
  477.             return $resourceMetadata->getShortName();
  478.         }
  480.         return $resourceMetadata->getOperation()->getShortName();
  481.     }
  482. }
  484. class_alias(ItemNormalizer::class, \ApiPlatform\Core\JsonApi\Serializer\ItemNormalizer::class);