@jmlq/auth 0.0.1-alpha.1

package/dist/src/infrastructure/jwt/token/tools/jwt-token-validator.d.ts

@@ -0,0 +1,32 @@
+/**
+ *Esta clase es el validador sintáctico del token JWT.
+ *Su función es detectar tokens mal formados o sospechosos antes de intentar decodificarlos.
+ */
+export declare class JwtTokenValidator {
+    /**
+     * Valida que el token JWT tenga un formato básico correcto.
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si el token no cumple con el formato básico JWT
+     */
+    validateTokenInput(token: string): void;
+    /**
+     * Comprueba lo más elemental sobre el formato del token JWT.
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si el token no cumple con los requisitos básicos
+     */
+    private validateBasicFormat;
+    /**
+     * Se asegura de que tenga una estructura básica JWT:
+     * - Mínimo 10 caracteres
+     * - Contener exactamente dos puntos (.) separando header, payload y signature
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si la estructura no es válida
+     */
+    private validateJwtStructure;
+    /**
+     * Verifica que el token solo contenga caracteres válidos Base64URL
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si se encuentran caracteres inválidos
+     */
+    private validateCharacters;
+}

package/dist/src/infrastructure/jwt/token/tools/jwt-token-validator.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JwtTokenValidator = void 0;
+const errors_1 = require("../../../../domain/errors");
+/**
+ *Esta clase es el validador sintáctico del token JWT.
+ *Su función es detectar tokens mal formados o sospechosos antes de intentar decodificarlos.
+ */
+class JwtTokenValidator {
+    /**
+     * Valida que el token JWT tenga un formato básico correcto.
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si el token no cumple con el formato básico JWT
+     */
+    validateTokenInput(token) {
+        this.validateBasicFormat(token);
+        this.validateJwtStructure(token);
+        this.validateCharacters(token);
+    }
+    /**
+     * Comprueba lo más elemental sobre el formato del token JWT.
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si el token no cumple con los requisitos básicos
+     */
+    validateBasicFormat(token) {
+        // Null o undefined
+        if (token == null) {
+            throw new errors_1.InvalidTokenFormatError("Token cannot be null or undefined");
+        }
+        // Tipo de dato
+        if (typeof token !== "string") {
+            throw new errors_1.InvalidTokenFormatError(`Token must be a string, received: ${typeof token}`);
+        }
+        // Cadena vacía o con espacios en blanco
+        if (token.length === 0) {
+            throw new errors_1.InvalidTokenFormatError("Token cannot be empty");
+        }
+        // Solo espacios en blanco o con espacios al inicio/final
+        if (token.trim().length === 0) {
+            throw new errors_1.InvalidTokenFormatError("Token cannot be only whitespace");
+        }
+        // Espacios al inicio o al final
+        if (token !== token.trim()) {
+            throw new errors_1.InvalidTokenFormatError("Token cannot have leading or trailing whitespace");
+        }
+    }
+    /**
+     * Se asegura de que tenga una estructura básica JWT:
+     * - Mínimo 10 caracteres
+     * - Contener exactamente dos puntos (.) separando header, payload y signature
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si la estructura no es válida
+     */
+    validateJwtStructure(token) {
+        // Mínimo viable: debe tener al menos 10 caracteres para ser un JWT válido
+        if (token.length < 10) {
+            throw new errors_1.InvalidTokenFormatError("Token is too short to be a valid JWT");
+        }
+        // Debe contener exactamente dos puntos (.) separando header, payload y signature
+        const dotCount = (token.match(/\./g) || []).length;
+        if (dotCount !== 2) {
+            throw new errors_1.InvalidTokenFormatError(`Invalid JWT format: expected 2 dots, found ${dotCount}`);
+        }
+    }
+    /**
+     * Verifica que el token solo contenga caracteres válidos Base64URL
+     * @param token El token JWT completo como string
+     * @throws InvalidTokenFormatError si se encuentran caracteres inválidos
+     */
+    validateCharacters(token) {
+        const base64UrlPattern = /^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+$/;
+        if (!base64UrlPattern.test(token)) {
+            throw new errors_1.InvalidTokenFormatError("Token contains invalid characters for JWT format");
+        }
+    }
+}
+exports.JwtTokenValidator = JwtTokenValidator;

