@jmlq/auth 0.0.1-alpha.1 → 0.0.1-alpha.3

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

@@ -1,131 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TokenSessionService = void 0;
-const domain_1 = require("../../domain");
-const shared_1 = require("../../shared");
-/**
- * Servicio de gestión de sesiones de usuario mediante tokens JWT.
- * Proporciona métodos para crear, refrescar, validar y revocar sesiones.
- */
-class TokenSessionService {
-    constructor(
-    // Servicio de tokens JWT
-    tokenService, 
-    // Repositorio de usuarios
-    userRepository, 
-    // Repositorio de credenciales
-    credentialRepository, 
-    // Algoritmo JWT a usar
-    algorithm, 
-    // Configuración de expiraciones y secretos
-    accessTokenExpiration = "15m", refreshTokenExpiration = "7d", accessTokenSecret, refreshTokenSecret) {
-        this.tokenService = tokenService;
-        this.userRepository = userRepository;
-        this.credentialRepository = credentialRepository;
-        this.algorithm = algorithm;
-        this.accessTokenExpiration = accessTokenExpiration;
-        this.refreshTokenExpiration = refreshTokenExpiration;
-        this.accessTokenSecret = accessTokenSecret;
-        this.refreshTokenSecret = refreshTokenSecret;
-        // Validar que los secretos estén presentes
-        if (!accessTokenSecret || !refreshTokenSecret)
-            throw new domain_1.JwtSecretError("Missing JWT secrets");
-        // Parsear las expiraciones a milisegundos
-        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"}`);
-        }
-    }
-    // Construir configuración JWT para generación de tokens
-    buildJwtConfig() {
-        return {
-            accessTokenExpirationMs: this.accessMs,
-            refreshTokenExpirationMs: this.refreshMs,
-            accessTokenSecret: this.accessTokenSecret,
-            refreshTokenSecret: this.refreshTokenSecret,
-            algorithm: this.algorithm,
-        };
-    }
-    // Crear una nueva sesión de usuario
-    async createSession(user) {
-        const config = this.buildJwtConfig();
-        // Generar tokens
-        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,
-        });
-        // Generar refresh token
-        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,
-        });
-        // Crear y guardar la credencial
-        const credential = domain_1.Credential.create(user.id, accessToken, refreshToken, new Date(Date.now() + this.accessMs));
-        // Guardar la credencial en el repositorio
-        await this.credentialRepository.save(credential);
-        // Retornar la credencial creada
-        return credential;
-    }
-    // Refrescar una sesión existente usando el refresh token
-    async refreshSession(refreshToken) {
-        // Verificar si la credencial con el refresh token existe
-        const existing = await this.credentialRepository.findByRefreshToken(refreshToken);
-        // Si no existe, lanzar error
-        if (!existing) {
-            throw new domain_1.InvalidOrExpiredRefreshTokenError();
-        }
-        // Verificar y obtener el payload del refresh token
-        const payload = await this.tokenService
-            .verifyRefreshToken(refreshToken)
-            .catch(() => {
-            throw new domain_1.InvalidOrExpiredRefreshTokenError();
-        });
-        // Obtener el usuario asociado al payload
-        const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
-        // Validar que el usuario exista y pueda iniciar sesión
-        if (!user)
-            throw new domain_1.UserNotFoundError();
-        // Validar que el usuario no esté deshabilitado
-        if (!user.canLogin())
-            throw new domain_1.UserDisabledError();
-        // Crear una nueva sesión para el usuario
-        const newCredential = await this.createSession(user);
-        // Eliminar la credencial antigua asociada al refresh token
-        await this.credentialRepository.deleteByRefreshToken(refreshToken); // rotación
-        // Retornar la nueva credencial
-        return newCredential;
-    }
-    // Validar una sesión usando el access token
-    async validateSession(accessToken) {
-        try {
-            // Verificar y obtener el payload del access token
-            const payload = await this.tokenService.verifyAccessToken(accessToken);
-            // Obtener el usuario asociado al payload
-            const user = await this.userRepository.findById(new domain_1.Id(payload.sub));
-            // Retornar el usuario si existe y puede iniciar sesión, sino retornar null
-            return user && user.canLogin() ? user : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    // Revocar una sesión usando el refresh token
-    async revokeSession(refreshToken) {
-        // Eliminar la credencial asociada al refresh token
-        await this.credentialRepository.deleteByRefreshToken(refreshToken);
-    }
-}
-exports.TokenSessionService = TokenSessionService;

package/dist/src/infrastructure/types/auth-service-container.d.ts

@@ -1,14 +0,0 @@
-import { LoginWithPasswordUseCase, LogoutUseCase, RefreshTokenUseCase, RegisterUserUseCase } from "../../application";
-import { ICredentialRepository, IPasswordHasher, IPasswordPolicy, ITokenService, ITokenSession, IUserRepository } from "../../domain";
-export interface IAuthServiceContainer {
-    userRepository: IUserRepository;
-    credentialRepository: ICredentialRepository;
-    passwordHasher: IPasswordHasher;
-    tokenService: ITokenService;
-    passwordPolicy: IPasswordPolicy;
-    tokenSession: ITokenSession;
-    registerUserUseCase: RegisterUserUseCase;
-    loginWithPasswordUseCase: LoginWithPasswordUseCase;
-    refreshTokenUseCase: RefreshTokenUseCase;
-    logoutUseCase: LogoutUseCase;
-}

package/dist/src/shared/constants/index.d.ts

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

package/dist/src/shared/constants/jwt-algorithms.d.ts

@@ -1,17 +0,0 @@
-export declare const algorithms: {
-    readonly hmac: {
-        readonly HS256: "HS256";
-        readonly HS384: "HS384";
-        readonly HS512: "HS512";
-    };
-    readonly rsa: {
-        readonly RS256: "RS256";
-        readonly RS384: "RS384";
-        readonly RS512: "RS512";
-    };
-    readonly ecdsa: {
-        readonly ES256: "ES256";
-        readonly ES384: "ES384";
-        readonly ES512: "ES512";
-    };
-};

package/dist/src/shared/constants/jwt-algorithms.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.algorithms = void 0;
-exports.algorithms = {
-    // simétrica (una sola clave)
-    hmac: {
-        HS256: "HS256",
-        HS384: "HS384",
-        HS512: "HS512",
-    },
-    // asimétrica (clave pública/privada)
-    rsa: {
-        RS256: "RS256",
-        RS384: "RS384",
-        RS512: "RS512",
-    },
-    // curvas elípticas
-    ecdsa: {
-        ES256: "ES256",
-        ES384: "ES384",
-        ES512: "ES512",
-    },
-};

package/dist/src/shared/encoders/base64-url-encoder.d.ts

@@ -1,29 +0,0 @@
-/**
- *Esta clase implementa la codificación y decodificación Base64 URL-safe,
- *que es una variante del estándar Base64 diseñada para ser segura en URLs.
- */
-export declare class Base64UrlEncoder {
-    /**
-     * Convierte una cadena de texto a formato Base64 URL-safe
-     * @param str La cadena a codificar
-     * @returns La cadena codificada en Base64 URL-safe
-     */
-    encode(str: string): string;
-    /**
-     * Convierte de Base64 URL-safe de vuelta a texto original
-     * @param str La cadena codificada en Base64 URL-safe
-     * @returns La cadena decodificada
-     */
-    decode(str: string): string;
-}
-/**
- * El Base64 estándar usa caracteres (+, /, =) que tienen significado especial en URLs.
- * Base64 URL-safe los reemplaza para evitar problemas cuando se usan en:
- *
- * - Parámetros de URL
- * - Tokens JWT (muy común)
- * - Headers HTTP
- * - Rutas de API
- *
- * Esta implementación es típicamente usada para codificar/decodificar las partes de un JWT (header y payload) de forma segura para transmisión web.
- */

package/dist/src/shared/encoders/base64-url-encoder.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Base64UrlEncoder = void 0;
-/**
- *Esta clase implementa la codificación y decodificación Base64 URL-safe,
- *que es una variante del estándar Base64 diseñada para ser segura en URLs.
- */
-class Base64UrlEncoder {
-    /**
-     * Convierte una cadena de texto a formato Base64 URL-safe
-     * @param str La cadena a codificar
-     * @returns La cadena codificada en Base64 URL-safe
-     */
-    encode(str) {
-        return Buffer.from(str)
-            .toString("base64")
-            .replace(/\+/g, "-")
-            .replace(/\//g, "_")
-            .replace(/=/g, "");
-    }
-    /**
-     * Convierte de Base64 URL-safe de vuelta a texto original
-     * @param str La cadena codificada en Base64 URL-safe
-     * @returns La cadena decodificada
-     */
-    decode(str) {
-        const padding = 4 - (str.length % 4);
-        if (padding !== 4) {
-            str += "=".repeat(padding);
-        }
-        return Buffer.from(str.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString();
-    }
-}
-exports.Base64UrlEncoder = Base64UrlEncoder;
-/**
- * El Base64 estándar usa caracteres (+, /, =) que tienen significado especial en URLs.
- * Base64 URL-safe los reemplaza para evitar problemas cuando se usan en:
- *
- * - Parámetros de URL
- * - Tokens JWT (muy común)
- * - Headers HTTP
- * - Rutas de API
- *
- * Esta implementación es típicamente usada para codificar/decodificar las partes de un JWT (header y payload) de forma segura para transmisión web.
- */

package/dist/src/shared/encoders/index.d.ts

@@ -1 +0,0 @@
-export * from "./base64-url-encoder";

package/dist/src/shared/encoders/index.js

@@ -1,17 +0,0 @@
-"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("./base64-url-encoder"), exports);

package/dist/src/shared/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./utils";
-export * from "./encoders";
-export * from "./constants";
-export * from "./types";

package/dist/src/shared/index.js

@@ -1,20 +0,0 @@
-"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("./utils"), exports);
-__exportStar(require("./encoders"), exports);
-__exportStar(require("./constants"), exports);
-__exportStar(require("./types"), exports);

package/dist/src/shared/types/index.d.ts

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

package/dist/src/shared/types/jwt.d.ts

@@ -1,25 +0,0 @@
-import { algorithms } from "../constants";
-/**
- * Tipos de algoritmos JWT soportados.
- */
-export type AlgorithmCategory = keyof typeof algorithms;
-/**
- * Nombres de todos los algoritmos soportados.
- */
-export type AlgorithmName = (typeof algorithms.hmac)[keyof typeof algorithms.hmac] | (typeof algorithms.rsa)[keyof typeof algorithms.rsa] | (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type HmacAlgorithm = (typeof algorithms.hmac)[keyof typeof algorithms.hmac];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type RsaAlgorithm = (typeof algorithms.rsa)[keyof typeof algorithms.rsa];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type EcdsaAlgorithm = (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
-/**
- * Tipo que agrupa todos los algoritmos posibles.
- */
-export type AnyAlgorithm = HmacAlgorithm | RsaAlgorithm | EcdsaAlgorithm;

package/dist/src/shared/types/jwt.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/shared/types/jwt.types.d.ts

@@ -1,39 +0,0 @@
-import { IAuthConfig } from "../../domain/ports";
-import { algorithms } from "../constants";
-/**
- * Tipos de algoritmos JWT soportados.
- */
-export type AlgorithmCategory = keyof typeof algorithms;
-/**
- * Nombres de todos los algoritmos soportados.
- */
-export type AlgorithmName = (typeof algorithms.hmac)[keyof typeof algorithms.hmac] | (typeof algorithms.rsa)[keyof typeof algorithms.rsa] | (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type HmacAlgorithm = (typeof algorithms.hmac)[keyof typeof algorithms.hmac];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type RsaAlgorithm = (typeof algorithms.rsa)[keyof typeof algorithms.rsa];
-/**
- * Tipos específicos de algoritmos por categoría.
- */
-export type EcdsaAlgorithm = (typeof algorithms.ecdsa)[keyof typeof algorithms.ecdsa];
-/**
- * Tipo que agrupa todos los algoritmos posibles.
- */
-export type AnyAlgorithm = HmacAlgorithm | RsaAlgorithm | EcdsaAlgorithm;
-/**
- * Configuración necesaria para los servicios de tokens JWT.
- * Esto lo usan clases como JwtTokenGenerator o JwtTokenVerifier paara saber cómo firmar y con qué tipo de clave.
- * Incluye opciones de JWT e información adicional.
- * @param algorithm Algoritmo de firma (opcional).
- * @param privateKey Clave privada para algoritmos RSA/ECDSA (opcional).
- * @param publicKey Clave pública para algoritmos RSA/ECDSA (opcional).
- */
-export type JwtTokenServiceConfig = IAuthConfig["jwt"] & IAuthConfig["info"] & {
-    algorithm: AnyAlgorithm;
-    privateKey?: string;
-    publicKey?: string;
-};

package/dist/src/shared/types/jwt.types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/tests/application/factory/auth-service-factory.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/application/factory/auth-service-factory.spec.js

@@ -1,97 +0,0 @@
-"use strict";
-// tests/application/factory/auth-service-factory.spec.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("../../../src/domain");
-const infrastructure_1 = require("../../../src/infrastructure");
-const use_cases_1 = require("../../../src/application/use-cases");
-const application_1 = require("src/application");
-describe("AuthServiceFactory", () => {
-    let config;
-    let userRepository;
-    let credentialRepository;
-    // const algorithm: AnyAlgorithm = "HS256";
-    beforeEach(() => {
-        config = {
-            jwt: {
-                accessTokenSecret: "access-secret",
-                refreshTokenSecret: "refresh-secret",
-                accessTokenExpirationMs: 15 * 60 * 1000,
-                refreshTokenExpirationMs: 7 * 24 * 60 * 60 * 1000,
-                accessTokenExpiration: "15m",
-                refreshTokenExpiration: "7d",
-            },
-            info: {
-                issuer: "test-issuer",
-                audience: "test-audience",
-            },
-            bcrypt: {
-                saltRounds: 10,
-            },
-            algorithm: "HS256",
-        };
-        userRepository = new infrastructure_1.InMemoryUserRepository();
-        credentialRepository = new infrastructure_1.InMemoryCredentialRepository();
-    });
-    it("debería crear un contenedor con todas las dependencias correctamente instanciadas", () => {
-        const container = application_1.AuthServiceFactory.create(config, userRepository, credentialRepository);
-        // Repositorios: deben ser exactamente los mismos que pasamos
-        expect(container.userRepository).toBe(userRepository);
-        expect(container.credentialRepository).toBe(credentialRepository);
-        // Servicios de dominio / infraestructura
-        expect(container.passwordHasher).toBeInstanceOf(infrastructure_1.BcryptPasswordHasher);
-        expect(container.passwordPolicy).toBeInstanceOf(domain_1.DefaultPasswordPolicy);
-        expect(container.tokenService).toBeInstanceOf(infrastructure_1.JwtTokenService);
-        expect(container.tokenSession).toBeInstanceOf(infrastructure_1.TokenSessionService);
-        // Casos de uso
-        expect(container.registerUserUseCase).toBeInstanceOf(use_cases_1.RegisterUserUseCase);
-        expect(container.loginWithPasswordUseCase).toBeInstanceOf(use_cases_1.LoginWithPasswordUseCase);
-        expect(container.refreshTokenUseCase).toBeInstanceOf(use_cases_1.RefreshTokenUseCase);
-        expect(container.logoutUseCase).toBeInstanceOf(use_cases_1.LogoutUseCase);
-    });
-    it("debería inyectar correctamente JwtTokenService con la configuración JWT recibida", () => {
-        const container = application_1.AuthServiceFactory.create(config, userRepository, credentialRepository);
-        const tokenService = container.tokenService;
-        const jwtConfig = tokenService.config;
-        expect(jwtConfig.accessTokenSecret).toBe(config.jwt.accessTokenSecret);
-        expect(jwtConfig.refreshTokenSecret).toBe(config.jwt.refreshTokenSecret);
-        expect(jwtConfig.accessTokenExpirationMs).toBe(config.jwt.accessTokenExpirationMs);
-        expect(jwtConfig.refreshTokenExpirationMs).toBe(config.jwt.refreshTokenExpirationMs);
-        expect(tokenService.jwtGenerator).toBeInstanceOf(infrastructure_1.JwtTokenGenerator);
-        expect(tokenService.jwtVerifier).toBeInstanceOf(infrastructure_1.JwtTokenVerifier);
-        expect(tokenService.jwtValidator).toBeInstanceOf(infrastructure_1.JwtTokenValidator);
-        const jwtGenerator = tokenService.jwtGenerator;
-        expect(jwtGenerator.signer).toBeInstanceOf(infrastructure_1.JwtSigner);
-        expect(jwtGenerator.encoder).toBeDefined();
-    });
-    it("debería compartir las mismas instancias de repositorios y servicios entre los casos de uso", () => {
-        const container = application_1.AuthServiceFactory.create(config, userRepository, credentialRepository);
-        const { userRepository: ur, credentialRepository: cr, passwordHasher, passwordPolicy, tokenService, tokenSession, registerUserUseCase, loginWithPasswordUseCase, refreshTokenUseCase, logoutUseCase, } = container;
-        // RegisterUserUseCase
-        expect(registerUserUseCase.userRepository).toBe(ur);
-        expect(registerUserUseCase.passwordHasher).toBe(passwordHasher);
-        expect(registerUserUseCase.passwordPolicy).toBe(passwordPolicy);
-        // LoginWithPasswordUseCase
-        expect(loginWithPasswordUseCase.userRepository).toBe(ur);
-        expect(loginWithPasswordUseCase.passwordHasher).toBe(passwordHasher);
-        expect(loginWithPasswordUseCase.tokenSessionService).toBe(tokenSession);
-        // RefreshTokenUseCase
-        const refreshValues = Object.values(refreshTokenUseCase);
-        expect(refreshValues).toContain(tokenSession);
-        // LogoutUseCase
-        const logoutValues = Object.values(logoutUseCase);
-        expect(logoutValues).toContain(tokenSession);
-        // TokenSessionService wiring interno
-        expect(tokenSession.userRepository).toBe(ur);
-        expect(tokenSession.credentialRepository).toBe(cr);
-        expect(tokenSession.tokenService).toBe(tokenService);
-    });
-    it("debería respetar las instancias de repositorios entregadas por el llamador", () => {
-        const otherUserRepo = new infrastructure_1.InMemoryUserRepository();
-        const otherCredRepo = new infrastructure_1.InMemoryCredentialRepository();
-        const container = application_1.AuthServiceFactory.create(config, otherUserRepo, otherCredRepo);
-        expect(container.userRepository).toBe(otherUserRepo);
-        expect(container.credentialRepository).toBe(otherCredRepo);
-        expect(container.userRepository).not.toBe(userRepository);
-        expect(container.credentialRepository).not.toBe(credentialRepository);
-    });
-});

package/dist/tests/application/use-cases/login-with-password.integration.spec.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/tests/application/use-cases/login-with-password.integration.spec.js

@@ -1,140 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const application_1 = require("src/application");
-const domain_1 = require("src/domain");
-const infrastructure_1 = require("src/infrastructure");
-/**
- * FakeTokenSession usa el repositorio de credenciales real,
- * pero genera tokens simples sin firmar, sólo para pruebas.
- */
-class FakeTokenSession {
-    constructor(credentialRepo) {
-        this.credentialRepo = credentialRepo;
-    }
-    async createSession(user) {
-        const credential = new domain_1.Credential({
-            userId: user.id,
-            accessToken: `access-${user.id.getValue()}`,
-            refreshToken: `refresh-${user.id.getValue()}`,
-            expiresAt: new Date(Date.now() + 60 * 60 * 1000),
-            createdAt: new Date(),
-        });
-        await this.credentialRepo.save(credential);
-        return credential;
-    }
-}
-// Constantes comunes
-const plainPassword = "MySecureP@ssw0rd";
-const bcryptHash = "$2b$10$CwTycUXWue0Thq9StjUM0uJ8E9aG7vlYgSi0hd0eZBwbNG0Ax7Anm";
-describe("LoginWithPasswordUseCase (integración con repositorios en memoria)", () => {
-    let userRepository;
-    let credentialRepository;
-    let passwordHasher;
-    let tokenSessionService;
-    let createSessionSpy;
-    let useCase;
-    beforeEach(() => {
-        userRepository = new infrastructure_1.InMemoryUserRepository();
-        credentialRepository = new infrastructure_1.InMemoryCredentialRepository();
-        passwordHasher = {
-            hash: jest.fn(),
-            compare: jest.fn(),
-        };
-        tokenSessionService = new FakeTokenSession(credentialRepository);
-        createSessionSpy = jest.spyOn(tokenSessionService, "createSession");
-        useCase = new application_1.LoginWithPasswordUseCase(userRepository, passwordHasher, tokenSessionService);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    const createUser = (props) => new domain_1.User({
-        id: new domain_1.Id("user-123"),
-        email: new domain_1.Email("login@example.com"),
-        password: new domain_1.HashedPassword(bcryptHash),
-        isActive: true,
-        roles: [new domain_1.Role("user")],
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ...props,
-    });
-    it("debe crear una sesión persistida al loguear correctamente", async () => {
-        const emailValue = "login@example.com";
-        const user = createUser({ email: new domain_1.Email(emailValue) });
-        await userRepository.save(user);
-        passwordHasher.compare.mockResolvedValue(true);
-        const request = {
-            email: emailValue,
-            password: plainPassword,
-        };
-        // Act
-        const response = await useCase.execute(request);
-        // Assert: respuesta
-        expect(response.accessToken).toBe("access-user-123");
-        expect(response.refreshToken).toBe("refresh-user-123");
-        // Assert: credencial persistida en el repositorio
-        const storedCredential = await credentialRepository.findByUserId(user.id);
-        expect(storedCredential).not.toBeNull();
-        expect(storedCredential?.accessToken).toBe("access-user-123");
-        expect(storedCredential?.refreshToken).toBe("refresh-user-123");
-        // Assert: se llamó a createSession
-        expect(createSessionSpy).toHaveBeenCalledTimes(1);
-        expect(createSessionSpy).toHaveBeenCalledWith(user);
-    });
-    it("debe loguear correctamente cuando las credenciales son válidas y el usuario está activo", async () => {
-        const emailValue = "user@example.com";
-        const user = createUser({ email: new domain_1.Email(emailValue) });
-        await userRepository.save(user);
-        passwordHasher.compare.mockResolvedValue(true);
-        const request = {
-            email: emailValue,
-            password: plainPassword,
-        };
-        // Act
-        const response = await useCase.execute(request);
-        // Assert
-        expect(passwordHasher.compare).toHaveBeenCalledTimes(1);
-        expect(passwordHasher.compare).toHaveBeenCalledWith(request.password, user.password.serialize());
-        expect(createSessionSpy).toHaveBeenCalledTimes(1);
-        expect(createSessionSpy).toHaveBeenCalledWith(user);
-        expect(response).toEqual({
-            accessToken: "access-user-123",
-            refreshToken: "refresh-user-123",
-        });
-    });
-    it("debe lanzar UserNotFoundError cuando el usuario no existe", async () => {
-        const request = {
-            email: "unknown@example.com",
-            password: "whatever",
-        };
-        await expect(useCase.execute(request)).rejects.toBeInstanceOf(domain_1.UserNotFoundError);
-        expect(passwordHasher.compare).not.toHaveBeenCalled();
-        expect(createSessionSpy).not.toHaveBeenCalled();
-    });
-    it("debe lanzar UserDisabledError cuando el usuario está inactivo", async () => {
-        const emailValue = "disabled@example.com";
-        const user = createUser({ email: new domain_1.Email(emailValue) });
-        // Forzamos que canLogin() devuelva false
-        jest.spyOn(user, "canLogin").mockReturnValue(false);
-        await userRepository.save(user);
-        const request = {
-            email: emailValue,
-            password: "any-password",
-        };
-        await expect(useCase.execute(request)).rejects.toBeInstanceOf(domain_1.UserDisabledError);
-        expect(passwordHasher.compare).not.toHaveBeenCalled();
-        expect(createSessionSpy).not.toHaveBeenCalled();
-    });
-    it("debe lanzar PasswordMismatchError cuando la contraseña es incorrecta", async () => {
-        const emailValue = "user@example.com";
-        const user = createUser({ email: new domain_1.Email(emailValue) });
-        await userRepository.save(user);
-        passwordHasher.compare.mockResolvedValue(false);
-        const request = {
-            email: emailValue,
-            password: "wrong-password",
-        };
-        await expect(useCase.execute(request)).rejects.toBeInstanceOf(domain_1.PasswordMismatchError);
-        expect(passwordHasher.compare).toHaveBeenCalledTimes(1);
-        expect(createSessionSpy).not.toHaveBeenCalled();
-    });
-});

package/dist/tests/application/use-cases/logout-use-case.spec.d.ts

@@ -1 +0,0 @@
-export {};