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

package/dist/src/infrastructure/jwt/token/actions/jwt-token-generator.d.ts

@@ -1,57 +0,0 @@
-import { JwtSigner } from "..";
-import { IGenerateAccessTokenProps, IGenerateRefreshTokenProps } from "../../../../domain/props";
-import { Base64UrlEncoder } from "../../../../shared";
-/**
- *Crea tokens JWT válidos (tanto de acceso como de refresco)
- *a partir de un usuario y una configuración.
- */
-export declare class JwtTokenGenerator {
-    private readonly encoder;
-    private readonly signer;
-    /**
-     * Crea una nueva instancia de JwtTokenGenerator
-     * @param encoder  El codificador Base64 URL-safe a usar
-     * @param signer El firmador JWT a usar
-     */
-    constructor(encoder: Base64UrlEncoder, signer: JwtSigner);
-    /**
-     * Genera un access token con accessTokenSecret
-     * @param props Las propiedades necesarias para generar el access token
-     * @returns El token JWT generado como string
-     */
-    generateAccessToken(props: IGenerateAccessTokenProps): string;
-    /**
-     * Genera un access token con refreshTokenSecret
-     * @param props Las propiedades necesarias para generar el refresh token
-     * @returns El token JWT generado como string
-     */
-    generateRefreshToken(props: IGenerateRefreshTokenProps): string;
-    /**
-     * Genera un token JWT completo (header.payload.signature)
-     * @param user El usuario para quien se genera el token
-     * @param props Las propiedades necesarias para generar el token
-     * @returns El token JWT generado como string
-     */
-    private generateToken;
-    /**
-     * Crea el payload del token JWT
-     * @param props Las propiedades necesarias para crear el payload
-     * @returns El payload del token JWT como objeto
-     */
-    private createPayload;
-    /**
-     * Define la cabecera del token JWT
-     * @param config La configuración del servicio JWT
-     * @returns El header del token JWT como objeto
-     */
-    private createHeader;
-    /**
-     * Codifica el header y el payload en Base64URL.
-     * Luego genera la firma y ensambla el token completo.
-     * @param header El header del token JWT
-     * @param payload El payload del token JWT
-     * @param secret La clave secreta para firmar el token
-     * @returns El token JWT completo como string
-     */
-    private assembleToken;
-}

package/dist/src/infrastructure/jwt/token/actions/jwt-token-generator.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtTokenGenerator = void 0;
-const shared_1 = require("../../../../shared");
-/**
- *Crea tokens JWT válidos (tanto de acceso como de refresco)
- *a partir de un usuario y una configuración.
- */
-class JwtTokenGenerator {
-    /**
-     * Crea una nueva instancia de JwtTokenGenerator
-     * @param encoder  El codificador Base64 URL-safe a usar
-     * @param signer El firmador JWT a usar
-     */
-    constructor(
-    // Base64UrlEncoder → codifica texto (header y payload) al formato Base64URL, estándar de JWT.
-    encoder, 
-    // JwtSigner → genera la firma criptográfica (signature) con el secreto correspondiente
-    signer // // Algoritmo de firma a usar (HS256, RS256, ES256, etc.) // private readonly algorithm: AnyAlgorithm
-    ) {
-        this.encoder = encoder;
-        this.signer = signer;
-    }
-    /**
-     * Genera un access token con accessTokenSecret
-     * @param props Las propiedades necesarias para generar el access token
-     * @returns El token JWT generado como string
-     */
-    generateAccessToken(props) {
-        return this.generateToken({
-            user: props.user,
-            expiresIn: props.expiresIn,
-            defaultExpirationMs: props.config.accessTokenExpirationMs,
-            secret: props.config.accessTokenSecret,
-            config: props.config,
-            customClaims: props.customClaims,
-        });
-    }
-    /**
-     * Genera un access token con refreshTokenSecret
-     * @param props Las propiedades necesarias para generar el refresh token
-     * @returns El token JWT generado como string
-     */
-    generateRefreshToken(props) {
-        return this.generateToken({
-            user: props.user,
-            expiresIn: props.expiresIn,
-            defaultExpirationMs: props.config.refreshTokenExpirationMs,
-            secret: props.config.refreshTokenSecret,
-            config: props.config,
-            customClaims: props.customClaims,
-        });
-    }
-    /**
-     * Genera un token JWT completo (header.payload.signature)
-     * @param user El usuario para quien se genera el token
-     * @param props Las propiedades necesarias para generar el token
-     * @returns El token JWT generado como string
-     */
-    generateToken(props) {
-        const { secret, config } = props;
-        // Crea el payload (datos que lleva el token).
-        const payload = this.createPayload(props);
-        // Crea el header (metadatos sobre el algoritmo).
-        const header = this.createHeader(config);
-        // une todo y lo firma.
-        return this.assembleToken(header, payload, secret, props.config.algorithm);
-    }
-    /**
-     * Crea el payload del token JWT
-     * @param props Las propiedades necesarias para crear el payload
-     * @returns El payload del token JWT como objeto
-     */
-    createPayload(props) {
-        const { user, expiresIn, defaultExpirationMs, customClaims } = props;
-        // Calcula el tiempo de expiración (exp) en milisegundos.
-        // Convierte el valor expiresIn (ej. "15m" o "1h") usando
-        // Si no se especifica, usa el valor por defecto del config
-        const expirationMs = expiresIn
-            ? shared_1.TimeParser.parseToMilliseconds(expiresIn)
-            : defaultExpirationMs;
-        const now = Date.now();
-        const exp = now + expirationMs;
-        // Luego construye el payload
-        return {
-            sub: user.id,
-            roles: user.roles.map((r) => r),
-            customClaims: customClaims || {},
-            jti: crypto.randomUUID(), // ID único del token
-            iat: Math.floor(now / 1000),
-            exp: Math.floor(exp / 1000),
-            iss: props.config.issuer,
-            aud: props.config.audience,
-        };
-    }
-    /**
-     * Define la cabecera del token JWT
-     * @param config La configuración del servicio JWT
-     * @returns El header del token JWT como objeto
-     */
-    createHeader(config) {
-        return {
-            alg: config.algorithm,
-            typ: "JWT",
-        };
-    }
-    /**
-     * Codifica el header y el payload en Base64URL.
-     * Luego genera la firma y ensambla el token completo.
-     * @param header El header del token JWT
-     * @param payload El payload del token JWT
-     * @param secret La clave secreta para firmar el token
-     * @returns El token JWT completo como string
-     */
-    assembleToken(header, payload, secret, algorithm) {
-        const encodedHeader = this.encoder.encode(JSON.stringify(header));
-        const encodedPayload = this.encoder.encode(JSON.stringify(payload));
-        // Une las tres partes
-        const signature = this.signer.sign(`${encodedHeader}.${encodedPayload}`, secret, algorithm);
-        return `${encodedHeader}.${encodedPayload}.${signature}`;
-    }
-}
-exports.JwtTokenGenerator = JwtTokenGenerator;

