Foreign Key issue in a virtual many-to-many user relationship when removing user - doctrine

Question

In my Symfony app, I have to handle some kind of friendship requests. It's basically a many to many relation between users, but with an accepted boolean property, and a createdAt DateTime, hence why I created an independent "friendship" entity instead of just a Many to many relations in the user entity.
Here is the issue though: I have a Sender property (one to many relation to user) and a recipient property (one to many relation to user as well). I set the orphanRemoval to true on the Friendships property in the user.
However, if I delete a user with only friendships where he was the sender, it works well and deletes the friendship entities. But if he is a recipient of a friend request, it just doesn't work and returns a Foreign Key constraint error, more precisely
SQLSTATE[23000]: Integrity constraint violation: 1451 Cannot delete or
update a parent row: a foreign key constraint fails
(portail.friendship, CONSTRAINT FK_7234A45FE92F8F78
FOREIGN KEY (recipient_id) REFERENCES user (id)).
I reckon it has something to do with the fact that user appears twice in my friendship entity, and obviously, it seems like only the sender is mentioned in the addFriendship() / removeFriendship() methods, but I'm not sure how to fix it, and I'd like to know if maybe I didn't tackle the issue the right way, and what I could do to change this and make it work (ie: remove all Friendships related to the User, whether he's the sender or recipient).
Below is the friendship entity, as well as the part of the User entity mentioning the Friendship entity relation.
<?php
namespace App\Entity;
use App\Repository\FriendshipRepository;
use Doctrine\ORM\Mapping as ORM;
/**
* #ORM\Entity(repositoryClass=FriendshipRepository::class)
*/
class Friendship
{
/**
* #ORM\Id
* #ORM\GeneratedValue
* #ORM\Column(type="integer")
*/
private $id;
/**
* #ORM\ManyToOne(targetEntity=User::class, inversedBy="friendships")
* #ORM\JoinColumn(nullable=false)
*/
private ?User $sender;
/**
* #ORM\ManyToOne(targetEntity=User::class, inversedBy="friendships")
* #ORM\JoinColumn(nullable=false)
*/
private ?User $recipient;
/**
* #ORM\Column(type="boolean")
*/
private ?bool $accepted;
/**
* #ORM\Column(type="datetime_immutable")
*/
private ?\DateTimeImmutable $createdAt;
public function getId(): ?int
{
return $this->id;
}
public function getSender(): ?User
{
return $this->sender;
}
public function setSender(?User $sender): self
{
$this->sender = $sender;
return $this;
}
public function getRecipient(): ?User
{
return $this->recipient;
}
public function setRecipient(?User $recipient): self
{
$this->recipient = $recipient;
return $this;
}
public function getAccepted(): ?bool
{
return $this->accepted;
}
public function setAccepted(bool $accepted): self
{
$this->accepted = $accepted;
return $this;
}
public function getCreatedAt(): ?\DateTimeImmutable
{
return $this->createdAt;
}
public function setCreatedAt(\DateTimeImmutable $createdAt): self
{
$this->createdAt = $createdAt;
return $this;
}
}
Part of the user
/**
* #ORM\OneToMany(targetEntity=Friendship::class, mappedBy="sender", orphanRemoval=true)
*/
private $friendships;
/**
* #return Collection|Friendship[]
*/
public function getFriendships(): Collection
{
return $this->friendships;
}
public function addFriendship(Friendship $friendship): self
{
if (!$this->friendships->contains($friendship)) {
$this->friendships[] = $friendship;
$friendship->setSender($this);
}
return $this;
}
public function removeFriendship(Friendship $friendship): self
{
if ($this->friendships->removeElement($friendship)) {
// set the owning side to null (unless already changed)
if ($friendship->getSender() === $this) {
$friendship->setSender(null);
}
}
return $this;
}

Answer 1

Arleigh was indeed correct. What I did wrong was set the same name, ie Friendships, while updating my friendship entity to get both relations in the user, whether he was a sender or recipient. I thought this would allow me to more easily get all friendships related to a user in my controllers and twig template, regardless of them being a recipient or a sender but in the end, all it did was make it all go wrong.
I fixed it by having two separate properties in my user, the friendshipRequestsSent(mapped by the sender field of the Friendship entity) and friendshipRequestsReceived (mapped by the recpient field of the Friendship entity) as well as the methods and typing of the properties associated. This is what it looks like in my User entity now
/**
* #ORM\OneToMany(targetEntity=Friendship::class, mappedBy="sender", orphanRemoval=true)
*/
private $friendshipRequestsSent;
/**
* #ORM\OneToMany(targetEntity=Friendship::class, mappedBy="recipient", orphanRemoval=true)
*/
private $friendshipRequestsReceived;
public function __construct()
{
$this->userSkills = new ArrayCollection();
$this->experiences = new ArrayCollection();
$this->missions = new ArrayCollection();
$this->friendshipRequestsSent = new ArrayCollection();
$this->friendshipRequestsReceived = new ArrayCollection();
}
/**
* #return Collection|Friendship[]
*/
public function getFriendshipRequestsSent(): Collection
{
return $this->friendshipRequestsSent;
}
public function addFriendshipRequestSent(Friendship $friendship): self
{
if (!$this->friendshipRequestsSent->contains($friendship)) {
$this->friendshipRequestsSent[] = $friendship;
$friendship->setSender($this);
}
return $this;
}
public function removeFriendshipRequestSent(Friendship $friendship): self
{
if ($this->friendshipRequestsSent->removeElement($friendship)) {
// set the owning side to null (unless already changed)
if ($friendship->getSender() === $this) {
$friendship->setSender(null);
}
}
return $this;
}
/**
* #return Collection|Friendship[]
*/
public function getFriendshipRequestsReceived(): Collection
{
return $this->friendshipRequestsReceived;
}
public function addFriendshipRequestReceived(Friendship $friendship): self
{
if (!$this->friendshipRequestsReceived->contains($friendship)) {
$this->friendshipRequestsReceived[] = $friendship;
$friendship->setSender($this);
}
return $this;
}
public function removeFriendshipRequestReceived(Friendship $friendship): self
{
if ($this->friendshipRequestsReceived->removeElement($friendship)) {
// set the owning side to null (unless already changed)
if ($friendship->getSender() === $this) {
$friendship->setSender(null);
}
}
return $this;
}
And this is how my Friendship entity sender and recipient properties are declared
/**
* #ORM\ManyToOne(targetEntity=User::class, inversedBy="friendshipRequestsSent")
* #ORM\JoinColumn(nullable=false)
*/
private ?User $sender;
/**
* #ORM\ManyToOne(targetEntity=User::class, inversedBy="friendshipRequestsReceived")
* #ORM\JoinColumn(nullable=false)
*/
private ?User $recipient;