Merge pull request #11835 from gseidel/fix-pre-persist-call-persist

fix: calling scheduleForInsert twice

Author: greg0ire

src/UnitOfWork.php

@@ -1060,7 +1060,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,112 @@
+<?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;
+
+use function uniqid;
+
+class PrePersistEventTest extends OrmFunctionalTestCase
+{
+    protected function setUp(): void
+    {
+        parent::setUp();
+
+        $this->createSchemaForModels(
+            EntityWithUnmappedEntity::class,
+            EntityWithCascadeAssociation::class
+        );
+    }
+
+    public function testCallingPersistInPrePersistHook(): void
+    {
+        $entityWithUnmapped = new EntityWithUnmappedEntity();
+        $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 EntityWithUnmappedEntity) {
+            $uow = $args->getObjectManager()->getUnitOfWork();
+
+            if ($object->unmapped && ! $uow->isInIdentityMap($object->unmapped) && ! $uow->isScheduledForInsert($object->unmapped)) {
+                $args->getObjectManager()->persist($object->unmapped);
+            }
+        }
+    }
+}
+
+/** @Entity */
+#[Entity]
+class EntityWithUnmappedEntity
+{
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string", length=255)
+     * @GeneratedValue(strategy="NONE")
+     */
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public $id;
+
+    /** @var ?EntityWithCascadeAssociation  */
+    public $unmapped = null;
+
+    public function __construct()
+    {
+        $this->id = uniqid(self::class, true);
+    }
+}
+
+/** @Entity */
+#[Entity]
+class EntityWithCascadeAssociation
+{
+    /**
+     * @var string
+     * @Id
+     * @Column(type="string", length=255)
+     * @GeneratedValue(strategy="NONE")
+     */
+    #[Id]
+    #[Column(type: 'string', length: 255)]
+    #[GeneratedValue(strategy: 'NONE')]
+    public $id;
+
+    /**
+     * @var ?EntityWithUnmappedEntity
+     * @ManyToOne(targetEntity=EntityWithUnmappedEntity::class, cascade={"persist"})
+     */
+    #[ManyToOne(targetEntity: EntityWithUnmappedEntity::class, cascade: ['persist'])]
+    public $cascaded = null;
+
+    public function __construct()
+    {
+        $this->id = uniqid(self::class, true);
+    }
+}