Writing to a Collection Relation

or should i use the serialization group in ApiResource class like we used to do it entity class ?

Hey @Joel-L!

You're doing something like PATCH:

{
    "name": "Cool product",
    "specs": [
        { "name": "weight", "value": "10 kg" },
        { "name": "color", "value": "red" },
    ]
}

Right? Without thinking about this too hard, yes, the answer should be to use serialization groups. This all comes down to the serializer: we want it to "accept" the serialization groups and return them into DTO objects. Then, by the time the code gets to our state processor, we should have (to use my example here) a ProductDto with a specs property full of ProductSpecDto objects. Then, transforming that into entity objects and saving them shouldn't be any different.

The biggest bummer for me when allowing embedded objects with this setup is that you suddenly do need to use serialization groups. The system simplified life so that we didn't need them anymore... but if you want to accept embedded data, then you do need them.

Cheers!

Thanks Ryan

in that direction i'm facing a new problem :

"type": "https://tools.ietf.org/html/rfc2616#section-10",
    "title": "An error occurred",
    "detail": "Could not determine access type for property \"items\" in class \"App\\Entity\\Product\".",
    "trace": [
        {
            "namespace": "",
            "short_class": "",
            "class": "",
            "type": "",
            "function": "",
            "file": "/api/vendor/symfony/property-access/PropertyAccessor.php",
            "line": 544,
            "args": []
        },

There is a Product and a (child) Item entity class.
I've created a ProductApi and ItemApi resource class everything is fine except for Patch operation who i got the error above.

It seems happening from the mapper $this->propertyAccessor->setValue($entity, 'items', $importItemEntities);
where $entity is ProductApi and items is ItemApi Collection.

Any idea ?

Hey @Joel-L!

On your Product class, how is the $items property accessible? You would typically have an addItem() and removeItem() method, and the property accessor is smart enough to call those. Do you have them (they're added by MakerBundle if you generated the relationship via make:entity and said that you wanted to map the "inverse" side of the relation),

Cheers!

yes i have them :
getItems()
addItem()
removeItem()

Hmm, then that just doesn't make sense. The error specifically is:

Could not determine access type for property \"items\" in class \"App\Entity\Product\".

So this means that PropertyAccess component is being asked to read or write the "items" property on the Product entity. And being able to use getItems() (in the case of reading) or addItem() / removeItem() is core to the property accessor component https://symfony.com/doc/current/components/property_access.html#writing-to-array-properties

Hmm, unless there is something weird happening because items on your entity is a Collection and on your DTO it is an array. You could try making your items on your DTO an ArrayCollection from Doctrine to test that theory (so that both sides are a type of "collection" object).

Cheers!

below the source code i'm using , jus tin case you have time :

Product entity

#[ORM\Entity(repositoryClass: ProductRepository::class)]
#[ORM\Table(name: 'sdp_product')]
class Product
{
	#[ORM\Id]
    #[ORM\Column(type: 'uuid', unique: true)]
    #[ORM\GeneratedValue(strategy: 'CUSTOM')]
    #[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
    private ?Uuid $id = null;

    #[ORM\OneToMany(mappedBy: 'importation', targetEntity: Item::class, cascade: ['persist'], orphanRemoval: true)]
    private Collection $items;

    public function __construct()
    {
     
        $this->items = new ArrayCollection();
     
    }

     public function getId(): ?Uuid
    {
        return $this->id;
    }


    /**
     * @return Collection<int, Item>
     */
    public function getItems(): Collection
    {
        return $this->items;
    }

    public function addItem(Item $item): self
    {
        if (!$this->items->contains($item)) {
            $this->items->add($item);
            $item->setImportation($this);
        }

        return $this;
    }

    public function removeItem(Item $item): self
    {
        if ($this->items->removeElement($item)) {
            // set the owning side to null (unless already changed)
            if ($item->getImportation() === $this) {
                $item->setImportation(null);
            }
        }

        return $this;
    }

}

Item entity

#[ORM\Entity(repositoryClass: ItemRepository::class)]
#[ORM\Table(name: 'sdp_item')]
class Item
{
    #[ORM\Id]
    #[ORM\Column(type: 'uuid', unique: true)]
    #[ORM\GeneratedValue(strategy: 'CUSTOM')]
    #[ORM\CustomIdGenerator(class: 'doctrine.uuid_generator')]
    private ?Uuid $id = null;


	#[ORM\ManyToOne(inversedBy: 'items')]
    private ?Product $product = null;

	public function getId(): ?Uuid
    {
        return $this->id;
    }

    public function getProduct(): ?Product
    {
        return $this->product;
    }

    public function setProduct(?Product $product): self
    {
        $this->product = $product;

        return $this;
    }

}

ProductApi resource

#[ApiResource(    
    normalizationContext: ['groups' => ['read']],
    denormalizationContext: ['groups' => ['write']],
    provider: EntityToDtoStateProvider::class,
    processor: EntityClassDtoStateProcessor::class,
    stateOptions: new Options(entityClass: Product::class),
)]
class ProductApi
{
    #[ApiProperty(readable: true, writable: false, identifier: true)]
    #[Groups(['read'])]
    private ?Uuid $id = null;