package/dist/src/infrastructure/repositories/index.d.ts

@@ -0,0 +1 @@
+export * from "./test";

package/dist/src/infrastructure/repositories/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./test"), exports);

package/dist/src/infrastructure/repositories/test/in-memory-credential.repository.d.ts

@@ -0,0 +1,12 @@
+import { Credential, ICredentialRepository, Id } from "../../../domain";
+export declare class InMemoryCredentialRepository implements ICredentialRepository {
+    private credentials;
+    private refreshTokenIndex;
+    save(credential: Credential): Promise<void>;
+    findByUserId(userId: Id): Promise<Credential | null>;
+    findByRefreshToken(refreshToken: string): Promise<Credential | null>;
+    update(credential: Credential): Promise<void>;
+    delete(userId: Id): Promise<void>;
+    deleteByRefreshToken(refreshToken: string): Promise<void>;
+    clear(): void;
+}

package/dist/src/infrastructure/repositories/test/in-memory-credential.repository.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCredentialRepository = void 0;
+// Esta clase es una implementación en memoria del repositorio de credenciales que sigue el patrón Repository de Domain-Driven Design (DDD). Su propósito principal es:
+// Almacenar y gestionar credenciales de usuario en memoria durante la ejecución de la aplicación, principalmente para desarrollo, testing y prototipos.
+class InMemoryCredentialRepository {
+    constructor() {
+        // Almacena las credenciales indexadas por el ID del usuario
+        this.credentials = new Map();
+        // Crea un índice inverso para buscar rápidamente por refresh token
+        this.refreshTokenIndex = new Map();
+    }
+    // Guarda una nueva credencial y actualiza el índice de refresh tokens
+    async save(credential) {
+        const key = credential.userId.getValue();
+        this.credentials.set(key, credential);
+        this.refreshTokenIndex.set(credential.refreshToken, key);
+    }
+    // Busca una credencial por ID de usuario
+    async findByUserId(userId) {
+        return this.credentials.get(userId.getValue()) || null;
+    }
+    // Busca una credencial por su refresh token
+    async findByRefreshToken(refreshToken) {
+        const userId = this.refreshTokenIndex.get(refreshToken);
+        if (!userId)
+            return null;
+        return this.credentials.get(userId) || null;
+    }
+    // Actualiza una credencial existente, limpiando el índice anterior
+    async update(credential) {
+        const key = credential.userId.getValue();
+        if (!this.credentials.has(key)) {
+            throw new Error("Credential not found");
+        }
+        // Limpiar el índice anterior
+        const oldCredential = this.credentials.get(key);
+        if (oldCredential) {
+            this.refreshTokenIndex.delete(oldCredential.refreshToken);
+        }
+        // Actualizar
+        this.credentials.set(key, credential);
+        this.refreshTokenIndex.set(credential.refreshToken, key);
+    }
+    // Elimina una credencial por ID de usuario
+    async delete(userId) {
+        const key = userId.getValue();
+        const credential = this.credentials.get(key);
+        if (credential) {
+            this.refreshTokenIndex.delete(credential.refreshToken);
+        }
+        this.credentials.delete(key);
+    }
+    // Elimina una credencial por su refresh token
+    async deleteByRefreshToken(refreshToken) {
+        const userId = this.refreshTokenIndex.get(refreshToken);
+        if (userId) {
+            this.credentials.delete(userId);
+            this.refreshTokenIndex.delete(refreshToken);
+        }
+    }
+    // Método auxiliar para limpiar todos los datos (útil en tests)
+    clear() {
+        this.credentials.clear();
+        this.refreshTokenIndex.clear();
+    }
+}
+exports.InMemoryCredentialRepository = InMemoryCredentialRepository;

package/dist/src/infrastructure/repositories/test/in-memory-token-session.repository.d.ts

