JSON Patch denormalizer

[DurandA]

I'd like to implement a subset of the application/json-patch+json format to partially update the lists/collections of some of my resources without modifying API Platform.

1. Is it possible to call a custom controller based on the Content-Type but keep the default wiring/actions for other content types with the same URIs? E.g. something like:

#[ApiResource(itemOperations: [
    'get',
    'patch',
    'json_patch' => [
        'method' => 'PATCH',
        'formats' => ['application/json-patch+json'],
        'controller' => PatchBook::class,
    ],
])]

I still want the non-custom application/merge-patch+json to work (not the same as application/json-patch+json).

2. Is there a better way of implementing a custom format without forking API Platform? I took a look at the serialization process but I am not sure how to implement this.

[DurandA]

After further investigation, here is how it can be implemented using a custom denormalizer.

Register the jsonpatch format

Add jsonpatch to apiplatform.yaml:

api_platform:
    patch_formats:
        json: ['application/merge-patch+json']
        jsonpatch: ['application/json-patch+json']

Register a JSON decoder for the jsonpatch format in services.yaml:

services:
    ApiPlatform\Core\Serializer\JsonEncoder:
        public: false
        arguments:
            - 'jsonpatch'
        tags:
            - { name: serializer.encoder }

Implement a JSON Patch denormalizer

Create a JSONPatchDenormalizer class:

namespace App\Serializer;

use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;

class JsonPatchDenormalizer implements ContextAwareDenormalizerInterface, DenormalizerAwareInterface
{
    use DenormalizerAwareTrait;

    private const ALREADY_CALLED = 'JSON_PATCH_DENORMALIZER_ALREADY_CALLED';

    public function denormalize($data, $type, $format = null, array $context = [])
    {
        // TODO
    }

    public function supportsDenormalization($data, $type, $format = null, array $context = []): bool
    {
        if (isset($context[self::ALREADY_CALLED])) {
            return false;
        }
        return $format === "jsonpatch";
    }
}

[DurandA]

Symfony seems to provide the basic infrastructure in order to read/write to objects using attribute names. In particular, PropertyAccessor and ReflectionExtractor are of great interest in order to translate JSON Patch paths into object accessors.

I will take a closer look on how the built-in denormalizers use them in order to transform the flattened input (Array in the screenshot below) into entity objects.

[DurandA]

It seems that AbstractItemNormalizer and its child class ItemNormalizer are the non-specialized (de)normalizers that perform the bulk of the process. As expected, PropertyAccessor is used there to manipulate objects from string keys.

[soyuka]

Hi! I may help a bit, just trying to get back into the hell of notifications :).

What you did above is the correct way but I'm not sure that you'll be able to do this only with a normalizer. In API Platform when a Patch operation is found, we set the Symfony's deep_object_to_populate serializer flag.

To change the normalization process it really depends how deep you need to go. I'd start by trying to extend the ApiPlatform\JsonLd\Serializer\ItemNormalizer, still extending AbstractItemNormalizer and see if I can make the rfc work.
You'll probably need to read and try to get how the AbstractItemNormalizer does his magic.

Last thing, I advise to use the main branch for such a feature. The code was quite refactored by revisiting how metadata works.

[hmonglee]

Should we really use ItemSerializer?

According to https://www.rfc-editor.org/rfc/rfc6902.html, we would receive a table of operations.

So, when decoding, we transform the array of operations from json to array.
Then for denormalization, we apply the operations to the object using the Symfony PropertyAccess component.

This would create a JsonPatchSerializer.

Can we allow ourselves to denormalize in this way? By this I mean that the input is an array of operations and the output is the object to which the operations have been applied.

By doing it this way, you don't have to worry about the “deep_object_to_populate” part, as you won't be using ObjectNormalizer for denormalization.

@DurandA @soyuka