Cannot persist new entity if primary key contains a foreign key and the referenced object is in state new and its id is not assigned

lib/Doctrine/ORM/UnitOfWork.php

@@ -940,7 +940,18 @@ private function persistNew($class, $entity)
                 $class->setIdentifierValues($entity, $idValue);
             }
 
-            $this->entityIdentifiers[$oid] = $idValue;
+            // Some identifiers may be foreign keys to new entities.
+            // In this case, we don't have the value yet and should treat it as if we have a post-insert generator
+            $hasMissingIdsWhichAreForeignKeys = false;
+            foreach($idValue as $idField => $idFieldValue) {
+                if($idFieldValue === null && isset($class->associationMappings[$idField])) {
+                    $hasMissingIdsWhichAreForeignKeys = true;
+                    break;
+                }
+            }
+            if(!$hasMissingIdsWhichAreForeignKeys) {
+                $this->entityIdentifiers[$oid] = $idValue;
+            }
         }
 
         $this->entityStates[$oid] = self::STATE_MANAGED;
@@ -1033,12 +1044,16 @@ private function executeInserts($class)
         $persister  = $this->getEntityPersister($className);
         $invoke     = $this->listenersInvoker->getSubscribedSystems($class, Events::postPersist);
 
+        $theseInsertions = [];
+
         foreach ($this->entityInsertions as $oid => $entity) {
 
             if ($this->em->getClassMetadata(get_class($entity))->name !== $className) {
                 continue;
             }
 
+            $theseInsertions[$oid] = $entity;
+
             $persister->addInsert($entity);
 
             unset($this->entityInsertions[$oid]);
@@ -1067,6 +1082,34 @@ private function executeInserts($class)
 
                 $this->addToIdentityMap($entity);
             }