@@ -0,0 +1,67 @@
+import { ITokenSession, Credential, User } from "../../../domain";
+/**
+ * Implementación de ITokenSession pensada como infraestructura sencilla
+ * para el ejemplo. En una app real esto sería un adaptador a Redis, BD, etc.
+ */
+export declare class InMemoryTokenSessionRepository implements ITokenSession {
+    /**
+     * Store principal de sesiones activas indexadas por refreshToken.
+     * Guardamos tanto la Credential como el User para poder cumplir con
+     * validateSession(accessToken): Promise<User | null>.
+     */
+    private readonly sessionsByRefreshToken;
+    /**
+     * Índice auxiliar por accessToken para validaciones rápidas.
+     */
+    private readonly sessionsByAccessToken;
+    /**
+     * TTL del access token en milisegundos.
+     * (En un sistema real vendría de la config de Auth/JWT).
+     */
+    private readonly accessTokenTtlMs;
+    /**
+     * TTL del refresh token en milisegundos.
+     * (Aquí se usa solo de referencia para ejemplo).
+     */
+    private readonly refreshTokenTtlMs;
+    constructor(options?: {
+        accessTokenTtlMs?: number;
+        refreshTokenTtlMs?: number;
+        initialSessions?: {
+            credential: Credential;
+            user: User;
+        }[];
+    });
+    /**
+     * Crea una nueva sesión para el usuario:
+     * - Genera accessToken y refreshToken aleatorios.
+     * - Calcula fecha de expiración del accessToken.
+     * - Crea una Credential y la almacena en memoria.
+     */
+    createSession(user: User): Promise<Credential>;
+    /**
+     * Refresca una sesión a partir del refreshToken:
+     * - Verifica que exista una sesión asociada.
+     * - Genera nuevos tokens y devuelve una nueva Credential.
+     * - Actualiza los índices in-memory.
+     */
+    refreshSession(refreshToken: string): Promise<Credential>;
+    /**
+     * Valida una sesión a partir del accessToken:
+     * - Verifica que exista.
+     * - Revisa si el accessToken está expirado.
+     * - Devuelve el User asociado o null si no es válido.
+     */
+    validateSession(accessToken: string): Promise<User | null>;
+    /**
+     * Revoca una sesión eliminando el refreshToken de la store.
+     * Si no existe, lanza un error genérico que luego el caso de uso
+     * puede envolver en LogoutError.
+     */
+    revokeSession(refreshToken: string): Promise<void>;
+    /**
+     * Helper para generar tokens pseudo-aleatorios.
+     * En producción usarías JWTs firmados, no simples random strings.
+     */
+    private generateToken;
+}