    #[Groups(['read','write'])]
    private Collection $items;


    public function __construct()
    {
        $this->items = new ArrayCollection();
    }



    /**
     * @return Collection<int, ItemApi>
     */
    public function getItems(): Collection
    {
        return $this->items;
    }

    public function addItem(ItemApi $item): self
    {
        if (!$this->items->contains($item)) {
            $this->items->add($item);
            $item->setImport($this);
        }

        return $this;
    }

    public function removeItem(ItemApi $item): self
    {
        if ($this->items->removeElement($item)) {            
            if ($item->getProduct() === $this) {
                $item->setProduct(null);
            }
        }

        return $this;
    }

}

ItemApi resource

#[ApiResource(    
    provider: EntityToDtoStateProvider::class,
    processor: EntityClassDtoStateProcessor::class,
    stateOptions: new Options(entityClass: Item::class),
)]
class ItemApi
{
    #[ApiProperty(readable: true, writable: false, identifier: true)]
    #[Groups(['read'])]
    private ?Uuid $id = null;

    #[Groups(['read','write'])]
    private ?int $price = null;

    #[Groups(['read','write'])]
    private ?int $quantity = null;


    ... with Getter and Setter
}

ProductApiToEntityMapper

#[AsMapper(from: ProductApi::class, to: Product::class)]
class ProductApiToEntityMapper implements MapperInterface
{
    public function __construct(
        private ProductRepository $productRepository,
        private MicroMapperInterface $microMapper,
        private PropertyAccessorInterface $propertyAccessor,
    )
    {
    }

    public function load(object $from, string $toClass, array $context): object
    {
        $dto = $from;
        assert($dto instanceof ProductApi);

        $userEntity = $dto->getId() ? $this->importationRepository->find($dto->getId()) : new Importation();
        if (!$userEntity) {
            throw new \Exception('Importation not found');
        }

        return $userEntity;
    }

    public function populate(object $from, object $to, array $context): object
    {
        $dto = $from;
        assert($dto instanceof ProductApi);
        $entity = $to;
        assert($entity instanceof Product);
                

        $itemEntities = [];
        foreach ($dto->getItems() as $itemApi) {
            $itemEntities[] = $this->microMapper->map($importItemApi, ImportationItem::class, [
                MicroMapperInterface::MAX_DEPTH => 1,
            ]);
        }        
        $this->propertyAccessor->setValue($entity, 'items', $itemEntities);

        return $entity;
    }
}

It all looks fine. My best guess, of something to try - just to see if it makes a difference - would be to make the items property in ProductApi an array, instead of an ArrayCollection. That shouldn't make any difference, but your entity looks fine. So the idea is that: perhaps the property accessor is getting confused by the ArrayCollection (not realizing it is a "collection") and so is not looking for an adder/remove and is instead only looking for a setter.

Cheers!

thanks for your time.
But unfortunately i got same error message.
I will still searching

i found the issue it was mispelling items name
fix now with Collection everywhere
thks againe for your time

Phew! Fantastic - glad you got it sorted.

Happy holidays!