Perf: Optimize pages loading (start work on method reading)

Signed-off-by: Kostiantyn Miakshyn <molodchick@gmail.com>

Author: Koc

appinfo/info.xml

@@ -4,7 +4,7 @@
   - SPDX-License-Identifier: AGPL-3.0-or-later
 -->
 <info xmlns:xsi= "http://www.w3.org/2001/XMLSchema-instance"
-      xsi:noNamespaceSchemaLocation="https://apps.nextcloud.com/schema/apps/info.xsd">
+	  xsi:noNamespaceSchemaLocation="https://apps.nextcloud.com/schema/apps/info.xsd">
 	<id>collectives</id>
 	<name>Collectives</name>
 	<summary>A place for activist and community projects to build shared knowledge</summary>

lib/Db/FileCacheMapper.php

@@ -0,0 +1,68 @@
+<?php
+
+declare(strict_types=1);
+
+/**
+ * SPDX-FileCopyrightText: 2025 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: AGPL-3.0-or-later
+ */
+
+namespace OCA\Collectives\Db;
+
+use OCA\Collectives\Model\FileInfo;
+use OCP\DB\QueryBuilder\IQueryBuilder;
+use OCP\IDBConnection;
+
+class FileCacheMapper {
+	private const BATCH_SIZE = 1000;
+
+	public function __construct(
+		private readonly IDBConnection $db,
+	) {
+	}
+
+	/**
+	 * Query filecache for file data by file IDs
+	 *
+	 * @param int[] $fileIds
+	 * @return array<int, FileInfo> Indexed by fileId
+	 */
+	public function findByFileIds(array $fileIds): array {
+		if (empty($fileIds)) {
+			return [];
+		}
+
+		$fileInfos = [];
+		foreach (array_chunk($fileIds, self::BATCH_SIZE) as $chunk) {
+			$qb = $this->db->getQueryBuilder();
+			$qb->select('fileid', 'storage', 'parent', 'path', 'name', 'mimetype', 'mimepart', 'size', 'mtime', 'storage_mtime', 'etag', 'encrypted', 'permissions', 'checksum', 'unencrypted_size')
+				->from('filecache')
+				->where($qb->expr()->in('fileid', $qb->createNamedParameter($chunk, IQueryBuilder::PARAM_INT_ARRAY)));
+
+			$result = $qb->executeQuery();
+			while ($row = $result->fetch()) {
+				$fileInfo = new FileInfo(
+					fileId: (int)$row['fileid'],
+					storage: (int)$row['storage'],
+					path: (string)$row['path'],
+					parent: (int)$row['parent'],
+					name: (string)$row['name'],
+					mimetype: (int)$row['mimetype'],
+					mimepart: (int)$row['mimepart'],
+					size: (int)$row['size'],
+					mtime: (int)$row['mtime'],
+					storage_mtime: (int)$row['storage_mtime'],
+					encrypted: (int)$row['encrypted'],
+					unencrypted_size: (int)$row['unencrypted_size'],
+					etag: (string)$row['etag'],
+					permissions: (int)$row['permissions'],
+					checksum: $row['checksum'] !== null ? (string)$row['checksum'] : null,
+				);
+				$fileInfos[$fileInfo->fileId] = $fileInfo;
+			}
+			$result->closeCursor();
+		}
+
+		return $fileInfos;
+	}
+}

lib/Db/PageLinkMapper.php

@@ -10,6 +10,7 @@
 namespace OCA\Collectives\Db;
 
 use OCP\DB\Exception;
