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

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

@@ -1,33 +0,0 @@
-import { AnyAlgorithm, Base64UrlEncoder } from "../../../../shared";
-/**
- *Firma y verifica la firma de un token JWT
- *convierte el texto del token en algo criptográficamente confiable, usando el algoritmo configurado
- */
-export declare class JwtSigner {
-    /**
-     * La fábrica de estrategias de firma
-     */
-    private readonly factory;
-    /**
-     * Crea una nueva instancia de JwtSigner
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(encoder: Base64UrlEncoder);
-    /**
-     *Pide a la fábrica una estrategia de firma compatible con el algoritmo
-     * @param data Los datos a firmar (normalmente "header.payload")
-     * @param key La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)
-     * @param algorithm El algoritmo de firma (por defecto 'HS256')
-     * @returns La firma digital como string codificado
-     */
-    sign(data: string, key: string, algorithm: AnyAlgorithm): string;
-    /**
-     * Verifica si la firma proporcionada coincide con la que se generaría al firmar data con la misma clave
-     * @param data Los datos a firmar (normalmente "header.payload")
-     * @param signature La firma digital a verificar
-     * @param key La clave para verificar (secreta para HMAC, pública para RSA/ECDSA)
-     * @param algorithm El algoritmo de firma (por defecto 'HS256')
-     * @returns true si la firma es válida, false si no lo es
-     */
-    verifySignature(data: string, signature: string, key: string, algorithm: AnyAlgorithm): boolean;
-}

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

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtSigner = void 0;
-const factory_1 = require("../../factory");
-/**
- *Firma y verifica la firma de un token JWT
- *convierte el texto del token en algo criptográficamente confiable, usando el algoritmo configurado
- */
-class JwtSigner {
-    /**
-     * Crea una nueva instancia de JwtSigner
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(encoder) {
-        // Usa una fábrica de estrategias de firma (SignatureStrategyFactory) para decidir cómo firmar o verificar
-        // La fábrica entrega una implementación distinta según el algoritmo
-        // El Base64UrlEncoder se usa internamente para codificar los resultados de la firma en formato JWT-seguro
-        this.factory = new factory_1.SignatureStrategyFactory(encoder);
-    }
-    /**
-     *Pide a la fábrica una estrategia de firma compatible con el algoritmo
-     * @param data Los datos a firmar (normalmente "header.payload")
-     * @param key La clave para firmar (secreta para HMAC, privada para RSA/ECDSA)
-     * @param algorithm El algoritmo de firma (por defecto 'HS256')
-     * @returns La firma digital como string codificado
-     */
-    sign(data, key, algorithm) {
-        // Firma el data (normalmente "header.payload") con la key usando esa estrategia
-        const strategy = this.factory.create(algorithm);
-        // Devuelve una cadena Base64URL que representa la firma digital del token.
-        return strategy.sign(data, key);
-    }
-    /**
-     * Verifica si la firma proporcionada coincide con la que se generaría al firmar data con la misma clave
-     * @param data Los datos a firmar (normalmente "header.payload")
-     * @param signature La firma digital a verificar
-     * @param key La clave para verificar (secreta para HMAC, pública para RSA/ECDSA)
-     * @param algorithm El algoritmo de firma (por defecto 'HS256')
-     * @returns true si la firma es válida, false si no lo es
-     */
-    verifySignature(data, signature, key, algorithm) {
-        const strategy = this.factory.create(algorithm);
-        return strategy.verify(data, signature, key);
-    }
-}
-exports.JwtSigner = JwtSigner;

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

