Merge branch '2.3.x' into merge-2.3.X

* 2.3.x:
  bot: fix cs [skip ci]
  fix: bug with factory collectin of persistent factory in unit test (#842)
  fix: use Doctrine metadata event when persist is disabled (#841)
  minor: add parameter "withAutoRefresh" to unproxy() function (#840)
  chore: upgrade also dama when upgrading phpunit version (#839)
  bot: fix cs [skip ci]
  changelog: update [skip ci]
  fix: can call ->create() in after persist callback (#833)

Author: nikophil

CHANGELOG.md

@@ -1,5 +1,11 @@
 # CHANGELOG
 
+## [v2.3.6](https://github.com/zenstruck/foundry/releases/tag/v2.3.6)
+
+February 25th, 2025 - [v2.3.5...v2.3.6](https://github.com/zenstruck/foundry/compare/v2.3.5...v2.3.6)
+
+* 300645b fix: can call ->create() in after persist callback (#833) by @nikophil
+
 ## [v2.3.5](https://github.com/zenstruck/foundry/releases/tag/v2.3.5)
 
 February 24th, 2025 - [v2.3.4...v2.3.5](https://github.com/zenstruck/foundry/compare/v2.3.4...v2.3.5)

phpunit

@@ -35,7 +35,7 @@ SHOULD_UPDATE_PHPUNIT=$(check_phpunit_version "${PHPUNIT_VERSION}")
 
 if [ "${SHOULD_UPDATE_PHPUNIT}" = "0" ]; then
   echo "ℹ️  Upgrading PHPUnit to ${PHPUNIT_VERSION}"
-  composer update brianium/paratest "phpunit/phpunit:^${PHPUNIT_VERSION}" -W
+  composer update dama/doctrine-test-bundle brianium/paratest "phpunit/phpunit:^${PHPUNIT_VERSION}" -W
 fi
 ### <<
 

src/Persistence/PersistentObjectFactory.php

@@ -14,6 +14,7 @@
 use Doctrine\Persistence\ObjectRepository;
 use Symfony\Component\VarExporter\Exception\LogicException as VarExportLogicException;
 use Zenstruck\Foundry\Configuration;
+use Zenstruck\Foundry\Exception\FoundryNotBooted;
 use Zenstruck\Foundry\Exception\PersistenceDisabled;
 use Zenstruck\Foundry\Exception\PersistenceNotAvailable;
 use Zenstruck\Foundry\Factory;
@@ -304,16 +305,17 @@ protected function normalizeParameter(string $field, mixed $value): mixed
             if ($inversedRelationshipMetadata && !$inversedRelationshipMetadata->isCollection) {
                 $inverseField = $inversedRelationshipMetadata->inverseField;
 
-                // we need to handle the circular dependency involved by inversed one-to-one relationship:
-                // a placeholder object is used, which will be replaced by the real object, after its instantiation
-                $inversedObject = $value->withPersistMode(PersistMode::NO_PERSIST_BUT_SCHEDULE_FOR_INSERT)
-                    ->create([$inverseField => $placeholder = (new \ReflectionClass(static::class()))->newInstanceWithoutConstructor()]);
+                $inversedObject = $value->withPersistMode(
+                    $this->isPersisting() ? PersistMode::NO_PERSIST_BUT_SCHEDULE_FOR_INSERT : PersistMode::WITHOUT_PERSISTING
+                )
 
-                // auto-refresh computes changeset and prevents the placeholder object to be cleanly
-                // forgotten fom the persistence manager
-                if ($inversedObject instanceof Proxy) {
-                    $inversedObject = $inversedObject->_real(withAutoRefresh: false);
-                }
+                    // we need to handle the circular dependency involved by inversed one-to-one relationship:
+                    // a placeholder object is used, which will be replaced by the real object, after its instantiation
+                    ->create([
+                        $inverseField => $placeholder = (new \ReflectionClass(static::class()))->newInstanceWithoutConstructor(),
+                    ]);
+
+                $inversedObject = unproxy($inversedObject, withAutoRefresh: false);
 
                 $this->tempAfterInstantiate[] = static function(object $object) use ($inversedObject, $inverseField, $pm, $placeholder) {
                     $pm->forget($placeholder);
@@ -324,12 +326,12 @@ protected function normalizeParameter(string $field, mixed $value): mixed
             }
         }
 
-        return unproxy(parent::normalizeParameter($field, $value));
+        return unproxy(parent::normalizeParameter($field, $value), withAutoRefresh: false);
     }
 
     protected function normalizeCollection(string $field, FactoryCollection $collection): array
     {
-        if (!$this->isPersisting() || !$collection->factory instanceof self) {
+        if (!Configuration::instance()->isPersistenceAvailable() || !$collection->factory instanceof self) {
             return parent::normalizeCollection($field, $collection);
         }
 
@@ -338,12 +340,15 @@ protected function normalizeCollection(string $field, FactoryCollection $collect
         $inverseRelationshipMetadata = $pm->inverseRelationshipMetadata(static::class(), $collection->factory::class(), $field);
 
         if ($inverseRelationshipMetadata && $inverseRelationshipMetadata->isCollection) {
-            $this->tempAfterInstantiate[] = static function(object $object) use ($collection, $inverseRelationshipMetadata, $field) {
+            $this->tempAfterInstantiate[] = function(object $object) use ($collection, $inverseRelationshipMetadata, $field) {
                 $inverseField = $inverseRelationshipMetadata->inverseField;
 
-                $inverseObjects = $collection->withPersistMode(PersistMode::NO_PERSIST_BUT_SCHEDULE_FOR_INSERT)->create([$inverseField => $object]);
+                $inverseObjects = $collection->withPersistMode(
+                    $this->isPersisting() ? PersistMode::NO_PERSIST_BUT_SCHEDULE_FOR_INSERT : PersistMode::WITHOUT_PERSISTING
+                )
+                    ->create([$inverseField => $object]);
 
-                $inverseObjects = unproxy($inverseObjects);
+                $inverseObjects = unproxy($inverseObjects, withAutoRefresh: false);
 
                 // if the collection is indexed by a field, index the array
                 if ($inverseRelationshipMetadata->collectionIndexedBy) {
@@ -379,9 +384,7 @@ protected function normalizeObject(object $object): object
             return $object;
         }
 
-        if ($object instanceof Proxy) {
-            $object = $object->_real(withAutoRefresh: false);
-        }
+        $object = unproxy($object, withAutoRefresh: false);
 
         $persistenceManager = $configuration->persistence();
         if (!$persistenceManager->hasPersistenceFor($object)) {

src/Persistence/ProxyGenerator.php

@@ -66,18 +66,18 @@ public static function wrapFactory(PersistentProxyObjectFactory $factory, callab
      *
      * @return T
      */
-    public static function unwrap(mixed $what): mixed
+    public static function unwrap(mixed $what, bool $withAutoRefresh = true): mixed
     {
         if (\is_array($what)) {
-            return \array_map(self::unwrap(...), $what); // @phpstan-ignore return.type
+            return \array_map(static fn(mixed $w) => self::unwrap($w, $withAutoRefresh), $what); // @phpstan-ignore return.type
         }
 
         if (\is_string($what) && \is_a($what, Proxy::class, true)) {
             return \get_parent_class($what) ?: throw new \LogicException('Could not unwrap proxy.'); // @phpstan-ignore return.type
         }
 
         if ($what instanceof Proxy) {
-            return $what->_real(); // @phpstan-ignore return.type
+            return $what->_real($withAutoRefresh); // @phpstan-ignore return.type
         }
 
         return $what;

src/Persistence/functions.php

@@ -107,9 +107,9 @@ function proxy(object $object): object
  *
  * @return T
  */
-function unproxy(mixed $what): mixed
+function unproxy(mixed $what, bool $withAutoRefresh = true): mixed
 {
-    return ProxyGenerator::unwrap($what);
+    return ProxyGenerator::unwrap($what, $withAutoRefresh);
 }
 
 /**

tests/Integration/ORM/EntityRelationship/EntityFactoryRelationshipTestCase.php

@@ -323,11 +323,21 @@ public function disabling_persistence_cascades_to_children(): void
         foreach ($contact->getTags() as $tag) {
             $this->assertNull($tag->id);
         }
+    }
 
+    /** @test */
+    #[Test]
+    #[DataProvider('provideCascadeRelationshipsCombinations')]
+    #[UsingRelationships(Contact::class, ['category'])]
+    public function disabling_persistence_cascades_to_children_one_to_many(): void
+    {
         $category = static::categoryFactory()->withoutPersisting()->create([
             'contacts' => static::contactFactory()->many(3),
         ]);
 
+        // ensure nothing was persisted in Doctrine by flushing
+        self::getContainer()->get(EntityManagerInterface::class)->flush(); // @phpstan-ignore method.notFound
+
         static::contactFactory()::assert()->empty();
         static::categoryFactory()::assert()->empty();
 
@@ -339,6 +349,27 @@ public function disabling_persistence_cascades_to_children(): void
         }
     }
 
+    /** @test */
+    #[Test]
+    #[DataProvider('provideCascadeRelationshipsCombinations')]
+    #[UsingRelationships(Contact::class, ['address'])]
+    public function disabling_persistence_cascades_to_children_inversed_one_to_one(): void
+    {
+        $address = static::addressFactory()->withoutPersisting()->create([
+            'contact' => static::contactFactory(),
+        ]);
+
+        // ensure nothing was persisted in Doctrine by flushing
+        self::getContainer()->get(EntityManagerInterface::class)->flush(); // @phpstan-ignore method.notFound
+
+        static::contactFactory()::assert()->empty();
+        static::addressFactory()::assert()->empty();
+
+        $this->assertNull($address->id);
+        $this->assertInstanceOf(Contact::class, $address->getContact());
+        $this->assertNull($address->getContact()->id);
+    }
+
     /** @test */
     #[Test]
     #[DataProvider('provideCascadeRelationshipsCombinations')]

tests/Unit/Persistence/PersistentObjectFactoryTest.php

@@ -13,6 +13,7 @@
 
 use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
+use Zenstruck\Foundry\FactoryCollection;
 use Zenstruck\Foundry\Test\Factories;
 use Zenstruck\Foundry\Tests\Fixture\Entity\GenericEntity;
 use Zenstruck\Foundry\Tests\Fixture\Factories\Entity\GenericEntityFactory;
@@ -62,4 +63,30 @@ public function random_or_create(): void
 
         $this->assertSame('foo', $entity->getProp1());
     }
+
+    /**
+     * @test
+     * @dataProvider factoryCollectionDataProvider
+     * @param FactoryCollection<GenericEntity, GenericEntityFactory> $collection
+     */
+    public function can_use_factory_collection_methods_in_data_providers(FactoryCollection $collection): void // @phpstan-ignore generics.notSubtype
+    {
+        self::assertEquals(
+            [
+                new GenericEntity('foo'),
+            ],
+            $collection->create(),
+        );
+    }
+
+    public static function factoryCollectionDataProvider(): iterable
+    {
+        yield [
+            GenericEntityFactory::new()->sequence([
+                [
+                    'prop1' => 'foo',
+                ],
+            ]),
+        ];
+    }
 }