Proveedor y procesador reutilizable Entidad->Dto

I'm having issues with my PHPStan telling me getStateOptions is from an internal class which it is. I'm using this in my provider where I can reach out for the stateOptions via $operation and $context. However both access the ApiPlatform\Metadata\Metadata class which is an internal one. Is there a different way to reach out for this data?

It seems the example provided does not work when using Writable Relation Fields with serialization groups.

Trying to create a new object though a relationship throws the dreaded Unable to generate an IRI for the item of type \"App\\ApiResource\\EntityApi\"" error. This seems to only affect Post Operations due to relationships not being properly hydrated during serialization. Get, Get Collection, and Patch all seem to work fine here.

For example, Lets say you have two entities: Business - OneToOne - Address. If you were to try create a new business by posting { "name":"Little Caesars", "address": { "city": "Detroit" }} to your /api/business/ endpoint you would see the following error Unable to generate an IRI for the item of type \"App\\ApiResource\\AddressApi\"". This is happening because the example in the script does not fully hydrate the DTO before api-platform tries to serialize.

Below is a quick and dirty fix that resolved the issue for me on my end.

Hope this helps someone!

<?php

class EntityClassDtoStateProcessor implements ProcessorInterface
{
    public function __construct(
        #[Autowire(service: PersistProcessor::class)] private ProcessorInterface $persistProcessor,
        #[Autowire(service: RemoveProcessor::class)] private ProcessorInterface $removeProcessor,
        private MicroMapperInterface $microMapper
    ) {
    }
    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = []): mixed
    {

        $stateOptions = $operation->getStateOptions();

        assert($stateOptions instanceof Options);

        $entityClass = $stateOptions->getEntityClass();
        $entity = $this->mapDtoToEntity($data, $entityClass);

        if ($operation instanceof DeleteOperationInterface) {
            $this->removeProcessor->process($entity, $operation, $uriVariables, $context);
            return null;
        }
        
        /**
        * Fix: In order to create the relationship IRI's we need to run the persistProcessor and then re-map to DTO so we can hydrate all relationships before passing back to serializer.
        */
        return $this->mapDtoToEntity($this->persistProcessor->process($entity, $operation, $uriVariables, $context), $operation->getClass());
    }
    private function mapDtoToEntity(object $dto, string $entityClass): object
    {
        return $this->microMapper->map($dto, $entityClass);
    }
}

One issue I came across with the generic/custom StateProcessor is that not all Entities use id/getId() as their identifier.

So in my DTO class, I leveraged the extraProperties array in the #[ApiResource] to expose that information to the StateProcessor.

The upside is that this works! The downside is that I already told ApiPlatform what my resource's ID is in my DTO class in the properties using the ApiProperty attribute. But there doesn't seem to be a way to get that information in the process method of the StateProcessor. Would be nice to not have to add this extraProperties config, but hey, this does the trick!

Any thoughts about gotchas with this approach?

DTO class

<?php

namespace App\ApiResource;

use ApiPlatform\Doctrine\Orm\State\Options;
use ApiPlatform\Metadata\ApiProperty;
use ApiPlatform\Metadata\ApiResource;
use App\Entity\Bookmark;
use App\Entity\User;
use App\State\DtoToEntityStateProcessor;
use App\State\EntityToDtoStateProvider;
use Ramsey\Uuid\UuidInterface;
use Symfony\Component\Serializer\Attribute\Ignore;

#[ApiResource(
    shortName: 'Bookmark',
    paginationItemsPerPage: 10,
    provider: EntityToDtoStateProvider::class,
    processor: DtoToEntityStateProcessor::class,
    stateOptions: new Options(
        entityClass: Bookmark::class,
    ),
    extraProperties: [
        'identifierProperty' => 'uuid',
        'identifierGetter' => 'getUuid',
    ],
)]
class BookmarkApi
{
    #[ApiProperty(identifier: false)]
    #[Ignore]
    public ?int $id = null;

    #[ApiProperty(identifier: true)]
    public ?UuidInterface $uuid = null;

    public ?string $title = null;

    public ?string $description = null;

    public ?User $createdBy = null;

    public ?User $updatedBy = null;
}

DtoToEntityStateProcessor class

<?php

namespace App\State;

use ApiPlatform\Doctrine\Common\State\PersistProcessor;
use ApiPlatform\Doctrine\Common\State\RemoveProcessor;
use ApiPlatform\Doctrine\Orm\State\Options;
use ApiPlatform\Metadata\DeleteOperationInterface;
use ApiPlatform\Metadata\Operation;
use ApiPlatform\State\ProcessorInterface;
use Symfony\Component\DependencyInjection\Attribute\Autowire;
use Symfonycasts\MicroMapper\MicroMapperInterface;

class DtoToEntityStateProcessor implements ProcessorInterface
{
    public function __construct(
        #[Autowire(service: PersistProcessor::class)]
        private PersistProcessor $persistProcessor,
        #[Autowire(service: RemoveProcessor::class)]
        private RemoveProcessor $removeProcessor,
        private MicroMapperInterface $microMapper,
    ) {
    }

    public function process(mixed $data, Operation $operation, array $uriVariables = [], array $context = [])
    {
        $stateOptions = $operation->getStateOptions();
        assert($stateOptions instanceof Options);

        $entityClass = $stateOptions->getEntityClass();

        $entity = $this->mapDtoToEntity($data, $entityClass);

        if ($operation instanceof DeleteOperationInterface) {
            $this->removeProcessor->process($entity, $operation, $uriVariables, $context);

            return null;
        }

        $this->persistProcessor->process($entity, $operation, $uriVariables, $context);

        // Allows custom identifiers to be set in the DTO class
        $extraProperties = $operation->getExtraProperties();
        $identifierProperty = $extraProperties['identifierProperty'] ?? 'id';
        $identifierGetter = $extraProperties['identifierGetter'] ?? 'getId';

        $data->{$identifierProperty} = $entity->{$identifierGetter}();
        return $data;
    }

    private function mapDtoToEntity(object $dto, string $entityClass): object
    {
        return $this->microMapper->map($dto, $entityClass);
    }
}