package/dist/src/infrastructure/repositories/test/in-memory-token-session.repository.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryTokenSessionRepository = void 0;
+// src/infrastructure/repositories/in-memory-token-session.repository.ts
+const crypto_1 = require("crypto");
+const domain_1 = require("../../../domain");
+/**
+ * Implementación de ITokenSession pensada como infraestructura sencilla
+ * para el ejemplo. En una app real esto sería un adaptador a Redis, BD, etc.
+ */
+class InMemoryTokenSessionRepository {
+    constructor(options) {
+        /**
+         * Store principal de sesiones activas indexadas por refreshToken.
+         * Guardamos tanto la Credential como el User para poder cumplir con
+         * validateSession(accessToken): Promise<User | null>.
+         */
+        this.sessionsByRefreshToken = new Map();
+        /**
+         * Índice auxiliar por accessToken para validaciones rápidas.
+         */
+        this.sessionsByAccessToken = new Map();
+        this.accessTokenTtlMs = options?.accessTokenTtlMs ?? 15 * 60 * 1000; // 15 minutos
+        this.refreshTokenTtlMs =
+            options?.refreshTokenTtlMs ?? 7 * 24 * 60 * 60 * 1000; // 7 días
+        if (options?.initialSessions) {
+            for (const record of options.initialSessions) {
+                this.sessionsByRefreshToken.set(record.credential.refreshToken, record);
+                this.sessionsByAccessToken.set(record.credential.accessToken, record);
+            }
+        }
+    }
+    /**
+     * Crea una nueva sesión para el usuario:
+     * - Genera accessToken y refreshToken aleatorios.
+     * - Calcula fecha de expiración del accessToken.
+     * - Crea una Credential y la almacena en memoria.
+     */
+    async createSession(user) {
+        const now = new Date();
+        const accessToken = this.generateToken("at");
+        const refreshToken = this.generateToken("rt");
+        const expiresAt = new Date(now.getTime() + this.accessTokenTtlMs);
+        const credential = new domain_1.Credential({
+            userId: user.id, // ajusta si tu VO de Id se instancia diferente
+            accessToken,
+            refreshToken,
+            expiresAt,
+            createdAt: now,
+        });
+        const record = { credential, user };
+        this.sessionsByRefreshToken.set(refreshToken, record);
+        this.sessionsByAccessToken.set(accessToken, record);
+        return credential;
+    }
+    /**
+     * Refresca una sesión a partir del refreshToken:
+     * - Verifica que exista una sesión asociada.
+     * - Genera nuevos tokens y devuelve una nueva Credential.
+     * - Actualiza los índices in-memory.
+     */
+    async refreshSession(refreshToken) {
+        const record = this.sessionsByRefreshToken.get(refreshToken);
+        if (!record) {
+            throw new Error("Refresh token not found");
+        }
+        // Eliminamos la sesión anterior
+        this.sessionsByRefreshToken.delete(record.credential.refreshToken);
+        this.sessionsByAccessToken.delete(record.credential.accessToken);
+        // Creamos una nueva sesión para el mismo usuario
+        const now = new Date();
+        const newAccessToken = this.generateToken("at");
+        const newRefreshToken = this.generateToken("rt");
+        const newExpiresAt = new Date(now.getTime() + this.accessTokenTtlMs);
+        const newCredential = new domain_1.Credential({
+            userId: record.user.id,
+            accessToken: newAccessToken,
+            refreshToken: newRefreshToken,
+            expiresAt: newExpiresAt,
+            createdAt: now,
+        });
+        const newRecord = { credential: newCredential, user: record.user };
+        this.sessionsByRefreshToken.set(newRefreshToken, newRecord);
+        this.sessionsByAccessToken.set(newAccessToken, newRecord);
+        return newCredential;
+    }
+    /**
+     * Valida una sesión a partir del accessToken:
+     * - Verifica que exista.
+     * - Revisa si el accessToken está expirado.
+     * - Devuelve el User asociado o null si no es válido.
+     */
+    async validateSession(accessToken) {
+        const record = this.sessionsByAccessToken.get(accessToken);
+        if (!record) {
+            return null;
+        }
+        const now = Date.now();
+        if (record.credential.expiresAt.getTime() <= now) {
+            // Limpieza agresiva de sesión expirada
+            this.sessionsByAccessToken.delete(record.credential.accessToken);
+            this.sessionsByRefreshToken.delete(record.credential.refreshToken);
+            return null;
+        }
+        return record.user;
+    }
+    /**
+     * Revoca una sesión eliminando el refreshToken de la store.
+     * Si no existe, lanza un error genérico que luego el caso de uso
+     * puede envolver en LogoutError.
+     */
+    async revokeSession(refreshToken) {
+        const record = this.sessionsByRefreshToken.get(refreshToken);
+        if (!record) {
+            throw new Error("Refresh token not found or already revoked");
+        }
+        this.sessionsByRefreshToken.delete(refreshToken);
+        this.sessionsByAccessToken.delete(record.credential.accessToken);
+    }
+    /**
+     * Helper para generar tokens pseudo-aleatorios.
+     * En producción usarías JWTs firmados, no simples random strings.
+     */
+    generateToken(prefix) {
+        return `${prefix}.${(0, crypto_1.randomBytes)(24).toString("hex")}`;
+    }
+}
+exports.InMemoryTokenSessionRepository = InMemoryTokenSessionRepository;

package/dist/src/infrastructure/repositories/test/in-memory-user.repository.d.ts

