fix: calling scheduleForInsert twice

If scheduleForInsert was called in prePersist hook already, then persistNew need to check this case first, otherwise a ORMInvalidArgumentException will be thrown

Author: gseidel

src/UnitOfWork.php

@@ -1059,7 +1059,9 @@ private function persistNew(ClassMetadata $class, $entity): void
 
         $this->entityStates[$oid] = self::STATE_MANAGED;
 
-        $this->scheduleForInsert($entity);
+        if (!isset($this->entityInsertions[$oid])) {
+            $this->scheduleForInsert($entity);;
+        }
     }
 
     /** @param mixed[] $idValue */

tests/Tests/ORM/Functional/PrePersistEventTest.php

@@ -0,0 +1,94 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\ORM\Event\PrePersistEventArgs;
+use Doctrine\ORM\Events;
+use Doctrine\ORM\Mapping\Column;
+use Doctrine\ORM\Mapping\Entity;
+use Doctrine\ORM\Mapping\GeneratedValue;
+use Doctrine\ORM\Mapping\Id;
+use Doctrine\ORM\Mapping\ManyToOne;
+use Doctrine\Tests\OrmFunctionalTestCase;
+
+/**
+ * PrePersistEventTest
+ */
+class PrePersistEventTest extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->createSchemaForModels(
+            EntityWithUnmapEntity::class,
+            EntityWithCascadeAssociation::class,
+        );
+    }
+
+    public function testCallingPersistInPrePersistHook(): void
+    {
+        $entityWithUnmapped = new EntityWithUnmapEntity();
+        $entityWithCascade = new EntityWithCascadeAssociation();
+
+        $entityWithUnmapped->unmapped = $entityWithCascade;
+        $entityWithCascade->cascaded = $entityWithUnmapped;
+
+        $this->_em->getEventManager()->addEventListener(Events::prePersist, new PrePersistUnmappedPersistListener);
+        $this->_em->persist($entityWithUnmapped);
+
+        $this->assertTrue($this->_em->getUnitOfWork()->isScheduledForInsert($entityWithCascade));
+        $this->assertTrue($this->_em->getUnitOfWork()->isScheduledForInsert($entityWithUnmapped));
+    }
+}
+
+class PrePersistUnmappedPersistListener
+{
+    public function prePersist(PrePersistEventArgs $args): void
+    {
+        $object = $args->getObject();
+
+        if ($object instanceof EntityWithUnmapEntity) {
+            $uow = $args->getObjectManager()->getUnitOfWork();
+
+            if (!$uow->isInIdentityMap($object->unmapped) && !$uow->isScheduledForInsert($object->unmapped) && $object->unmapped) {
+                $args->getObjectManager()->persist($object->unmapped);
+            }
+        }
+    }
+}
+
+#[Entity]
+class EntityWithUnmapEntity
+{
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public string $id;
+
+    public EntityWithCascadeAssociation|null $unmapped = null;
+
+    public function __construct()
+    {
+        $this->id = uniqid(self::class, true);
+    }
+}
+
+#[Entity]
+class EntityWithCascadeAssociation
+{
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public string $id;
+
+    #[ManyToOne(targetEntity: EntityWithUnmapEntity::class, cascade: ['persist'])]
+    public EntityWithUnmapEntity|null $cascaded = null;
+
+    public function __construct()
+    {
+        $this->id = uniqid(self::class, true);
+    }
+}