Leveraging the Core Processor

Hello dear SymfonyCast,

I have created a Processor where I want to check if the is a new User entity being posted.
I want to create a additional resource/ new entity UserProfile when this happens.

But I keep getting an error: Unable to generate an IRI for the item of type "App\ApiResource\UserProfileApi"
I have dealt with this error before, but know I cant really figure out how to deal with in this situation.

I tried setting it up within the mapper, where I get the same issue, but it does create a UserProfile after creating the User entity.
I thought maybe if I create the user First within the StateProcessor with the $this->persistProcessor and then proceed with creating the UserProfile but it did not work out as I thought.

I have AppFixtures where I can succesfully create userProfile after creating a User with no problems, so I am a little stuck.

I was thinking about creating a eventSubscriber/ Listener that check if a new User has a UserProfile, if not then create one and store it
I hope to get some pointers how to resolve this issue.

State Processor:

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;
        }

        if($operation->getMethod() === "PUT"){
            foreach($context["request"]->attributes as $key => $property){
                if($key === 'data'){
                    $context["previous_data"] = $this->mapDtoToEntity($property, $entityClass);
                    // $property = $this->mapDtoToEntity($property, User::class);
                }
            }
            // $context["previous_data"] = $this->mapDtoToEntity($context["previous_data"], User::class);
        }

        // dd(['created entity' => $entity]);
        $this->persistProcessor->process($entity, $operation, $uriVariables, $context);
        
        if($operation->getMethod() === "POST" && assert($entity instanceof User)){
            // dd("it passes");
            // $getLatestUser = $this->entityManager->getRepository(User::class)->findOneBy([], ['id' => 'desc']);
            $newProfile = new UserProfileApi();
            // $sequenceUser = $getLatestUser->getId();
            // $sequenceNr = $getLatestUser->getId() + 1;
            $newProfile->userUniq =  $this->mapDtoToEntity($entity, UserApi::class);
            // $newProfile->userUniq =  $this->mapDtoToEntity($entity, UserApi::class);/
            // $newProfile->userUniq = $sequenceNr;
            
            $userProfile = $this->microMapper->map($newProfile, UserProfile::class);
            
            // $userProfile->setUserUniq($entity);
            $this->entityManager->persist($userProfile);
            $this->entityManager->flush();
        }

        $data->id = $entity->getId();
        
        return $data;
        // $this->sendWelcomeEmail($data);
    }

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

UserProfileApi:

#[ApiResource(
    shortName: 'profile',
    provider: EntityToDtoStateProvider::class,
    processor: EntityClassDtoStateProcessor::class,
    paginationItemsPerPage: 10,
    stateOptions: new Options(entityClass: UserProfile::class),
    operations: [
        new Get(
            security: 'is_granted("ROLE_ADMIN")' 
        ),
        new GetCollection(
            security: 'is_granted("ROLE_ADMIN")' 
        ),
        new Post(
            security: 'is_granted("ROLE_ADMIN")' 
        ),
        new Patch(
            security: 'is_granted("ROLE_ADMIN")' 
        ),
        new Put(
            security: 'is_granted("ROLE_ADMIN")'
        ),
        new Delete(
            security: 'is_granted("ROLE_ADMIN")' 
        ),
    ],
    normalizationContext: [
        'groups' => ['profile:read']
            ],
    denormalizationContext: [
        'groups' => ['profile:write']
    ],
)]
class UserProfileApi
{
    public function __construct()
    {
        $this->postEvents = new ArrayCollection();
        $this->tokenManagers = new ArrayCollection();
        // $this->tokenManager = new TokenManagerApi();
        $this->subscribeToEvents = new ArrayCollection();
    }