@@ -1,30 +0,0 @@
-import { IJWTPayload } from "../../../../domain";
-import { Base64UrlEncoder } from "../../../../shared";
-/**
- *Leer y decodificar el contenido de un JWT (sin verificar la firma ni la validez temporal).
- *Separa las partes, decodifica el payload, y valida que sea un objeto JSON bien formado.
- */
-export declare class JwtTokenParser {
-    private readonly encoder;
-    /**
-     * Recibe un Base64UrlEncoder, encargado de decodificar texto en formato Base64URL
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(encoder: Base64UrlEncoder);
-    extractParts(token: string): [string, string, string];
-    /**
-     * Leer el contenido del token (por ejemplo, para obtener exp, userId, etc.).
-     * No valida la firma ni la validez temporal.
-     * @param token El token JWT completo como string
-     * @returns El payload decodificado como objeto
-     */
-    parsePayload(token: string): any;
-    /**
-     *Una versión más estricta, usada cuando necesitas asegurarte de que el payload es
-     *válido antes de continuar
-     * @param payloadPart La parte del payload del token JWT (Base64URL)
-     * @returns El payload decodificado como objeto
-     * @throws InvalidTokenFormatError si el payload no es un objeto JSON válido
-     */
-    parseAndValidatePayload(payloadPart: string): IJWTPayload;
-}

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

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtTokenParser = void 0;
-const domain_1 = require("../../../../domain");
-/**
- *Leer y decodificar el contenido de un JWT (sin verificar la firma ni la validez temporal).
- *Separa las partes, decodifica el payload, y valida que sea un objeto JSON bien formado.
- */
-class JwtTokenParser {
-    /**
-     * Recibe un Base64UrlEncoder, encargado de decodificar texto en formato Base64URL
-     * @param encoder El codificador Base64 URL-safe a usar
-     */
-    constructor(encoder) {
-        this.encoder = encoder;
-    }
-    // Divide el token en sus tres partes estándar: header, payload y signature.
-    extractParts(token) {
-        const parts = token.split(".");
-        return [parts[0], parts[1], parts[2]];
-    }
-    /**
-     * Leer el contenido del token (por ejemplo, para obtener exp, userId, etc.).
-     * No valida la firma ni la validez temporal.
-     * @param token El token JWT completo como string
-     * @returns El payload decodificado como objeto
-     */
-    parsePayload(token) {
-        const [, payloadPart] = this.extractParts(token);
-        return JSON.parse(this.encoder.decode(payloadPart));
-    }
-    /**
-     *Una versión más estricta, usada cuando necesitas asegurarte de que el payload es
-     *válido antes de continuar
-     * @param payloadPart La parte del payload del token JWT (Base64URL)
-     * @returns El payload decodificado como objeto
-     * @throws InvalidTokenFormatError si el payload no es un objeto JSON válido
-     */
-    parseAndValidatePayload(payloadPart) {
-        let payload;
-        try {
-            // Intenta decodificarlo: Si falla, lanza InvalidTokenFormatError
-            payload = JSON.parse(this.encoder.decode(payloadPart));
-        }
-        catch (decodeError) {
-            throw new domain_1.InvalidTokenFormatError("Invalid token payload encoding");
-        }
-        // Verifica que el resultado sea un objeto JSON válido (no null ni array)
-        if (payload === null ||
-            typeof payload !== "object" ||
-            Array.isArray(payload)) {
-            throw new domain_1.InvalidTokenFormatError("Token payload must be an object");
-        }
-        return payload;
-    }
-}
-exports.JwtTokenParser = JwtTokenParser;

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

