How to update an entity and its relations on multiple levels? - symfony

Question

I am making a web app with Symfony 3 and Doctrine that permits to draw a tree structure and persist it.
A node contains subNodes in a OneToMany relation called children, the root of the tree being the only node that is not a child of any other node.
Here is the entity:
/**
* #ORM\Entity(repositoryClass="App\Repository\NodeRepository")
*/
class Node
{
/**
* #ORM\Id()
* #ORM\GeneratedValue()
* #ORM\Column(type="integer")
*/
public $id;
/**
* #ORM\Column(type="string", length=255)
*/
public $name;
/**
* #ORM\OneToMany(targetEntity="App\Entity\Node", mappedBy="parent")
*/
public $children;
/**
* #ORM\ManyToOne(targetEntity="App\Entity\Node", inversedBy="children")
* #ORM\JoinColumn(name="id_parent", referencedColumnName="id")
*/
public $parent;
public function __construct()
{
$this->children = new ArrayCollection();
}
public function getId(): ?int
{
return $this->id;
}
public function getName(): ?string
{
return $this->name;
}
public function setName(string $name): self
{
$this->name = $name;
return $this;
}
/**
* #return Collection|Node[]
*/
public function getChildren(): Collection
{
return $this->children;
}
public function addChild(Node $child): self
{
if (!$this->children->contains($child)) {
$this->children[] = $child;
$child->setParent($this);
}
return $this;
}
public function removeChild(Node $child): self
{
if ($this->children->contains($child)) {
$this->children->removeElement($child);
// set the owning side to null (unless already changed)
if ($child->getParent() === $this) {
$child->setParent(null);
}
}
return $this;
}
public function getParent(): ?self
{
return $this->parent;
}
public function setParent(?self $parent): self
{
$this->parent = $parent;
return $this;
}
}
I have no particular issue creating a tree. But when it comes to updating it, I am not sure what is the best way to do it.
The main example is removing a node (but the question is also applicable for moving a node) which I will take further down to illustrate my question.
I have a updateNodeAction controller that takes the whole new tree as a parameter (with the doctrine ids set all along the structure). I want to merge the incoming tree with the already persisted one so that removed nodes are removed when performing the flush.
In my dreams, I imagine something like (the parameter $node being the root node with its id set):
public function updateNodeAction(Node $node, EntityManagerInterface $entityManager) {
$entityManager->merge($node);
$entityManager->flush();
return new Response('OK');
}
where Doctrine deals with doing all the modifications of the node itself and all its descendants (additions, removals, moves) in database. For example, if the following tree with root's id is 1 is already persisted in database
and then I call my update controller with the following one (respecting the ids of course)
Doctrine would be able to "see" that node 5 is missing in the new structure and then do the $entityManager->remove($node5) by itself.
Is this not a dream and there is some kind of way to make Doctrine behave like this? Or do I have to recursively go down the tree and make a node-by-node comparison in order to make the modifications via entityManager myself?

Answer 1

I went to the conclusion that Doctrine was not such magical ;)
So I had to:
declare the Doctrine merge operation to propagate along the children relation (with the cascade={"merge"} annotation)
merge the root node
call the $em->remove operation on the nodes that existed on the tree before the merge, and that are not present on the incoming tree
finally, call $em->flush