Merge branch 'main' of ssh://git.homelab.nestor-server.fr:2222/colgora/Mangarr

# Conflicts:
#	src/Domain/Manga/Application/CommandHandler/DeleteChapterHandler.php
#	src/Domain/Manga/Application/CommandHandler/EditMultipleChaptersHandler.php
#	src/Domain/Manga/Application/EventListener/ChapterImportedEventListener.php
#	src/Domain/Manga/Application/EventListener/VolumeImportedEventListener.php
#	src/Domain/Manga/Application/Response/ChapterResponse.php
#	src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteCbzProvider.php
#	src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteChapterProvider.php
#	src/Domain/Manga/Infrastructure/Persistence/Repository/LegacyChapterRepository.php

.claude/skills/testing-strategy/SKILL.md

@@ -178,7 +178,6 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
 | Adapter                          | Interface implémentée                    |
 |----------------------------------|------------------------------------------|
 | `InMemoryMangaRepository`        | `MangaRepositoryInterface`               |
-| `InMemoryChapterRepository`      | `ChapterRepositoryInterface`             |
 | `InMemoryImageProcessor`         | `ImageProcessorInterface`                |
 | `InMemoryMangadexClient`         | `MangadexClientInterface`                |
 | `InMemoryMangaProvider`          | `MangaProviderInterface`                 |

config/services.yaml

@@ -148,10 +148,6 @@ services:
             $publicDir: '%kernel.project_dir%/public'
             $httpClient: '@GuzzleHttp\Client'
 
-    # Chapter Repository
-    App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface:
-        alias: App\Domain\Manga\Infrastructure\Persistence\Repository\LegacyChapterRepository
-
     # File Service
     App\Domain\Manga\Domain\Contract\Service\FileServiceInterface:
         alias: App\Domain\Manga\Infrastructure\Service\FileService

migrations/Version20260309165048.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace DoctrineMigrations;
+
+use Doctrine\DBAL\Schema\Schema;
+use Doctrine\Migrations\AbstractMigration;
+
+/**
+ * Auto-generated Migration: Please modify to your needs!
+ */
+final class Version20260309165048 extends AbstractMigration
+{
+    public function getDescription(): string
+    {
+        return '';
+    }
+
+    public function up(Schema $schema): void
+    {
+        // this up() migration is auto-generated, please modify it to your needs
+        $this->addSql('ALTER TABLE chapter ADD pages_directory VARCHAR(255) DEFAULT NULL');
+        $this->addSql('ALTER TABLE chapter ADD page_count INT DEFAULT 0 NOT NULL');
+        $this->addSql('DROP INDEX IF EXISTS idx_available_at');
+        $this->addSql('DROP INDEX IF EXISTS idx_delivered_at');
+        $this->addSql('DROP INDEX IF EXISTS idx_queue_available');
+        $this->addSql('DROP INDEX IF EXISTS idx_queue_name');
+    }
+
+    public function down(Schema $schema): void
+    {
+        // this down() migration is auto-generated, please modify it to your needs
+        $this->addSql('CREATE SCHEMA public');
+        $this->addSql('CREATE INDEX idx_available_at ON messenger_messages (available_at)');
+        $this->addSql('CREATE INDEX idx_delivered_at ON messenger_messages (delivered_at)');
+        $this->addSql('CREATE INDEX idx_queue_available ON messenger_messages (queue_name, available_at)');
+        $this->addSql('CREATE INDEX idx_queue_name ON messenger_messages (queue_name)');
+        $this->addSql('ALTER TABLE chapter DROP pages_directory');
+        $this->addSql('ALTER TABLE chapter DROP page_count');
+    }
+}

phparkitect.php

@@ -23,6 +23,7 @@ return static function (Config $config): void {
         'Symfony\Component\HttpKernel\Exception',
         'Throwable',
         'InvalidArgumentException',
+        'App\Domain\Shared\Domain\Model\AggregateRoot',
     ];
 
     // Dépendances externes autorisées

src/Domain/Manga/Application/CommandHandler/DeleteCbzHandler.php

@@ -3,19 +3,17 @@
 namespace App\Domain\Manga\Application\CommandHandler;
 
 use App\Domain\Manga\Application\Command\DeleteCbz;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
 use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Shared\Domain\Contract\CommandHandlerInterface;
 use App\Domain\Shared\Domain\Contract\CommandInterface;
 
 readonly class DeleteCbzHandler implements CommandHandlerInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository,
+        private MangaRepositoryInterface $mangaRepository,
         private FileServiceInterface $fileService
     ) {
     }
@@ -24,33 +22,18 @@ readonly class DeleteCbzHandler implements CommandHandlerInterface
     {
         assert($command instanceof DeleteCbz);
 
-        $chapter = $this->chapterRepository->findVisibleById($command->chapterId);
+        $chapter = $this->mangaRepository->findVisibleChapterById($command->chapterId);
 
         if (!$chapter) {
             throw new ChapterNotFoundException($command->chapterId);
         }
 
-        // Check if chapter has a CBZ file
         if (!$chapter->isAvailable()) {
             throw new CbzFileNotFoundException($command->chapterId);
         }
 
-        // Delete the physical CBZ file
+        $manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
-        // Note: We'll need to get the CBZ path from somewhere, likely from a legacy repository
+        $manga->removeChapterPages($chapter);
-        // For now, we'll just mark the chapter as not available
+        $this->mangaRepository->save($manga);
-
-        // Update chapter to mark CBZ as not available
-        $updatedChapter = new Chapter(
-            new ChapterId($chapter->getId()),
-            $chapter->getMangaId(),
-            $chapter->getNumber(),
-            $chapter->getTitle(),
-            $chapter->getVolume(),
-            $chapter->isVisible(),
-            null,
-            $chapter->getCreatedAt()
-        );
-
-        $this->chapterRepository->save($updatedChapter);
     }
 }

src/Domain/Manga/Application/CommandHandler/DeleteChapterHandler.php

@@ -3,17 +3,15 @@
 namespace App\Domain\Manga\Application\CommandHandler;
 
 use App\Domain\Manga\Application\Command\DeleteChapter;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Shared\Domain\Contract\CommandHandlerInterface;
 use App\Domain\Shared\Domain\Contract\CommandInterface;
 
 readonly class DeleteChapterHandler implements CommandHandlerInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository
+        private MangaRepositoryInterface $mangaRepository
     ) {
     }
 
@@ -21,23 +19,14 @@ readonly class DeleteChapterHandler implements CommandHandlerInterface
     {
         assert($command instanceof DeleteChapter);
 
-        $chapter = $this->chapterRepository->findVisibleById($command->chapterId);
+        $chapter = $this->mangaRepository->findVisibleChapterById($command->chapterId);
 
         if (!$chapter) {
             throw new ChapterNotFoundException($command->chapterId);
         }
 
-        $updatedChapter = new Chapter(
+        $manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
-            id: new ChapterId($chapter->getId()),
+        $manga->hideChapter($chapter);
-            mangaId: $chapter->getMangaId(),
+        $this->mangaRepository->save($manga);
-            number: $chapter->getNumber(),
-            title: $chapter->getTitle(),
-            volume: $chapter->getVolume(),
-            isVisible: false,
-            cbzPath: $chapter->getCbzPath(),
-            createdAt: $chapter->getCreatedAt()
-        );
-
-        $this->chapterRepository->save($updatedChapter);
     }
 }

src/Domain/Manga/Application/CommandHandler/EditMultipleChaptersHandler.php

@@ -3,36 +3,36 @@
 namespace App\Domain\Manga\Application\CommandHandler;
 
 use App\Domain\Manga\Application\Command\EditMultipleChapters;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
 
 readonly class EditMultipleChaptersHandler
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository
+        private MangaRepositoryInterface $mangaRepository
     ) {
     }
 
     public function handle(EditMultipleChapters $command): void
     {
         foreach ($command->chapters as $chapterData) {
-            $chapter = $this->chapterRepository->findById($chapterData->id);
+            $chapter = $this->mangaRepository->findChapterById($chapterData->id);
 
             if (!$chapter) {
                 throw new ChapterNotFoundException($chapterData->id);
             }
 
-            $updatedChapter = $chapter;
+            $manga = $this->mangaRepository->findById($chapter->getMangaId()->getValue());
 
             if ($chapterData->title !== null) {
-                $updatedChapter = $updatedChapter->updateTitle($chapterData->title);
+                $manga->updateChapterTitle($chapter, $chapterData->title);
             }
 
             if ($chapterData->volume !== null) {
-                $updatedChapter = $updatedChapter->updateVolume($chapterData->volume);
+                $manga->updateChapterVolume($chapter, $chapterData->volume);
             }
 
-            $this->chapterRepository->save($updatedChapter);
+            $this->mangaRepository->save($manga);
         }
     }
 }

