@jmlq/auth 0.0.1-alpha.15 → 0.0.1-alpha.18

package/dist/application/dtos/response/login.response.d.ts

@@ -1,5 +1,5 @@
 export interface LoginResponse {
     sessionId: string;
     accessToken: string;
-    refreshToken: string;
+    refreshToken?: string;
 }

package/dist/application/use-cases/refresh-token.use-case.js

@@ -10,13 +10,21 @@ class RefreshTokenUseCase {
         try {
             // Refrescar la sesión
             const credential = await this.tokenSession.refreshSession(request.refreshToken);
+            // Rotación obligatoria: si no hay refreshToken nuevo, el refresh falló.
+            const newRefreshToken = credential.refreshToken;
+            if (!newRefreshToken || !newRefreshToken.trim()) {
+                // Mensaje genérico por seguridad
+                throw new errors_1.TokenExpiredError();
+            }
             return {
                 sessionId: credential.sessionId.getValue(),
                 accessToken: credential.accessToken,
-                refreshToken: credential.refreshToken,
+                refreshToken: newRefreshToken,
             };
         }
         catch (error) {
+            // Si quieres, aquí puedes mapear SOLO expiración e invalid-token a TokenExpiredError
+            // y relanzar el resto. Mantengo tu comportamiento actual para no cambiar semántica.
             throw new errors_1.TokenExpiredError();
         }
     }

package/dist/domain/entities/credential.entity.d.ts

