chore: Refactor collections loading with a Preloader

Author: marienfressinaud

src/controllers/profiles/Opml.php

@@ -35,6 +35,8 @@ public function show(Request $request): Response
         ]);
         $collections = utils\Sorter::localeSort($collections, 'name');
 
+        models\collections\Preloader::for($collections)->timeFiltersFor($user);
+
         return Response::ok('profiles/opml/show.opml.xml.twig', [
             'user' => $user,
             'collections' => $collections,

src/controllers/streams/Sources.php

@@ -37,8 +37,17 @@ public function index(Request $request): Response
 
         auth\Access::require($user, 'view', $stream);
 
+        $sources = $stream->sources([
+            'context_user' => $user,
+        ]);
+
+        models\collections\Preloader::for($sources)
+            ->publishers()
+            ->countStreamsFor($user);
+
         return Response::ok('streams/sources/index.html.twig', [
             'stream' => $stream,
+            'sources' => $sources,
         ]);
     }
 
@@ -67,6 +76,11 @@ public function edit(Request $request): Response
             'context_user' => $user,
         ]);
 
+        $sources_to_preload = array_merge($followed_sources, $existing_sources);
+        models\collections\Preloader::for($sources_to_preload)
+            ->publishers()
+            ->countStreamsFor($user);
+
         $suggested_sources = array_udiff(
             $followed_sources,
             $existing_sources,

src/models/Collection.php

@@ -99,12 +99,6 @@ class Collection
     #[Database\Column(computed: true)]
     public ?int $number_links = null;
 
-    #[Database\Column(computed: true)]
-    public ?int $number_streams = null;
-
-    #[Database\Column(computed: true)]
-    public ?string $time_filter = null;
-
     public function __construct()
     {
         $this->id = \Minz\Random::timebased();
@@ -261,25 +255,39 @@ public function preloadOwner(?User $owner): void
         $this->memoizeValue('owner', $owner);
     }
 
+    /**
+     * Set the publishers of the collection without querying the database.
+     *
+     * @see collections\Preloader
+     *
+     * @param User[] $publishers
+     */
+    public function preloadPublishers(array $publishers): void
+    {
+        $this->memoizeValue('publishers', $publishers);
+    }
+
     /**
      * Return the list of users with write access.
      *
      * @return User[]
      */
     public function publishers(): array
     {
-        $owner = $this->owner();
-        $shares = $this->shares(['access_type' => 'write']);
+        return $this->memoize('publishers', function (): array {
+            $owner = $this->owner();
+            $shares = $this->shares(['access_type' => 'write']);
 
-        $publishers = array_map(function (CollectionShare $share): User {
-            return $share->user();
-        }, $shares);
+            $publishers = array_map(function (CollectionShare $share): User {
+                return $share->user();
+            }, $shares);
 
-        if ($owner) {
-            array_unshift($publishers, $owner);
-        }
+            if ($owner) {
+                array_unshift($publishers, $owner);
+            }
 
-        return $publishers;
+            return $publishers;
+        });
     }
 
     /**
@@ -395,17 +403,48 @@ public function groupForUser(string $user_id): ?Group
     /**
      * Return the number of streams of the given user in which this collection
      * is a source.
-     *
-     * This is the same information as the number_streams computed property,
-     * for a collection that has been loaded on its own.
      */
     public function countStreamsByUser(User $user): int
     {
         return $this->memoize("count_streams_{$user->id}", function () use ($user): int {
-            return StreamToFollow::countByUserAndSource($user, $this);
+            $counts = StreamToFollow::countByUserAndSources($user, [$this]);
+            return $counts[$this->id] ?? 0;
         });
     }
 
+    /**
+     * Set the number of streams of a user without querying the database.
+     *
+     * @see collections\Preloader
+     */
+    public function preloadCountStreamsByUser(User $user, int $count): void
+    {
+        $this->memoizeValue("count_streams_{$user->id}", $count);
+    }
+
+    /**
+     * Return the time filter applied by the given user to this collection, or
+     * null if the user doesn't follow it.
+     */
+    public function timeFilterByUser(User $user): ?string
+    {
+        return $this->memoize("time_filter_{$user->id}", function () use ($user): ?string {
+            $follows = FollowedCollection::listByUserAndCollections($user, [$this]);
+            $follow = $follows[$this->id] ?? null;
+            return $follow?->time_filter;
+        });
+    }
+
+    /**
+     * Set the time filter of a user without querying the database.
+     *
+     * @see collections\Preloader
+     */
+    public function preloadTimeFilterByUser(User $user, ?string $time_filter): void
+    {
+        $this->memoizeValue("time_filter_{$user->id}", $time_filter);
+    }
+
     /**
      * Return the topics attached to the current collection.
      *
@@ -457,6 +496,8 @@ public function shareWith(User $user, string $access_type): void
     {
         $collection_share = new CollectionShare($user->id, $this->id, $access_type);
         $collection_share->save();
+
+        $this->unmemoize('publishers');
     }
 
     /**
@@ -468,6 +509,8 @@ public function unshareWith(User $user): void
             'collection_id' => $this->id,
             'user_id' => $user->id,
         ]);
+
+        $this->unmemoize('publishers');
     }
 
     /**

src/models/CollectionShare.php

@@ -55,6 +55,47 @@ public function __construct(string $user_id, string $collection_id, string $type
         $this->type = $type;
     }
 
+    /**
+     * Return the ids of the users the given collections are shared with in
+     * write access, indexed by the ids of these collections.
+     *
+     * The collections shared with nobody are absent from the returned array.
+     *
+     * @param Collection[] $collections
+     *
+     * @return array<string, string[]>
+     */
+    public static function listWriterIdsByCollections(array $collections): array
+    {
+        if (!$collections) {
+            return [];
+        }
+
+        $collection_ids = array_column($collections, 'id');
+        $ids_as_question_marks = array_fill(0, count($collection_ids), '?');
+        $ids_as_question_marks = implode(', ', $ids_as_question_marks);
+
+        $sql = <<<SQL
+            SELECT cs.collection_id, cs.user_id
+            FROM collection_shares cs
+
+            WHERE cs.collection_id IN ({$ids_as_question_marks})
+            AND cs.type = 'write'
+        SQL;
+
+        $database = Database::get();
+        $statement = $database->prepare($sql);
+        $statement->execute($collection_ids);
+
+        $user_ids_by_collection_ids = [];
+
+        foreach ($statement->fetchAll() as $row) {
+            $user_ids_by_collection_ids[$row['collection_id']][] = $row['user_id'];
+        }
+
+        return $user_ids_by_collection_ids;
+    }
+
     /**
      * Return the user attached to the CollectionShare
      */

src/models/FollowedCollection.php

@@ -63,6 +63,37 @@ public static function findOrCreate(User $user, Collection $collection): self
         ]);
     }
 
