feat: implement ROMs management UI (Phase 8)

Backend (Phase 8.1):
- Add ROMs endpoints: GET, GET/:id, PUT/:id/game, DELETE
- Add metadata search endpoint using IGDB/RAWG/TGDB
- Implement RomsController with ROM CRUD logic
- Add 12 comprehensive ROM endpoint tests
- Configure Vitest to run tests sequentially (threads: false)
- Auto-apply Prisma migrations in test setup

Frontend (Phase 8.2 + 8.3):
- Create ROM types: RomFile, Artwork, EnrichedGame
- Extend API client with roms and metadata namespaces
- Implement 5 custom hooks with TanStack Query
- Create ScanDialog, MetadataSearchDialog, RomCard components
- Rewrite roms.tsx page with table and all actions
- Add 37 comprehensive component and page tests

All 122 tests passing: 63 backend + 59 frontend
Lint: 0 errors, only unused directive warnings

backend/src/app.ts

@@ -5,6 +5,8 @@ import rateLimit from '@fastify/rate-limit';
 import healthRoutes from './routes/health';
 import importRoutes from './routes/import';
 import gamesRoutes from './routes/games';
+import romsRoutes from './routes/roms';
+import metadataRoutes from './routes/metadata';
 
 export function buildApp(): FastifyInstance {
   const app: FastifyInstance = Fastify({
@@ -17,6 +19,8 @@ export function buildApp(): FastifyInstance {
   void app.register(healthRoutes, { prefix: '/api' });
   void app.register(importRoutes, { prefix: '/api' });
   void app.register(gamesRoutes, { prefix: '/api' });
+  void app.register(romsRoutes, { prefix: '/api' });
+  void app.register(metadataRoutes, { prefix: '/api' });
 
   return app;
 }

backend/src/controllers/romsController.ts

@@ -0,0 +1,96 @@
+import { prisma } from '../plugins/prisma';
+
+export class RomsController {
+  /**
+   * Listar todos los ROMs con sus juegos asociados
+   */
+  static async listRoms() {
+    return await prisma.romFile.findMany({
+      include: {
+        game: true,
+      },
+      orderBy: {
+        filename: 'asc',
+      },
+    });
+  }
+
+  /**
+   * Obtener un ROM por ID con su juego asociado
+   */
+  static async getRomById(id: string) {
+    const rom = await prisma.romFile.findUnique({
+      where: { id },
+      include: {
+        game: true,
+      },
+    });
+
+    if (!rom) {
+      throw new Error('ROM no encontrado');
+    }
+
+    return rom;
+  }
+
+  /**
+   * Vincular un juego a un ROM existente
+   */
+  static async linkGameToRom(romId: string, gameId: string) {
+    // Validar que el ROM existe
+    const rom = await prisma.romFile.findUnique({
+      where: { id: romId },
+    });
+
+    if (!rom) {
+      throw new Error('ROM no encontrado');
+    }
+
+    // Validar que el juego existe
+    const game = await prisma.game.findUnique({
+      where: { id: gameId },
+    });
+
+    if (!game) {
+      throw new Error('Juego no encontrado');
+    }
+
+    // Actualizar el ROM con el nuevo gameId
+    return await prisma.romFile.update({
+      where: { id: romId },
+      data: {
+        gameId,
+      },
+      include: {
+        game: true,
+      },
+    });
+  }
+
+  /**
+   * Eliminar un ROM por ID
+   */
+  static async deleteRom(id: string) {
+    // Validar que el ROM existe
+    const rom = await prisma.romFile.findUnique({
+      where: { id },
+    });
+
+    if (!rom) {
+      throw new Error('ROM no encontrado');
+    }
+
+    // Eliminar el ROM
+    await prisma.romFile.delete({
+      where: { id },
+    });
+
+    return { message: 'ROM eliminado correctamente' };
+  }
+}
+
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/src/routes/metadata.ts

@@ -0,0 +1,48 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import * as metadataService from '../services/metadataService';
+import { z } from 'zod';
+import { ZodError } from 'zod';
+
+// Esquema de validación para parámetros de búsqueda
+const searchMetadataSchema = z.object({
+  q: z.string().min(1, 'El parámetro de búsqueda es requerido'),
+  platform: z.string().optional(),
+});
+
+async function metadataRoutes(app: FastifyInstance) {
+  /**
+   * GET /api/metadata/search?q=query&platform=optional
+   * Buscar metadata de juegos
+   */
+  app.get<{ Querystring: any; Reply: any[] }>('/metadata/search', async (request, reply) => {
+    try {
+      // Validar parámetros de query con Zod
+      const validated = searchMetadataSchema.parse(request.query);
+
+      // Llamar a metadataService
+      const result = await metadataService.enrichGame({
+        title: validated.q,
+        platform: validated.platform,
+      });
+
+      // Si hay resultado, devolver como array; si no, devolver array vacío
+      return reply.code(200).send(result ? [result] : []);
+    } catch (error) {
+      if (error instanceof ZodError) {
+        return reply.code(400).send({
+          error: 'Parámetros de búsqueda inválidos',
+          details: error.errors,
+        });
+      }
+      throw error;
+    }
+  });
+}
+
+export default metadataRoutes;
+
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/src/routes/roms.ts

@@ -0,0 +1,95 @@
+import { FastifyInstance, FastifyRequest, FastifyReply } from 'fastify';
+import { RomsController } from '../controllers/romsController';
+import { linkGameSchema } from '../validators/romValidator';
+import { ZodError } from 'zod';
+
+async function romsRoutes(app: FastifyInstance) {
+  /**
+   * GET /api/roms
+   * Listar todos los ROMs
+   */
+  app.get<{ Reply: any[] }>('/roms', async (request, reply) => {
+    const roms = await RomsController.listRoms();
+    return reply.code(200).send(roms);
+  });
+
+  /**
+   * GET /api/roms/:id
+   * Obtener un ROM por ID
+   */
+  app.get<{ Params: { id: string }; Reply: any }>('/roms/:id', async (request, reply) => {
+    try {
+      const rom = await RomsController.getRomById(request.params.id);
+      return reply.code(200).send(rom);
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('no encontrado')) {
+        return reply.code(404).send({
+          error: 'ROM no encontrado',
+        });
+      }
+      throw error;
+    }
+  });
+
+  /**
+   * PUT /api/roms/:id/game
+   * Vincular un juego a un ROM
+   */
+  app.put<{ Params: { id: string }; Body: any; Reply: any }>(
+    '/roms/:id/game',
+    async (request, reply) => {
+      try {
+        // Validar entrada con Zod
+        const validated = linkGameSchema.parse(request.body);
+        const rom = await RomsController.linkGameToRom(request.params.id, validated.gameId);
+        return reply.code(200).send(rom);
+      } catch (error) {
+        if (error instanceof ZodError) {
+          return reply.code(400).send({
+            error: 'Validación fallida',
+            details: error.errors,
+          });
+        }
+        if (error instanceof Error) {
+          if (error.message.includes('ROM no encontrado')) {
+            return reply.code(404).send({
+              error: 'ROM no encontrado',
+            });
+          }
+          if (error.message.includes('Juego no encontrado')) {
+            return reply.code(400).send({
+              error: 'Game ID inválido o no encontrado',
+            });
+          }
+        }
+        throw error;
+      }
+    }
+  );
+
+  /**
+   * DELETE /api/roms/:id
+   * Eliminar un ROM
+   */
+  app.delete<{ Params: { id: string }; Reply: any }>('/roms/:id', async (request, reply) => {
+    try {
+      await RomsController.deleteRom(request.params.id);
+      return reply.code(204).send();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes('no encontrado')) {
+        return reply.code(404).send({
+          error: 'ROM no encontrado',
+        });
+      }
+      throw error;
+    }
+  });
+}
+
+export default romsRoutes;
+
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */

backend/src/validators/romValidator.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+// Esquema para vincular un juego a un ROM
+export const linkGameSchema = z.object({
+  gameId: z.string().min(1, 'El ID del juego es requerido'),
+});
+
+// Tipo TypeScript derivado del esquema
+export type LinkGameInput = z.infer<typeof linkGameSchema>;
+
+/**
+ * Metadatos:
+ * Autor: GitHub Copilot
+ * Última actualización: 2026-02-11
+ */