5 files changed, 405 insertions, 0 deletions

diff --git a/vendor/doctrine/orm/src/Cache/Persister/Collection/AbstractCollectionPersister.php b/vendor/doctrine/orm/src/Cache/Persister/Collection/AbstractCollectionPersister.php
new file mode 100644
index 0000000..8c087a8
--- /dev/null
+++ b/vendor/doctrine/orm/src/Cache/Persister/Collection/AbstractCollectionPersister.php
@@ -0,0 +1,168 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\CollectionHydrator;
+use Doctrine\ORM\Cache\Logging\CacheLogger;
+use Doctrine\ORM\Cache\Persister\Entity\CachedEntityPersister;
+use Doctrine\ORM\Cache\Region;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\AssociationMapping;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\Mapping\ClassMetadataFactory;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
+use Doctrine\ORM\UnitOfWork;
+
+use function array_values;
+use function assert;
+use function count;
+
+abstract class AbstractCollectionPersister implements CachedCollectionPersister
+{
+    protected UnitOfWork $uow;
+    protected ClassMetadataFactory $metadataFactory;
+    protected ClassMetadata $sourceEntity;
+    protected ClassMetadata $targetEntity;
+
+    /** @var mixed[] */
+    protected array $queuedCache = [];
+
+    protected string $regionName;
+    protected CollectionHydrator $hydrator;
+    protected CacheLogger|null $cacheLogger;
+
+    public function __construct(
+        protected CollectionPersister $persister,
+        protected Region $region,
+        EntityManagerInterface $em,
+        protected AssociationMapping $association,
+    ) {
+        $configuration = $em->getConfiguration();
+        $cacheConfig   = $configuration->getSecondLevelCacheConfiguration();
+        $cacheFactory  = $cacheConfig->getCacheFactory();
+
+        $this->regionName      = $region->getName();
+        $this->uow             = $em->getUnitOfWork();
+        $this->metadataFactory = $em->getMetadataFactory();
+        $this->cacheLogger     = $cacheConfig->getCacheLogger();
+        $this->hydrator        = $cacheFactory->buildCollectionHydrator($em, $association);
+        $this->sourceEntity    = $em->getClassMetadata($association->sourceEntity);
+        $this->targetEntity    = $em->getClassMetadata($association->targetEntity);
+    }
+
+    public function getCacheRegion(): Region
+    {
+        return $this->region;
+    }
+
+    public function getSourceEntityMetadata(): ClassMetadata
+    {
+        return $this->sourceEntity;
+    }
+
+    public function getTargetEntityMetadata(): ClassMetadata
+    {
+        return $this->targetEntity;
+    }
+
+    public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key): array|null
+    {
+        $cache = $this->region->get($key);
+
+        if ($cache === null) {
+            return null;
+        }
+
+        return $this->hydrator->loadCacheEntry($this->sourceEntity, $key, $cache, $collection);
+    }
+
+    public function storeCollectionCache(CollectionCacheKey $key, Collection|array $elements): void
+    {
+        $associationMapping = $this->sourceEntity->associationMappings[$key->association];
+        $targetPersister    = $this->uow->getEntityPersister($this->targetEntity->rootEntityName);
+        assert($targetPersister instanceof CachedEntityPersister);
+        $targetRegion   = $targetPersister->getCacheRegion();
+        $targetHydrator = $targetPersister->getEntityHydrator();
+
+        // Only preserve ordering if association configured it
+        if (! $associationMapping->isIndexed()) {
+            // Elements may be an array or a Collection
+            $elements = array_values($elements instanceof Collection ? $elements->getValues() : $elements);
+        }
+
+        $entry = $this->hydrator->buildCacheEntry($this->targetEntity, $key, $elements);
+
+        foreach ($entry->identifiers as $index => $entityKey) {
+            if ($targetRegion->contains($entityKey)) {
+                continue;
+            }
+
+            $class     = $this->targetEntity;
+            $className = DefaultProxyClassNameResolver::getClass($elements[$index]);
+
+            if ($className !== $this->targetEntity->name) {
+                $class = $this->metadataFactory->getMetadataFor($className);
+            }
+
+            $entity      = $elements[$index];
+            $entityEntry = $targetHydrator->buildCacheEntry($class, $entityKey, $entity);
+
+            $targetRegion->put($entityKey, $entityEntry);
+        }
+
+        if ($this->region->put($key, $entry)) {
+            $this->cacheLogger?->collectionCachePut($this->regionName, $key);
+        }
+    }
+
+    public function contains(PersistentCollection $collection, object $element): bool
+    {
+        return $this->persister->contains($collection, $element);
+    }
+
+    public function containsKey(PersistentCollection $collection, mixed $key): bool
+    {
+        return $this->persister->containsKey($collection, $key);
+    }
+
+    public function count(PersistentCollection $collection): int
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association->fieldName, $ownerId);
+        $entry   = $this->region->get($key);
+
+        if ($entry !== null) {
+            return count($entry->identifiers);
+        }
+
+        return $this->persister->count($collection);
+    }
+
+    public function get(PersistentCollection $collection, mixed $index): mixed
+    {
+        return $this->persister->get($collection, $index);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function slice(PersistentCollection $collection, int $offset, int|null $length = null): array
+    {
+        return $this->persister->slice($collection, $offset, $length);
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function loadCriteria(PersistentCollection $collection, Criteria $criteria): array
+    {
+        return $this->persister->loadCriteria($collection, $criteria);
+    }
+}
diff --git a/vendor/doctrine/orm/src/Cache/Persister/Collection/CachedCollectionPersister.php b/vendor/doctrine/orm/src/Cache/Persister/Collection/CachedCollectionPersister.php
new file mode 100644
index 0000000..6b10c80
--- /dev/null
+++ b/vendor/doctrine/orm/src/Cache/Persister/Collection/CachedCollectionPersister.php
@@ -0,0 +1,36 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\Common\Collections\Collection;
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\Persister\CachedPersister;
+use Doctrine\ORM\Mapping\ClassMetadata;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+
+/**
+ * Interface for second level cache collection persisters.
+ */
+interface CachedCollectionPersister extends CachedPersister, CollectionPersister
+{
+    public function getSourceEntityMetadata(): ClassMetadata;
+
+    public function getTargetEntityMetadata(): ClassMetadata;
+
+    /**
+     * Loads a collection from cache
+     *
+     * @return mixed[]|null
+     */
+    public function loadCollectionCache(PersistentCollection $collection, CollectionCacheKey $key): array|null;
+
+    /**
+     * Stores a collection into cache
+     *
+     * @param mixed[]|Collection $elements
+     */
+    public function storeCollectionCache(CollectionCacheKey $key, Collection|array $elements): void;
+}
diff --git a/vendor/doctrine/orm/src/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php b/vendor/doctrine/orm/src/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php
new file mode 100644
index 0000000..ac861f4
--- /dev/null
+++ b/vendor/doctrine/orm/src/Cache/Persister/Collection/NonStrictReadWriteCachedCollectionPersister.php
@@ -0,0 +1,74 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\PersistentCollection;
+
+use function spl_object_id;
+
+class NonStrictReadWriteCachedCollectionPersister extends AbstractCollectionPersister
+{
+    public function afterTransactionComplete(): void
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->storeCollectionCache($item['key'], $item['list']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $key) {
+                $this->region->evict($key);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    public function afterTransactionRolledBack(): void
+    {
+        $this->queuedCache = [];
+    }
+
+    public function delete(PersistentCollection $collection): void
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association->fieldName, $ownerId);
+
+        $this->persister->delete($collection);
+
+        $this->queuedCache['delete'][spl_object_id($collection)] = $key;
+    }
+
+    public function update(PersistentCollection $collection): void
+    {
+        $isInitialized = $collection->isInitialized();
+        $isDirty       = $collection->isDirty();
+
+        if (! $isInitialized && ! $isDirty) {
+            return;
+        }
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association->fieldName, $ownerId);
+
+       // Invalidate non initialized collections OR ordered collection
+        if ($isDirty && ! $isInitialized || $this->association->isOrdered()) {
+            $this->persister->update($collection);
+
+            $this->queuedCache['delete'][spl_object_id($collection)] = $key;
+
+            return;
+        }
+
+        $this->persister->update($collection);
+
+        $this->queuedCache['update'][spl_object_id($collection)] = [
+            'key'   => $key,
+            'list'  => $collection,
+        ];
+    }
+}
diff --git a/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php b/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php
new file mode 100644
index 0000000..96e0a4b
--- /dev/null
+++ b/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadOnlyCachedCollectionPersister.php
@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Cache\Exception\CannotUpdateReadOnlyCollection;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Proxy\DefaultProxyClassNameResolver;
+
+class ReadOnlyCachedCollectionPersister extends NonStrictReadWriteCachedCollectionPersister
+{
+    public function update(PersistentCollection $collection): void
+    {
+        if ($collection->isDirty() && $collection->getSnapshot()) {
+            throw CannotUpdateReadOnlyCollection::fromEntityAndField(
+                DefaultProxyClassNameResolver::getClass($collection->getOwner()),
+                $this->association->fieldName,
+            );
+        }
+
+        parent::update($collection);
+    }
+}
diff --git a/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php b/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php
new file mode 100644
index 0000000..347a065
--- /dev/null
+++ b/vendor/doctrine/orm/src/Cache/Persister/Collection/ReadWriteCachedCollectionPersister.php
@@ -0,0 +1,103 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Doctrine\ORM\Cache\Persister\Collection;
+
+use Doctrine\ORM\Cache\CollectionCacheKey;
+use Doctrine\ORM\Cache\ConcurrentRegion;
+use Doctrine\ORM\EntityManagerInterface;
+use Doctrine\ORM\Mapping\AssociationMapping;
+use Doctrine\ORM\PersistentCollection;
+use Doctrine\ORM\Persisters\Collection\CollectionPersister;
+
+use function spl_object_id;
+
+class ReadWriteCachedCollectionPersister extends AbstractCollectionPersister
+{
+    public function __construct(
+        CollectionPersister $persister,
+        ConcurrentRegion $region,
+        EntityManagerInterface $em,
+        AssociationMapping $association,
+    ) {
+        parent::__construct($persister, $region, $em, $association);
+    }
+
+    public function afterTransactionComplete(): void
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    public function afterTransactionRolledBack(): void
+    {
+        if (isset($this->queuedCache['update'])) {
+            foreach ($this->queuedCache['update'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        if (isset($this->queuedCache['delete'])) {
+            foreach ($this->queuedCache['delete'] as $item) {
+                $this->region->evict($item['key']);
+            }
+        }
+
+        $this->queuedCache = [];
+    }
+
+    public function delete(PersistentCollection $collection): void
+    {
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association->fieldName, $ownerId);
+        $lock    = $this->region->lock($key);
+
+        $this->persister->delete($collection);
+
+        if ($lock === null) {
+            return;
+        }
+
+        $this->queuedCache['delete'][spl_object_id($collection)] = [
+            'key'   => $key,
+            'lock'  => $lock,
+        ];
+    }
+
+    public function update(PersistentCollection $collection): void
+    {
+        $isInitialized = $collection->isInitialized();
+        $isDirty       = $collection->isDirty();
+
+        if (! $isInitialized && ! $isDirty) {
+            return;
+        }
+
+        $this->persister->update($collection);
+
+        $ownerId = $this->uow->getEntityIdentifier($collection->getOwner());
+        $key     = new CollectionCacheKey($this->sourceEntity->rootEntityName, $this->association->fieldName, $ownerId);
+        $lock    = $this->region->lock($key);
+
+        if ($lock === null) {
+            return;
+        }
+
+        $this->queuedCache['update'][spl_object_id($collection)] = [
+            'key'   => $key,
+            'lock'  => $lock,
+        ];
+    }
+}