src/Domain/Manga/Application/CommandHandler/FetchMangaChaptersHandler.php

@@ -30,5 +30,6 @@ readonly class FetchMangaChaptersHandler
 
         // Synchronisation initiale (pas d'événements)
         $this->chapterSynchronizationService->synchronizeChapters($manga);
+        $this->mangaRepository->save($manga);
     }
 }

src/Domain/Manga/Application/CommandHandler/ImportChapterHandler.php

@@ -3,20 +3,15 @@
 namespace App\Domain\Manga\Application\CommandHandler;
 
 use App\Domain\Manga\Application\Command\ImportChapter;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Shared\Domain\Contract\MangaPathManagerInterface;
-use Ramsey\Uuid\Uuid;
 
 readonly class ImportChapterHandler
 {
     public function __construct(
         private MangaRepositoryInterface $mangaRepository,
-        private ChapterRepositoryInterface $chapterRepository,
         private MangaPathManagerInterface $pathManager
     ) {
     }
@@ -35,7 +30,7 @@ readonly class ImportChapterHandler
         }
 
         // 3. Check if chapter exists
-        $existingChapter = $this->chapterRepository->findByMangaIdAndChapterNumber(
+        $existingChapter = $this->mangaRepository->findChapterByMangaIdAndNumber(
             $command->mangaId,
             $command->chapterNumber
         );
@@ -47,37 +42,20 @@ readonly class ImportChapterHandler
         // 4. Save the CBZ file to storage using the path manager
         $cbzPath = $this->saveCbzFile($command, $manga, $existingChapter);
 
-        // 5. Update existing chapter with new CBZ path
+        // 5. Update existing chapter with new path through the aggregate
-        $updatedChapter = new Chapter(
+        $manga->updateChapterPages($existingChapter, $cbzPath, $existingChapter->getPageCount());
-            id: new ChapterId($existingChapter->getId()),
+        $this->mangaRepository->save($manga);
-            mangaId: $existingChapter->getMangaId(),
-            number: $existingChapter->getNumber(),
-            title: $existingChapter->getTitle(),
-            volume: $existingChapter->getVolume(),
-            isVisible: $existingChapter->isVisible(),
-            cbzPath: $cbzPath,
-            createdAt: $existingChapter->getCreatedAt()
-        );
-        $this->chapterRepository->save($updatedChapter);
     }
 
-    /**
-     * Validate that the binary data is a valid CBZ (ZIP) file
-     */
     private function isValidCbzFile(string $fileBinary): bool
     {
-        // CBZ files are ZIP archives, check for ZIP magic number
         $zipMagicNumber = "\x50\x4b\x03\x04"; // PK\x03\x04
 
         return strpos($fileBinary, $zipMagicNumber) === 0;
     }
 
-    /**
+    private function saveCbzFile(ImportChapter $command, \App\Domain\Manga\Domain\Model\Manga $manga, \App\Domain\Manga\Domain\Model\Chapter $chapter): string
-     * Save the CBZ file to storage and return the path
-     */
-    private function saveCbzFile(ImportChapter $command, \App\Domain\Manga\Domain\Model\Manga $manga, Chapter $chapter): string
     {
-        // Build the final CBZ path using the path manager (creates directories)
         $volumeNumber = $chapter->getVolume() ?? 0;
         $cbzPath = $this->pathManager->buildChapterCbzPath(
             $manga->getTitle()->getValue(),
@@ -86,7 +64,6 @@ readonly class ImportChapterHandler
             (string)$command->chapterNumber
         );
 
-        // Write the binary content directly to the CBZ path
         if (!file_put_contents($cbzPath, $command->fileBinary)) {
             throw new \RuntimeException('Failed to save CBZ file');
         }

src/Domain/Manga/Application/CommandHandler/ImportVolumeHandler.php

@@ -3,18 +3,14 @@
 namespace App\Domain\Manga\Application\CommandHandler;
 
 use App\Domain\Manga\Application\Command\ImportVolume;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Shared\Domain\Contract\MangaPathManagerInterface;
 
 readonly class ImportVolumeHandler
 {
     public function __construct(
         private MangaRepositoryInterface $mangaRepository,
-        private ChapterRepositoryInterface $chapterRepository,
         private MangaPathManagerInterface $pathManager
     ) {
     }
@@ -33,7 +29,7 @@ readonly class ImportVolumeHandler
         }
 
         // 3. Get all chapters for this volume
-        $chapters = $this->chapterRepository->findByMangaIdAndVolume(
+        $chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume(
             $command->mangaId,
             $command->volumeNumber
         );
@@ -47,46 +43,28 @@ readonly class ImportVolumeHandler
         // 4. Save the CBZ file to storage using the path manager
         $cbzPath = $this->saveCbzFile($command, $manga);
 
-        // 5. Update all chapters with the volume CBZ path
+        // 5. Update all chapters with the volume path through the aggregate
         foreach ($chapters as $chapter) {
-            $updatedChapter = new Chapter(
+            $manga->updateChapterPages($chapter, $cbzPath, $chapter->getPageCount());
-                id: new ChapterId($chapter->getId()),
-                mangaId: $chapter->getMangaId(),
-                number: $chapter->getNumber(),
-                title: $chapter->getTitle(),
-                volume: $chapter->getVolume(),
-                isVisible: $chapter->isVisible(),
-                cbzPath: $cbzPath,
-                createdAt: $chapter->getCreatedAt()
-            );
-            $this->chapterRepository->save($updatedChapter);
         }
+        $this->mangaRepository->save($manga);
     }
 
-    /**
-     * Validate that the binary data is a valid CBZ (ZIP) file
-     */
     private function isValidCbzFile(string $fileBinary): bool
     {
-        // CBZ files are ZIP archives, check for ZIP magic number
         $zipMagicNumber = "\x50\x4b\x03\x04"; // PK\x03\x04
 
         return strpos($fileBinary, $zipMagicNumber) === 0;
     }
 
-    /**
-     * Save the CBZ file to storage and return the path
-     */
     private function saveCbzFile(ImportVolume $command, \App\Domain\Manga\Domain\Model\Manga $manga): string
     {
-        // Build the final CBZ path using the path manager (creates directories)
         $cbzPath = $this->pathManager->buildVolumeCbzPath(
             $manga->getTitle()->getValue(),
             (string)$manga->getPublicationYear(),
             $command->volumeNumber
         );
 
-        // Write the binary content directly to the CBZ path
         if (!file_put_contents($cbzPath, $command->fileBinary)) {
             throw new \RuntimeException('Failed to save CBZ file');
         }

src/Domain/Manga/Application/EventListener/ChapterImportedEventListener.php

@@ -4,10 +4,7 @@ declare(strict_types=1);
 
 namespace App\Domain\Manga\Application\EventListener;
 
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 use App\Domain\Shared\Domain\Event\ChapterImported;
 
@@ -15,7 +12,6 @@ readonly class ChapterImportedEventListener
 {
     public function __construct(
         private MangaRepositoryInterface $mangaRepository,
-        private ChapterRepositoryInterface $chapterRepository,
     ) {
     }
 
@@ -23,23 +19,14 @@ readonly class ChapterImportedEventListener
     {
         $manga = $this->mangaRepository->findBySlug(new MangaSlug($event->mangaSlug));
         if (!$manga) {
-            return; // Manga introuvable, on ignore
+            return;
         }
 
-        $chapters = $this->chapterRepository->findVisibleByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
+        $chapters = $this->mangaRepository->findVisibleChaptersByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
         foreach ($chapters as $chapter) {
             if ($chapter->getNumber() === (float) $event->chapterNumber) {
-                $updated = new Chapter(
+                $manga->updateChapterPages($chapter, $event->cbzPath, $chapter->getPageCount());
-                    new ChapterId($chapter->getId()),
+                $this->mangaRepository->save($manga);
-                    $chapter->getMangaId(),
-                    $chapter->getNumber(),
-                    $chapter->getTitle(),
-                    $chapter->getVolume(),
-                    $chapter->isVisible(),
-                    $event->cbzPath,
-                    $chapter->getCreatedAt(),
-                );
-                $this->chapterRepository->save($updated);
                 break;
             }
         }

src/Domain/Manga/Application/EventListener/VolumeImportedEventListener.php

@@ -4,10 +4,7 @@ declare(strict_types=1);
 
 namespace App\Domain\Manga\Application\EventListener;
 
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 use App\Domain\Shared\Domain\Event\VolumeImported;
 
@@ -15,7 +12,6 @@ readonly class VolumeImportedEventListener
 {
     public function __construct(
         private MangaRepositoryInterface $mangaRepository,
-        private ChapterRepositoryInterface $chapterRepository,
     ) {
     }
 
@@ -26,23 +22,14 @@ readonly class VolumeImportedEventListener
             return;
         }
 
-        $chapters = $this->chapterRepository->findByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
+        $chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume($manga->getId()->getValue(), (int) $event->volume);
         if ($chapters === []) {
             return;
         }
 
         foreach ($chapters as $chapter) {
-            $updated = new Chapter(
+            $manga->updateChapterPages($chapter, $event->cbzPath, $chapter->getPageCount());
-                new ChapterId($chapter->getId()),
-                $chapter->getMangaId(),
-                $chapter->getNumber(),
-                $chapter->getTitle(),
-                $chapter->getVolume(),
-                $chapter->isVisible(),
-                $event->cbzPath,
-                $chapter->getCreatedAt(),
-            );
-            $this->chapterRepository->save($updated);
         }
+        $this->mangaRepository->save($manga);
     }
 }

src/Domain/Manga/Application/QueryHandler/DownloadCbzHandler.php

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Application\QueryHandler;
 
 use App\Domain\Manga\Application\Query\DownloadCbz;
 use App\Domain\Manga\Application\Response\DownloadResponse;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
 use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
@@ -16,7 +16,7 @@ use App\Domain\Shared\Domain\Contract\ResponseInterface;
 readonly class DownloadCbzHandler implements QueryHandlerInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository,
+        private MangaRepositoryInterface $mangaRepository,
         private FileServiceInterface $fileService
     ) {
     }
@@ -25,7 +25,7 @@ readonly class DownloadCbzHandler implements QueryHandlerInterface
     {
         assert($query instanceof DownloadCbz);
 
-        $chapter = $this->chapterRepository->findVisibleById($query->chapterId);
+        $chapter = $this->mangaRepository->findVisibleChapterById($query->chapterId);
 
         if (!$chapter) {
             throw new ChapterNotFoundException($query->chapterId);
@@ -35,14 +35,11 @@ readonly class DownloadCbzHandler implements QueryHandlerInterface
             throw new ChapterNotAvailableException($query->chapterId);
         }
 
-        // Use the actual CBZ path from the chapter
+        $pagesDirectory = $chapter->getPagesDirectory();
-        $cbzPath = $chapter->getCbzPath();
+        $filename = basename($pagesDirectory);
-
-        // Extract the existing filename from the path
-        $filename = basename($cbzPath);
 
         try {
-            $httpResponse = $this->fileService->downloadCbz($cbzPath, $filename);
+            $httpResponse = $this->fileService->downloadCbz($pagesDirectory, $filename);
         } catch (CbzFileNotFoundException $e) {
             throw new ChapterNotAvailableException($query->chapterId);
         }

src/Domain/Manga/Application/QueryHandler/DownloadVolumeHandler.php

@@ -4,7 +4,6 @@ namespace App\Domain\Manga\Application\QueryHandler;
 
 use App\Domain\Manga\Application\Query\DownloadVolume;
 use App\Domain\Manga\Application\Response\DownloadResponse;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Contract\Service\FileServiceInterface;
 use App\Domain\Manga\Domain\Exception\MangaNotFoundException;
@@ -16,7 +15,6 @@ use App\Domain\Shared\Domain\Contract\ResponseInterface;
 readonly class DownloadVolumeHandler implements QueryHandlerInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository,
         private MangaRepositoryInterface $mangaRepository,
         private FileServiceInterface $fileService
     ) {
@@ -32,7 +30,7 @@ readonly class DownloadVolumeHandler implements QueryHandlerInterface
             throw new MangaNotFoundException($query->mangaId);
         }
 
-        $chapters = $this->chapterRepository->findVisibleWithCbzByMangaIdAndVolume(
+        $chapters = $this->mangaRepository->findVisibleChaptersWithPagesByMangaIdAndVolume(
             $query->mangaId,
             $query->volume
         );
@@ -41,10 +39,9 @@ readonly class DownloadVolumeHandler implements QueryHandlerInterface
             throw new VolumeNotFoundException($query->mangaId, $query->volume);
         }
 
-        // Collect CBZ paths for all chapters
         $cbzPaths = [];
         foreach ($chapters as $chapter) {
-            $cbzPaths[] = $chapter->getCbzPath();
+            $cbzPaths[] = $chapter->getPagesDirectory();
         }
 
         $volumeName = sprintf(

src/Domain/Manga/Application/QueryHandler/GetMangaChaptersHandler.php

@@ -40,8 +40,8 @@ readonly class GetMangaChaptersHandler
                     title: $chapter->getTitle(),
                     volume: $chapter->getVolume(),
                     isVisible: $chapter->isVisible(),
-                    cbzPath: $chapter->getCbzPath(),
+                    pagesDirectory: $chapter->getPagesDirectory(),
-                    createdAt: $chapter->getCreatedAt()
+                    createdAt: $chapter->getCreatedAt()->format(\DateTimeInterface::RFC3339)
                 ),
                 $chapters
             ),

