A new entity was found through the relationship

[vitoff34]

I am trying to build Cart functionality. These are my entities
Order:

<?php

namespace App\Entity;

use App\Repository\OrderRepository;
use App\Utils\AppUtils;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: OrderRepository::class)]
#[ORM\Table(name: '`order`')]
class Order
{
    const STATUS_CART = 'cart'; // The order is in the cart and has not been placed yet.
    const STATUS_PENDING = 'pending'; // The order has been placed but not yet processed.
    const STATUS_PROCESSING = 'processing'; // The order is being processed.
    const STATUS_SHIPPED = 'shipped'; // The order has been shipped.
    const STATUS_COMPLETED = 'completed'; // The order has been processed and completed.
    const STATUS_CANCELLED = 'cancelled'; // The order has been cancelled.

    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255, nullable: true)]
    private ?string $status = null;

    #[ORM\OneToMany(targetEntity: OrderItem::class, mappedBy: 'order')]
    private Collection $items;

    #[ORM\ManyToOne(inversedBy: 'orders')]
    private ?User $user = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE)]
    private ?\DateTimeInterface $createdAt = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $updatedAt = null;

    #[ORM\Column(length: 255, unique: true)]
    private ?string $orderRef = null;

    public static function getStatuses(): array
    {
        return [
            self::STATUS_CART => self::STATUS_CART,
            self::STATUS_PENDING => self::STATUS_PENDING,
            self::STATUS_PROCESSING => self::STATUS_PROCESSING,
            self::STATUS_SHIPPED => self::STATUS_SHIPPED,
            self::STATUS_COMPLETED => self::STATUS_COMPLETED,
            self::STATUS_CANCELLED => self::STATUS_CANCELLED,
        ];
    }

    public function __construct()
    {
        $this->createdAt = new \DateTime();

        $this->items = new ArrayCollection();

        $this->status = self::STATUS_CART;

        $this->orderRef = AppUtils::generateRandomString(12);
    }

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

    public function getStatus(): ?string
    {
        return $this->status;
    }

    public function setStatus(string $status): static
    {
        $this->status = $status;

        return $this;
    }

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

    public function addItem(OrderItem $item): static
    {
        if (!$this->items->contains($item))
        {
            $this->items->add($item);
            $item->setOrder($this);
        }
        return $this;
    }

    public function removeItem(OrderItem $item): static
    {
        $this->items->removeElement($item);
        $item->setOrder(null);
        return $this;
    }

    public function removeItems()
    {
        foreach ($this->items as $item)
        {
            $this->removeItem($item);
        }
        return $this;
    }

    public function getUser(): ?User
    {
        return $this->user;
    }

    public function setUser(?User $user): static
    {
        $this->user = $user;
        $user->addOrder($this);

        return $this;
    }

    public function getCreatedAt(): ?\DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(\DateTimeInterface $createdAt): static
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    public function getUpdatedAt(): ?\DateTimeInterface
    {
        return $this->updatedAt;
    }

    public function setUpdatedAt(?\DateTimeInterface $updatedAt): static
    {
        $this->updatedAt = $updatedAt;

        return $this;
    }

    public function getOrderRef(): ?string
    {
        return $this->orderRef;
    }

    public function setOrderRef(string $orderRef): static
    {
        $this->orderRef = $orderRef;

        return $this;
    }
}

OrderItem:

<?php

namespace App\Entity;

use App\Repository\OrderItemRepository;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: OrderItemRepository::class)]
class OrderItem
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

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

    #[ORM\Column]
    private ?int $quantity = null;

    #[ORM\ManyToOne(inversedBy: 'orderItems')]
    #[ORM\JoinColumn(nullable: false)]
    private ?Product $product = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE)]
    private ?\DateTimeInterface $createdAt = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $updateAt = null;

    public function __construct()
    {
        $this->createdAt = new \DateTime();
    }


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

    public function getOrder(): ?Order
    {
        return $this->order;
    }

    public function setOrder(?Order $order): static
    {
        $this->order = $order;

        return $this;
    }

    public function getQuantity(): ?int
    {
        return $this->quantity;
    }

    public function setQuantity(int $quantity): static
    {
        $this->quantity = $quantity;

        return $this;
    }

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

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

        return $this;
    }

    public function getCreatedAt(): ?\DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(\DateTimeInterface $createdAt): static
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    public function getUpdateAt(): ?\DateTimeInterface
    {
        return $this->updateAt;
    }

    public function setUpdateAt(?\DateTimeInterface $updateAt): static
    {
        $this->updateAt = $updateAt;

        return $this;
    }
}

Product:

<?php

namespace App\Entity;

use App\Repository\ProductRepository;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use Doctrine\DBAL\Types\Types;
use Doctrine\ORM\Mapping as ORM;

