Embedded relation without dedicated route

[esistgut]

I have a Product entity having a OneToMany relation with a ProductTranslation entity without the "@ApiResource" annotation. I set up the relevant serialization groups for both the normalization_context and the denormalization_context so a GET to /products/ returns as expected:

{
 	"id": 2,
 	"code": "sku123",
 	"translations": [{
 		"id": 12,
 		"name": "Pen",
 		"description": "it is a pen",
 		"locale": "en"
 	}, {
 		"id": 14,
 		"name": "Stylo",
 		"description": "il est un stylo",
 		"locale": "fr"
 	}]
 }

It is working as expected when creating a new object via POST too. My problem is when I try to update a translation via PUT to /products/2:

{
	"code": "sku123",
	"translations": [{
		"id": 12,
		"name": "Biro",
		"description": "it is still a pen",
		"locale": "en"
	}]
}

this would not update the existing relation but just add a new one (another ProductTranslation with another ID).
It works as expected if I add the "@ApiResource" annotation to the ProductTranslation entity (and change the translation id to something like "/product_translations/12") but that would also create an end point for this entity and that is wrong because it is never required to be used directly.

So my question is: is there a way to make the PUT update work for an embedded relation which does not have its own routing / end point?

[soyuka]

It should work as expected. Maybe you need to set up some transitive persistence for Doctrine to update your ManyToMany relation.

I don't have a real example, but you should be able to do something like:

PUT /products/2

{'@id': '/products/2', translations: [{'@id': '/translation/2', name: 'foobar'}]

And doctrine will update the given item (maybe that a merge operation is required on the Doctrine side, not sure). If you add one without an @id and if cascade persist is set up, doctrine should create a new association.

[esistgut]

What if there is no '/translation/2' because I don't want the translations to have their own route?

[soyuka]

So those are not associations? If you want the association to be handled by api-platform correctly it should be a Resource.

[teohhanhui]

A resource should always have an IRI, unless it's an anonymous resource (with no ID whatsoever - not supported in API Platform yet anyway) in which case it cannot be updated / deleted.

[phiamo]

i have a similar problem:
we have events with entryfees
entry fees vary between events and are never reused.

so they should afaiu not be a own resource since that would not make sense, but are embedded.

When using a usual doctrine relation they will need a own ApiResource annotation otherwise api-platform will complain about missing route to generate @id

is there any best practive, or can one disable certain routes to be visible at the generated doc?

[alexsegura]

Not sure this is what you want to do, but you can use a custom Normalizer

Let's say you have a MenuItem with a price property, but you want to actually serialize it into an Offer

{
  "@id":"/menu_items/1",
  "@type":"http://schema.org/MenuItem",
  "name":"Pizza",
  "offers":{
    "@type":"http://schema.org/Offer",
    "price":10.99,
    "priceCurrency":"EUR"
  }
}

src/AppBundle/Entity/MenuItem.php

/**
 * @ORM\Entity
 * @ApiResource(iri="http://schema.org/MenuItem")
 */
class MenuItem extends Thing
{
    /**
     * @ORM\Column(type="integer")
     * @ORM\Id
     * @ORM\GeneratedValue(strategy="IDENTITY")
     */
    private $id;

    /**
     * @ORM\Column(type="float", nullable=true)
     * @Assert\Type(type="float")
     * @ApiProperty(iri="https://schema.org/price")
     */
    protected $price;

    /**
     * Gets id.
     *
     * @return int
     */
    public function getId()
    {
        return $this->id;
    }

    public function setPrice($price)
    {
        $this->price = $price;

        return $this;
    }

    public function getPrice()
    {
        return $this->price;
    }
}

src/AppBundle/Serializer/MenuItemNormalizer.php

class MenuItemNormalizer implements NormalizerInterface, DenormalizerInterface
{
    private $normalizer;

    public function __construct(ItemNormalizer $normalizer)
    {
        $this->normalizer = $normalizer;
    }

    public function normalize($object, $format = null, array $context = array())
    {
        $data =  $this->normalizer->normalize($object, $format, $context);

        $data['offers'] = [
            '@type' => 'http://schema.org/Offer',
            'price' => $object->getPrice(),
            'priceCurrency' => 'EUR',
        ];

        return $data;
    }

    public function supportsNormalization($data, $format = null)
    {
        return $this->normalizer->supportsNormalization($data, $format) && $data instanceof MenuItem;
    }

    public function denormalize($data, $class, $format = null, array $context = array())
    {
        return $this->normalizer->denormalize($data, $class, $format, $context);
    }

    public function supportsDenormalization($data, $type, $format = null)
    {
        return $this->normalizer->supportsDenormalization($data, $type, $format) && $type instanceof MenuItem;
    }
}

app/config/services.yml

app.menu_item_normalizer:
    class: AppBundle\Serializer\MenuItemNormalizer
    arguments:
      - "@api_platform.jsonld.normalizer.item"
    tags: [ { name: serializer.normalizer, priority: 128 } ]

[Simperfit]

@esistgut is it ok for you ?