+use OCP\DB\QueryBuilder\IQueryBuilder;
 use OCP\IDBConnection;
 
 class PageLinkMapper {
@@ -32,6 +33,36 @@ public function findByPageId(int $pageId): array {
 		return array_values($result);
 	}
 
+	/**
+	 * @param int[] $pageIds
+	 * @return array<int, array<int>> Indexed by page_id, values are arrays of linked_page_ids
+	 * @throws Exception
+	 */
+	public function findByPageIds(array $pageIds): array {
+		if (empty($pageIds)) {
+			return [];
+		}
+
+		$qb = $this->db->getQueryBuilder();
+		$qb->select('page_id', 'linked_page_id')
+			->from(self::TABLE_NAME)
+			->where($qb->expr()->in('page_id', $qb->createNamedParameter($pageIds, IQueryBuilder::PARAM_INT_ARRAY)));
+
+		$result = $qb->executeQuery();
+		$linkedPagesByPageId = [];
+		while ($row = $result->fetch()) {
+			$pageId = (int)$row['page_id'];
+			$linkedPageId = (int)$row['linked_page_id'];
+			if (!isset($linkedPagesByPageId[$pageId])) {
+				$linkedPagesByPageId[$pageId] = [];
+			}
+			$linkedPagesByPageId[$pageId][] = $linkedPageId;
+		}
+		$result->closeCursor();
+
+		return $linkedPagesByPageId;
+	}
+
 	/**
 	 * @throws Exception
 	 */

lib/Db/PageMapper.php

@@ -110,6 +110,26 @@ public function findByFileIds(array $fileIds, bool $trashed = false): array {
 		return $pagesByFileId;
 	}
 
+	/**
+	 * @return Page[]
+	 */
+	public function findByCollectiveId(int $collectiveId, bool $trashed = false): array {
+		$qb = $this->db->getQueryBuilder();
+		$andX = [
+			$qb->expr()->eq('collective_id', $qb->createNamedParameter($collectiveId, IQueryBuilder::PARAM_INT)),
+		];
+		// fixme: change index to use timestamp as well?
+		if ($trashed) {
+			$andX[] = $qb->expr()->isNotNull('trash_timestamp');
+		} else {
+			$andX[] = $qb->expr()->isNull('trash_timestamp');
+		}
+		$qb->select('*')
+			->from($this->tableName)
+			->where($qb->expr()->andX(...$andX));
+		return $this->findEntities($qb);
+	}
+
 	/**
 	 * @return Page[]
 	 */

lib/Fs/NodeHelper.php

@@ -10,12 +10,14 @@
 namespace OCA\Collectives\Fs;
 
 use OCA\Collectives\Model\PageInfo;
+use OCA\Collectives\Mount\CollectiveStorage;
 use OCA\Collectives\Service\NotFoundException;
 use OCA\Collectives\Service\NotPermittedException;
 use OCP\Files\File;
 use OCP\Files\Folder;
 use OCP\Files\GenericFileException;
 use OCP\Files\InvalidPathException;
+use OCP\Files\Node;
 use OCP\Files\NotFoundException as FilesNotFoundException;
 use OCP\Files\NotPermittedException as FilesNotPermittedException;
 use OCP\IDBConnection;
@@ -257,12 +259,11 @@ public static function folderHasSubPage(Folder $folder, string $title): int {
 	 * Only processes collective pages (not versions)
 	 */
 	public static function extractCollectiveIdFromPath(string $path): ?int {
-		// fixme: cover all possible cases with unit test
 		$parts = explode('/', $path);
-		if (!str_starts_with($parts[0], 'appdata_')) {
+		if (!isset($parts[0]) || !str_starts_with($parts[0], 'appdata_')) {
 			return null;
 		}
-		if ($parts[1] !== 'collectives') {
+		if (!isset($parts[1]) || $parts[1] !== 'collectives') {
 			return null;
 		}
 
@@ -276,4 +277,21 @@ public static function extractCollectiveIdFromPath(string $path): ?int {
 
 		return (int)$collectiveId;
 	}
+
+	/**
+	 * Get collective ID from node if it is a markdown file belonging to a CollectiveStorage
+	 */
+	public static function getCollectiveIdFromNode(Node $node): ?int {
+		if (!($node instanceof File) || !self::isPage($node)) {
+			return null;
+		}
+
+		$storage = $node->getStorage();
+		if (!$storage->instanceOfStorage(CollectiveStorage::class)) {
+			return null;
+		}
+
+		/** @var CollectiveStorage $storage */
+		return $storage->getFolderId();
+	}
 }

lib/Listeners/NodeDeletedListener.php

@@ -10,12 +10,11 @@
 namespace OCA\Collectives\Listeners;
 
 use OCA\Collectives\Db\PageMapper;
-use OCA\Collectives\Mount\CollectiveStorage;
+use OCA\Collectives\Fs\NodeHelper;
 use OCA\Collectives\Service\PageService;
 use OCP\EventDispatcher\Event;
 use OCP\EventDispatcher\IEventListener;
 use OCP\Files\Events\Node\NodeDeletedEvent;
-use OCP\Files\File;
 
 /** @template-implements IEventListener<Event|NodeDeletedEvent> */
 class NodeDeletedListener implements IEventListener {
@@ -30,27 +29,16 @@ public function handle(Event $event): void {
 			return;
 		}
 
-		// Skip if this deletion originated from Collectives itself
 		if ($this->pageService->isFromCollectives()) {
 			return;
 		}
 
 		$node = $event->getNode();
-
-		if (!($node instanceof File)) {
-			return;
-		}
-
-		if ($node->getMimeType() !== 'text/markdown') {
-			return;
-		}
-
-		$storage = $node->getStorage();
-		if (!$storage->instanceOfStorage(CollectiveStorage::class)) {
+		$collectiveId = NodeHelper::getCollectiveIdFromNode($node);
+		if ($collectiveId === null) {
 			return;
 		}
 
-		// Delete the page entry from collectives_pages
 		$this->pageMapper->deleteByFileId($node->getId());
 	}
 }

lib/Listeners/NodeRenamedListener.php

@@ -11,13 +11,10 @@
 
 use OCA\Collectives\Db\PageMapper;
 use OCA\Collectives\Fs\NodeHelper;
-use OCA\Collectives\Mount\CollectiveStorage;
 use OCA\Collectives\Service\PageService;
 use OCP\EventDispatcher\Event;
 use OCP\EventDispatcher\IEventListener;
 use OCP\Files\Events\Node\NodeRenamedEvent;
-use OCP\Files\File;
-use OCP\Files\Node;
 
 /** @template-implements IEventListener<Event|NodeRenamedEvent> */
 class NodeRenamedListener implements IEventListener {
@@ -36,39 +33,20 @@ public function handle(Event $event): void {
 			return;
 		}
 
-		$source = $event->getSource();
 		$target = $event->getTarget();
-		if (!($source instanceof File && $target instanceof File)) {
-			return;
-		}
-
-		// Only handle markdown files in collectives
-		if ($target->getMimeType() !== 'text/markdown') {
-			return;
-		}
-
-//		// File moved out of a collective -> delete page entry
-		$targetCollectiveId = $this->getCollectiveId($target);
+		$targetCollectiveId = NodeHelper::getCollectiveIdFromNode($target);
 		if ($targetCollectiveId === null) {
 			// fixme: it seems like this case not works
 			$this->pageMapper->deleteByFileId($target->getId());
 			return;
 		}
 
 		// File moved into a collective or between collectives - update collectiveId
+		$source = $event->getSource();
 		$title = null;
 		if ($source->getName() !== $target->getName()) {
 			$title = NodeHelper::getTitleFromFile($target);
 		}
 		$this->pageService->updatePage($targetCollectiveId, $target->getId(), null, null, null, $title);
 	}
-
-	private function getCollectiveId(Node|File $node): ?int {
-		$sourceStorage = $node->getStorage();
-		if ($sourceStorage->instanceOfStorage(CollectiveStorage::class)) {
-			/** @var CollectiveStorage $sourceStorage */
-			return $sourceStorage->getFolderId();
-		}
-		return null;
-	}
 }

lib/Listeners/NodeWrittenListener.php

@@ -13,12 +13,10 @@
 use OCA\Collectives\Db\PageLinkMapper;
 use OCA\Collectives\Fs\MarkdownHelper;
 use OCA\Collectives\Fs\NodeHelper;
-use OCA\Collectives\Mount\CollectiveStorage;
 use OCA\Collectives\Service\PageService;
 use OCP\EventDispatcher\Event;
 use OCP\EventDispatcher\IEventListener;
 use OCP\Files\Events\Node\NodeWrittenEvent;
-use OCP\Files\File;
 use OCP\Files\Node;
 use OCP\IConfig;
 
@@ -38,16 +36,11 @@ public function handle(Event $event): void {
 		}
 
 		$node = $event->getNode();
-		$storage = $node->getStorage();
-		// fixme: handle directory creation in order to create readme file with corresponding collective page
-		if (!($node instanceof File)
-			|| $node->getMimeType() !== 'text/markdown'
-			|| !$node->getStorage()->instanceOfStorage(CollectiveStorage::class)) {
+		$collectiveId = NodeHelper::getCollectiveIdFromNode($node);
+		if ($collectiveId === null) {
 			return;
 		}
 
-		/** @var CollectiveStorage $storage */
-		$collectiveId = $storage->getFolderId();
 		$fileId = $node->getId();
 		$this->updatePageLinks($collectiveId, $node, $fileId);
 
@@ -58,13 +51,13 @@ public function handle(Event $event): void {
 		$this->updateCollectivePage($node, $collectiveId, $fileId);
 	}
 
-	private function updatePageLinks(int $collectiveId, Node|File $node, int $fileId): void {
+	private function updatePageLinks(int $collectiveId, Node $node, int $fileId): void {
 		$collective = $this->collectiveMapper->idToCollective($collectiveId);
 		$linkedPageIds = MarkdownHelper::getLinkedPageIds($collective, $node->getContent(), $this->config->getSystemValue('trusted_domains', []));
 		$this->pageLinkMapper->updateByPageId($fileId, $linkedPageIds);
 	}
 
-	private function updateCollectivePage(Node|File $node, int $collectiveId, int $fileId): void {
+	private function updateCollectivePage(Node $node, int $collectiveId, int $fileId): void {
 		$title = NodeHelper::getTitleFromFile($node);
 		$userId = $node->getOwner()->getUID();
 		$this->pageService->updatePage($collectiveId, $fileId, $userId, null, null, $title);

lib/Migration/Version030401Date20250331000000.php

@@ -31,8 +31,8 @@ public function changeSchema(IOutput $output, Closure $schemaClosure, array $opt
 				$changed = true;
 			}
 
-			if (!$table->hasIndex('collectives_pages_collective_id_index')) {
-				$table->addIndex(['collective_id'], 'collectives_pages_collective_id_index');
+			if (!$table->hasIndex('collectives_pages_c_id_idx')) {
+				$table->addIndex(['collective_id'], 'collectives_pages_c_id_idx');
 				$changed = true;
 			}