src/Domain/Manga/Application/Response/ChapterResponse.php

@@ -10,8 +10,8 @@ readonly class ChapterResponse
         public ?string $title,
         public ?int $volume,
         public bool $isVisible,
-        public ?string $cbzPath,
+        public ?string $pagesDirectory,
-        public \DateTimeImmutable $createdAt
+        public string $createdAt
     ) {
     }
 }

src/Domain/Manga/Domain/Contract/Repository/ChapterRepositoryInterface.php

@@ -1,29 +0,0 @@
-<?php
-
-namespace App\Domain\Manga\Domain\Contract\Repository;
-
-use App\Domain\Manga\Domain\Model\Chapter;
-
-interface ChapterRepositoryInterface
-{
-    public function findById(string $id): ?Chapter;
-    public function findVisibleById(string $id): ?Chapter;
-    public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter;
-    public function save(Chapter $chapter): void;
-    public function delete(Chapter $chapter): void;
-
-    /**
-     * @return Chapter[]
-     */
-    public function findByMangaIdAndVolume(string $mangaId, int $volume): array;
-
-    /**
-     * @return Chapter[]
-     */
-    public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array;
-
-    /**
-     * @return Chapter[]
-     */
-    public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array;
-}

src/Domain/Manga/Domain/Contract/Repository/MangaRepositoryInterface.php

@@ -6,23 +6,35 @@ use App\Domain\Manga\Application\Query\MonitoringCriteria;
 use App\Domain\Manga\Domain\Model\Manga;
 use App\Domain\Manga\Domain\Model\Chapter;
 use App\Domain\Manga\Domain\Model\ValueObject\ExternalId;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 
 interface MangaRepositoryInterface
 {
+    // --- Manga ---
+
     public function findAll(int $page = 1, int $limit = 20, string $sortBy = 'title', string $sortOrder = 'asc'): array;
     public function count(): int;
     public function findById(string $id): ?Manga;
+    public function findBySlug(MangaSlug $slug): ?Manga;
+    public function findByExternalId(ExternalId $externalId): ?Manga;
     public function save(Manga $manga): void;
     public function delete(Manga $manga): void;
-    public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array;
-    public function countChapters(string $mangaId): int;
-    public function findByExternalId(ExternalId $externalId): ?Manga;
-    public function saveChapter(Chapter $chapter): ChapterId;
-    public function findBySlug(MangaSlug $slug): ?Manga;
     public function search(string $query, int $page = 1, int $limit = 20): array;
     public function countSearch(string $query): int;
+
+    /**
+     * @return Manga[]
+     */
+    public function findByMonitoringCriteria(MonitoringCriteria $criteria): array;
+
+    // --- Chapters (read) ---
+
+    public function findChapters(string $mangaId, int $page = 1, int $limit = 20, string $sortOrder = 'desc'): array;
+    public function countChapters(string $mangaId): int;
+    public function findChapterById(string $id): ?Chapter;
+    public function findVisibleChapterById(string $id): ?Chapter;
+    public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter;
+
     /**
      * @param float[] $chapterNumbers
      * @return array<float, Chapter>
@@ -30,7 +42,18 @@ interface MangaRepositoryInterface
     public function findExistingChaptersByNumbers(string $mangaId, array $chapterNumbers): array;
 
     /**
-     * @return Manga[]
+     * @return Chapter[]
      */
-    public function findByMonitoringCriteria(MonitoringCriteria $criteria): array;
+    public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array;
+
+    /**
+     * @return Chapter[]
+     */
+    public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array;
+
+    /**
+     * @return Chapter[]
+     */
+    public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array;
+
 }