    // #[Groups(["read_customer"])]
    #[ORM\Id, ORM\Column, ORM\GeneratedValue]
    #[Groups(['profile:read'])]
    #[ApiProperty(identifier: true)] // readable:false, 
    public ?int $id = null;

UserAPi Resource:

#[ApiResource(
    shortName: 'User',
    provider: EntityToDtoStateProvider::class,
    processor: EntityClassDtoStateProcessor::class,
    paginationItemsPerPage: 10,
    stateOptions: new Options(entityClass: User::class),
    operations: [
        new Get(    
            security: 'is_granted("ROLE_ADMIN")',     
            uriTemplate: '/user_by_email/{email}/email',
            uriVariables: 'email'
        ),
        new GetCollection(
            security: 'is_granted("ROLE_ADMIN")',     
        ),
        new Post(
            security: 'is_granted("PUBLIC_ACCESS")',
        ),
        new Patch(   
            security: 'is_granted("ROLE_ADMIN")',  
            uriTemplate: '/user_by_email/{email}/email',
            uriVariables: 'email'
        ),
        // new Patch(),
        new Put(
            security: 'is_granted("ROLE_ADMIN")',  
            uriTemplate: '/user_by_email/{email}/email',
            uriVariables: 'email'
        ),
        new Delete(
            security: 'is_granted("ROLE_ADMIN")', 
        ),
    ],
    normalizationContext: [
        'groups' => ['user:read']
    ],
    denormalizationContext: [
        'groups' => ['user:write']
    ],
)]
final class UserApi 
{
    public function __construct()
    {
        $this->userProfile = new UserProfileApi();
        $this->products = new ArrayCollection();
        $this->userAddresses = new ArrayCollection();
        $this->shopOrders = new ArrayCollection();
        $this->subscriptions = new ArrayCollection();
    }

    #[Groups(['user:read', 'profile:read'])]
    public ?int $id = null;
    

Hello Rayan

I have created a "UserApi mapper" to map the Doctrine User entity and a "BlogApi mapper" to map the Doctrine Blog entity. I try to create a sub-resource of the type /api/users/{id}/blogs, with itemUriTemplate: '/users/{userId}/blogs/{blogId}'. However, I get an error :

Example of how to reproduce a bug :

<?php

namespace App\ApiResource;

#[ApiResource(
    shortName: 'users',
    operations: [
        new Get(
            uriTemplate: '/users/{id}'
        ),
    ],
    provider: UserProvider::class,
    stateOptions: new Options(entityClass: User::class),
)]
class UserApi
{

    #[ApiProperty(readable: false, writable: false, identifier: true)]
    public ?int $id =null;
    #[Assert\NotBlank()]
    public ?string $username=null;
    /** @var BlogApi[]  */
    public array $blogs = [];
}

#[ApiResource(
    shortName: 'blogs',
    operations: [
        new Get(
            uriTemplate: '/users/{userId}/blogs/{blogId}',
            uriVariables: [
                'userId' => new Link(
                    toProperty: 'owner',
                    fromClass: User::class
                ),
                'blogId' => new Link(
                    fromClass: Blog::class
                ),
            ],

        ),
        new GetCollection(
            uriTemplate: '/users/{userId}/blogs',
            uriVariables: [
                'userId' => new Link(
                    toProperty: 'owner',
                    fromClass: User::class,
                ),
            ],
            denormalizationContext: [ 'force_resource_class' => Blog::class],
            itemUriTemplate: '/users/{userId}/blogs/{blogId}',
        )
    ],
    paginationItemsPerPage: 5,
    provider: BlogProvider::class,
    processor: BlogProcessor::class,
    stateOptions: new Options(entityClass: Blog::class)

)]

class BlogApi
{
    #[ApiProperty(readable: false, writable: false, identifier: true)]
    public ?int $id = null;
    public ?UserApi $owner = null;

}

   {
    "@context": "/api/contexts/Error",
    "@type": "hydra:Error",
    "hydra:title": "An error occurred",
    "hydra:description": "Unable to generate an IRI for the item of type \"App\\ApiResource\\BlogApi\"",
}