@@ -19,7 +19,7 @@ export declare class Credential {
     /**
      * Token de refresco asociado
      */
-    private readonly _refreshToken;
+    private readonly _refreshToken?;
     /**
      * Fecha de expiración del token de acceso
      */
@@ -48,7 +48,7 @@ export declare class Credential {
     /**
      * Obtiene el token de refresco
      */
-    get refreshToken(): string;
+    get refreshToken(): string | undefined;
     /**
      * Obtiene la fecha de expiración del token de acceso
      */
@@ -73,9 +73,31 @@ export declare class Credential {
     static create(sessionId: Id, userId: Id, accessToken: string, refreshToken: string, expirationDate: Date): Credential;
     /**
      *Reconstitution method for repository
-     *Método usado por un repositorio para reconstruir la entidad desde la base de datos
-     * @param props Propiedades de las credenciales
-     * @returns Nueva instancia de Credential
+     *refreshToken puede venir undefined si en DB solo existe hash.
      */
     static reconstitute(props: ICredentialProps): Credential;
+    /**
+     * Crea una nueva credencial como resultado de una rotación de refresh token.
+     * Impone que refreshToken exista (rotación obligatoria).
+     */
+    static rotate(props: {
+        sessionId: Id;
+        userId: Id;
+        accessToken: string;
+        refreshToken: string;
+        expiresAt: Date;
+        createdAt?: Date;
+    }): Credential;
+    /**
+     * Devuelve el refresh token o lanza si no existe.
+     *
+     * Uso:
+     * - Flujos donde el refresh token es OBLIGATORIO
+     *   (login, refresh/rotación).
+     *
+     * Seguridad:
+     * - Evita usar `!` o cast inseguros.
+     * - Hace explícito el invariante del dominio.
+     */
+    requireRefreshToken(): string;
 }

package/dist/domain/entities/credential.entity.js

@@ -83,12 +83,41 @@ class Credential {
     }
     /**
      *Reconstitution method for repository
-     *Método usado por un repositorio para reconstruir la entidad desde la base de datos
-     * @param props Propiedades de las credenciales
-     * @returns Nueva instancia de Credential
+     *refreshToken puede venir undefined si en DB solo existe hash.
      */
     static reconstitute(props) {
         return new Credential(props);
     }
+    /**
+     * Crea una nueva credencial como resultado de una rotación de refresh token.
+     * Impone que refreshToken exista (rotación obligatoria).
+     */
+    static rotate(props) {
+        return new Credential({
+            sessionId: props.sessionId,
+            userId: props.userId,
+            accessToken: props.accessToken,
+            refreshToken: props.refreshToken,
+            expiresAt: props.expiresAt,
+            createdAt: props.createdAt ?? new Date(),
+        });
+    }
+    /**
+     * Devuelve el refresh token o lanza si no existe.
+     *
+     * Uso:
+     * - Flujos donde el refresh token es OBLIGATORIO
+     *   (login, refresh/rotación).
+     *
+     * Seguridad:
+     * - Evita usar `!` o cast inseguros.
+     * - Hace explícito el invariante del dominio.
+     */
+    requireRefreshToken() {
+        if (!this._refreshToken) {
+            throw new Error("Invariant violation: refreshToken is required but missing");
+        }
+        return this._refreshToken;
+    }
 }
 exports.Credential = Credential;

package/dist/domain/ports/repository/credential.repository.d.ts

@@ -45,4 +45,19 @@ export interface ICredentialRepositoryPort {
      * Elimina una sesión por refresh token (logout basado en refresh).
      */
     deleteByRefreshToken(refreshToken: string): Promise<void>;
+    /**
+     * Rotación atómica de refresh token (single-use).
+     *
+     * Debe:
+     * - “consumir” el refreshToken actual (el entrante) de forma atómica,
+     * - y persistir la credencial nueva para la MISMA sessionId.
+     *
+     * Retorna true si la rotación ocurrió (1 fila afectada),
+     * false si el refresh token ya fue usado / revocado / no existe.
+     *
+     * Nota:
+     * - El core NO sabe de hashes.
+     * - La implementación infra puede usar refreshTokenHash internamente.
+     */
+    rotateByRefreshToken(currentRefreshToken: string, nextCredential: Credential): Promise<boolean>;
 }

package/dist/domain/props/entities/credential.props.d.ts

@@ -3,7 +3,14 @@ export interface ICredentialProps {
     sessionId: Id;
     userId: Id;
     accessToken: string;
-    refreshToken: string;
+    /**
+     * Token de refresco (secreto).
+     * Nota de seguridad:
+     * - En persistencia NO debe guardarse en claro.
+     * - En reconstitución desde DB puede ser undefined (solo existe el hash).
+     * - En flujos que emiten tokens (login/refresh) debe existir.
+     */
+    refreshToken?: string;
     expiresAt: Date;
     createdAt: Date;
 }

package/dist/in-memory/in-memory-credential.repository.d.ts

@@ -5,6 +5,7 @@ import { Credential, ICredentialRepositoryPort, Id } from "../domain";
  * Soporta múltiples sesiones por usuario (multi-dispositivo) usando `sessionId`.
  */
 export declare class InMemoryCredentialRepository implements ICredentialRepositoryPort {
+    rotateByRefreshToken(currentRefreshToken: string, nextCredential: Credential): Promise<boolean>;
     /**
      * Fuente de verdad: credenciales indexadas por sessionId.
      */

package/dist/in-memory/in-memory-credential.repository.js

@@ -21,6 +21,9 @@ class InMemoryCredentialRepository {
          */
         this.refreshTokenIndex = new Map();
     }
+    rotateByRefreshToken(currentRefreshToken, nextCredential) {
+        throw new Error("Method not implemented.");
+    }
     /**
      * Guarda (upsert) una credencial por (userId, sessionId).
      * - Si existía una credencial para ese sessionId, limpia el índice de refreshToken viejo.
@@ -31,13 +34,14 @@ class InMemoryCredentialRepository {
         const userKey = credential.userId.getValue();
         // Si existía una credencial para esa sesión, limpiar refresh index anterior
         const old = this.credentialsBySessionId.get(sessionKey);
-        if (old) {
+        if (old?.refreshToken) {
             this.refreshTokenIndex.delete(old.refreshToken);
         }
         // Guardar credencial por sesión
         this.credentialsBySessionId.set(sessionKey, credential);
         // Indexar refresh -> session
-        this.refreshTokenIndex.set(credential.refreshToken, sessionKey);
+        if (credential.refreshToken)
+            this.refreshTokenIndex.set(credential.refreshToken, sessionKey);
         // Indexar user -> sessions
         const sessions = this.sessionsByUserId.get(userKey) ?? new Set();
         sessions.add(sessionKey);
@@ -97,7 +101,7 @@ class InMemoryCredentialRepository {
             return;
         for (const sid of sessionIds) {
             const c = this.credentialsBySessionId.get(sid);
-            if (c) {
+            if (c?.refreshToken) {
                 this.refreshTokenIndex.delete(c.refreshToken);
             }
             this.credentialsBySessionId.delete(sid);
@@ -113,7 +117,8 @@ class InMemoryCredentialRepository {
         if (!c)
             return;
         // limpiar refresh index
-        this.refreshTokenIndex.delete(c.refreshToken);
+        if (c.refreshToken)
+            this.refreshTokenIndex.delete(c.refreshToken);
         // limpiar relación user -> sessions
         const userKey = c.userId.getValue();
         const sessions = this.sessionsByUserId.get(userKey);

package/dist/infrastructure/services/token-session.service.js

@@ -1,4 +1,5 @@
 "use strict";
+// src/infrastructure/services/token-session.service.ts
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TokenSessionService = void 0;
 const domain_1 = require("../../domain");
@@ -292,20 +293,15 @@ class TokenSessionService {
         const { accessToken, refreshToken: newRefreshToken, expiresAt, } = await this.issueTokens(user, sessionId);
         const rotated = domain_1.Credential.create(sessionId, user.id, accessToken, newRefreshToken, expiresAt);
         /**
-         * Estrategia simple (sin sobreingeniería):
-         * - Borrar por sessionId
-         * - Guardar credencial rotada
-         *
-         * Ventaja:
-         * - Funciona aunque no exista update/UPSERT
-         * - Mantiene invariantes del repo simples
-         *
-         * Consideración:
-         * - Si tu storage soporta transacciones, esto puede envolver en una transacción
-         *   para evitar “ventana” de inconsistencia en sistemas altamente concurrentes.
+         * Rotación atómica (single-use):
+         * - Si otro request ya consumió este refreshToken, esta operación debe fallar.
+         * - Evita que el mismo refreshToken se use dos veces bajo concurrencia.
          */
-        await this.credentialRepository.deleteBySessionId(sessionId);
-        await this.credentialRepository.save(rotated);
+        const rotatedOk = await this.credentialRepository.rotateByRefreshToken(refreshToken, rotated);
+        if (!rotatedOk) {
+            // Token ya consumido/revocado/no existe (no filtramos detalle)
+            throw new domain_1.TokenExpiredError();
+        }
         return rotated;
     }
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jmlq/auth",
   "description": "JWT authentication package with clean architecture",
-  "version": "0.0.1-alpha.15",
+  "version": "0.0.1-alpha.18",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {