Merge pull request #27 from josesalazar2025/feature/refactor-backend

backend/docs/AUTH.md

@@ -47,6 +47,14 @@ Sembrados por `prisma/seed.js` (idempotente, se puede re-ejecutar):
 
 ## 4. Endpoints
 
+> Resumen rápido:
+>
+> | Método | Path | Auth | Descripción |
+> |---|---|---|---|
+> | `POST` | `/api/v1/auth/login`  | No | Obtener JWT |
+> | `GET`  | `/api/v1/auth/me`     | Bearer | Perfil del usuario autenticado |
+> | `POST` | `/api/v1/auth/logout` | Bearer | Invalidar token activo |
+
 ### `GET /api/v1/health`
 
 Sanity check. Respuesta:
@@ -107,6 +115,26 @@ Errores:
 |---|---|---|
 | `401` | `UNAUTHORIZED` | Sin header, token mal formado, expirado, manipulado, o usuario desactivado |
 
+### `POST /api/v1/auth/logout`
+
+Requiere header `Authorization: Bearer <token>`. Invalida el token activo añadiendo su `jti` a la denylist en memoria — cualquier request posterior con ese token recibirá `401 UNAUTHORIZED`.
+
+El cliente debe descartar el token en cuanto reciba la respuesta.
+
+Respuesta `200`:
+
+```json
+{ "ok": true, "data": { "message": "Logged out successfully" } }
+```
+
+Errores:
+
+| HTTP | code | cuándo |
+|---|---|---|
+| `401` | `UNAUTHORIZED` | Sin header, token mal formado, expirado, manipulado, o ya invalidado |
+
+> **Nota:** la denylist es en memoria; si el servidor se reinicia los tokens previos al reinicio quedan tecnicamente activos, pero expirarán solos en máx 1 h (TTL del JWT).
+
 ## 5. Ejemplos con `curl`
 
 ```bash
@@ -117,15 +145,24 @@ TOKEN=$(curl -s -X POST http://localhost:7860/api/v1/auth/login \
   | jq -r '.data.token')
 
 # 2) Llamar a /me con el token
+curl -s http://localhost:7860/api/v1/auth/me \
+  -H "Authorization: Bearer $TOKEN" | jq
+
+# 3) Logout (invalida el token)
+curl -s -X POST http://localhost:7860/api/v1/auth/logout \
+  -H "Authorization: Bearer $TOKEN" | jq
+
+# 4) Verificar que el token ya no funciona (debe devolver 401)
 curl -s http://localhost:7860/api/v1/auth/me \
   -H "Authorization: Bearer $TOKEN" | jq
 ```
 
-## 6. Login desde el frontend (referencia)
+## 6. Login / Logout desde el frontend (referencia)
 
-El JWT es opaco para el front: basta con guardarlo (sessionStorage o estado en memoria) y enviarlo en cada request protegido.
+El JWT es opaco para el front: basta con guardarlo (sessionStorage o estado en memoria) y enviarlo en cada request protegido. Al hacer logout, llamar al endpoint **antes** de descartar el token localmente para que quede invalidado en el servidor.
 
 ```js
+// Login
 const res = await fetch('/api/v1/auth/login', {
   method: 'POST',
   headers: { 'Content-Type': 'application/json' },
@@ -134,10 +171,17 @@ const res = await fetch('/api/v1/auth/login', {
 const json = await res.json();
 if (!json.ok) throw new Error(json.error.code);
 const { token, user } = json.data;
-// guardar token y user
+// guardar token y user en estado / sessionStorage
 
-// requests autenticados
+// Requests autenticados
 fetch('/api/v1/auth/me', { headers: { Authorization: `Bearer ${token}` } });
+
+// Logout
+await fetch('/api/v1/auth/logout', {
+  method: 'POST',
+  headers: { Authorization: `Bearer ${token}` },
+});
+// descartar token del estado / sessionStorage
 ```
 
 > En dev, Vite proxea `/api/*` al backend (`localhost:7860`); no hace falta CORS si va por el proxy, pero ya está configurado por si el front llama directo.

backend/package.json

@@ -14,6 +14,7 @@
     "db:migrate": "prisma migrate dev",
     "db:generate": "prisma generate",
     "db:seed": "node prisma/seed.js",
+    "db:reset": "prisma migrate reset --force",
     "db:studio": "prisma studio"
   },
   "dependencies": {

backend/prisma/migrations/20260516071158_init_auth/migration.sql

@@ -3,7 +3,6 @@ CREATE TABLE "User" (
     "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
     "email" TEXT NOT NULL,
     "passwordHash" TEXT NOT NULL,
-    "role" TEXT NOT NULL DEFAULT 'user',
     "isActive" BOOLEAN NOT NULL DEFAULT true,
     "telegramChatId" TEXT,
     "createdAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
@@ -20,6 +19,11 @@ CREATE TABLE "Market" (
     "noPrice" REAL,
     "volumeEur" REAL,
     "liquidityEur" REAL,
+    "spread" REAL,
+    "bestBid" REAL,
+    "bestAsk" REAL,
+    "clobTokenId" TEXT,
+    "analyzable" BOOLEAN NOT NULL DEFAULT true,
     "status" TEXT NOT NULL DEFAULT 'active',
     "closesAt" DATETIME,
     "lastSynced" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
@@ -35,6 +39,9 @@ CREATE TABLE "AISignal" (
     "keyRisk" TEXT,
     "newsCount" INTEGER NOT NULL DEFAULT 0,
     "modelVersion" TEXT NOT NULL DEFAULT 'Qwen3-8B',
+    "impliedProb" REAL,
+    "fairProb" REAL,
+    "edgePoints" REAL,
     "generatedAt" DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
     CONSTRAINT "AISignal_marketId_fkey" FOREIGN KEY ("marketId") REFERENCES "Market" ("id") ON DELETE CASCADE ON UPDATE CASCADE
 );

backend/src/auth/auth.controller.js

@@ -2,17 +2,20 @@
  * Controladores del modulo de autenticacion.
  *
  * Responsabilidades:
- *   - login  → recibir credenciales, delegar validacion a auth.service.js,
- *              responder con { token, user }.
- *   - me     → devolver el usuario autenticado extraido del JWT (req.user).
+ *   - login   → recibir credenciales, delegar validacion a auth.service.js,
+ *               responder con { token, user }.
+ *   - me      → devolver el usuario autenticado extraido del JWT (req.user).
+ *   - logout  → invalidar el token activo (jti + exp extraidos del payload JWT
+ *               ya verificado por requireAuth); responder 200 con mensaje.
  *
  * Errores:
  *   - 401 INVALID_CREDENTIALS → email o password incorrectos (mensaje generico).
- *   - 401 UNAUTHORIZED        → token invalido o ausente (en requireAuth).
+ *   - 401 UNAUTHORIZED        → token invalido, ausente o ya invalidado (en requireAuth).
  */
 
 import * as authService from './auth.service.js';
 import { ok } from '../utils/apiResponse.js';
+import { verifyToken } from './jwt.js';
 
 export const login = async (req, res) => {
   const data = await authService.login(req.body);
@@ -27,3 +30,10 @@ export const register = async (req, res) => {
 export const me = async (req, res) => {
   ok(res, { user: req.user });
 };
+
+export const logout = (req, res) => {
+  const token = req.headers.authorization.slice('Bearer '.length).trim();
+  const payload = verifyToken(token);
+  authService.logout({ jti: payload.jti, exp: payload.exp });
+  ok(res, { message: 'Logged out successfully' });
+};

backend/src/auth/auth.routes.js

@@ -12,6 +12,11 @@
  *     → requireAuth
  *     → authController.me
  *     → Devuelve el usuario autenticado (req.user).
+ *
+ *   POST /api/v1/auth/logout
+ *     → requireAuth (verifica token valido y no bloqueado)
+ *     → authController.logout
+ *     → Invalida el jti del token en la denylist; responde 200.
  */
 
 import { Router } from 'express';
@@ -26,5 +31,6 @@ const router = Router();
 router.post('/login', rateLimitLogin, validate(loginSchema), ctrl.login);
 router.post('/register', validate(registerSchema), ctrl.register);
 router.get('/me', requireAuth, ctrl.me);
+router.post('/logout', requireAuth, ctrl.logout);
 
 export default router;

backend/src/auth/auth.service.js

@@ -2,23 +2,27 @@
  * Logica de negocio del modulo de autenticacion.
  *
  * Responsabilidades:
- *   - login({ email, password }) → buscar usuario, comparar hash con bcrypt,
+ *   - login({ email, password })  → buscar usuario, comparar hash con bcrypt,
  *     verificar que este activo (isActive) y firmar JWT.
+ *   - logout({ jti, exp })        → invalidar el token activo anadiendo su jti
+ *     a la denylist en memoria hasta su expiracion original.
  *
  * Seguridad:
- *   - Mensaje generico en fallo ("Email or password is incorrect")
+ *   - Mensaje generico en fallo de login ("Email or password is incorrect")
  *     para no revelar si el email existe.
  *   - Bcrypt con salt rounds configurable (BCRYPT_ROUNDS, default 10).
  *   - JWT firmado con HS256 y expiracion (JWT_EXPIRES_IN).
+ *   - Logout invalida el jti del token; el cliente debe descartar el token.
  *
  * Devuelve:
- *   { token: string, user: { id, email } }
+ *   login  → { token: string, user: { id, email } }
+ *   logout → void
  */
 
 import bcrypt from 'bcryptjs';
 import { prisma } from '../utils/prisma.js';
 import { HttpError } from '../utils/apiResponse.js';
-import { signToken } from './jwt.js';
+import { signToken, addToDenylist } from './jwt.js';
 
 const INVALID_CREDENTIALS = new HttpError(401, 'INVALID_CREDENTIALS', 'Email or password is incorrect');
 
@@ -55,3 +59,7 @@ export const register = async ({ email, password }) => {
     user: { id: user.id, email: user.email },
   };
 };
+
+export const logout = ({ jti, exp }) => {
+  if (jti && exp) addToDenylist(jti, exp);
+};

backend/src/auth/jwt.js

@@ -2,26 +2,58 @@
  * Helpers para firmar y verificar tokens JWT.
  *
  * Responsabilidades:
- *   - signToken(payload)  → firma un token HS256 con expiracion configurable.
- *   - verifyToken(token)  → verifica firma, expiracion y algoritmo (solo HS256).
+ *   - signToken(payload)        → firma un token HS256 con expiracion configurable.
+ *                                 Incluye claim `jti` (UUID v4) para poder invalidarlo.
+ *   - verifyToken(token)        → verifica firma, expiracion y algoritmo (solo HS256).
+ *   - addToDenylist(jti, exp)   → anota el jti como invalidado hasta su expiracion.
+ *   - isBlocked(jti)            → true si el jti esta en la denylist.
+ *   - pruneExpiredDenylist()    → elimina entradas ya expiradas (llamado en cada logout).
+ *
+ * Denylist:
+ *   - En memoria (Map<jti, expEpochMs>). Sin persistencia entre reinicios.
+ *   - Aceptable porque el TTL del token es 1h; al reiniciar el servidor
+ *     cualquier token antiguo expirara por si solo antes de que importe.
  *
  * Consumido por:
- *   - auth.service.js   → al hacer login exitoso.
- *   - requireAuth.js    → en cada peticion protegida.
+ *   - auth.service.js   → signToken al hacer login; addToDenylist al hacer logout.
+ *   - requireAuth.js    → verifyToken + isBlocked en cada peticion protegida.
  *
  * Configuracion:
  *   - JWT_SECRET    : minimo 32 chars (validado en config.js).
  *   - JWT_EXPIRES_IN: default '1h'.
  */
 
+import { randomUUID } from 'node:crypto';
 import jwt from 'jsonwebtoken';
 import { config } from '../config.js';
 
+/** @type {Map<string, number>} jti → expiry timestamp (ms) */
+const denylist = new Map();
+
 export const signToken = (payload) =>
-  jwt.sign(payload, config.JWT_SECRET, {
+  jwt.sign({ ...payload, jti: randomUUID() }, config.JWT_SECRET, {
     algorithm: 'HS256',
     expiresIn: config.JWT_EXPIRES_IN,
   });
 
 export const verifyToken = (token) =>
   jwt.verify(token, config.JWT_SECRET, { algorithms: ['HS256'] });
+
+export const addToDenylist = (jti, exp) => {
+  pruneExpiredDenylist();
+  denylist.set(jti, exp * 1000);
+};
+
+export const isBlocked = (jti) => {
+  const exp = denylist.get(jti);
+  if (exp === undefined) return false;
+  if (Date.now() > exp) { denylist.delete(jti); return false; }
+  return true;
+};
+
+export const pruneExpiredDenylist = () => {
+  const now = Date.now();
+  for (const [jti, exp] of denylist) {
+    if (now > exp) denylist.delete(jti);
+  }
+};

backend/src/middlewares/requireAuth.js

@@ -4,17 +4,20 @@
  * Responsabilidades:
  *   - Extraer el header Authorization: Bearer <token>.
  *   - Verificar la firma y expiracion del token con jwt.verify().
+ *   - Comprobar que el jti no este en la denylist (logout previo).
  *   - Buscar el usuario en la base de datos y comprobar que esta activo (isActive).
  *   - Adjuntar req.user para que controladores y servicios posteriores lo usen.
  *
  * Rutas protegidas:
  *   - Todas bajo /positions, /watchlist, /alerts.
  *   - GET /auth/me.
+ *   - POST /auth/logout.
  *
- * Si falta token, es invalido o el usuario no existe/inactivo → 401 UNAUTHORIZED.
+ * Si falta token, es invalido, fue invalidado por logout, o el usuario
+ * no existe/inactivo → 401 UNAUTHORIZED.
  */
 
-import { verifyToken } from '../auth/jwt.js';
+import { verifyToken, isBlocked } from '../auth/jwt.js';
 import { prisma } from '../utils/prisma.js';
 import { HttpError } from '../utils/apiResponse.js';
 
@@ -29,6 +32,9 @@ export const requireAuth = async (req, _res, next) => {
     if (!token) throw UNAUTHORIZED;
 
     const payload = verifyToken(token);
+
+    if (payload.jti && isBlocked(payload.jti)) throw UNAUTHORIZED;
+
     const user = await prisma.user.findUnique({
       where: { id: payload.sub },
       select: { id: true, email: true, isActive: true, createdAt: true },

package.json

@@ -16,6 +16,7 @@
     "preview:frontend": "npm run preview --workspace=frontend",
     "db:migrate": "npm run db:migrate --workspace=backend",
     "db:generate": "npm run db:generate --workspace=backend",
+    "db:reset": "npm run db:reset --workspace=backend",
     "db:studio": "npm run db:studio --workspace=backend"
   },
   "engines": {