@@ -1,32 +0,0 @@
-/**
- *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

@@ -1,77 +0,0 @@
-"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

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

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

@@ -1,67 +0,0 @@
-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

@@ -1,128 +0,0 @@
-"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/services/default-token-session.service.d.ts

@@ -1,18 +0,0 @@
-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/jwt-token.service.d.ts

@@ -1,15 +0,0 @@
-import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps, IJWTPayload, ITokenService } from "../../domain";
-import { JwtTokenServiceConfig } from "../../shared";
-import { JwtTokenGenerator, JwtTokenValidator, JwtTokenVerifier } from "../jwt";
-export declare class JwtTokenService implements ITokenService {
-    private readonly config;
-    private readonly jwtGenerator;
-    private readonly jwtVerifier;
-    private readonly jwtValidator;
-    constructor(config: JwtTokenServiceConfig, jwtGenerator: JwtTokenGenerator, jwtVerifier: JwtTokenVerifier, jwtValidator: JwtTokenValidator);
-    generateAccessToken(props: IGenerateAccessTokenProps): Promise<string>;
-    generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
-    verifyAccessToken(token: string): Promise<IJWTPayload>;
-    verifyRefreshToken(token: string): Promise<IJWTPayload>;
-    getTokenExpiration(token: string): Promise<Date>;
-}

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

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtTokenService = void 0;
-// Servicio de tokens JWT que implementa ITokenService
-class JwtTokenService {
-    constructor(
-    // config → secretos, tiempos de expiración y algoritmo.
-    config, 
-    // jwtGenerator → crea y firma los tokens.
-    jwtGenerator, 
-    // jwtVerifier → comprueba firmas y expiraciones.
-    jwtVerifier, 
-    // jwtValidator → revisa formato y estructura
-    jwtValidator) {
-        this.config = config;
-        this.jwtGenerator = jwtGenerator;
-        this.jwtVerifier = jwtVerifier;
-        this.jwtValidator = jwtValidator;
-    }
-    // Genera un access token
-    async generateAccessToken(props) {
-        return this.jwtGenerator.generateAccessToken(props);
-    }
-    // Genera un refresh token
-    async generateRefreshToken(props) {
-        return this.jwtGenerator.generateRefreshToken(props);
-    }
-    // verifica si el token es válido y retorna el payload
-    async verifyAccessToken(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.verifyAccessToken(token, this.config);
-    }
-    // verifica si el refresh token es válido y retorna el payload
-    async verifyRefreshToken(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.verifyRefreshToken(token, this.config);
-    }
-    // Obtiene la fecha de expiración del token
-    async getTokenExpiration(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.getTokenExpiration(token);
-    }
-}
-exports.JwtTokenService = JwtTokenService;

package/dist/src/infrastructure/services/simple-jwt-token.service.d.ts

@@ -1,15 +0,0 @@
-import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps, IJWTPayload, ITokenService } from "../../domain";
-import { JwtTokenServiceConfig } from "../../shared";
-import { JwtTokenGenerator, JwtTokenValidator, JwtTokenVerifier } from "../jwt";
-export declare class SimpleJwtTokenService implements ITokenService {
-    private readonly config;
-    private readonly jwtGenerator;
-    private readonly jwtVerifier;
-    private readonly jwtValidator;
-    constructor(config: JwtTokenServiceConfig, jwtGenerator: JwtTokenGenerator, jwtVerifier: JwtTokenVerifier, jwtValidator: JwtTokenValidator);
-    generateAccessToken(props: IGenerateAccessTokenProps): Promise<string>;
-    generateRefreshToken(props: IGenerateRefreshTokenProps): Promise<string>;
-    verifyAccessToken(token: string): Promise<IJWTPayload>;
-    verifyRefreshToken(token: string): Promise<IJWTPayload>;
-    getTokenExpiration(token: string): Promise<Date>;
-}

package/dist/src/infrastructure/services/simple-jwt-token.service.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SimpleJwtTokenService = void 0;
-// Fachada principal del sistema de tokens JWT.
-// Servicio de alto nivel que orquesta las operaciones de generación, validación y verificación de tokens,
-// ocultando los detalles internos de las clases más técnicas (JwtTokenGenerator, JwtTokenVerifier, JwtTokenValidator).
-class SimpleJwtTokenService {
-    constructor(
-    // config → secretos, tiempos de expiración y algoritmo.
-    config, 
-    // jwtGenerator → crea y firma los tokens.
-    jwtGenerator, 
-    // jwtVerifier → comprueba firmas y expiraciones.
-    jwtVerifier, 
-    // jwtValidator → revisa formato y estructura
-    jwtValidator) {
-        this.config = config;
-        this.jwtGenerator = jwtGenerator;
-        this.jwtVerifier = jwtVerifier;
-        this.jwtValidator = jwtValidator;
-    }
-    // Genera un access token
-    async generateAccessToken(props) {
-        return this.jwtGenerator.generateAccessToken(props);
-    }
-    // Genera un refresh token
-    async generateRefreshToken(props) {
-        return this.jwtGenerator.generateRefreshToken(props);
-    }
-    // verifica si el token es válido y retorna el payload
-    async verifyAccessToken(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.verifyAccessToken(token, this.config);
-    }
-    // verifica si el refresh token es válido y retorna el payload
-    async verifyRefreshToken(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.verifyRefreshToken(token, this.config);
-    }
-    // Obtiene la fecha de expiración del token
-    async getTokenExpiration(token) {
-        this.jwtValidator.validateTokenInput(token);
-        return this.jwtVerifier.getTokenExpiration(token);
-    }
-}
-exports.SimpleJwtTokenService = SimpleJwtTokenService;

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

@@ -1,24 +0,0 @@
-import { Credential, ICredentialRepository, ITokenService, ITokenSession, IUserRepository, User } from "../../domain";
-import { AnyAlgorithm } from "../../shared";
-/**
- * Servicio de gestión de sesiones de usuario mediante tokens JWT.
- * Proporciona métodos para crear, refrescar, validar y revocar sesiones.
- */
-export declare class TokenSessionService implements ITokenSession {
-    private readonly tokenService;
-    private readonly userRepository;
-    private readonly credentialRepository;
-    private readonly algorithm;
-    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, algorithm: AnyAlgorithm, 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>;
-}