#[ORM\Entity(repositoryClass: ProductRepository::class)]
class Product
{
    #[ORM\Id]
    #[ORM\GeneratedValue]
    #[ORM\Column]
    private ?int $id = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE)]
    private ?\DateTimeInterface $createdAt = null;

    #[ORM\Column(type: Types::DATETIME_MUTABLE, nullable: true)]
    private ?\DateTimeInterface $updatedAt = null;

    #[ORM\ManyToOne(inversedBy: 'products')]
    private ?User $createdBy = null;

    #[ORM\Column(type: Types::DECIMAL, precision: 10, scale: 2, nullable: true)]
    private ?string $price = null;

    #[ORM\OneToOne(mappedBy: 'product', cascade: ['persist', 'remove'])]
    private ?Recipe $recipe = null;

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

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

    public function getCreatedAt(): ?\DateTimeInterface
    {
        return $this->createdAt;
    }

    public function setCreatedAt(\DateTimeInterface $createdAt): static
    {
        $this->createdAt = $createdAt;

        return $this;
    }

    public function getUpdatedAt(): ?\DateTimeInterface
    {
        return $this->updatedAt;
    }

    public function setUpdatedAt(?\DateTimeInterface $updatedAt): static
    {
        $this->updatedAt = $updatedAt;

        return $this;
    }

    public function getCreatedBy(): ?User
    {
        return $this->createdBy;
    }

    public function setCreatedBy(?User $createdBy): static
    {
        $this->createdBy = $createdBy;

        return $this;
    }

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

    public function setPrice(?string $price): static
    {
        $this->price = $price;

        return $this;
    }

    public function getRecipe(): ?Recipe
    {
        return $this->recipe;
    }

    public function setRecipe(?Recipe $recipe): static
    {
        $this->recipe = $recipe;

        return $this;
    }
}

This is my CartService:

<?php

namespace App\Service;

use App\Entity\Order;
use App\Entity\OrderItem;
use App\Entity\Product;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\SecurityBundle\Security;
use Symfony\Component\HttpFoundation\Session\SessionInterface;

class CartService
{
    private $session;
    private $entityManager;
    private $security;

    public function __construct(EntityManagerInterface $entityManager, SessionInterface $session, Security $security)
    {
        $this->entityManager = $entityManager;
        $this->session = $session;
        $this->security = $security;
    }

    public function getCartItems()
    {
        $cart = $this->getCart();

        return $cart->getItems();
    }

    public function addItem($product, $quantity = 1)
    {
        $cart = $this->getCart();

        $productEntity = $this->entityManager->getRepository(Product::class)->find($product);

        $orderItem = $this->entityManager->getRepository(OrderItem::class)->findOneBy(['product' => $productEntity, 'order' => $cart]);

        if (!$orderItem instanceof OrderItem)
        {
            $orderItem = new OrderItem();
            $orderItem->setProduct($productEntity);
            $orderItem->setQuantity(1);
            $orderItem->setOrder($cart);

        } else
        {
            $orderItem->setQuantity($orderItem->getQuantity() + $quantity);
        }

        $this->entityManager->persist($cart);
        $this->entityManager->persist($orderItem);
        $this->entityManager->flush();

        return [
            'cart' => $cart,
            'totalItems' => count($cart->getItems())
        ];
    }

    public function removeItem($product)
    {
        $cart = $this->getCart();

        $productEntity = $this->entityManager->getRepository(Product::class)->find($product);

        $orderItem = $this->entityManager->getRepository(OrderItem::class)->findOneBy(['product' => $productEntity, 'order' => $cart]);

        if ($orderItem instanceof OrderItem)
        {
            if ($orderItem->getQuantity() > 1)
            {
                $orderItem->setQuantity($orderItem->getQuantity() - 1);
                $this->entityManager->persist($orderItem);
                $this->entityManager->flush();
            } else
            {
                $orderItem->setOrder(null);
                $this->entityManager->persist($orderItem);
                $this->entityManager->flush();
            }
        }

        return $cart;
    }

    public function getCartTotal()
    {
        $total = 0;
        foreach ($this->getCartItems() as $item)
        {
            $total += $item->getProduct()->getPrice() * $item->getQuantity();
        }

        return $total;
    }

    public function getCart()
    {
        $cart = $this->session->get('cart', []);

        if (!$cart || !$this->entityManager->getRepository(Order::class)->findOneBy(['id' => $cart->getId()]))
        {
            $cart = new Order();

            if ($this->security->getUser())
            {
                $cart->setUser($this->security->getUser());
            }

            $this->entityManager->persist($cart);
            $this->entityManager->flush();

            $this->session->set('cart', $cart);
        }

        return $cart;
    }

    public function removeCart()
    {
        $this->session->remove('cart');

        return true;
    }
}

Whenever I delete an item from the cart using removeItem I am unable to add it again to the cart. I get this error:
A new entity was found through the relationship 'App\Entity\Order#user' that was not configured to cascade persist operations for entity
However I do not understand what new entity I am trying to create? Can anyone explain to me the issue?