@@ -0,0 +1,11 @@
+import { Email, Id, IUserRepository, User } from "../../../domain";
+export declare class InMemoryUserRepository implements IUserRepository {
+    private users;
+    save(user: User): Promise<void>;
+    findById(id: Id): Promise<User | null>;
+    findByEmail(email: Email): Promise<User | null>;
+    update(user: User): Promise<void>;
+    delete(id: Id): Promise<void>;
+    exists(email: Email): Promise<boolean>;
+    clear(): void;
+}

package/dist/src/infrastructure/repositories/test/in-memory-user.repository.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryUserRepository = void 0;
+// Esta clase es una implementación en memoria del repositorio de usuarios que gestiona la persistencia de entidades User durante la ejecución de la aplicación.
+// Función principal: Almacenar y gestionar usuarios en memoria, proporcionando operaciones CRUD completas para la entidad User.
+class InMemoryUserRepository {
+    constructor() {
+        // almacena los usuarios indexados por su ID único
+        this.users = new Map();
+    }
+    // Guarda un nuevo usuario en el repositorio
+    async save(user) {
+        this.users.set(user.id.getValue(), user);
+    }
+    // Busca un usuario por su ID único
+    async findById(id) {
+        return this.users.get(id.getValue()) || null;
+    }
+    // Busca un usuario por su dirección de email
+    async findByEmail(email) {
+        for (const user of this.users.values()) {
+            if (user.email.equals(email)) {
+                return user;
+            }
+        }
+        return null;
+    }
+    // Actualiza un usuario existente
+    async update(user) {
+        if (!this.users.has(user.id.getValue())) {
+            throw new Error("User not found");
+        }
+        this.users.set(user.id.getValue(), user);
+    }
+    // Elimina un usuario por su ID
+    async delete(id) {
+        this.users.delete(id.getValue());
+    }
+    // Verifica si existe un usuario con el email dado
+    async exists(email) {
+        const user = await this.findByEmail(email);
+        return user !== null;
+    }
+    // Método auxiliar para limpiar todos los datos
+    clear() {
+        this.users.clear();
+    }
+}
+exports.InMemoryUserRepository = InMemoryUserRepository;

package/dist/src/infrastructure/repositories/test/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./in-memory-credential.repository";
+export * from "./in-memory-user.repository";

package/dist/src/infrastructure/repositories/test/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./in-memory-credential.repository"), exports);
+__exportStar(require("./in-memory-user.repository"), exports);

package/dist/src/infrastructure/security/bcrypt-password-hasher.d.ts

@@ -0,0 +1,6 @@
+import { IPasswordHasher } from "../../domain/ports";
+export declare class BcryptPasswordHasher implements IPasswordHasher {
+    private readonly saltRounds;
+    hash(password: string): Promise<string>;
+    compare(plainPassword: string, hashedPassword: string): Promise<boolean>;
+}

package/dist/src/infrastructure/security/bcrypt-password-hasher.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BcryptPasswordHasher = void 0;
+const bcryptjs_1 = __importDefault(require("bcryptjs"));
+class BcryptPasswordHasher {
+    constructor() {
+        this.saltRounds = 10;
+    }
+    async hash(password) {
+        return bcryptjs_1.default.hash(password, this.saltRounds);
+    }
+    async compare(plainPassword, hashedPassword) {
+        return bcryptjs_1.default.compare(plainPassword, hashedPassword);
+    }
+}
+exports.BcryptPasswordHasher = BcryptPasswordHasher;

package/dist/src/infrastructure/security/index.d.ts

@@ -0,0 +1 @@
+export * from "./bcrypt-password-hasher";

package/dist/src/infrastructure/security/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bcrypt-password-hasher"), exports);

package/dist/src/infrastructure/services/default-token-session.service.d.ts

