feat: throw when withoutDoctrineEvents() is called within flush_after()

.roave-backward-compatibility-check.xml

@@ -9,5 +9,6 @@
         <ignored-regex>#(.*)Zenstruck\\Foundry\\Utils\\Rector(.*)#</ignored-regex>
         <ignored-regex>#(.*)initializeInternal(.*)#</ignored-regex>
         <ignored-regex>#\[BC\] CHANGED: Method getIdentifierValues\(\) of class Zenstruck\\Foundry\\Persistence\\PersistenceStrategy became final#</ignored-regex>
+        <ignored-regex>#"Zenstruck\\Foundry\\Test\\(CommonResetDatabase|CommonFactories)" could not be found in the located source(.*)#</ignored-regex>
     </baseline>
 </roave-bc-check>

bin/tools/bc-check/composer.json

@@ -1,5 +1,5 @@
 {
     "require": {
-        "roave/backward-compatibility-check": "^8.15"
+        "roave/backward-compatibility-check": "^8.17"
     }
 }

docs/index.rst

@@ -1319,9 +1319,7 @@ them during object creation to avoid this.
 
 ::
 
-    use App\Entity\Post;
     use App\Factory\PostFactory;
-    use function Zenstruck\Foundry\Persistence\persistent_factory;
 
     // disable ALL Doctrine event listeners during creation
     $post = PostFactory::new()->withoutDoctrineEvents()->create(); // returns Post
@@ -1342,6 +1340,10 @@ If you'd like your factory to always disable Doctrine events, override its ``ini
         ;
     }
 
+.. note::
+
+    ``withoutDoctrineEvents()`` cannot be used inside ``flush_after()``.
+
 Array factories
 ~~~~~~~~~~~~~~~
 

src/Mongo/MongoPersistenceStrategy.php

@@ -11,6 +11,7 @@
 
 namespace Zenstruck\Foundry\Mongo;
 
+use Doctrine\Common\EventManager;
 use Doctrine\ODM\MongoDB\DocumentManager;
 use Doctrine\ODM\MongoDB\Mapping\MappingException as MongoMappingException;
 use Doctrine\Persistence\Mapping\MappingException;
@@ -94,4 +95,29 @@ public function getIdentifierValues(object $object): array
     {
         return $this->classMetadata($object::class)->getIdentifierValues($object);
     }
+
+    public function withoutDoctrineEvents(string $entityClass, array $disabledClasses, callable $callback): mixed
+    {
+        $eventManager = $this->objectManagerFor($entityClass)->getEventManager();
+        $removed = [];
+
+        foreach ($eventManager->getAllListeners() as $eventName => $listeners) {
+            foreach ($listeners as $listener) {
+                if ([] === $disabledClasses || \in_array($listener::class, $disabledClasses, true)) {
+                    $eventManager->removeEventListener([$eventName], $listener);
+                    $removed[$eventName][] = $listener;
+                }
+            }
+        }
+
+        try {
+            return $callback();
+        } finally {
+            foreach ($removed as $eventName => $listeners) {
+                foreach ($listeners as $listener) {
+                    $eventManager->addEventListener([$eventName], $listener);
+                }
+            }
+        }
+    }
 }

src/ORM/AbstractORMPersistenceStrategy.php

@@ -11,9 +11,11 @@
 
 namespace Zenstruck\Foundry\ORM;
 
+use Doctrine\Common\EventManager;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\Mapping\MappingException as ORMMappingException;
 use Doctrine\Persistence\Mapping\MappingException;
+use Doctrine\Persistence\ObjectManager;
 use Zenstruck\Foundry\Persistence\PersistenceStrategy;
 
 /**
@@ -118,4 +120,103 @@ function(mixed $value) use ($object) {
             $identifiers
         );
     }
+
+    public function withoutDoctrineEvents(string $entityClass, array $disabledClasses, callable $callback): mixed
+    {
+        $om = $this->objectManagerFor($entityClass);
+
+        // Entity listeners first: getClassMetadata() triggers loadClassMetadata which registers
+        // #[AsEntityListener] listeners. Global listeners must still be active at that point.
+        $entityListenersBackup = $this->removeEntityListeners($om, $entityClass, $disabledClasses);
+        $globalListenersBackup = $this->removeGlobalListeners($om, $disabledClasses);
+
+        try {
+            return $callback();
+        } finally {
+            $this->restoreGlobalListeners($om, $globalListenersBackup);
+            $this->restoreEntityListeners($om, $entityClass, $entityListenersBackup);
+        }
+    }
+
+    /**
+     * @param list<class-string> $disabledClasses
+     *
+     * @return array<string, list<object>>
+     */
+    private function removeGlobalListeners(EntityManagerInterface $om, array $disabledClasses): array
+    {
+        $eventManager = $om->getEventManager();
+        $removed = [];
+
+        foreach ($eventManager->getAllListeners() as $eventName => $listeners) {
+            foreach ($listeners as $listener) {
+                if ([] === $disabledClasses || \in_array($listener::class, $disabledClasses, true)) {
+                    $eventManager->removeEventListener([$eventName], $listener);
+                    $removed[$eventName][] = $listener;
+                }
+            }
+        }
+
+        return $removed;
+    }
+
+    /**
+     * @param array<string, list<object>> $removedListeners
+     */
+    private function restoreGlobalListeners(EntityManagerInterface $om, array $removedListeners): void
+    {
+        $eventManager = $om->getEventManager();
+
+        foreach ($removedListeners as $eventName => $listeners) {
+            foreach ($listeners as $listener) {
+                $eventManager->addEventListener([$eventName], $listener);
+            }
+        }
+    }
+
+    /**
+     * @param class-string       $entityClass
+     * @param list<class-string> $disabledClasses
+     *
+     * @return array<string, list<array{class: class-string, method: string}>>
+     */
+    private function removeEntityListeners(EntityManagerInterface $om, string $entityClass, array $disabledClasses): array
+    {
+        $metadata = $om->getClassMetadata($entityClass);
+        $original = $metadata->entityListeners;
+
+        if ([] === $original) {
+            return [];
+        }
+
+        if ([] === $disabledClasses) {
+            $metadata->entityListeners = [];
+
+            return $original;
+        }
+
+        $metadata->entityListeners = \array_filter(
+            \array_map(
+                static fn(array $listeners) => \array_values(\array_filter(
+                    $listeners,
+                    static fn(array $listener) => !\in_array($listener['class'], $disabledClasses, true),
+                )),
+                $original,
+            ),
+            static fn(array $listeners) => [] !== $listeners,
+        );
+
+        return $original;
+    }
+
+    /**
+     * @param class-string                                                    $entityClass
+     * @param array<string, list<array{class: class-string, method: string}>> $original
+     */
+    private function restoreEntityListeners(EntityManagerInterface $om, string $entityClass, array $original): void
+    {
+        if ([] !== $original) {
+            $om->getClassMetadata($entityClass)->entityListeners = $original;
+        }
+    }
 }