+        } else {
+            foreach ($theseInsertions as $oid => $entity) {
+                if(!isset($this->entityIdentifiers[$oid])) {
+                    //entity was not added to identity map because some identifiers are foreign keys to new entities.
+                    //add it now
+                    $identifier = [];
+                    $idFields   = $class->getIdentifierFieldNames();
+                    foreach ($idFields as $idField) {
+                        $value = $class->getFieldValue($entity, $idField);
+
+                        if (isset($class->associationMappings[$idField])) {
+                            // NOTE: Single Columns as associated identifiers only allowed - this constraint it is enforced.
+                            $value = $this->getSingleIdentifierValue($value);
+                        }
+
+                        $identifier[$idField] = $value;
+                    }
+
+                    $this->entityIdentifiers[$oid] = $identifier;
+
+                    foreach($identifier as $idField => $idValue) {
+                        $this->originalEntityData[$oid][$idField] = $idValue;
+                    }
+
+                    $this->entityStates[$oid] = self::STATE_MANAGED;
+                    $this->addToIdentityMap($entity);
+                }
+            }
         }
 
         foreach ($entities as $entity) {

tests/Doctrine/Tests/Models/IdentityThroughForeignKeyTest/Product.php

@@ -0,0 +1,50 @@
+<?php
+
+namespace Doctrine\Tests\Models\IdentityThroughForeignKeyTest;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * Class Product
+ * @package Doctrine\Tests\Models\IdentityThroughForeignKeyTest
+ * @Entity()
+ * @Table(name="identitythroughforeignkey_product")
+ */
+class Product
+{
+
+    /**
+     * @var integer
+     * @Id()
+     * @GeneratedValue(strategy="IDENTITY")
+     * @Column(name="id")
+     */
+    public $id;
+
+    /**
+     * @var Collection|ProductColor[]
+     * @OneToMany(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductColor", mappedBy="product", cascade={"persist"})
+     */
+    public $colors;
+
+    /**
+     * @var Collection|ProductColor[]
+     * @OneToMany(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductSize", mappedBy="product", cascade={"persist"})
+     */
+    public $sizes;
+
+    /**
+     * @var Collection|ProductVariant[]
+     * @OneToMany(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductVariant", mappedBy="product", cascade={"persist"})
+     */
+    public $variants;
+
+    public function __construct()
+    {
+        $this->colors   = new ArrayCollection();
+        $this->sizes    = new ArrayCollection();
+        $this->variants = new ArrayCollection();
+    }
+}

tests/Doctrine/Tests/Models/IdentityThroughForeignKeyTest/ProductColor.php

@@ -0,0 +1,28 @@
+<?php
+
+namespace Doctrine\Tests\Models\IdentityThroughForeignKeyTest;
+
+/**
+ * Class ProductColor
+ * @package Doctrine\Tests\Models\IdentityThroughForeignKeyTest
+ * @Entity()
+ * @Table(name="identitythroughforeignkey_product_color")
+ */
+class ProductColor
+{
+
+    /**
+     * @var integer
+     * @Id()
+     * @GeneratedValue(strategy="IDENTITY")
+     * @Column(name="id", type="integer")
+     */
+    public $id;
+
+    /**
+     * @var Product
+     * @ManyToOne(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\Product", inversedBy="colors")
+     * @JoinColumn(name="product_id", referencedColumnName="id")
+     */
+    public $product;
+}

tests/Doctrine/Tests/Models/IdentityThroughForeignKeyTest/ProductSize.php

@@ -0,0 +1,30 @@
+<?php
+
+namespace Doctrine\Tests\Models\IdentityThroughForeignKeyTest;
+
+use Doctrine\ORM\Mapping as ORM;
+
+/**
+ * Class ProductSize
+ * @package Doctrine\Tests\Models\IdentityThroughForeignKeyTest
+ * @Entity()
+ * @Table(name="identitythroughforeignkey_product_size")
+ */
+class ProductSize
+{
+
+    /**
+     * @var integer
+     * @Id()
+     * @GeneratedValue(strategy="IDENTITY")
+     * @Column(name="id", type="integer")
+     */
+    public $id;
+
+    /**
+     * @var Product
+     * @ManyToOne(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\Product", inversedBy="sizes")
+     * @JoinColumn(name="product_id", referencedColumnName="id")
+     */
+    public $product;
+}

tests/Doctrine/Tests/Models/IdentityThroughForeignKeyTest/ProductVariant.php

@@ -0,0 +1,37 @@
+<?php
+
+namespace Doctrine\Tests\Models\IdentityThroughForeignKeyTest;
+
+/**
+ * Class ProductVariant
+ * @package Doctrine\Tests\Models\IdentityThroughForeignKeyTest
+ * @Entity()
+ * @Table(name="identitythroughforeignkey_product_variant")
+ */
+class ProductVariant
+{
+
+    /**
+     * @var Product
+     * @Id()
+     * @ManyToOne(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\Product", inversedBy="variants")
+     * @JoinColumn(name="product_id", referencedColumnName="id")
+     */
+    public $product;
+
+    /**
+     * @var ProductColor
+     * @Id()
+     * @ManyToOne(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductColor")
+     * @JoinColumn(name="color_id", referencedColumnName="id")
+     */
+    public $color;
+
+    /**
+     * @var ProductSize
+     * @Id()
+     * @ManyToOne(targetEntity="Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductSize")
+     * @JoinColumn(name="size_id", referencedColumnName="id")
+     */
+    public $size;
+}

tests/Doctrine/Tests/ORM/Functional/IdentityThroughForeignKeyTest.php

@@ -0,0 +1,59 @@
+<?php
+
+namespace Doctrine\Tests\ORM\Functional;
+
+use Doctrine\ORM\EntityManager;
+use Doctrine\Tests\Mocks\ConnectionMock;
+use Doctrine\Tests\Models\IdentityThroughForeignKeyTest\Product;
+use Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductColor;
+use Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductSize;
+use Doctrine\Tests\Models\IdentityThroughForeignKeyTest\ProductVariant;
+use Doctrine\Tests\OrmTestCase;
+
+class IdentityThroughForeignKeyTest extends OrmTestCase
+{
+
+    /** @var EntityManager */
+    protected $em;
+
+    protected function setUp()
+    {
+        parent::setUp();
+        $this->em = $this->_getTestEntityManager();
+    }
+
+
+    public function testIdentityThroughForeignKeyCollectionPersistence()
+    {
+        $product = new Product();
+
+        $color          = new ProductColor();
+        $color->product = $product;
+        $product->colors->add($color);
+
+        $size          = new ProductSize();
+        $size->product = $product;
+        $product->sizes->add($size);
+
+        $variant          = new ProductVariant();
+        $variant->product = $product;
+        $variant->color   = $color;
+        $variant->size    = $size;
+        $product->variants->add($variant);
+
+        $this->em->persist($product);
+
+        //check that flush does not throw
+        $this->em->flush();
+
+        $identifier = $this->em->getClassMetadata(ProductVariant::class)->getIdentifierValues($variant);
+
+        foreach ($identifier as $k => $v) {
+            $identifier[$k] = $this->em->getClassMetadata(get_class($v))->getIdentifierValues($v)['id'];
+        }
+
+        //check that identityMap content is correct
+        //find by primary key should return the same instance
+        $this->assertTrue($variant === $this->em->find(ProductVariant::class, $identifier));
+    }
+}