+    /**
+     * Return the follows of the given user for the given collections, indexed
+     * by the ids of these collections.
+     *
+     * The collections that the user doesn't follow are absent from the
+     * returned array.
+     *
+     * @param Collection[] $collections
+     *
+     * @return array<string, self>
+     */
+    public static function listByUserAndCollections(User $user, array $collections): array
+    {
+        if (!$collections) {
+            return [];
+        }
+
+        $follows = self::listBy([
+            'user_id' => $user->id,
+            'collection_id' => array_column($collections, 'id'),
+        ]);
+
+        $follows_by_collection_ids = [];
+
+        foreach ($follows as $follow) {
+            $follows_by_collection_ids[$follow->collection_id] = $follow;
+        }
+
+        return $follows_by_collection_ids;
+    }
+
     /**
      * Return the streams in which the followed collection is a source.
      *

src/models/StreamToFollow.php

@@ -67,28 +67,47 @@ public static function findOrCreate(Stream $stream, Collection $source): self
     }
 
     /**
-     * Return the number of streams of the given user in which the source is
-     * attached.
+     * Return the numbers of streams of the given user in which the given
+     * sources are attached, indexed by the ids of these sources.
+     *
+     * The sources that are in no stream are absent from the returned array.
+     *
+     * @param Collection[] $sources
+     *
+     * @return array<string, int>
      */
-    public static function countByUserAndSource(User $user, Collection $source): int
+    public static function countByUserAndSources(User $user, array $sources): array
     {
+        if (!$sources) {
+            return [];
+        }
+
+        $source_ids = array_column($sources, 'id');
+        $ids_as_question_marks = array_fill(0, count($source_ids), '?');
+        $ids_as_question_marks = implode(', ', $ids_as_question_marks);
+
         $sql = <<<SQL
-            SELECT COUNT(*)
+            SELECT fc.collection_id, COUNT(*) AS count
             FROM streams_to_follows sf, followed_collections fc
 
             WHERE sf.follow_id = fc.id
-            AND fc.user_id = :user_id
-            AND fc.collection_id = :source_id
+            AND fc.user_id = ?
+            AND fc.collection_id IN ({$ids_as_question_marks})
+
+            GROUP BY fc.collection_id
         SQL;
 
         $database = Database::get();
         $statement = $database->prepare($sql);
-        $statement->execute([
-            'user_id' => $user->id,
-            'source_id' => $source->id,
-        ]);
+        $statement->execute([$user->id, ...$source_ids]);
+
+        $counts = [];
+
+        foreach ($statement->fetchAll() as $row) {
+            $counts[$row['collection_id']] = intval($row['count']);
+        }
 
-        return intval($statement->fetchColumn());
+        return $counts;
     }
 
     /**