src/Domain/Manga/Domain/Model/Chapter.php

@@ -3,17 +3,19 @@
 namespace App\Domain\Manga\Domain\Model;
 
 use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
+use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
 
-readonly class Chapter
+class Chapter
 {
     public function __construct(
         private ChapterId $id,
-        private string $mangaId,
+        private MangaId $mangaId,
         private float $number,
         private ?string $title,
         private ?int $volume,
         private bool $isVisible,
-        private ?string $cbzPath = null,
+        private ?string $pagesDirectory = null,
+        private int $pageCount = 0,
         private \DateTimeImmutable $createdAt = new \DateTimeImmutable()
     ) {
     }
@@ -23,7 +25,7 @@ readonly class Chapter
         return $this->id->getValue();
     }
 
-    public function getMangaId(): string
+    public function getMangaId(): MangaId
     {
         return $this->mangaId;
     }
@@ -50,12 +52,17 @@ readonly class Chapter
 
     public function isAvailable(): bool
     {
-        return $this->cbzPath !== null;
+        return $this->pagesDirectory !== null;
     }
 
-    public function getCbzPath(): ?string
+    public function getPagesDirectory(): ?string
     {
-        return $this->cbzPath;
+        return $this->pagesDirectory;
+    }
+
+    public function getPageCount(): int
+    {
+        return $this->pageCount;
     }
 
     public function getCreatedAt(): \DateTimeImmutable
@@ -63,31 +70,24 @@ readonly class Chapter
         return $this->createdAt;
     }
 
-    public function updateTitle(?string $title): self
+    public function updateTitle(?string $title): void
     {
-        return new self(
+        $this->title = $title;
-            $this->id,
-            $this->mangaId,
-            $this->number,
-            $title,
-            $this->volume,
-            $this->isVisible,
-            $this->cbzPath,
-            $this->createdAt
-        );
     }
 
-    public function updateVolume(?int $volume): self
+    public function updateVolume(?int $volume): void
     {
-        return new self(
+        $this->volume = $volume;
-            $this->id,
+    }
-            $this->mangaId,
+
-            $this->number,
+    public function updatePagesDirectory(?string $pagesDirectory, int $pageCount = 0): void
-            $this->title,
+    {
-            $volume,
+        $this->pagesDirectory = $pagesDirectory;
-            $this->isVisible,
+        $this->pageCount = $pageCount;
-            $this->cbzPath,
+    }
-            $this->createdAt
+
-        );
+    public function hide(): void
+    {
+        $this->isVisible = false;
     }
 }

src/Domain/Manga/Domain/Model/Manga.php

@@ -8,10 +8,20 @@ use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
 use App\Domain\Manga\Domain\Model\ValueObject\MonitoringStatus;
+use App\Domain\Shared\Domain\Model\AggregateRoot;
 use DateTimeImmutable;
 
-final class Manga
+final class Manga extends AggregateRoot
 {
+    /** @var Chapter[] */
+    private array $newChapters = [];
+
+    /** @var array<string, Chapter> */
+    private array $modifiedChapters = [];
+
+    /** @var Chapter[] */
+    private array $chaptersToDelete = [];
+
     public function __construct(
         private MangaId     $id,
         private MangaTitle  $title,
@@ -189,4 +199,66 @@ final class Manga
     {
         $this->lastMonitoringCheck = $lastMonitoringCheck;
     }
+
+    public function addChapter(Chapter $chapter): void
+    {
+        $this->newChapters[] = $chapter;
+    }
+
+    public function updateChapterTitle(Chapter $chapter, ?string $title): void
+    {
+        $chapter->updateTitle($title);
+        $this->modifiedChapters[$chapter->getId()] = $chapter;
+    }
+
+    public function updateChapterVolume(Chapter $chapter, ?int $volume): void
+    {
+        $chapter->updateVolume($volume);
+        $this->modifiedChapters[$chapter->getId()] = $chapter;
+    }
+
+    public function updateChapterPages(Chapter $chapter, ?string $pagesDirectory, int $pageCount = 0): void
+    {
+        $chapter->updatePagesDirectory($pagesDirectory, $pageCount);
+        $this->modifiedChapters[$chapter->getId()] = $chapter;
+    }
+
+    public function hideChapter(Chapter $chapter): void
+    {
+        $chapter->hide();
+        $this->modifiedChapters[$chapter->getId()] = $chapter;
+    }
+
+    public function removeChapterPages(Chapter $chapter): void
+    {
+        $chapter->updatePagesDirectory(null, 0);
+        $this->modifiedChapters[$chapter->getId()] = $chapter;
+    }
+
+    /** @return Chapter[] */
+    public function pullNewChapters(): array
+    {
+        $chapters = $this->newChapters;
+        $this->newChapters = [];
+
+        return $chapters;
+    }
+
+    /** @return Chapter[] */
+    public function pullModifiedChapters(): array
+    {
+        $chapters = array_values($this->modifiedChapters);
+        $this->modifiedChapters = [];
+
+        return $chapters;
+    }
+
+    /** @return Chapter[] */
+    public function pullChaptersToDelete(): array
+    {
+        $chapters = $this->chaptersToDelete;
+        $this->chaptersToDelete = [];
+
+        return $chapters;
+    }
 }

src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteCbzProvider.php

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider;
 
 use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProviderInterface;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
 use App\Domain\Manga\Domain\Exception\CbzFileNotFoundException;
 use App\Domain\Manga\Infrastructure\ApiPlatform\Resource\DeleteCbzResource;
@@ -13,7 +13,7 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 readonly class DeleteCbzProvider implements ProviderInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository
+        private MangaRepositoryInterface $mangaRepository
     ) {
     }
 
@@ -26,7 +26,7 @@ readonly class DeleteCbzProvider implements ProviderInterface
         $chapterId = $uriVariables['id'];
 
         try {
-            $chapter = $this->chapterRepository->findVisibleById($chapterId);
+            $chapter = $this->mangaRepository->findVisibleChapterById($chapterId);
 
             if (!$chapter) {
                 throw new ChapterNotFoundException($chapterId);

src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/DeleteChapterProvider.php

@@ -4,7 +4,7 @@ namespace App\Domain\Manga\Infrastructure\ApiPlatform\State\Provider;
 
 use ApiPlatform\Metadata\Operation;
 use ApiPlatform\State\ProviderInterface;
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
+use App\Domain\Manga\Domain\Contract\Repository\MangaRepositoryInterface;
 use App\Domain\Manga\Domain\Exception\ChapterNotFoundException;
 use App\Domain\Manga\Infrastructure\ApiPlatform\Resource\DeleteChapterResource;
 use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
@@ -12,7 +12,7 @@ use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
 readonly class DeleteChapterProvider implements ProviderInterface
 {
     public function __construct(
-        private ChapterRepositoryInterface $chapterRepository
+        private MangaRepositoryInterface $mangaRepository
     ) {
     }
 
@@ -25,7 +25,7 @@ readonly class DeleteChapterProvider implements ProviderInterface
         $chapterId = $uriVariables['id'];
 
         try {
-            $chapter = $this->chapterRepository->findVisibleById($chapterId);
+            $chapter = $this->mangaRepository->findVisibleChapterById($chapterId);
 
             if (!$chapter) {
                 throw new ChapterNotFoundException($chapterId);

src/Domain/Manga/Infrastructure/ApiPlatform/State/Provider/GetMangaChaptersStateProvider.php

@@ -53,8 +53,8 @@ readonly class GetMangaChaptersStateProvider implements ProviderInterface
             title: $chapter->title,
             volume: $chapter->volume,
             isVisible: $chapter->isVisible,
-            isAvailable: $chapter->cbzPath !== null,
+            isAvailable: $chapter->pagesDirectory !== null,
-            createdAt: $chapter->createdAt->format(\DateTimeInterface::RFC3339)
+            createdAt: $chapter->createdAt
         );
     }
 }

src/Domain/Manga/Infrastructure/Persistence/LegacyMangaRepository.php

@@ -116,6 +116,44 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
         if ($entity->getId()) {
             $manga->updateId(new MangaId((string) $entity->getId()));
         }
+
+        // Handle new chapters added through the aggregate
+        foreach ($manga->pullNewChapters() as $chapter) {
+            $mangaEntity = $this->entityManager->find(EntityManga::class, (int) $manga->getId()->getValue());
+            $chapterEntity = new EntityChapter();
+            $chapterEntity->setManga($mangaEntity)
+                ->setNumber($chapter->getNumber())
+                ->setTitle($chapter->getTitle())
+                ->setVolume($chapter->getVolume())
+                ->setVisible($chapter->isVisible())
+                ->setPagesDirectory($chapter->getPagesDirectory())
+                ->setPageCount($chapter->getPageCount());
+            $this->entityManager->persist($chapterEntity);
+        }
+
+        // Handle chapters modified through the aggregate
+        foreach ($manga->pullModifiedChapters() as $chapter) {
+            $chapterEntity = $this->entityManager->find(EntityChapter::class, $chapter->getId());
+            if ($chapterEntity) {
+                $chapterEntity->setVisible($chapter->isVisible())
+                    ->setPagesDirectory($chapter->getPagesDirectory())
+                    ->setPageCount($chapter->getPageCount())
+                    ->setTitle($chapter->getTitle())
+                    ->setVolume($chapter->getVolume())
+                    ->setCbzPath($chapter->getPagesDirectory());
+                $this->entityManager->persist($chapterEntity);
+            }
+        }
+
+        // Handle chapters deleted through the aggregate
+        foreach ($manga->pullChaptersToDelete() as $chapter) {
+            $chapterEntity = $this->entityManager->find(EntityChapter::class, $chapter->getId());
+            if ($chapterEntity) {
+                $this->entityManager->remove($chapterEntity);
+            }
+        }
+
+        $this->entityManager->flush();
     }
 
     public function delete(DomainManga $manga): void
@@ -167,25 +205,75 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
         return $entity ? $this->toDomain($entity) : null;
     }
 
