Provide an opt-in ItemNormalizer decorator to help with `id` identified resources

[soyuka]

See #2022 (comment) for more details.

refs: #1937, #2018, #1741, api-platform/api-platform#343 #2022

[soullivaneuh]

@dunglas I finally end up with this workaround:

services:
    App\Normalizer\ItemNormalizer:
        arguments:
            $normalizer: '@api_platform.serializer.normalizer.item'

namespace App\Normalizer;

use ApiPlatform\Core\Api\IriConverterInterface;
use ApiPlatform\Core\Api\ResourceClassResolverInterface;
use ApiPlatform\Core\Exception\InvalidArgumentException;
use ApiPlatform\Core\Metadata\Property\Factory\PropertyMetadataFactoryInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\NormalizerInterface;

/**
 * @see https://github.com/api-platform/core/pull/2022#issuecomment-398861586
 * @see https://github.com/api-platform/core/issues/2200
 */
final class ItemNormalizer implements NormalizerInterface, DenormalizerInterface
{
    /**
     * @var NormalizerInterface|DenormalizerInterface
     */
    private $normalizer;

    /**
     * @var PropertyMetadataFactoryInterface
     */
    private $propertyMetadataFactory;

    /**
     * @var IriConverterInterface
     */
    private $iriConverter;

    /**
     * @var ResourceClassResolverInterface
     */
    private $resourceClassResolver;

    public function __construct(NormalizerInterface $normalizer, PropertyMetadataFactoryInterface $propertyMetadataFactory, IriConverterInterface $iriConverter, ResourceClassResolverInterface $resourceClassResolver)
    {
        $this->normalizer = $normalizer;
        $this->propertyMetadataFactory = $propertyMetadataFactory;
        $this->iriConverter = $iriConverter;
        $this->resourceClassResolver = $resourceClassResolver;
    }

    /**
     * {@inheritdoc}
     */
    public function normalize($object, $format = null, array $context = [])
    {
        return $this->normalizer->normalize($object, $format, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function supportsNormalization($data, $format = null)
    {
        return $this->normalizer->supportsNormalization($data, $format);
    }

    /**
     * {@inheritdoc}
     */
    public function denormalize($data, $class, $format = null, array $context = [])
    {
        if (\is_array($data)) {
            foreach ($data as $key => &$value) {
                $propertyMetadata = $this->propertyMetadataFactory->create($class, $key);
                $propertyType = $propertyMetadata->getType();

                if (null === $propertyType
                    ||
                    null === $propertyType->getClassName()
                    ||
                    !$this->resourceClassResolver->isResourceClass($propertyType->getClassName())
                ) {
                    continue;
                }

                try {
                    $value = $this->iriConverter->getItemIriFromResourceClass($propertyType->getClassName(), [
                        'id' => $value,
                    ]);
                } catch (InvalidArgumentException $exception) {
                    // Do nothing if failing. The value is maybe already an IRI format.
                }
            }

            unset($value);
        }

        return $this->normalizer->denormalize($data, $class, $format, $context);
    }

    /**
     * {@inheritdoc}
     */
    public function supportsDenormalization($data, $type, $format = null)
    {
        return $this->normalizer->supportsDenormalization($data, $type, $format);
    }
}

Basically, it turns this:

{
    "server": 1
}

To this:

{
    "server": "/api/servers/1"
}

And calls the api-platform normalizer.

It wont touch anything if the relation is already using the IRI format.

It works for my needs, but does it feet what you want to do in #2022 (comment)?

NB: It needs #2325 to fully work with autowiring.

[soullivaneuh]

The only issue I found is the error case:

Item not found for \"/api/hostings/155548\"

Quiet weird if the customer is just using the ID.

[discordier]

Solution in #2200 (comment) still works but has to be adapted as follows:

-final class ItemNormalizer implements NormalizerInterface, DenormalizerInterface
+final class ItemNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface
 {
+    public function setSerializer(SerializerInterface $serializer)
+    {
+        if ($this->normalizer instanceof SerializerAwareInterface) {
+            $this->normalizer->setSerializer($serializer);
+        }
+    }

As otherwise the serialization will not work anymore as the decorated service will not get the serializer set.

[soyuka]

https://api-platform.com/docs/core/serialization/#plain-identifiers

[azribilel]

Thanks @soyuka, i used the example to create a generic Denormalizer using ReflectionProperty.

<?php

namespace App\Serializer;

use ApiPlatform\Api\IriConverterInterface;
use Ramsey\Uuid\Uuid;
use ReflectionProperty;
use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;

class PlainIdentifierDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
{
    use DenormalizerAwareTrait;

    private $iriConverter;

    public function __construct(IriConverterInterface $iriConverter)
    {
        $this->iriConverter = $iriConverter;
    }

    public function denormalize(mixed $data, string $type, string $format = null, array $context = [])
    {
        foreach ($data as $key => $value){
            if (is_string($value) && Uuid::isValid($value)) {
                $rp = new ReflectionProperty($type, $key);
                $data[$key] = $this->iriConverter->getIriFromResource(resource: $rp->getType()->getName(), context: ['uri_variables' => ['id' => $value]]);
            }
            /* if you have int ID's switch:  if (is_string($value) && Uuid::isValid($value)) { ... } 
               to the following condition
            if (is_int($value)) {
                $rp = new ReflectionProperty($type, $key);
                $propertyType = $rp->getType()->getName();
                if (class_exists($propertyType) && !enum_exists($propertyType)) {
                    $data[$key] = $this->iriConverter->getIriFromResource(resource: $propertyType, context: ['uri_variables' => ['id' => $value]]);
                }
            }
            */
        }

        return $this->denormalizer->denormalize($data, $type, $format, $context + [__CLASS__ => true]);
    }

    public function supportsDenormalization(mixed $data, string $type, string $format = null, array $context = []): bool
    {
        return \in_array($format, ['json', 'jsonld'], true) && !isset($context[__CLASS__]);
    }
}