feat: add UI components for alert dialog, badge, checkbox, dialog, label, select, sheet, table, textarea

- Implemented AlertDialog component with overlay, content, header, footer, title, description, action, and cancel functionalities.
- Created Badge component with variant support for different styles.
- Developed Checkbox component with custom styling and indicator.
- Added Dialog component with trigger, close, overlay, content, header, footer, title, and description.
- Introduced Label component for form elements.
- Built Select component with trigger, content, group, item, label, separator, and scroll buttons.
- Created Sheet component with trigger, close, overlay, content, header, footer, title, and description.
- Implemented Table component with header, body, footer, row, head, cell, and caption.
- Added Textarea component with custom styling.
- Established API service for game management with CRUD operations and metadata search functionalities.
- Updated dependencies in package lock files.

backend/dist/tests/jobs/importRunner.spec.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const importRunner_1 = require("../../src/jobs/importRunner");
+(0, vitest_1.describe)('jobs/importRunner', () => {
+    (0, vitest_1.it)('enqueue rechaza después de stop', async () => {
+        const runner = new importRunner_1.ImportRunner(1);
+        runner.start();
+        runner.stop();
+        await (0, vitest_1.expect)(runner.enqueue(() => 'x')).rejects.toThrow();
+    });
+    (0, vitest_1.it)('rechaza tareas en cola tras stop', async () => {
+        const r = new importRunner_1.ImportRunner(1);
+        // Primera tarea comienza inmediatamente
+        const t1 = r.enqueue(async () => {
+            await new Promise((res) => setTimeout(res, 50));
+            return 'ok1';
+        });
+        // Segunda tarea quedará en cola
+        const t2 = r.enqueue(async () => 'ok2');
+        // Parar el runner inmediatamente
+        r.stop();
+        await (0, vitest_1.expect)(t1).resolves.toBe('ok1');
+        await (0, vitest_1.expect)(t2).rejects.toThrow(/ImportRunner stopped/);
+        const s = r.getStatus();
+        (0, vitest_1.expect)(s.completed).toBeGreaterThanOrEqual(1);
+    });
+    (0, vitest_1.it)('completed incrementa en rechazo', async () => {
+        const runner = new importRunner_1.ImportRunner(1);
+        runner.start();
+        const p = runner.enqueue(() => Promise.reject(new Error('boom')));
+        await (0, vitest_1.expect)(p).rejects.toThrow('boom');
+        const status = runner.getStatus();
+        (0, vitest_1.expect)(status.completed).toBeGreaterThanOrEqual(1);
+        runner.stop();
+    });
+    (0, vitest_1.it)('enqueue resuelve con el resultado de la tarea', async () => {
+        const runner = new importRunner_1.ImportRunner(2);
+        runner.start();
+        const result = await runner.enqueue(async () => 'ok');
+        (0, vitest_1.expect)(result).toBe('ok');
+        const status = runner.getStatus();
+        (0, vitest_1.expect)(status.completed).toBe(1);
+        (0, vitest_1.expect)(status.running).toBe(0);
+        (0, vitest_1.expect)(status.queued).toBe(0);
+        (0, vitest_1.expect)(status.concurrency).toBe(2);
+        runner.stop();
+    });
+    (0, vitest_1.it)('respeta la concurrencia configurada', async () => {
+        const concurrency = 2;
+        const runner = new importRunner_1.ImportRunner(concurrency);
+        runner.start();
+        let active = 0;
+        const observed = [];
+        const makeTask = (delay) => async () => {
+            active++;
+            observed.push(active);
+            await new Promise((r) => setTimeout(r, delay));
+            active--;
+            return 'done';
+        };
+        const promises = [];
+        for (let i = 0; i < 5; i++) {
+            promises.push(runner.enqueue(makeTask(80)));
+        }
+        await Promise.all(promises);
+        (0, vitest_1.expect)(Math.max(...observed)).toBeLessThanOrEqual(concurrency);
+        runner.stop();
+    });
+    (0, vitest_1.it)('getStatus reporta queued, running, completed y concurrency', async () => {
+        const concurrency = 2;
+        const runner = new importRunner_1.ImportRunner(concurrency);
+        runner.start();
+        const p1 = runner.enqueue(() => new Promise((r) => setTimeout(() => r('a'), 60)));
+        const p2 = runner.enqueue(() => new Promise((r) => setTimeout(() => r('b'), 60)));
+        const p3 = runner.enqueue(() => new Promise((r) => setTimeout(() => r('c'), 60)));
+        // allow the runner to start tasks
+        await new Promise((r) => setImmediate(r));
+        const statusNow = runner.getStatus();
+        (0, vitest_1.expect)(statusNow.concurrency).toBe(concurrency);
+        (0, vitest_1.expect)(statusNow.running).toBeLessThanOrEqual(concurrency);
+        (0, vitest_1.expect)(statusNow.queued).toBeGreaterThanOrEqual(0);
+        await Promise.all([p1, p2, p3]);
+        const statusAfter = runner.getStatus();
+        (0, vitest_1.expect)(statusAfter.queued).toBe(0);
+        (0, vitest_1.expect)(statusAfter.running).toBe(0);
+        (0, vitest_1.expect)(statusAfter.completed).toBe(3);
+        runner.stop();
+    });
+});

backend/dist/tests/models/game.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const vitest_1 = require("vitest");
+// Import PrismaClient dynamically after running `prisma generate`
+// to allow the test setup to run `prisma generate`/`prisma migrate` first.
+// Nota: Estos tests siguen TDD. Al principio deben FALLAR hasta que se creen migraciones.
+(0, vitest_1.describe)('Prisma / Game model', () => {
+    const tmpDir = os_1.default.tmpdir();
+    const dbFile = path_1.default.join(tmpDir, `quasar-test-${Date.now()}-${Math.random().toString(36).slice(2)}.db`);
+    const databaseUrl = `file:${dbFile}`;
+    let prisma;
+    (0, vitest_1.beforeAll)(async () => {
+        // Asegurarse de que la DB de prueba no exista antes de empezar
+        try {
+            fs_1.default.unlinkSync(dbFile);
+        }
+        catch (e) {
+            /* ignore */
+        }
+        // Apuntar Prisma a la DB temporal
+        process.env.DATABASE_URL = databaseUrl;
+        // Ejecutar migraciones contra la DB de prueba
+        // Esto fallará si no hay migraciones: esperado en la fase TDD inicial
+        (0, child_process_1.execSync)('yarn prisma migrate deploy --schema=./prisma/schema.prisma', {
+            stdio: 'inherit',
+            cwd: path_1.default.resolve(__dirname, '..', '..'),
+        });
+        // Intentar requerir el cliente generado; si no existe, intentar generarlo (fallback)
+        let GeneratedPrismaClient;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            GeneratedPrismaClient = require('@prisma/client').PrismaClient;
+        }
+        catch (e) {
+            try {
+                (0, child_process_1.execSync)('yarn prisma generate --schema=./prisma/schema.prisma', {
+                    stdio: 'inherit',
+                    cwd: path_1.default.resolve(__dirname, '..', '..'),
+                });
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                GeneratedPrismaClient = require('@prisma/client').PrismaClient;
+            }
+            catch (err) {
+                // Si generation falla (por ejemplo PnP), reintentar require para mostrar mejor error
+                // eslint-disable-next-line @typescript-eslint/no-var-requires
+                GeneratedPrismaClient = require('@prisma/client').PrismaClient;
+            }
+        }
+        prisma = new GeneratedPrismaClient();
+        await prisma.$connect();
+    });
+    (0, vitest_1.afterAll)(async () => {
+        if (prisma) {
+            await prisma.$disconnect();
+        }
+        try {
+            fs_1.default.unlinkSync(dbFile);
+        }
+        catch (e) {
+            /* ignore */
+        }
+    });
+    (0, vitest_1.it)('can create a Game and read title/slug', async () => {
+        const created = await prisma.game.create({ data: { title: 'Test Game', slug: 'test-game' } });
+        const found = await prisma.game.findUnique({ where: { id: created.id } });
+        (0, vitest_1.expect)(found).toBeTruthy();
+        (0, vitest_1.expect)(found?.title).toBe('Test Game');
+        (0, vitest_1.expect)(found?.slug).toBe('test-game');
+    });
+    (0, vitest_1.it)('enforces unique slug constraint', async () => {
+        const slug = `unique-${Date.now()}`;
+        await prisma.game.create({ data: { title: 'G1', slug } });
+        let threw = false;
+        try {
+            await prisma.game.create({ data: { title: 'G2', slug } });
+        }
+        catch (err) {
+            threw = true;
+        }
+        (0, vitest_1.expect)(threw).toBe(true);
+    });
+});