-    public function saveChapter(Chapter $chapter): ChapterId
+    public function findChapterById(string $id): ?Chapter
     {
-        $manga = $this->entityManager->find(EntityManga::class, $chapter->getMangaId());
+        $entity = $this->entityManager->find(EntityChapter::class, $id);
 
-        if (!$manga) {
+        return $entity ? $this->toChapterDomain($entity) : null;
-            throw new \RuntimeException('Manga not found');
+    }
-        }
 
-        $entity = new EntityChapter();
+    public function findVisibleChapterById(string $id): ?Chapter
-        $entity->setManga($manga)
+    {
-            ->setNumber($chapter->getNumber())
+        $entity = $this->entityManager->createQueryBuilder()
-            ->setTitle($chapter->getTitle())
+            ->select('c')
-            ->setVolume($chapter->getVolume())
+            ->from(EntityChapter::class, 'c')
-            ->setVisible($chapter->isVisible());
+            ->where('c.id = :id')
+            ->andWhere('c.visible = :visible')
+            ->setParameter('id', $id)
+            ->setParameter('visible', 1)
+            ->getQuery()
+            ->getOneOrNullResult();
 
-        $this->entityManager->persist($entity);
+        return $entity ? $this->toChapterDomain($entity) : null;
-        $this->entityManager->flush();
+    }
 
-        return new ChapterId((string) $entity->getId());
+    public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter
+    {
+        $entity = $this->entityManager->createQueryBuilder()
+            ->select('c')
+            ->from(EntityChapter::class, 'c')
+            ->where('c.manga = :mangaId')
+            ->andWhere('c.number = :chapterNumber')
+            ->setParameter('mangaId', $mangaId)
+            ->setParameter('chapterNumber', $chapterNumber)
+            ->getQuery()
+            ->getOneOrNullResult();
+
+        return $entity ? $this->toChapterDomain($entity) : null;
+    }
+
+    public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        $entities = $this->entityManager->getRepository(EntityChapter::class)
+            ->findBy(['manga' => $mangaId, 'volume' => $volume]);
+
+        return array_map([$this, 'toChapterDomain'], $entities);
+    }
+
+    public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        $entities = $this->entityManager->getRepository(EntityChapter::class)
+            ->findBy(['manga' => $mangaId, 'volume' => $volume, 'visible' => true]);
+
+        return array_map([$this, 'toChapterDomain'], $entities);
+    }
+
+    public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        $entities = $this->entityManager->createQueryBuilder()
+            ->select('c')
+            ->from(EntityChapter::class, 'c')
+            ->where('c.manga = :mangaId')
+            ->andWhere('c.volume = :volume')
+            ->andWhere('c.visible = true')
+            ->andWhere('c.pagesDirectory IS NOT NULL OR c.cbzPath IS NOT NULL')
+            ->setParameter('mangaId', $mangaId)
+            ->setParameter('volume', $volume)
+            ->orderBy('c.number', 'ASC')
+            ->getQuery()
+            ->getResult();
+
+        return array_map([$this, 'toChapterDomain'], $entities);
     }
 
     public function search(string $query, int $page = 1, int $limit = 20): array
@@ -315,12 +403,14 @@ readonly class LegacyMangaRepository implements MangaRepositoryInterface
     {
         return new Chapter(
             id: new ChapterId((string) $entity->getId()),
-            mangaId: $entity->getManga()->getId(),
+            mangaId: new MangaId((string) $entity->getManga()->getId()),
             number: $entity->getNumber(),
             title: $entity->getTitle(),
             volume: $entity->getVolume(),
             isVisible: $entity->isVisible(),
-            cbzPath: $entity->getCbzPath()
+            // Fallback to cbzPath during transition (Phase 4 will drop cbzPath column)
+            pagesDirectory: $entity->getPagesDirectory() ?? $entity->getCbzPath(),
+            pageCount: $entity->getPageCount(),
         );
     }
 }

src/Domain/Manga/Infrastructure/Persistence/Repository/LegacyChapterRepository.php

@@ -1,129 +0,0 @@
-<?php
-
-namespace App\Domain\Manga\Infrastructure\Persistence\Repository;
-
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
-use App\Domain\Manga\Domain\Model\Chapter;
-use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
-use App\Entity\Chapter as ChapterEntity;
-use Doctrine\ORM\EntityManagerInterface;
-
-readonly class LegacyChapterRepository implements ChapterRepositoryInterface
-{
-    public function __construct(
-        private EntityManagerInterface $entityManager
-    ) {
-    }
-
-    public function findById(string $id): ?Chapter
-    {
-        $entity = $this->entityManager->find(ChapterEntity::class, $id);
-
-        return $entity ? $this->toDomainModel($entity) : null;
-    }
-
-    public function findVisibleById(string $id): ?Chapter
-    {
-        $qb = $this->entityManager->createQueryBuilder()
-            ->select('c')
-            ->from(ChapterEntity::class, 'c')
-            ->where('c.id = :id')
-            ->andWhere('c.visible = :visible')
-            ->setParameter('id', $id)
-            ->setParameter('visible', 1);
-
-        $entity = $qb->getQuery()->getOneOrNullResult();
-
-        return $entity ? $this->toDomainModel($entity) : null;
-    }
-
-    public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter
-    {
-        $qb = $this->entityManager->createQueryBuilder()
-            ->select('c')
-            ->from(ChapterEntity::class, 'c')
-            ->where('c.manga = :mangaId')
-            ->andWhere('c.number = :chapterNumber')
-            ->setParameter('mangaId', $mangaId)
-            ->setParameter('chapterNumber', $chapterNumber);
-
-        $entity = $qb->getQuery()->getOneOrNullResult();
-
-        return $entity ? $this->toDomainModel($entity) : null;
-    }
-
-    public function save(Chapter $chapter): void
-    {
-        $entity = $this->entityManager->find(ChapterEntity::class, $chapter->getId());
-
-        if (!$entity) {
-            throw new \RuntimeException(sprintf('Chapter with id %s not found', $chapter->getId()));
-        }
-
-        $entity->setVisible($chapter->isVisible());
-        $entity->setCbzPath($chapter->getCbzPath());
-        $entity->setTitle($chapter->getTitle());
-        $entity->setVolume($chapter->getVolume());
-
-        $this->entityManager->persist($entity);
-        $this->entityManager->flush();
-    }
-
-    public function delete(Chapter $chapter): void
-    {
-        $entity = $this->entityManager->find(ChapterEntity::class, $chapter->getId());
-
-        if ($entity) {
-            $this->entityManager->remove($entity);
-            $this->entityManager->flush();
-        }
-    }
-
-    public function findByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        $entities = $this->entityManager->getRepository(ChapterEntity::class)
-            ->findBy(['manga' => $mangaId, 'volume' => $volume]);
-
-        return array_map([$this, 'toDomainModel'], $entities);
-    }
-
-    public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        $entities = $this->entityManager->getRepository(ChapterEntity::class)
-            ->findBy(['manga' => $mangaId, 'volume' => $volume, 'visible' => true]);
-
-        return array_map([$this, 'toDomainModel'], $entities);
-    }
-
-    public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        $qb = $this->entityManager->createQueryBuilder()
-            ->select('c')
-            ->from(ChapterEntity::class, 'c')
-            ->where('c.manga = :mangaId')
-            ->andWhere('c.volume = :volume')
-            ->andWhere('c.visible = true')
-            ->andWhere('c.cbzPath IS NOT NULL')
-            ->setParameter('mangaId', $mangaId)
-            ->setParameter('volume', $volume)
-            ->orderBy('c.number', 'ASC');
-
-        $entities = $qb->getQuery()->getResult();
-
-        return array_map([$this, 'toDomainModel'], $entities);
-    }
-
-    private function toDomainModel(ChapterEntity $entity): Chapter
-    {
-        return new Chapter(
-            new ChapterId((string) $entity->getId()),
-            (string) $entity->getManga()->getId(),
-            $entity->getNumber(),
-            $entity->getTitle(),
-            $entity->getVolume(),
-            $entity->isVisible(),
-            $entity->getCbzPath(),
-            new \DateTimeImmutable()
-        );
-    }
-}