package/dist/src/infrastructure/jwt/token/actions/jwt-token-verifier.d.ts

@@ -1,59 +0,0 @@
-import { JwtSigner, JwtTokenParser } from "..";
-import { IJWTPayload } from "../../../../domain/ports";
-import { AnyAlgorithm, JwtTokenServiceConfig } from "../../../../shared";
-/**
- *Esta clase es el verificador de tokens JWT dentro de una arquitectura limpia
- *Su papel es comprobar la validez y vigencia de un token (tanto access como refresh),
- *sin depender de frameworks externos directamente.
- */
-export declare class JwtTokenVerifier {
-    private readonly signer;
-    private readonly parser;
-    private readonly algorithm;
-    /**
-     * Crea una nueva instancia de JwtTokenVerifier
-     * @param signer firma y verifica la firma de un token JWT
-     * @param parser separa y valida las partes del token (header.payload.signature) y convierte el payload en objeto.
-     */
-    constructor(signer: JwtSigner, parser: JwtTokenParser, algorithm: AnyAlgorithm);
-    /**
-     *Verifica un token de acceso usando la clave accessTokenSecret definida en JwtTokenServiceConfig.
-     *Devuelve un objeto TokenPayload con los datos del usuario.
-     * @param token El token JWT completo como string
-     * @param config La configuración del servicio JWT
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    verifyAccessToken(token: string, config: JwtTokenServiceConfig): IJWTPayload;
-    /**
-     *Verifica un token de acceso usando la clave refreshTokenSecret definida en JwtTokenServiceConfig.
-     *Devuelve un objeto TokenPayload con los datos del usuario.
-     * @param token El token JWT completo como string
-     * @param config La configuración del servicio JWT
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    verifyRefreshToken(token: string, config: JwtTokenServiceConfig): IJWTPayload;
-    /**
-     * Extrae la parte payload del token y devuelve la fecha de expiración (exp) como un objeto Date.
-     * No valida la firma ni la validez temporal.
-     * @param token El token JWT completo como string
-     * @returns La fecha de expiración del token como objeto Date
-     */
-    getTokenExpiration(token: string): Date;
-    /**
-     * Verifica el token JWT completo:
-     * - Extrae las partes usando JwtTokenParser
-     * - Verifica la firma con JwtSigner
-     * - Valida la expiración del token
-     * - Devuelve un TokenPayload limpio
-     * @param token El token JWT completo como string
-     * @param secret La clave secreta para verificar la firma
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    private verifyToken;
-    /**
-     * Valida si el token ha expirado basándose en el campo 'exp' del payload.
-     * @param payload El payload decodificado del token JWT
-     * @throws TokenExpiredError si el token ha expirado
-     */
-    private validateExpiration;
-}

package/dist/src/infrastructure/jwt/token/actions/jwt-token-verifier.js

