Optimize fetching of metadata associations

Author: codedmonkey

src/Controller/Dashboard/DashboardPackagesInfoController.php

@@ -4,11 +4,13 @@
 
 use CodedMonkey\Dirigent\Attribute\IsGrantedAccess;
 use CodedMonkey\Dirigent\Attribute\MapPackage;
+use CodedMonkey\Dirigent\Doctrine\Entity\Metadata;
 use CodedMonkey\Dirigent\Doctrine\Entity\Package;
 use CodedMonkey\Dirigent\Doctrine\Entity\PackageProvideLink;
 use CodedMonkey\Dirigent\Doctrine\Entity\PackageRequireLink;
 use CodedMonkey\Dirigent\Doctrine\Entity\PackageSuggestLink;
 use CodedMonkey\Dirigent\Doctrine\Entity\Version;
+use CodedMonkey\Dirigent\Doctrine\Repository\MetadataRepository;
 use CodedMonkey\Dirigent\EasyAdmin\PackagePaginator;
 use Doctrine\ORM\EntityManagerInterface;
 use Doctrine\ORM\QueryBuilder;
@@ -44,6 +46,10 @@ public function info(#[MapPackage] Package $package): Response
     #[IsGrantedAccess]
     public function versionInfo(#[MapPackage] Package $package, #[MapPackage] Version $version): Response
     {
+        /** @var MetadataRepository $metadataRepository */
+        $metadataRepository = $this->entityManager->getRepository(Metadata::class);
+        $metadataRepository->fetchMetadataCollections($version->getCurrentMetadata());
+
         $dependentCount = $this->entityManager->getRepository(PackageRequireLink::class)->count(['linkedPackageName' => $package->getName()]);
         $implementationCount = $this->entityManager->getRepository(PackageProvideLink::class)->count(['linkedPackageName' => $package->getName(), 'implementation' => true]);
         $providerCount = $this->entityManager->getRepository(PackageProvideLink::class)->count(['linkedPackageName' => $package->getName(), 'implementation' => false]);

src/Doctrine/Entity/Metadata.php

@@ -8,6 +8,9 @@
 use Composer\Pcre\Preg;
 use Doctrine\Common\Collections\ArrayCollection;
 use Doctrine\Common\Collections\Collection;
+use Doctrine\Common\Collections\Criteria;
+use Doctrine\Common\Collections\Order;
+use Doctrine\Common\Collections\Selectable;
 use Doctrine\DBAL\Types\Types;
 use Doctrine\ORM\Mapping as ORM;
 
@@ -98,49 +101,43 @@ class Metadata extends TrackedEntity implements \Stringable
     private Package $package;
 
     /**
-     * @var Collection<int, MetadataRequireLink>
+     * @var Collection<int, MetadataRequireLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataRequireLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $requireLinks;
 
     /**
-     * @var Collection<int, MetadataDevRequireLink>
+     * @var Collection<int, MetadataDevRequireLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataDevRequireLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $devRequireLinks;
 
     /**
-     * @var Collection<int, MetadataConflictLink>
+     * @var Collection<int, MetadataConflictLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataConflictLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $conflictLinks;
 
     /**
-     * @var Collection<int, MetadataProvideLink>
+     * @var Collection<int, MetadataProvideLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataProvideLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $provideLinks;
 
     /**
-     * @var Collection<int, MetadataReplaceLink>
+     * @var Collection<int, MetadataReplaceLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataReplaceLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $replaceLinks;
 
     /**
-     * @var Collection<int, MetadataSuggestLink>
+     * @var Collection<int, MetadataSuggestLink>&Selectable
      */
     #[ORM\OneToMany(targetEntity: MetadataSuggestLink::class, mappedBy: 'metadata', cascade: ['persist', 'detach'])]
-    #[ORM\OrderBy(['index' => 'ASC'])]
     private Collection $suggestLinks;
 
     /**
-     * @var Collection<int, MetadataKeyword>
+     * @var Collection<int, MetadataKeyword>&Selectable
      */
     #[ORM\OneToMany(mappedBy: 'metadata', targetEntity: MetadataKeyword::class, cascade: ['persist', 'detach'])]
     private Collection $keywords;
@@ -418,55 +415,55 @@ public function getPackage(): Package
      */
     public function getRequireLinks(): Collection
     {
-        return $this->requireLinks;
+        return self::getOrderedCollection($this->requireLinks);
     }
 
     /**
      * @return Collection<int, MetadataDevRequireLink>
      */
     public function getDevRequireLinks(): Collection
     {
-        return $this->devRequireLinks;
+        return self::getOrderedCollection($this->devRequireLinks);
     }
 
     /**
      * @return Collection<int, MetadataConflictLink>
      */
     public function getConflictLinks(): Collection
     {
-        return $this->conflictLinks;
+        return self::getOrderedCollection($this->conflictLinks);
     }
 
     /**
      * @return Collection<int, MetadataProvideLink>
      */
     public function getProvideLinks(): Collection
     {
-        return $this->provideLinks;
+        return self::getOrderedCollection($this->provideLinks);
     }
 
     /**
      * @return Collection<int, MetadataReplaceLink>
      */
     public function getReplaceLinks(): Collection
     {
-        return $this->replaceLinks;
+        return self::getOrderedCollection($this->replaceLinks);
     }
 
     /**
      * @return Collection<int, MetadataSuggestLink>
      */
     public function getSuggestLinks(): Collection
     {
-        return $this->suggestLinks;
+        return self::getOrderedCollection($this->suggestLinks);
     }
 
     /**
      * @return Collection<int, MetadataKeyword>
      */
     public function getKeywords(): Collection
     {
-        return $this->keywords;
+        return self::getOrderedCollection($this->keywords);
     }
 
     public function hasSource(): bool
@@ -675,4 +672,15 @@ public function toComposerArray(): array
 
         return $data;
     }
+
+    private static function getOrderedCollection(Collection&Selectable $collection): Collection
+    {
+        static $criteria = Criteria::create()
+            ->orderBy(['index' => Order::Ascending]);
+
+        /** @var Collection $collection */
+        $collection = $collection->matching($criteria);
+
+        return $collection;
+    }
 }

src/Doctrine/Repository/MetadataRepository.php

@@ -3,6 +3,7 @@
 namespace CodedMonkey\Dirigent\Doctrine\Repository;
 
 use CodedMonkey\Dirigent\Doctrine\Entity\Metadata;
+use CodedMonkey\Dirigent\Entity\MetadataLinkType;
 use Doctrine\Bundle\DoctrineBundle\Repository\ServiceEntityRepository;
 use Doctrine\Persistence\ManagerRegistry;
 
@@ -39,6 +40,49 @@ public function remove(Metadata $entity, bool $flush = false): void
         }
     }
 