src/Domain/Manga/Infrastructure/Service/MangadxChapterSynchronizationService.php

@@ -68,12 +68,13 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
                 if ($shouldReplaceChapter) {
                     $chaptersByNumber[(string) $chapterNumber] = new Chapter(
                         new ChapterId((string) Uuid::uuid4()),
-                        $manga->getId()->getValue(),
+                        $manga->getId(),
                         $chapterNumber,
                         $title,
                         isset($chapterData['attributes']['volume']) ? (int) $chapterData['attributes']['volume'] : null,
                         true,
                         null,
+                        0,
                         new \DateTimeImmutable()
                     );
                     $chapterLanguages[(string) $chapterNumber] = $language;
@@ -98,8 +99,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
         // Sauvegarde uniquement les nouveaux chapitres et collecte leurs IDs
         foreach ($chaptersByNumber as $chapterNumber => $chapter) {
             if (!isset($existingChapters[(float) $chapterNumber])) {
-                $newChapterId = $this->mangaRepository->saveChapter($chapter);
+                $manga->addChapter($chapter);
-                $newChapterIds[] = $newChapterId->getValue(); // ✨ Collecte des IDs
+                $newChapterIds[] = $chapter->getId();
             }
         }
 
@@ -143,7 +144,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
                     $currentChapter->getTitle(),
                     null, // volume = null
                     $currentChapter->isVisible(),
-                    $currentChapter->getCbzPath(),
+                    $currentChapter->getPagesDirectory(),
+                    $currentChapter->getPageCount(),
                     $currentChapter->getCreatedAt()
                 );
             }
@@ -156,7 +158,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
                     $currentChapter->getTitle(),
                     $prevVolume, // prend le volume des adjacents
                     $currentChapter->isVisible(),
-                    $currentChapter->getCbzPath(),
+                    $currentChapter->getPagesDirectory(),
+                    $currentChapter->getPageCount(),
                     $currentChapter->getCreatedAt()
                 );
             }
@@ -210,7 +213,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
                     $currentChapter->getTitle(),
                     $prevVolume,
                     $currentChapter->isVisible(),
-                    $currentChapter->getCbzPath(),
+                    $currentChapter->getPagesDirectory(),
+                    $currentChapter->getPageCount(),
                     $currentChapter->getCreatedAt()
                 );
             }
@@ -223,7 +227,8 @@ readonly class MangadxChapterSynchronizationService implements ChapterSynchroniz
                     $currentChapter->getTitle(),
                     $nextVolume,
                     $currentChapter->isVisible(),
-                    $currentChapter->getCbzPath(),
+                    $currentChapter->getPagesDirectory(),
+                    $currentChapter->getPageCount(),
                     $currentChapter->getCreatedAt()
                 );
             }

src/Domain/Shared/Domain/Model/AggregateRoot.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Domain\Shared\Domain\Model;
+
+abstract class AggregateRoot
+{
+    private array $domainEvents = [];
+
+    protected function recordEvent(object $event): void
+    {
+        $this->domainEvents[] = $event;
+    }
+
+    public function pullDomainEvents(): array
+    {
+        $events = $this->domainEvents;
+        $this->domainEvents = [];
+
+        return $events;
+    }
+}

src/Entity/Chapter.php

@@ -39,6 +39,12 @@ class Chapter
     #[ORM\Column(length: 255, nullable: true)]
     private ?string $cbzPath = null;
 
+    #[ORM\Column(length: 255, nullable: true)]
+    private ?string $pagesDirectory = null;
+
+    #[ORM\Column(options: ['default' => 0])]
+    private int $pageCount = 0;
+
     #[ORM\Column(type: 'boolean', options: ['default' => true])]
     private ?bool $visible = true;
 
@@ -146,4 +152,28 @@ class Chapter
 
         return $this;
     }
+
+    public function getPagesDirectory(): ?string
+    {
+        return $this->pagesDirectory;
+    }
+
+    public function setPagesDirectory(?string $pagesDirectory): static
+    {
+        $this->pagesDirectory = $pagesDirectory;
+
+        return $this;
+    }
+
+    public function getPageCount(): int
+    {
+        return $this->pageCount;
+    }
+
+    public function setPageCount(int $pageCount): static
+    {
+        $this->pageCount = $pageCount;
+
+        return $this;
+    }
 }

tests/Domain/Manga/Adapter/InMemoryChapterRepository.php

@@ -1,95 +0,0 @@
-<?php
-
-namespace App\Tests\Domain\Manga\Adapter;
-
-use App\Domain\Manga\Domain\Contract\Repository\ChapterRepositoryInterface;
-use App\Domain\Manga\Domain\Model\Chapter;
-
-class InMemoryChapterRepository implements ChapterRepositoryInterface
-{
-    /** @var array<string, Chapter> */
-    private array $chapters = [];
-
-    public function findById(string $id): ?Chapter
-    {
-        return $this->chapters[$id] ?? null;
-    }
-
-    public function findVisibleById(string $id): ?Chapter
-    {
-        $chapter = $this->chapters[$id] ?? null;
-        if ($chapter && $chapter->isVisible()) {
-            return $chapter;
-        }
-
-        return null;
-    }
-
-    public function findByMangaIdAndChapterNumber(string $mangaId, float $chapterNumber): ?Chapter
-    {
-        foreach ($this->chapters as $chapter) {
-            if ($chapter->getMangaId() === $mangaId && $chapter->getNumber() === $chapterNumber) {
-                return $chapter;
-            }
-        }
-
-        return null;
-    }
-
-    public function save(Chapter $chapter): void
-    {
-        $this->chapters[$chapter->getId()] = $chapter;
-    }
-
-    public function delete(Chapter $chapter): void
-    {
-        unset($this->chapters[$chapter->getId()]);
-    }
-
-    public function findByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        return array_filter(
-            $this->chapters,
-            fn (Chapter $chapter) => $chapter->getMangaId() === $mangaId && $chapter->getVolume() === $volume
-        );
-    }
-
-    public function findVisibleByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        return array_filter(
-            $this->chapters,
-            fn (Chapter $chapter) =>
-                $chapter->getMangaId() === $mangaId &&
-                $chapter->getVolume() === $volume &&
-                $chapter->isVisible()
-        );
-    }
-
-    public function findVisibleWithCbzByMangaIdAndVolume(string $mangaId, int $volume): array
-    {
-        return array_filter(
-            $this->chapters,
-            fn (Chapter $chapter) =>
-                $chapter->getMangaId() === $mangaId &&
-                $chapter->getVolume() === $volume &&
-                $chapter->isVisible() &&
-                $chapter->isAvailable()
-        );
-    }
-
-    /**
-     * Get all chapters
-     */
-    public function getAll(): array
-    {
-        return array_values($this->chapters);
-    }
-
-    /**
-     * Clear all chapters
-     */
-    public function clear(): void
-    {
-        $this->chapters = [];
-    }
-}

tests/Domain/Manga/Adapter/InMemoryMangaRepository.php