@@ -1,100 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.JwtTokenVerifier = void 0;
-const errors_1 = require("../../../../domain/errors");
-/**
- *Esta clase es el verificador de tokens JWT dentro de una arquitectura limpia
- *Su papel es comprobar la validez y vigencia de un token (tanto access como refresh),
- *sin depender de frameworks externos directamente.
- */
-class JwtTokenVerifier {
-    /**
-     * Crea una nueva instancia de JwtTokenVerifier
-     * @param signer firma y verifica la firma de un token JWT
-     * @param parser separa y valida las partes del token (header.payload.signature) y convierte el payload en objeto.
-     */
-    constructor(
-    // Se encarga de firmar y verificar firmas digitales usando el secreto correspondiente.
-    signer, 
-    // Separa y valida las partes del token (header.payload.signature) y convierte el payload en objeto.
-    parser, 
-    // Algoritmo de firma a usar (HS256, RS256, ES256, etc.)
-    algorithm) {
-        this.signer = signer;
-        this.parser = parser;
-        this.algorithm = algorithm;
-    }
-    /**
-     *Verifica un token de acceso usando la clave accessTokenSecret definida en JwtTokenServiceConfig.
-     *Devuelve un objeto TokenPayload con los datos del usuario.
-     * @param token El token JWT completo como string
-     * @param config La configuración del servicio JWT
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    verifyAccessToken(token, config) {
-        return this.verifyToken(token, config.accessTokenSecret);
-    }
-    /**
-     *Verifica un token de acceso usando la clave refreshTokenSecret definida en JwtTokenServiceConfig.
-     *Devuelve un objeto TokenPayload con los datos del usuario.
-     * @param token El token JWT completo como string
-     * @param config La configuración del servicio JWT
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    verifyRefreshToken(token, config) {
-        return this.verifyToken(token, config.refreshTokenSecret);
-    }
-    /**
-     * Extrae la parte payload del token y devuelve la fecha de expiración (exp) como un objeto Date.
-     * No valida la firma ni la validez temporal.
-     * @param token El token JWT completo como string
-     * @returns La fecha de expiración del token como objeto Date
-     */
-    getTokenExpiration(token) {
-        const payload = this.parser.parsePayload(token);
-        return new Date(payload.exp * 1000);
-    }
-    /**
-     * Verifica el token JWT completo:
-     * - Extrae las partes usando JwtTokenParser
-     * - Verifica la firma con JwtSigner
-     * - Valida la expiración del token
-     * - Devuelve un TokenPayload limpio
-     * @param token El token JWT completo como string
-     * @param secret La clave secreta para verificar la firma
-     * @returns Un objeto TokenPayload con los datos del usuario
-     */
-    verifyToken(token, secret) {
-        // Divide el token en sus tres partes
-        const [headerPart, payloadPart, signaturePart] = this.parser.extractParts(token);
-        // Verifica la firma con el JwtSigner: Si la firma no coincide, lanza un InvalidSignatureError.
-        if (!this.signer.verifySignature(`${headerPart}.${payloadPart}`, signaturePart, secret, this.algorithm)) {
-            throw new errors_1.InvalidSignatureError("Invalid token signature");
-        }
-        // Verifica el tiempo de expiración del token.
-        const payload = this.parser.parseAndValidatePayload(payloadPart);
-        this.validateExpiration(payload);
-        // Devuelve un TokenPayload limpio
-        return {
-            sub: payload.sub,
-            roles: payload.roles,
-            customClaims: payload.customClaims || {},
-            iat: payload.iat,
-            exp: payload.exp,
-            jti: payload.jti,
-            iss: payload.iss,
-            aud: payload.aud,
-        };
-    }
-    /**
-     * Valida si el token ha expirado basándose en el campo 'exp' del payload.
-     * @param payload El payload decodificado del token JWT
-     * @throws TokenExpiredError si el token ha expirado
-     */
-    validateExpiration(payload) {
-        if (payload.exp && Date.now() >= payload.exp * 1000) {
-            throw new errors_1.TokenExpiredError("Token expired");
-        }
-    }
-}
-exports.JwtTokenVerifier = JwtTokenVerifier;

package/dist/src/infrastructure/jwt/token/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./actions/jwt-token-generator";
-export * from "./actions/jwt-token-verifier";
-export * from "./tools/jwt-signer";
-export * from "./tools/jwt-token-parser";
-export * from "./tools/jwt-token-validator";

package/dist/src/infrastructure/jwt/token/index.js

@@ -1,21 +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("./actions/jwt-token-generator"), exports);
-__exportStar(require("./actions/jwt-token-verifier"), exports);
-__exportStar(require("./tools/jwt-signer"), exports);
-__exportStar(require("./tools/jwt-token-parser"), exports);
-__exportStar(require("./tools/jwt-token-validator"), exports);

package/dist/src/infrastructure/jwt/token/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/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 = "HS256") {
-        // 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 = "HS256") {
-        const strategy = this.factory.create(algorithm);
-        return strategy.verify(data, signature, key);
-    }
-}
-exports.JwtSigner = JwtSigner;

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

@@ -1,29 +0,0 @@
-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): any;
-}

package/dist/src/infrastructure/jwt/token/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/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/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;