+    /**
+     * Initializes all link and keyword collections for the given metadata.
+     */
+    public function fetchMetadataCollections(Metadata ...$metadata): void
+    {
+        if ([] === $metadata) {
+            return;
+        }
+
+        $metadataCollection = $metadata;
+
+        foreach (MetadataLinkType::cases() as $linkType) {
+            $association = match ($linkType) {
+                MetadataLinkType::Require => 'requireLinks',
+                MetadataLinkType::DevRequire => 'devRequireLinks',
+                MetadataLinkType::Conflict => 'conflictLinks',
+                MetadataLinkType::Provide => 'provideLinks',
+                MetadataLinkType::Replace => 'replaceLinks',
+                MetadataLinkType::Suggest => 'suggestLinks',
+            };
+
+            $this->getEntityManager()->createQueryBuilder()
+                ->select('metadata', $association)
+                ->from(Metadata::class, 'metadata')
+                ->leftJoin("metadata.$association", $association)
+                ->where('metadata IN (:metadata)')
+                ->setParameter('metadata', $metadataCollection)
+                ->getQuery()
+                ->getResult();
+        }
+
+        $this->getEntityManager()->createQueryBuilder()
+            ->select('metadata', 'keywords')
+            ->from(Metadata::class, 'metadata')
+            ->leftJoin('metadata.keywords', 'keywords')
+            ->leftJoin('keywords.keyword', 'keyword')
+            ->addSelect('keyword')
+            ->where('metadata IN (:metadata)')
+            ->setParameter('metadata', $metadataCollection)
+            ->getQuery()
+            ->getResult();
+    }
+
     public function getNextRevision(Metadata $metadata): int
     {
         $version = $metadata->getVersion();