@@ -8,6 +8,7 @@ use App\Domain\Manga\Domain\Model\Chapter;
 use App\Domain\Manga\Domain\Model\Manga;
 use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\ExternalId;
+use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 
 class InMemoryMangaRepository implements MangaRepositoryInterface
@@ -18,8 +19,8 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
     /** @var array<string, array<Chapter>> */
     private array $chapters = [];
 
-    /** @var array<Chapter> */
+    /** @var array<string, Chapter> */
-    private array $savedChapters = [];
+    private array $chaptersById = [];
 
     public function findAll(int $page = 1, int $limit = 20, string $sortBy = 'title', string $sortOrder = 'asc'): array
     {
@@ -62,6 +63,39 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
     public function save(Manga $manga): void
     {
         $this->mangas[$manga->getId()->getValue()] = $manga;
+
+        foreach ($manga->pullNewChapters() as $chapter) {
+            $mangaIdValue = $chapter->getMangaId()->getValue();
+            if (!isset($this->chapters[$mangaIdValue])) {
+                $this->chapters[$mangaIdValue] = [];
+            }
+            $this->chapters[$mangaIdValue][] = $chapter;
+            $this->chaptersById[$chapter->getId()] = $chapter;
+        }
+
+        foreach ($manga->pullModifiedChapters() as $chapter) {
+            $this->chaptersById[$chapter->getId()] = $chapter;
+            $mangaIdValue = $chapter->getMangaId()->getValue();
+            if (isset($this->chapters[$mangaIdValue])) {
+                foreach ($this->chapters[$mangaIdValue] as $key => $existing) {
+                    if ($existing->getId() === $chapter->getId()) {
+                        $this->chapters[$mangaIdValue][$key] = $chapter;
+                        break;
+                    }
+                }
+            }
+        }
+
+        foreach ($manga->pullChaptersToDelete() as $chapter) {
+            unset($this->chaptersById[$chapter->getId()]);
+            $mangaIdValue = $chapter->getMangaId()->getValue();
+            if (isset($this->chapters[$mangaIdValue])) {
+                $this->chapters[$mangaIdValue] = array_values(array_filter(
+                    $this->chapters[$mangaIdValue],
+                    fn (Chapter $c) => $c->getId() !== $chapter->getId()
+                ));
+            }
+        }
     }
 
     public function delete(Manga $manga): void
@@ -101,20 +135,77 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
         return count($this->chapters[$mangaId] ?? []);
     }
 
+    public function findChapterById(string $id): ?Chapter
+    {
+        return $this->chaptersById[$id] ?? null;
+    }
+
+    public function findVisibleChapterById(string $id): ?Chapter
+    {
+        $chapter = $this->chaptersById[$id] ?? null;
+        if ($chapter && $chapter->isVisible()) {
+            return $chapter;
+        }
+        return null;
+    }
+
+    public function findChapterByMangaIdAndNumber(string $mangaId, float $chapterNumber): ?Chapter
+    {
+        foreach ($this->chaptersById as $chapter) {
+            if ($chapter->getMangaId()->getValue() === $mangaId && $chapter->getNumber() === $chapterNumber) {
+                return $chapter;
+            }
+        }
+        return null;
+    }
+
+    public function findChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        return array_values(array_filter(
+            $this->chaptersById,
+            fn (Chapter $chapter) => $chapter->getMangaId()->getValue() === $mangaId && $chapter->getVolume() === $volume
+        ));
+    }
+
+    public function findVisibleChaptersByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        return array_values(array_filter(
+            $this->chaptersById,
+            fn (Chapter $chapter) =>
+                $chapter->getMangaId()->getValue() === $mangaId &&
+                $chapter->getVolume() === $volume &&
+                $chapter->isVisible()
+        ));
+    }
+
+    public function findVisibleChaptersWithPagesByMangaIdAndVolume(string $mangaId, int $volume): array
+    {
+        return array_values(array_filter(
+            $this->chaptersById,
+            fn (Chapter $chapter) =>
+                $chapter->getMangaId()->getValue() === $mangaId &&
+                $chapter->getVolume() === $volume &&
+                $chapter->isVisible() &&
+                $chapter->isAvailable()
+        ));
+    }
+
     public function addChaptersToManga(string $mangaId, int $count): void
     {
         $this->chapters[$mangaId] = [];
 
         for ($i = 1; $i <= $count; $i++) {
-            $this->chapters[$mangaId][] = new Chapter(
+            $chapter = new Chapter(
                 id: new ChapterId((string)$i),
-                mangaId: $mangaId,
+                mangaId: new MangaId($mangaId),
                 number: (float)$i,
                 title: "Chapter $i",
                 volume: (int)ceil($i / 10),
                 isVisible: true,
                 createdAt: new \DateTimeImmutable()
             );
+            $this->chapters[$mangaId][] = $chapter;
+            $this->chaptersById[$chapter->getId()] = $chapter;
         }
     }
 
@@ -128,27 +219,11 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
         return null;
     }
 
-    public function saveChapter(Chapter $chapter): ChapterId
-    {
-        $this->savedChapters[] = $chapter;
-        if (!isset($this->chapters[$chapter->getMangaId()])) {
-            $this->chapters[$chapter->getMangaId()] = [];
-        }
-        $this->chapters[$chapter->getMangaId()][] = $chapter;
-        return new ChapterId($chapter->getId());
-    }
-
-    /** @return array<Chapter> */
-    public function getSavedChapters(): array
-    {
-        return $this->savedChapters;
-    }
-
     public function clear(): void
     {
         $this->mangas = [];
         $this->chapters = [];
-        $this->savedChapters = [];
+        $this->chaptersById = [];
     }
 
     public function search(string $query, int $page = 1, int $limit = 20): array
@@ -161,7 +236,6 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
                 $manga->getDescription()
             ];
 
-            // Ajouter les slugs alternatifs aux champs de recherche
             foreach ($manga->getAlternativeSlugs() as $altSlug) {
                 $searchableFields[] = $altSlug;
             }
@@ -186,6 +260,7 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
     {
         return count($this->search($query, 1, PHP_INT_MAX));
     }