@@ -0,0 +1,18 @@
+import { Credential, ICredentialRepository, ITokenService, ITokenSession, IUserRepository, User } from "../../domain";
+export declare class DefaultTokenSessionService implements ITokenSession {
+    private readonly tokenService;
+    private readonly userRepository;
+    private readonly credentialRepository;
+    private readonly accessTokenExpiration;
+    private readonly refreshTokenExpiration;
+    private readonly accessTokenSecret?;
+    private readonly refreshTokenSecret?;
+    private readonly accessMs;
+    private readonly refreshMs;
+    constructor(tokenService: ITokenService, userRepository: IUserRepository, credentialRepository: ICredentialRepository, accessTokenExpiration?: string, refreshTokenExpiration?: string, accessTokenSecret?: string | undefined, refreshTokenSecret?: string | undefined);
+    private buildJwtConfig;
+    createSession(user: User): Promise<Credential>;
+    refreshSession(refreshToken: string): Promise<Credential>;
+    validateSession(accessToken: string): Promise<User | null>;
+    revokeSession(refreshToken: string): Promise<void>;
+}

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

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultTokenSessionService = void 0;
+const domain_1 = require("../../domain");
+const shared_1 = require("../../shared");
+class DefaultTokenSessionService {
+    constructor(tokenService, userRepository, credentialRepository, accessTokenExpiration = "15m", refreshTokenExpiration = "7d", accessTokenSecret, refreshTokenSecret) {
+        this.tokenService = tokenService;
+        this.userRepository = userRepository;
+        this.credentialRepository = credentialRepository;
+        this.accessTokenExpiration = accessTokenExpiration;
+        this.refreshTokenExpiration = refreshTokenExpiration;
+        this.accessTokenSecret = accessTokenSecret;
+        this.refreshTokenSecret = refreshTokenSecret;
+        try {
+            this.accessMs = shared_1.TimeParser.parseToMilliseconds(accessTokenExpiration);
+            this.refreshMs = shared_1.TimeParser.parseToMilliseconds(refreshTokenExpiration);
+        }
+        catch (error) {
+            throw new Error(`Invalid token expiration configuration: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    buildJwtConfig() {
+        return {
+            accessTokenExpirationMs: this.accessMs,
+            refreshTokenExpirationMs: this.refreshMs,
+            accessTokenSecret: this.accessTokenSecret,
+            refreshTokenSecret: this.refreshTokenSecret,
+        };
+    }
+    async createSession(user) {
+        const config = this.buildJwtConfig();
+        const accessToken = await this.tokenService.generateAccessToken({
+            user: {
+                id: user.id.toString(),
+                email: user.email.toString(),
+                roles: user.roles.map((role) => role.getValuePublic()),
+            },
+            expiresIn: this.accessTokenExpiration,
+            config,
+        });
+        const refreshToken = await this.tokenService.generateRefreshToken({
+            user: {
+                id: user.id.toString(),
+                email: user.email.toString(),
+                roles: user.roles.map((role) => role.getValuePublic()),
+            },
+            expiresIn: this.refreshTokenExpiration,
+            config,
+        });
+        const credential = domain_1.Credential.create(user.id, accessToken, refreshToken, new Date(Date.now() + this.accessMs));
+        await this.credentialRepository.save(credential);
+        return credential;
+    }
+    async refreshSession(refreshToken) {
+        const existing = await this.credentialRepository.findByRefreshToken(refreshToken);
+        if (!existing) {
+            throw new domain_1.InvalidOrExpiredRefreshTokenError();
+        }
+        const payload = await this.tokenService
+            .verifyRefreshToken(refreshToken)
+            .catch(() => {
+            throw new domain_1.InvalidOrExpiredRefreshTokenError();
+        });
+        const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
+        if (!user)
+            throw new domain_1.UserNotFoundError();
+        if (!user.canLogin())
+            throw new domain_1.UserDisabledError();
+        const newCredential = await this.createSession(user);
+        await this.credentialRepository.deleteByRefreshToken(refreshToken); // rotación
+        return newCredential;
+    }
+    async validateSession(accessToken) {
+        try {
+            const payload = await this.tokenService.verifyAccessToken(accessToken);
+            const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
+            return user && user.canLogin() ? user : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async revokeSession(refreshToken) {
+        await this.credentialRepository.deleteByRefreshToken(refreshToken);
+    }
+}
+exports.DefaultTokenSessionService = DefaultTokenSessionService;

package/dist/src/infrastructure/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./token-session.service";
+export * from "./jwt-token.service";