backend/dist/tests/routes/games.spec.js

@@ -0,0 +1,228 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const app_1 = require("../../src/app");
+const prisma_1 = require("../../src/plugins/prisma");
+(0, vitest_1.describe)('Games API', () => {
+    let app;
+    (0, vitest_1.beforeEach)(async () => {
+        app = (0, app_1.buildApp)();
+        await app.ready();
+        // Limpiar base de datos antes de cada test
+        // Orden importante: relaciones de FK primero
+        await prisma_1.prisma.purchase.deleteMany();
+        await prisma_1.prisma.gamePlatform.deleteMany();
+        await prisma_1.prisma.artwork.deleteMany();
+        await prisma_1.prisma.priceHistory.deleteMany();
+        await prisma_1.prisma.game.deleteMany();
+        await prisma_1.prisma.platform.deleteMany();
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await app.close();
+    });
+    (0, vitest_1.describe)('GET /api/games', () => {
+        (0, vitest_1.it)('debería devolver una lista vacía cuando no hay juegos', async () => {
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/games',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            (0, vitest_1.expect)(res.json()).toEqual([]);
+        });
+        (0, vitest_1.it)('debería devolver una lista de juegos con todas sus propiedades', async () => {
+            // Crear un juego de prueba
+            const platform = await prisma_1.prisma.platform.create({
+                data: { name: 'Nintendo', slug: 'nintendo' },
+            });
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'The Legend of Zelda',
+                    slug: 'legend-of-zelda',
+                    description: 'Un videojuego clásico',
+                    source: 'manual',
+                    gamePlatforms: {
+                        create: {
+                            platformId: platform.id,
+                        },
+                    },
+                    purchases: {
+                        create: {
+                            priceCents: 5000,
+                            currency: 'USD',
+                            store: 'eBay',
+                            date: new Date('2025-01-15'),
+                        },
+                    },
+                },
+                include: {
+                    gamePlatforms: {
+                        include: {
+                            platform: true,
+                        },
+                    },
+                    purchases: true,
+                },
+            });
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/games',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(Array.isArray(body)).toBe(true);
+            (0, vitest_1.expect)(body.length).toBe(1);
+            (0, vitest_1.expect)(body[0]).toHaveProperty('id');
+            (0, vitest_1.expect)(body[0]).toHaveProperty('title');
+        });
+    });
+    (0, vitest_1.describe)('POST /api/games', () => {
+        (0, vitest_1.it)('debería crear un juego válido con todos los campos', async () => {
+            // Crear plataforma primero
+            const platform = await prisma_1.prisma.platform.create({
+                data: { name: 'Nintendo 64', slug: 'n64' },
+            });
+            const payload = {
+                title: 'Super Mario 64',
+                platformId: platform.id,
+                description: 'Notas sobre el juego',
+                priceCents: 15000,
+                currency: 'USD',
+                store: 'Local Shop',
+                date: '2025-01-20',
+                condition: 'CIB',
+            };
+            const res = await app.inject({
+                method: 'POST',
+                url: '/api/games',
+                payload,
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(201);
+            const body = res.json();
+            (0, vitest_1.expect)(body).toHaveProperty('id');
+            (0, vitest_1.expect)(body.title).toBe('Super Mario 64');
+            (0, vitest_1.expect)(body.description).toBe('Notas sobre el juego');
+        });
+        (0, vitest_1.it)('debería fallar si falta el título (requerido)', async () => {
+            const res = await app.inject({
+                method: 'POST',
+                url: '/api/games',
+                payload: {
+                    platformId: 'non-existing-id',
+                    priceCents: 10000,
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+        });
+        (0, vitest_1.it)('debería fallar si el título está vacío', async () => {
+            const res = await app.inject({
+                method: 'POST',
+                url: '/api/games',
+                payload: {
+                    title: '',
+                    platformId: 'some-id',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+        });
+        (0, vitest_1.it)('debería crear un juego con solo los campos requeridos', async () => {
+            const res = await app.inject({
+                method: 'POST',
+                url: '/api/games',
+                payload: {
+                    title: 'Game Title Only',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(201);
+            const body = res.json();
+            (0, vitest_1.expect)(body).toHaveProperty('id');
+            (0, vitest_1.expect)(body.title).toBe('Game Title Only');
+        });
+    });
+    (0, vitest_1.describe)('PUT /api/games/:id', () => {
+        (0, vitest_1.it)('debería actualizar un juego existente', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Original Title',
+                    slug: 'original-title',
+                    source: 'manual',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: `/api/games/${game.id}`,
+                payload: {
+                    title: 'Updated Title',
+                    description: 'Updated description',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(body.title).toBe('Updated Title');
+            (0, vitest_1.expect)(body.description).toBe('Updated description');
+        });
+        (0, vitest_1.it)('debería devolver 404 si el juego no existe', async () => {
+            const res = await app.inject({
+                method: 'PUT',
+                url: '/api/games/non-existing-id',
+                payload: {
+                    title: 'Some Title',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(404);
+        });
+        (0, vitest_1.it)('debería permitir actualización parcial', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Original Title',
+                    slug: 'original',
+                    description: 'Original description',
+                    source: 'manual',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: `/api/games/${game.id}`,
+                payload: {
+                    description: 'New description only',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(body.title).toBe('Original Title'); // No cambió
+            (0, vitest_1.expect)(body.description).toBe('New description only'); // Cambió
+        });
+    });
+    (0, vitest_1.describe)('DELETE /api/games/:id', () => {
+        (0, vitest_1.it)('debería eliminar un juego existente', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Game to Delete',
+                    slug: 'game-to-delete',
+                    source: 'manual',
+                },
+            });
+            const res = await app.inject({
+                method: 'DELETE',
+                url: `/api/games/${game.id}`,
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(204);
+            // Verificar que el juego fue eliminado
+            const deletedGame = await prisma_1.prisma.game.findUnique({
+                where: { id: game.id },
+            });
+            (0, vitest_1.expect)(deletedGame).toBeNull();
+        });
+        (0, vitest_1.it)('debería devolver 404 si el juego no existe', async () => {
+            const res = await app.inject({
+                method: 'DELETE',
+                url: '/api/games/non-existing-id',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(404);
+        });
+    });
+});
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/tests/routes/import.spec.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const app_1 = require("../../src/app");
+(0, vitest_1.describe)('routes/import', () => {
+    (0, vitest_1.it)('POST /api/import/scan devuelve 202 o 200', async () => {
+        const app = (0, app_1.buildApp)();
+        await app.ready();
+        const res = await app.inject({
+            method: 'POST',
+            url: '/api/import/scan',
+            payload: { persist: false },
+        });
+        (0, vitest_1.expect)([200, 202]).toContain(res.statusCode);
+        await app.close();
+    });
+});

backend/dist/tests/routes/metadata.spec.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const app_1 = require("../../src/app");
+const metadataService = __importStar(require("../../src/services/metadataService"));
+(0, vitest_1.describe)('Metadata API', () => {
+    let app;
+    (0, vitest_1.beforeEach)(async () => {
+        app = (0, app_1.buildApp)();
+        await app.ready();
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await app.close();
+        vitest_1.vi.restoreAllMocks();
+    });
+    (0, vitest_1.describe)('GET /api/metadata/search', () => {
+        (0, vitest_1.it)('debería devolver resultados cuando se busca un juego existente', async () => {
+            const mockResults = [
+                {
+                    source: 'igdb',
+                    externalIds: { igdb: 1 },
+                    title: 'The Legend of Zelda',
+                    slug: 'the-legend-of-zelda',
+                    releaseDate: '1986-02-21',
+                    genres: ['Adventure'],
+                    coverUrl: 'https://example.com/cover.jpg',
+                },
+            ];
+            vitest_1.vi.spyOn(metadataService, 'enrichGame').mockResolvedValue(mockResults[0]);
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/metadata/search?q=zelda',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(Array.isArray(body)).toBe(true);
+            (0, vitest_1.expect)(body.length).toBeGreaterThan(0);
+            (0, vitest_1.expect)(body[0].title).toContain('Zelda');
+        });
+        (0, vitest_1.it)('debería devolver lista vacía cuando no hay resultados', async () => {
+            vitest_1.vi.spyOn(metadataService, 'enrichGame').mockResolvedValue(null);
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/metadata/search?q=nonexistentgame12345',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(Array.isArray(body)).toBe(true);
+            (0, vitest_1.expect)(body.length).toBe(0);
+        });
+        (0, vitest_1.it)('debería devolver 400 si falta el parámetro query', async () => {
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/metadata/search',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+            (0, vitest_1.expect)(res.json()).toHaveProperty('error');
+        });
+        (0, vitest_1.it)('debería devolver 400 si el parámetro query está vacío', async () => {
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/metadata/search?q=',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+        });
+        (0, vitest_1.it)('debería pasar el parámetro platform a enrichGame si se proporciona', async () => {
+            const enrichSpy = vitest_1.vi.spyOn(metadataService, 'enrichGame').mockResolvedValue(null);
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/metadata/search?q=mario&platform=Nintendo%2064',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            (0, vitest_1.expect)(enrichSpy).toHaveBeenCalledWith({
+                title: 'mario',
+                platform: 'Nintendo 64',
+            });
+        });
+    });
+});
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/tests/routes/roms.spec.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const app_1 = require("../../src/app");
+const prisma_1 = require("../../src/plugins/prisma");
+(0, vitest_1.describe)('ROMs API', () => {
+    let app;
+    (0, vitest_1.beforeEach)(async () => {
+        app = (0, app_1.buildApp)();
+        await app.ready();
+        // Limpiar base de datos antes de cada test (eliminar ROMs primero por foreign key)
+        await prisma_1.prisma.romFile.deleteMany();
+        await prisma_1.prisma.gamePlatform.deleteMany();
+        await prisma_1.prisma.purchase.deleteMany();
+        await prisma_1.prisma.artwork.deleteMany();
+        await prisma_1.prisma.priceHistory.deleteMany();
+        await prisma_1.prisma.game.deleteMany();
+    });
+    (0, vitest_1.afterEach)(async () => {
+        await app.close();
+    });
+    (0, vitest_1.describe)('GET /api/roms', () => {
+        (0, vitest_1.it)('debería devolver una lista vacía cuando no hay ROMs', async () => {
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/roms',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            (0, vitest_1.expect)(res.json()).toEqual([]);
+        });
+        (0, vitest_1.it)('debería devolver una lista de ROMs con sus propiedades', async () => {
+            // Crear un ROM de prueba
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/games/',
+                    filename: 'game.zip',
+                    checksum: 'abc123def456',
+                    size: 1024,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/roms',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(Array.isArray(body)).toBe(true);
+            (0, vitest_1.expect)(body.length).toBe(1);
+            (0, vitest_1.expect)(body[0].id).toBe(rom.id);
+            (0, vitest_1.expect)(body[0].filename).toBe('game.zip');
+        });
+        (0, vitest_1.it)('debería incluir información del juego asociado', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Test Game',
+                    slug: 'test-game',
+                },
+            });
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'test-with-game.zip',
+                    checksum: 'checksum-game-123',
+                    size: 2048,
+                    format: 'zip',
+                    gameId: game.id,
+                },
+            });
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/roms',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            // Buscar el ROM que creamos por checksum
+            const createdRom = body.find((r) => r.checksum === 'checksum-game-123');
+            (0, vitest_1.expect)(createdRom).toBeDefined();
+            (0, vitest_1.expect)(createdRom.game).toBeDefined();
+            (0, vitest_1.expect)(createdRom.game.title).toBe('Test Game');
+        });
+    });
+    (0, vitest_1.describe)('GET /api/roms/:id', () => {
+        (0, vitest_1.it)('debería retornar un ROM existente', async () => {
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'game1.zip',
+                    checksum: 'checksum1',
+                    size: 1024,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'GET',
+                url: `/api/roms/${rom.id}`,
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(body.id).toBe(rom.id);
+            (0, vitest_1.expect)(body.filename).toBe('game1.zip');
+        });
+        (0, vitest_1.it)('debería retornar 404 si el ROM no existe', async () => {
+            const res = await app.inject({
+                method: 'GET',
+                url: '/api/roms/non-existing-id',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(404);
+            (0, vitest_1.expect)(res.json()).toHaveProperty('error');
+        });
+        (0, vitest_1.it)('debería incluir el juego asociado al ROM', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Zelda',
+                    slug: 'zelda',
+                },
+            });
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'zelda.zip',
+                    checksum: 'checksum2',
+                    size: 2048,
+                    format: 'zip',
+                    gameId: game.id,
+                },
+            });
+            const res = await app.inject({
+                method: 'GET',
+                url: `/api/roms/${rom.id}`,
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(body.game).toBeDefined();
+            (0, vitest_1.expect)(body.game.title).toBe('Zelda');
+        });
+    });
+    (0, vitest_1.describe)('PUT /api/roms/:id/game', () => {
+        (0, vitest_1.it)('debería vincular un juego a un ROM existente', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Mario',
+                    slug: 'mario',
+                },
+            });
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'mario.zip',
+                    checksum: 'checksum3',
+                    size: 512,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: `/api/roms/${rom.id}/game`,
+                payload: {
+                    gameId: game.id,
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(200);
+            const body = res.json();
+            (0, vitest_1.expect)(body.gameId).toBe(game.id);
+            (0, vitest_1.expect)(body.game.title).toBe('Mario');
+        });
+        (0, vitest_1.it)('debería devolver 400 si el gameId es inválido', async () => {
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'game.zip',
+                    checksum: 'checksum4',
+                    size: 1024,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: `/api/roms/${rom.id}/game`,
+                payload: {
+                    gameId: 'invalid-game-id',
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+        });
+        (0, vitest_1.it)('debería devolver 404 si el ROM no existe', async () => {
+            const game = await prisma_1.prisma.game.create({
+                data: {
+                    title: 'Test',
+                    slug: 'test',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: '/api/roms/non-existing-id/game',
+                payload: {
+                    gameId: game.id,
+                },
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(404);
+        });
+        (0, vitest_1.it)('debería devolver 400 si falta gameId', async () => {
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'game.zip',
+                    checksum: 'checksum5',
+                    size: 1024,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'PUT',
+                url: `/api/roms/${rom.id}/game`,
+                payload: {},
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(400);
+        });
+    });
+    (0, vitest_1.describe)('DELETE /api/roms/:id', () => {
+        (0, vitest_1.it)('debería eliminar un ROM existente', async () => {
+            const rom = await prisma_1.prisma.romFile.create({
+                data: {
+                    path: '/roms/',
+                    filename: 'delete-me.zip',
+                    checksum: 'checksum6',
+                    size: 1024,
+                    format: 'zip',
+                },
+            });
+            const res = await app.inject({
+                method: 'DELETE',
+                url: `/api/roms/${rom.id}`,
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(204);
+            // Verificar que el ROM fue eliminado
+            const deletedRom = await prisma_1.prisma.romFile.findUnique({
+                where: { id: rom.id },
+            });
+            (0, vitest_1.expect)(deletedRom).toBeNull();
+        });
+        (0, vitest_1.it)('debería devolver 404 si el ROM no existe', async () => {
+            const res = await app.inject({
+                method: 'DELETE',
+                url: '/api/roms/non-existing-id',
+            });
+            (0, vitest_1.expect)(res.statusCode).toBe(404);
+        });
+    });
+});
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/dist/tests/server.spec.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const app_1 = require("../src/app");
+(0, vitest_1.describe)('Server', () => {
+    (0, vitest_1.it)('GET /api/health devuelve 200 y { status: "ok" }', async () => {
+        const app = (0, app_1.buildApp)();
+        await app.ready();
+        const res = await app.inject({ method: 'GET', url: '/api/health' });
+        (0, vitest_1.expect)(res.statusCode).toBe(200);
+        (0, vitest_1.expect)(res.json()).toEqual({ status: 'ok' });
+        await app.close();
+    });
+});
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-07
+ */

backend/dist/tests/services/archiveReader.integration.spec.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const checksumService_1 = require("../../src/services/checksumService");
+const archiveReader_1 = require("../../src/services/archiveReader");
+const crypto_1 = require("crypto");
+function hasBinary(bin) {
+    try {
+        (0, child_process_1.execSync)(`which ${bin}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+const wantIntegration = process.env.INTEGRATION === '1';
+const canCreate = hasBinary('7z') || hasBinary('zip');
+if (!wantIntegration) {
+    vitest_1.test.skip('archiveReader integration tests require INTEGRATION=1', () => { });
+}
+else if (!canCreate) {
+    vitest_1.test.skip('archiveReader integration tests skipped: no archive creation tool (7z or zip) available', () => { });
+}
+else {
+    (0, vitest_1.test)('reads entry from zip using system tools', async () => {
+        const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(process.cwd(), 'tmp-arc-'));
+        const inner = path_1.default.join(tmpDir, 'game.rom');
+        const content = 'QUASAR-INTEGRATION-TEST';
+        await fs_1.promises.writeFile(inner, content);
+        const archivePath = path_1.default.join(tmpDir, 'simple.zip');
+        // create zip using available tool
+        if (hasBinary('7z')) {
+            (0, child_process_1.execSync)(`7z a -tzip ${JSON.stringify(archivePath)} ${JSON.stringify(inner)}`, {
+                stdio: 'ignore',
+            });
+        }
+        else {
+            (0, child_process_1.execSync)(`zip -j ${JSON.stringify(archivePath)} ${JSON.stringify(inner)}`, {
+                stdio: 'ignore',
+            });
+        }
+        const stream = await (0, archiveReader_1.streamArchiveEntry)(archivePath, path_1.default.basename(inner));
+        (0, vitest_1.expect)(stream).not.toBeNull();
+        const hashes = await (0, checksumService_1.computeHashesFromStream)(stream);
+        const expectedMd5 = (0, crypto_1.createHash)('md5').update(content).digest('hex');
+        (0, vitest_1.expect)(hashes.md5).toBe(expectedMd5);
+        await fs_1.promises.rm(tmpDir, { recursive: true, force: true });
+    });
+}

backend/dist/tests/services/archiveReader.spec.js

@@ -0,0 +1,75 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+// Mockeamos el módulo `child_process` para controlar las llamadas a `exec`.
+vitest_1.vi.mock('child_process', () => ({ exec: vitest_1.vi.fn() }));
+const child_process = __importStar(require("child_process"));
+const archiveReader_1 = require("../../src/services/archiveReader");
+(0, vitest_1.describe)('services/archiveReader', () => {
+    (0, vitest_1.it)('lista entradas usando 7z -slt', async () => {
+        const stdout = `Path = file1.txt\nSize = 123\nPacked Size = 0\n\nPath = dir/file2.bin\nSize = 456\nPacked Size = 0\n`;
+        child_process.exec.mockImplementation((cmd, cb) => {
+            cb(null, stdout, '');
+            return {};
+        });
+        const entries = await (0, archiveReader_1.listArchiveEntries)('/roms/archive.7z', console);
+        (0, vitest_1.expect)(entries.length).toBe(2);
+        (0, vitest_1.expect)(entries[0].name).toBe('file1.txt');
+        (0, vitest_1.expect)(entries[0].size).toBe(123);
+        child_process.exec.mockRestore?.();
+    });
+    (0, vitest_1.it)('usa unzip como fallback para zip cuando 7z falla', async () => {
+        child_process.exec
+            .mockImplementationOnce((cmd, cb) => {
+            // simular fallo de 7z
+            cb(new Error('7z not found'), '', '');
+            return {};
+        })
+            .mockImplementationOnce((cmd, cb) => {
+            // salida simulada de unzip -l
+            cb(null, '   123 file1.txt\n   456 file2.bin\n', '');
+            return {};
+        });
+        const entries = await (0, archiveReader_1.listArchiveEntries)('/roms/archive.zip', console);
+        (0, vitest_1.expect)(entries.length).toBe(2);
+        (0, vitest_1.expect)(entries[0].name).toBe('file1.txt');
+        child_process.exec.mockRestore?.();
+    });
+    (0, vitest_1.it)('retorna vacío para formatos no soportados', async () => {
+        const entries = await (0, archiveReader_1.listArchiveEntries)('/roms/simple.bin');
+        (0, vitest_1.expect)(entries).toEqual([]);
+    });
+});

backend/dist/tests/services/archiveReader.stream.spec.js

@@ -0,0 +1,89 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const stream_1 = require("stream");
+const events_1 = require("events");
+vitest_1.vi.mock('child_process', () => ({ spawn: vitest_1.vi.fn() }));
+const child_process = __importStar(require("child_process"));
+const archiveReader_1 = require("../../src/services/archiveReader");
+(0, vitest_1.afterEach)(() => {
+    vitest_1.vi.restoreAllMocks();
+});
+(0, vitest_1.describe)('services/archiveReader streamArchiveEntry', () => {
+    (0, vitest_1.it)('streams entry using 7z stdout', async () => {
+        const pass = new stream_1.PassThrough();
+        const proc = new events_1.EventEmitter();
+        proc.stdout = pass;
+        child_process.spawn.mockImplementation(() => proc);
+        // Emular producción de datos de forma asíncrona
+        setImmediate(() => {
+            pass.write(Buffer.from('content-from-7z'));
+            pass.end();
+        });
+        const stream = await (0, archiveReader_1.streamArchiveEntry)('/roms/archive.7z', 'path/file.txt');
+        (0, vitest_1.expect)(stream).not.toBeNull();
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(Buffer.from(chunk));
+        }
+        (0, vitest_1.expect)(Buffer.concat(chunks).toString()).toBe('content-from-7z');
+    });
+    (0, vitest_1.it)('falls back to unzip -p when 7z throws', async () => {
+        const pass = new stream_1.PassThrough();
+        const proc2 = new events_1.EventEmitter();
+        proc2.stdout = pass;
+        child_process.spawn
+            .mockImplementationOnce(() => {
+            throw new Error('spawn ENOENT');
+        })
+            .mockImplementationOnce(() => proc2);
+        setImmediate(() => {
+            pass.write(Buffer.from('fallback-content'));
+            pass.end();
+        });
+        const stream = await (0, archiveReader_1.streamArchiveEntry)('/roms/archive.zip', 'file.dat');
+        (0, vitest_1.expect)(stream).not.toBeNull();
+        const chunks = [];
+        for await (const chunk of stream) {
+            chunks.push(Buffer.from(chunk));
+        }
+        (0, vitest_1.expect)(Buffer.concat(chunks).toString()).toBe('fallback-content');
+    });
+    (0, vitest_1.it)('returns null for unsupported formats', async () => {
+        const res = await (0, archiveReader_1.streamArchiveEntry)('/roms/archive.bin', 'entry');
+        (0, vitest_1.expect)(res).toBeNull();
+    });
+});

backend/dist/tests/services/checksumService.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const path_1 = __importDefault(require("path"));
+const checksumService_1 = require("../../src/services/checksumService");
+const fixturesDir = path_1.default.join(__dirname, '..', 'fixtures');
+const simpleRom = path_1.default.join(fixturesDir, 'simple-rom.bin');
+(0, vitest_1.describe)('services/checksumService', () => {
+    (0, vitest_1.it)('exporta computeHashes', () => {
+        (0, vitest_1.expect)(typeof checksumService_1.computeHashes).toBe('function');
+    });
+    (0, vitest_1.it)('calcula hashes', async () => {
+        const meta = await (0, checksumService_1.computeHashes)(simpleRom);
+        (0, vitest_1.expect)(meta).toBeDefined();
+        (0, vitest_1.expect)(meta.size).toBeGreaterThan(0);
+        (0, vitest_1.expect)(meta.md5).toBeDefined();
+        (0, vitest_1.expect)(meta.sha1).toBeDefined();
+        (0, vitest_1.expect)(meta.crc32).toBeDefined();
+    });
+});

backend/dist/tests/services/checksumService.stream.spec.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const stream_1 = require("stream");
+const promises_1 = __importDefault(require("fs/promises"));
+const path_1 = __importDefault(require("path"));
+const checksumService_1 = require("../../src/services/checksumService");
+(0, vitest_1.describe)('services/checksumService (stream)', () => {
+    (0, vitest_1.it)('computeHashesFromStream produces same result as computeHashes(file)', async () => {
+        const data = Buffer.from('quasar-stream-test');
+        const tmpDir = await promises_1.default.mkdtemp(path_1.default.join(process.cwd(), 'tmp-checksum-'));
+        const tmpFile = path_1.default.join(tmpDir, 'test.bin');
+        await promises_1.default.writeFile(tmpFile, data);
+        const expected = await (0, checksumService_1.computeHashes)(tmpFile);
+        const rs = stream_1.Readable.from([data]);
+        const actual = await (0, checksumService_1.computeHashesFromStream)(rs);
+        (0, vitest_1.expect)(actual).toEqual(expected);
+        await promises_1.default.rm(tmpDir, { recursive: true, force: true });
+    });
+});

backend/dist/tests/services/datVerifier.spec.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const datVerifier_1 = require("../../src/services/datVerifier");
+const FIXTURE = path_1.default.resolve('tests/fixtures/sample.dat.xml');
+(0, vitest_1.describe)('services/datVerifier', () => {
+    (0, vitest_1.it)('parseDat parses simple DAT XML', () => {
+        const xml = fs_1.default.readFileSync(FIXTURE, 'utf8');
+        const dat = (0, datVerifier_1.parseDat)(xml);
+        (0, vitest_1.expect)(dat).toBeTruthy();
+        (0, vitest_1.expect)(Array.isArray(dat.games)).toBe(true);
+        (0, vitest_1.expect)(dat.games.length).toBe(2);
+        const g0 = dat.games[0];
+        (0, vitest_1.expect)(g0.name).toBe('Game Alpha');
+        (0, vitest_1.expect)(g0.roms.length).toBeGreaterThan(0);
+        (0, vitest_1.expect)(g0.roms[0].name).toBe('alpha1.bin');
+        (0, vitest_1.expect)(g0.roms[0].crc).toBeDefined();
+        (0, vitest_1.expect)(g0.roms[0].md5).toBeDefined();
+        const g1 = dat.games[1];
+        (0, vitest_1.expect)(g1.name).toBe('Game Beta');
+        (0, vitest_1.expect)(g1.roms.some((r) => r.name === 'beta2.rom')).toBe(true);
+    });
+    (0, vitest_1.it)('verifyHashesAgainstDat finds match by CRC', () => {
+        const xml = fs_1.default.readFileSync(FIXTURE, 'utf8');
+        const dat = (0, datVerifier_1.parseDat)(xml);
+        const match = (0, datVerifier_1.verifyHashesAgainstDat)(dat, { crc: 'DEADBEEF' });
+        (0, vitest_1.expect)(match).not.toBeNull();
+        (0, vitest_1.expect)(match?.gameName).toBe('Game Beta');
+        (0, vitest_1.expect)(match?.romName).toBe('beta1.rom');
+        (0, vitest_1.expect)(match?.matchedOn).toBe('crc');
+    });
+    (0, vitest_1.it)('verifyHashesAgainstDat finds match by MD5, SHA1 and size', () => {
+        const xml = fs_1.default.readFileSync(FIXTURE, 'utf8');
+        const dat = (0, datVerifier_1.parseDat)(xml);
+        const md5match = (0, datVerifier_1.verifyHashesAgainstDat)(dat, { md5: '11111111111111111111111111111111' });
+        (0, vitest_1.expect)(md5match).not.toBeNull();
+        (0, vitest_1.expect)(md5match?.gameName).toBe('Game Alpha');
+        (0, vitest_1.expect)(md5match?.romName).toBe('alpha1.bin');
+        (0, vitest_1.expect)(md5match?.matchedOn).toBe('md5');
+        const sha1match = (0, datVerifier_1.verifyHashesAgainstDat)(dat, {
+            sha1: 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+        });
+        (0, vitest_1.expect)(sha1match).not.toBeNull();
+        (0, vitest_1.expect)(sha1match?.gameName).toBe('Game Alpha');
+        (0, vitest_1.expect)(sha1match?.romName).toBe('alpha2.bin');
+        (0, vitest_1.expect)(sha1match?.matchedOn).toBe('sha1');
+        const sizematch = (0, datVerifier_1.verifyHashesAgainstDat)(dat, { size: 4000 });
+        (0, vitest_1.expect)(sizematch).not.toBeNull();
+        (0, vitest_1.expect)(sizematch?.gameName).toBe('Game Beta');
+        (0, vitest_1.expect)(sizematch?.romName).toBe('beta2.rom');
+        (0, vitest_1.expect)(sizematch?.matchedOn).toBe('size');
+    });
+    (0, vitest_1.it)('verifyHashesAgainstDat returns null when no match', () => {
+        const xml = fs_1.default.readFileSync(FIXTURE, 'utf8');
+        const dat = (0, datVerifier_1.parseDat)(xml);
+        const noMatch = (0, datVerifier_1.verifyHashesAgainstDat)(dat, { md5: 'ffffffffffffffffffffffffffffffff' });
+        (0, vitest_1.expect)(noMatch).toBeNull();
+    });
+});

backend/dist/tests/services/fsScanner.archiveEntries.spec.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_1 = require("fs");
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('../../src/services/archiveReader', () => ({ listArchiveEntries: vitest_1.vi.fn() }));
+const fsScanner_1 = __importDefault(require("../../src/services/fsScanner"));
+const archiveReader_1 = require("../../src/services/archiveReader");
+(0, vitest_1.afterEach)(() => vitest_1.vi.restoreAllMocks());
+(0, vitest_1.it)('expone entradas internas de archivos como items virtuales', async () => {
+    const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'fsScanner-test-'));
+    const collectionFile = path_1.default.join(tmpDir, 'collection.zip');
+    await fs_1.promises.writeFile(collectionFile, '');
+    archiveReader_1.listArchiveEntries.mockResolvedValue([
+        { name: 'inner/rom1.bin', size: 1234 },
+    ]);
+    const results = await (0, fsScanner_1.default)(tmpDir);
+    const expectedPath = `${collectionFile}::inner/rom1.bin`;
+    const found = results.find((r) => r.path === expectedPath);
+    (0, vitest_1.expect)(found).toBeDefined();
+    (0, vitest_1.expect)(found.isArchiveEntry).toBe(true);
+    (0, vitest_1.expect)(found.containerPath).toBe(collectionFile);
+    (0, vitest_1.expect)(found.entryPath).toBe('inner/rom1.bin');
+    (0, vitest_1.expect)(found.filename).toBe('rom1.bin');
+    (0, vitest_1.expect)(found.format).toBe('bin');
+    await fs_1.promises.rm(tmpDir, { recursive: true, force: true });
+});
+(0, vitest_1.it)('ignora entradas con traversal o paths absolutos', async () => {
+    const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'fsScanner-test-'));
+    const collectionFile = path_1.default.join(tmpDir, 'collection.zip');
+    await fs_1.promises.writeFile(collectionFile, '');
+    archiveReader_1.listArchiveEntries.mockResolvedValue([
+        { name: '../evil.rom', size: 10 },
+        { name: '/abs/evil.rom', size: 20 },
+        { name: 'good/rom.bin', size: 30 },
+    ]);
+    const results = await (0, fsScanner_1.default)(tmpDir);
+    const safePath = `${collectionFile}::good/rom.bin`;
+    (0, vitest_1.expect)(results.find((r) => r.path === safePath)).toBeDefined();
+    (0, vitest_1.expect)(results.find((r) => r.path === `${collectionFile}::../evil.rom`)).toBeUndefined();
+    (0, vitest_1.expect)(results.find((r) => r.path === `${collectionFile}::/abs/evil.rom`)).toBeUndefined();
+    await fs_1.promises.rm(tmpDir, { recursive: true, force: true });
+});
+(0, vitest_1.it)('respeta ARCHIVE_MAX_ENTRIES', async () => {
+    const tmpDir = await fs_1.promises.mkdtemp(path_1.default.join(os_1.default.tmpdir(), 'fsScanner-test-'));
+    const collectionFile = path_1.default.join(tmpDir, 'collection.zip');
+    await fs_1.promises.writeFile(collectionFile, '');
+    // Set env var temporarily
+    const prev = process.env.ARCHIVE_MAX_ENTRIES;
+    process.env.ARCHIVE_MAX_ENTRIES = '1';
+    archiveReader_1.listArchiveEntries.mockResolvedValue([
+        { name: 'one.bin', size: 1 },
+        { name: 'two.bin', size: 2 },
+        { name: 'three.bin', size: 3 },
+    ]);
+    const results = await (0, fsScanner_1.default)(tmpDir);
+    const matches = results.filter((r) => String(r.path).startsWith(collectionFile + '::'));
+    (0, vitest_1.expect)(matches.length).toBe(1);
+    // restore
+    if (prev === undefined)
+        delete process.env.ARCHIVE_MAX_ENTRIES;
+    else
+        process.env.ARCHIVE_MAX_ENTRIES = prev;
+    await fs_1.promises.rm(tmpDir, { recursive: true, force: true });
+});

backend/dist/tests/services/fsScanner.spec.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const path_1 = __importDefault(require("path"));
+const fsScanner_1 = require("../../src/services/fsScanner");
+const fixturesDir = path_1.default.join(__dirname, '..', 'fixtures');
+const emptyDir = path_1.default.join(fixturesDir, 'empty');
+(0, vitest_1.describe)('services/fsScanner', () => {
+    (0, vitest_1.it)('exporta scanDirectory', () => {
+        (0, vitest_1.expect)(typeof fsScanner_1.scanDirectory).toBe('function');
+    });
+    (0, vitest_1.it)('carpeta vacía devuelve array', async () => {
+        const res = await (0, fsScanner_1.scanDirectory)(emptyDir);
+        (0, vitest_1.expect)(Array.isArray(res)).toBe(true);
+        (0, vitest_1.expect)(res.length).toBe(0);
+    });
+    (0, vitest_1.it)('detecta simple-rom.bin', async () => {
+        const res = await (0, fsScanner_1.scanDirectory)(fixturesDir);
+        const found = res.find((r) => r.filename === 'simple-rom.bin' || r.name === 'simple-rom.bin');
+        (0, vitest_1.expect)(found).toBeTruthy();
+        (0, vitest_1.expect)(found.size).toBeGreaterThan(0);
+        (0, vitest_1.expect)(found.format).toBeDefined();
+    });
+});

backend/dist/tests/services/importService.archiveEntry.spec.js

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const stream_1 = require("stream");
+vitest_1.vi.mock('../../src/services/fsScanner', () => ({ scanDirectory: vitest_1.vi.fn() }));
+vitest_1.vi.mock('../../src/services/archiveReader', () => ({ streamArchiveEntry: vitest_1.vi.fn() }));
+vitest_1.vi.mock('../../src/plugins/prisma', () => ({
+    default: {
+        game: { findFirst: vitest_1.vi.fn(), create: vitest_1.vi.fn(), update: vitest_1.vi.fn() },
+    },
+}));
+const importService_1 = __importDefault(require("../../src/services/importService"));
+const fsScanner_1 = require("../../src/services/fsScanner");
+const archiveReader_1 = require("../../src/services/archiveReader");
+const prisma_1 = __importDefault(require("../../src/plugins/prisma"));
+const crypto_1 = require("crypto");
+(0, vitest_1.beforeEach)(() => {
+    vitest_1.vi.restoreAllMocks();
+});
+(0, vitest_1.describe)('services/importService (archive entries)', () => {
+    (0, vitest_1.it)('procesa una entrada interna usando streamArchiveEntry y crea Game con source=rom', async () => {
+        const files = [
+            {
+                path: '/roms/collection.zip::inner/rom1.bin',
+                containerPath: '/roms/collection.zip',
+                entryPath: 'inner/rom1.bin',
+                filename: 'rom1.bin',
+                name: 'inner/rom1.bin',
+                size: 123,
+                format: 'bin',
+                isArchiveEntry: true,
+            },
+        ];
+        const data = Buffer.from('import-archive-test');
+        fsScanner_1.scanDirectory.mockResolvedValue(files);
+        archiveReader_1.streamArchiveEntry.mockResolvedValue(stream_1.Readable.from([data]));
+        prisma_1.default.game.findFirst.mockResolvedValue(null);
+        prisma_1.default.game.create.mockResolvedValue({
+            id: 77,
+            title: 'ROM1',
+            slug: 'rom1',
+        });
+        const md5 = (0, crypto_1.createHash)('md5').update(data).digest('hex');
+        const summary = await (0, importService_1.default)({ dir: '/roms', persist: true });
+        (0, vitest_1.expect)(archiveReader_1.streamArchiveEntry.mock.calls.length).toBe(1);
+        (0, vitest_1.expect)(archiveReader_1.streamArchiveEntry.mock.calls[0][0]).toBe('/roms/collection.zip');
+        (0, vitest_1.expect)(archiveReader_1.streamArchiveEntry.mock.calls[0][1]).toBe('inner/rom1.bin');
+        (0, vitest_1.expect)(prisma_1.default.game.findFirst.mock.calls[0][0]).toEqual({
+            where: { source: 'rom', romChecksum: md5 },
+        });
+        (0, vitest_1.expect)(prisma_1.default.game.create.mock.calls[0][0]).toEqual({
+            data: {
+                title: 'ROM1',
+                slug: 'rom1-1234567890123',
+                source: 'rom',
+                romPath: '/roms/collection.zip::inner/rom1.bin',
+                romFilename: 'rom1.bin',
+                romSize: 123,
+                romChecksum: md5,
+                romFormat: 'bin',
+                romHashes: vitest_1.expect.any(String),
+                addedAt: vitest_1.expect.any(Date),
+                lastSeenAt: vitest_1.expect.any(Date),
+            },
+        });
+        (0, vitest_1.expect)(summary).toEqual({ processed: 1, createdCount: 1, upserted: 0 });
+    });
+});

backend/dist/tests/services/importService.spec.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('../../src/services/fsScanner', () => ({
+    scanDirectory: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../src/services/checksumService', () => ({
+    computeHashes: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../src/plugins/prisma', () => ({
+    default: {
+        game: { findFirst: vitest_1.vi.fn(), create: vitest_1.vi.fn(), update: vitest_1.vi.fn() },
+    },
+}));
+const importService_1 = require("../../src/services/importService");
+const fsScanner_1 = require("../../src/services/fsScanner");
+const checksumService_1 = require("../../src/services/checksumService");
+const prisma_1 = __importDefault(require("../../src/plugins/prisma"));
+(0, vitest_1.describe)('services/importService', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.it)('exporta createSlug e importDirectory', () => {
+        (0, vitest_1.expect)(typeof importService_1.createSlug).toBe('function');
+        (0, vitest_1.expect)(typeof importService_1.importDirectory).toBe('function');
+    });
+    (0, vitest_1.it)('cuando hay un archivo y persist:true crea Game con source=rom y devuelve resumen', async () => {
+        const files = [
+            {
+                path: '/roms/Sonic.bin',
+                filename: 'Sonic.bin',
+                name: 'Sonic.bin',
+                size: 123,
+                format: 'bin',
+                isArchive: false,
+            },
+        ];
+        const hashes = { size: 123, md5: 'md5-abc', sha1: 'sha1-abc', crc32: 'abcd' };
+        fsScanner_1.scanDirectory.mockResolvedValue(files);
+        checksumService_1.computeHashes.mockResolvedValue(hashes);
+        prisma_1.default.game.findFirst.mockResolvedValue(null);
+        prisma_1.default.game.create.mockResolvedValue({
+            id: 77,
+            title: 'Sonic',
+            slug: 'sonic',
+        });
+        const summary = await (0, importService_1.importDirectory)({ dir: '/roms', persist: true });
+        (0, vitest_1.expect)(fsScanner_1.scanDirectory.mock.calls[0][0]).toBe('/roms');
+        (0, vitest_1.expect)(checksumService_1.computeHashes.mock.calls[0][0]).toBe('/roms/Sonic.bin');
+        (0, vitest_1.expect)(prisma_1.default.game.findFirst.mock.calls[0][0]).toEqual({
+            where: { source: 'rom', romChecksum: 'md5-abc' },
+        });
+        (0, vitest_1.expect)(prisma_1.default.game.create.mock.calls[0][0]).toEqual({
+            data: {
+                title: 'Sonic',
+                slug: 'sonic-1234567890123',
+                source: 'rom',
+                romPath: '/roms/Sonic.bin',
+                romFilename: 'Sonic.bin',
+                romSize: 123,
+                romChecksum: 'md5-abc',
+                romFormat: 'bin',
+                romHashes: JSON.stringify(hashes),
+                addedAt: vitest_1.expect.any(Date),
+                lastSeenAt: vitest_1.expect.any(Date),
+            },
+        });
+        (0, vitest_1.expect)(summary).toEqual({ processed: 1, createdCount: 1, upserted: 0 });
+    });
+    (0, vitest_1.it)('cuando el juego ya existe (mismo checksum), actualiza lastSeenAt', async () => {
+        const files = [
+            {
+                path: '/roms/Sonic.bin',
+                filename: 'Sonic.bin',
+                name: 'Sonic.bin',
+                size: 123,
+                format: 'bin',
+                isArchive: false,
+            },
+        ];
+        const hashes = { size: 123, md5: 'md5-abc', sha1: 'sha1-abc', crc32: 'abcd' };
+        fsScanner_1.scanDirectory.mockResolvedValue(files);
+        checksumService_1.computeHashes.mockResolvedValue(hashes);
+        prisma_1.default.game.findFirst.mockResolvedValue({
+            id: 77,
+            title: 'Sonic',
+            slug: 'sonic',
+        });
+        prisma_1.default.game.update.mockResolvedValue({
+            id: 77,
+            title: 'Sonic',
+            slug: 'sonic',
+        });
+        const summary = await (0, importService_1.importDirectory)({ dir: '/roms', persist: true });
+        (0, vitest_1.expect)(prisma_1.default.game.update.mock.calls[0][0]).toEqual({
+            where: { id: 77 },
+            data: {
+                lastSeenAt: vitest_1.expect.any(Date),
+                romHashes: JSON.stringify(hashes),
+            },
+        });
+        (0, vitest_1.expect)(summary).toEqual({ processed: 1, createdCount: 0, upserted: 1 });
+    });
+    (0, vitest_1.it)('cuando persist=false no guarda nada en la base de datos', async () => {
+        const files = [
+            {
+                path: '/roms/Sonic.bin',
+                filename: 'Sonic.bin',
+                name: 'Sonic.bin',
+                size: 123,
+                format: 'bin',
+                isArchive: false,
+            },
+        ];
+        const hashes = { size: 123, md5: 'md5-abc', sha1: 'sha1-abc', crc32: 'abcd' };
+        fsScanner_1.scanDirectory.mockResolvedValue(files);
+        checksumService_1.computeHashes.mockResolvedValue(hashes);
+        const summary = await (0, importService_1.importDirectory)({ dir: '/roms', persist: false });
+        (0, vitest_1.expect)(prisma_1.default.game.findFirst).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(prisma_1.default.game.create).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(prisma_1.default.game.update).not.toHaveBeenCalled();
+        (0, vitest_1.expect)(summary).toEqual({ processed: 1, createdCount: 0, upserted: 0 });
+    });
+});

backend/dist/tests/services/metadataService.spec.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+vitest_1.vi.mock('../../src/services/igdbClient', () => ({
+    searchGames: vitest_1.vi.fn(),
+    getGameById: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../src/services/rawgClient', () => ({
+    searchGames: vitest_1.vi.fn(),
+    getGameById: vitest_1.vi.fn(),
+}));
+vitest_1.vi.mock('../../src/services/thegamesdbClient', () => ({
+    searchGames: vitest_1.vi.fn(),
+    getGameById: vitest_1.vi.fn(),
+}));
+const igdb = __importStar(require("../../src/services/igdbClient"));
+const rawg = __importStar(require("../../src/services/rawgClient"));
+const tgdb = __importStar(require("../../src/services/thegamesdbClient"));
+const metadataService_1 = require("../../src/services/metadataService");
+(0, vitest_1.describe)('services/metadataService', () => {
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+    });
+    (0, vitest_1.it)('prioriza IGDB cuando hay resultados', async () => {
+        igdb.searchGames.mockResolvedValue([
+            {
+                id: 11,
+                name: 'Sonic',
+                slug: 'sonic',
+                releaseDate: '1991-06-23',
+                genres: ['Platform'],
+                coverUrl: 'http://img',
+                source: 'igdb',
+            },
+        ]);
+        rawg.searchGames.mockResolvedValue([]);
+        tgdb.searchGames.mockResolvedValue([]);
+        const res = await (0, metadataService_1.enrichGame)({ title: 'Sonic' });
+        (0, vitest_1.expect)(res).not.toBeNull();
+        (0, vitest_1.expect)(res?.source).toBe('igdb');
+        (0, vitest_1.expect)(res?.externalIds.igdb).toBe(11);
+        (0, vitest_1.expect)(res?.title).toBe('Sonic');
+    });
+    (0, vitest_1.it)('cae a RAWG cuando IGDB no responde resultados', async () => {
+        igdb.searchGames.mockResolvedValue([]);
+        rawg.searchGames.mockResolvedValue([
+            {
+                id: 22,
+                name: 'Sonic (rawg)',
+                slug: 'sonic-rawg',
+                releaseDate: '1991-06-23',
+                genres: ['Platform'],
+                coverUrl: 'http://img',
+                source: 'rawg',
+            },
+        ]);
+        tgdb.searchGames.mockResolvedValue([]);
+        const res = await (0, metadataService_1.enrichGame)({ title: 'Sonic' });
+        (0, vitest_1.expect)(res).not.toBeNull();
+        (0, vitest_1.expect)(res?.source).toBe('rawg');
+        (0, vitest_1.expect)(res?.externalIds.rawg).toBe(22);
+    });
+    (0, vitest_1.it)('retorna null si no hay resultados en ninguna API', async () => {
+        igdb.searchGames.mockResolvedValue([]);
+        rawg.searchGames.mockResolvedValue([]);
+        tgdb.searchGames.mockResolvedValue([]);
+        const res = await (0, metadataService_1.enrichGame)({ title: 'Juego inexistente' });
+        (0, vitest_1.expect)(res).toBeNull();
+    });
+});

backend/dist/tests/setup.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const dotenv_1 = __importDefault(require("dotenv"));
+const child_process_1 = require("child_process");
+// Cargar variables de entorno desde .env
+dotenv_1.default.config();
+// Ejecutar migraciones de Prisma antes de los tests
+try {
+    (0, child_process_1.execSync)('npx prisma migrate deploy', {
+        cwd: process.cwd(),
+        stdio: 'inherit',
+    });
+}
+catch (error) {
+    console.error('Failed to run Prisma migrations:', error);
+}
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-12
+ */