+
     public function findExistingChaptersByNumbers(string $mangaId, array $chapterNumbers): array
     {
         if (!isset($this->chapters[$mangaId])) {
@@ -203,12 +278,10 @@ class InMemoryMangaRepository implements MangaRepositoryInterface
         return array_filter(
             array_values($this->mangas),
             function (Manga $manga) use ($criteria) {
-                // Vérifier si le monitoring est activé selon le critère
                 if ($manga->getMonitoringStatus()->isEnabled() !== $criteria->enabled) {
                     return false;
                 }
 
-                // Vérifier la date de dernière vérification si spécifiée
                 if ($criteria->lastCheckBefore !== null) {
                     $lastCheck = $manga->getLastMonitoringCheck();
                     if ($lastCheck === null || $lastCheck >= $criteria->lastCheckBefore) {

tests/Domain/Manga/Application/CommandHandler/ImportChapterHandlerTest.php

@@ -12,7 +12,6 @@ use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
-use App\Tests\Domain\Manga\Adapter\InMemoryChapterRepository;
 use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
 use App\Tests\Domain\Manga\Adapter\InMemoryPathManager;
 use PHPUnit\Framework\TestCase;
@@ -20,18 +19,15 @@ use PHPUnit\Framework\TestCase;
 class ImportChapterHandlerTest extends TestCase
 {
     private InMemoryMangaRepository $mangaRepository;
-    private InMemoryChapterRepository $chapterRepository;
     private InMemoryPathManager $pathManager;
     private ImportChapterHandler $handler;
 
     protected function setUp(): void
     {
         $this->mangaRepository = new InMemoryMangaRepository();
-        $this->chapterRepository = new InMemoryChapterRepository();
         $this->pathManager = new InMemoryPathManager();
         $this->handler = new ImportChapterHandler(
             $this->mangaRepository,
-            $this->chapterRepository,
             $this->pathManager
         );
     }
@@ -66,7 +62,7 @@ class ImportChapterHandlerTest extends TestCase
         $this->handler->handle($command);
     }
 
-    public function test_it_updates_existing_chapter_with_new_cbz(): void
+    public function test_it_updates_existing_chapter_with_new_path(): void
     {
         // Arrange
         $mangaId = 'manga-123';
@@ -80,19 +76,18 @@ class ImportChapterHandlerTest extends TestCase
             ['action', 'adventure'],
             'ongoing'
         );
-        $this->mangaRepository->save($manga);
+        // Create an existing chapter without pages and add through the aggregate
-
-        // Create an existing chapter without CBZ
         $existingChapter = new Chapter(
             new ChapterId('chapter-123'),
-            $mangaId,
+            new MangaId($mangaId),
             1.5,
             'Chapter 1.5',
             1,
             true,
             null
         );
-        $this->chapterRepository->save($existingChapter);
+        $manga->addChapter($existingChapter);
+        $this->mangaRepository->save($manga);
 
         // Import the same chapter with CBZ
         $cbzBinary = $this->createValidCbzBinary();
@@ -106,18 +101,16 @@ class ImportChapterHandlerTest extends TestCase
         $this->handler->handle($command);
 
         // Assert
-        $chapters = $this->chapterRepository->getAll();
+        $updatedChapter = $this->mangaRepository->findChapterById('chapter-123');
-        $this->assertCount(1, $chapters); // Still only one chapter
+        $this->assertNotNull($updatedChapter);
-
-        $updatedChapter = $chapters[0];
         $this->assertEquals('chapter-123', $updatedChapter->getId());
-        $this->assertEquals($mangaId, $updatedChapter->getMangaId());
+        $this->assertEquals($mangaId, $updatedChapter->getMangaId()->getValue());
         $this->assertEquals(1.5, $updatedChapter->getNumber());
-        $this->assertEquals('Chapter 1.5', $updatedChapter->getTitle()); // Title preserved
+        $this->assertEquals('Chapter 1.5', $updatedChapter->getTitle());
-        $this->assertEquals(1, $updatedChapter->getVolume()); // Volume preserved
+        $this->assertEquals(1, $updatedChapter->getVolume());
         $this->assertTrue($updatedChapter->isVisible());
-        $this->assertTrue($updatedChapter->isAvailable()); // Now has CBZ
+        $this->assertTrue($updatedChapter->isAvailable());
-        $this->assertStringContainsString('_vol1_ch1.5.cbz', $updatedChapter->getCbzPath());
+        $this->assertNotNull($updatedChapter->getPagesDirectory());
     }
 
     public function test_it_throws_exception_when_manga_not_found(): void
@@ -168,24 +161,16 @@ class ImportChapterHandlerTest extends TestCase
         $this->handler->handle($command);
     }
 
-    /**
-     * Create a minimal valid CBZ (ZIP) binary for testing
-     */
     private function createValidCbzBinary(): string
     {
         $tmpFile = tempnam(sys_get_temp_dir(), 'cbz');
-
-        // Delete the empty file created by tempnam
         unlink($tmpFile);
 
         $zip = new \ZipArchive();
-
-        // Create a new ZIP archive (avoid opening empty file)
         if ($zip->open($tmpFile, \ZipArchive::CREATE | \ZipArchive::OVERWRITE) !== true) {
             throw new \RuntimeException('Cannot create test CBZ file');
         }
 
-        // Add a dummy image file to the ZIP
         $zip->addFromString('image1.jpg', 'fake-image-data');
         $zip->close();
 

tests/Domain/Manga/Application/CommandHandler/ImportVolumeHandlerTest.php

@@ -11,7 +11,6 @@ use App\Domain\Manga\Domain\Model\ValueObject\ChapterId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaId;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaSlug;
 use App\Domain\Manga\Domain\Model\ValueObject\MangaTitle;
-use App\Tests\Domain\Manga\Adapter\InMemoryChapterRepository;
 use App\Tests\Domain\Manga\Adapter\InMemoryMangaRepository;
 use App\Tests\Domain\Manga\Adapter\InMemoryPathManager;
 use PHPUnit\Framework\TestCase;
@@ -19,18 +18,15 @@ use PHPUnit\Framework\TestCase;
 class ImportVolumeHandlerTest extends TestCase
 {
     private InMemoryMangaRepository $mangaRepository;
-    private InMemoryChapterRepository $chapterRepository;
     private InMemoryPathManager $pathManager;
     private ImportVolumeHandler $handler;
 
     protected function setUp(): void
     {
         $this->mangaRepository = new InMemoryMangaRepository();
-        $this->chapterRepository = new InMemoryChapterRepository();
         $this->pathManager = new InMemoryPathManager();
         $this->handler = new ImportVolumeHandler(
             $this->mangaRepository,
-            $this->chapterRepository,
             $this->pathManager
         );
     }
@@ -50,21 +46,20 @@ class ImportVolumeHandlerTest extends TestCase
             ['action', 'adventure'],
             'ongoing'
         );
-        $this->mangaRepository->save($manga);
+        // Create chapters in volume 1 and add through the aggregate
-
-        // Create chapters in volume 1
         for ($i = 1; $i <= 3; $i++) {
             $chapter = new Chapter(
                 new ChapterId("chapter-$i"),
-                $mangaId,
+                new MangaId($mangaId),
                 (float)$i,
                 "Chapter $i",
                 $volumeNumber,
                 true,
                 null
             );
-            $this->chapterRepository->save($chapter);
+            $manga->addChapter($chapter);
         }
+        $this->mangaRepository->save($manga);
 
         $cbzBinary = $this->createValidCbzBinary();
         $command = new ImportVolume(
@@ -77,12 +72,12 @@ class ImportVolumeHandlerTest extends TestCase
         $this->handler->handle($command);
 
         // Assert
-        $chapters = $this->chapterRepository->findByMangaIdAndVolume($mangaId, $volumeNumber);
+        $chapters = $this->mangaRepository->findChaptersByMangaIdAndVolume($mangaId, $volumeNumber);
         $this->assertCount(3, $chapters);
 
         foreach ($chapters as $chapter) {
             $this->assertTrue($chapter->isAvailable());
-            $this->assertStringContainsString('_vol' . $volumeNumber . '.cbz', $chapter->getCbzPath());
+            $this->assertNotNull($chapter->getPagesDirectory());
         }
     }
 
@@ -153,7 +148,7 @@ class ImportVolumeHandlerTest extends TestCase
         $cbzBinary = $this->createValidCbzBinary();
         $command = new ImportVolume(
             mangaId: $mangaId,
-            volumeNumber: 999,  // Non-existent volume
+            volumeNumber: 999,
             fileBinary: $cbzBinary
         );
 
@@ -165,9 +160,6 @@ class ImportVolumeHandlerTest extends TestCase
         $this->handler->handle($command);
     }
 
-    /**
-     * Create a minimal valid CBZ (ZIP) binary for testing
-     */
     private function createValidCbzBinary(): string
     {
         $tmpFile = tempnam(sys_get_temp_dir(), 'cbz_');
@@ -187,7 +179,3 @@ class ImportVolumeHandlerTest extends TestCase
         return $binaryContent;
     }
 }
-
-
-
-

tests/Feature/Manga/GetMangaListTest.php

@@ -3,12 +3,15 @@
 namespace App\Tests\Feature\Manga;
 
 use App\Entity\Manga;
+use App\Factory\ChapterFactory;
+use App\Factory\MangaFactory;
 use App\Tests\Feature\AbstractApiTestCase;
+use Zenstruck\Foundry\Test\Factories;
 use Zenstruck\Foundry\Test\ResetDatabase;
 
 class GetMangaListTest extends AbstractApiTestCase
 {
-    use ResetDatabase;
+    use ResetDatabase, Factories;
 
     public function testGetEmptyMangaList(): void
     {
@@ -80,6 +83,34 @@ class GetMangaListTest extends AbstractApiTestCase
         $this->assertEquals('Manga C', $data['items'][2]['title']);
     }
 
+    public function testGetMangaListWithChapters(): void
+    {
+        // Given — manga with chapters triggers Doctrine EAGER loading of chapters collection
+        // (regression: colonne pages_directory doit exister sinon 500)
+        $manga = MangaFactory::createOne([
+            'title' => 'One Piece',
+            'slug' => 'one-piece',
+            'imageUrl' => 'https://example.com/image.jpg',
+            'thumbnailUrl' => 'https://example.com/thumb.jpg',
+        ]);
+        ChapterFactory::createOne([
+            'manga' => $manga,
+            'number' => 1.0,
+            'title' => 'Romance Dawn',
+            'volume' => 1,
+            'visible' => true,
+        ]);
+
+        // When
+        $client = static::createClient();
+        $client->request('GET', '/api/mangas');
+
+        // Then — doit retourner 200 même avec des chapitres (eager loading OK)
+        $this->assertResponseIsSuccessful();
+        $data = $client->getResponse()->toArray();
+        $this->assertEquals(1, $data['total']);
+    }
+
     private function createMangas(int $count): void
     {
         for ($i = 1; $i <= $count; $i++) {