@jmlq/auth 0.0.1-alpha.1

package/dist/src/infrastructure/jwt/strategies/hmac-signature.strategy.js

@@ -0,0 +1,129 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HmacSignatureStrategy = void 0;
+const crypto = __importStar(require("crypto"));
+const shared_1 = require("../../../shared");
+/**
+ *Esta clase implementa la estrategia de firma digital usando HMAC (Hash-based Message Authentication Code) para JWT.
+ *Maneja la firma y verificación de tokens JWT usando algoritmos HMAC con funciones hash SHA, que utilizan una clave secreta compartida.
+ */
+class HmacSignatureStrategy {
+    /**
+     * Crea una nueva instancia de HmacSignatureStrategy
+     * @param algorithm El algoritmo HMAC a usar (por ejemplo, 'HS256')
+     * @param encoder El codificador Base64 URL-safe a usar
+     */
+    constructor(algorithm, encoder) {
+        this.algorithm = algorithm;
+        this.encoder = encoder;
+    }
+    /**
+     * Firma digitalmente los datos usando la clave secreta HMAC
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param secret La clave secreta para firmar
+     * @returns La firma digital como string codificado
+     */
+    sign(data, secret) {
+        // Obtiene el algoritmo hash correspondiente (sha256, sha384, sha512)
+        const hashAlgorithm = this.getHashAlgorithm();
+        // Crea un HMAC usando el algoritmo hash y la clave secreta
+        const base64 = crypto
+            .createHmac(hashAlgorithm, secret)
+            .update(data)
+            .digest("base64");
+        // Codifica en Base64URL para JWT
+        return this.encoder.encode(base64);
+    }
+    /**
+     * Verifica si una firma es válida para los datos dados usando la clave secreta HMAC
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param secret La clave secreta para verificar
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data, signature, secret) {
+        try {
+            // Genera la firma esperada usando los mismos datos y clave
+            const expectedSignature = this.sign(data, secret);
+            // Compara de forma segura para evitar timing attacks
+            return this.secureCompare(signature, expectedSignature);
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Retorna el algoritmo que soporta esta estrategia específica.
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm() {
+        return this.algorithm;
+    }
+    /**
+     * Convierte el algoritmo JWT HMAC (como 'HS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'sha256').
+     * @returns El algoritmo hash correspondiente
+     * @throws Error si el algoritmo HMAC no es soportado
+     */
+    getHashAlgorithm() {
+        const hashAlgorithm = HmacSignatureStrategy.ALGORITHM_MAP[this.algorithm];
+        if (!hashAlgorithm) {
+            throw new Error(`Unsupported HMAC algorithm: ${this.algorithm}`);
+        }
+        return hashAlgorithm;
+    }
+    /**
+     * Compara dos strings de forma segura para evitar timing attacks
+     * @param a El primer string a comparar
+     * @param b El segundo string a comparar
+     * @returns true si son iguales, false si no lo son
+     */
+    secureCompare(a, b) {
+        if (a.length !== b.length) {
+            return false;
+        }
+        return crypto.timingSafeEqual(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+    }
+}
+exports.HmacSignatureStrategy = HmacSignatureStrategy;
+/**
+ * Mapea los algoritmos JWT HMAC a los algoritmos hash de Node.js crypto.
+ * Por ejemplo, 'HS256' → 'sha256'
+ */
+HmacSignatureStrategy.ALGORITHM_MAP = {
+    [shared_1.algorithms.hmac.HS256]: "sha256",
+    [shared_1.algorithms.hmac.HS384]: "sha384",
+    [shared_1.algorithms.hmac.HS512]: "sha512",
+};

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

@@ -0,0 +1,3 @@
+export * from "./ecdsa-signature.strategy";
+export * from "./hmac-signature.strategy";
+export * from "./rsa-signature.strategy";

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

@@ -0,0 +1,19 @@
+"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("./ecdsa-signature.strategy"), exports);
+__exportStar(require("./hmac-signature.strategy"), exports);
+__exportStar(require("./rsa-signature.strategy"), exports);

package/dist/src/infrastructure/jwt/strategies/rsa-signature-strategy.d.ts

@@ -0,0 +1,47 @@
+import { SignatureStrategy } from "../../../domain/ports";
+import { Base64UrlEncoder, RsaAlgorithm } from "../../../shared";
+/**
+ *Esta clase implementa la estrategia de firma digital usando RSA (Rivest-Shamir-Adleman) para JWT.
+ *Maneja la firma y verificación de tokens JWT usando algoritmos RSA con funciones hash SHA, que utilizan claves asimétricas (privada para firmar, pública para verificar).
+ */
+export declare class RsaSignatureStrategy implements SignatureStrategy {
+    private readonly algorithm;
+    private readonly encoder;
+    /**
+     * Mapea los algoritmos JWT RSA a los algoritmos hash de Node.js crypto.
+     * Por ejemplo, 'RS256' → 'RSA-SHA256'
+     */
+    private static readonly ALGORITHM_MAP;
+    /**
+     * Crea una nueva instancia de RsaSignatureStrategy
+     * @param algorithm El algoritmo RSA a usar (por ejemplo, 'RS256')
+     * @param encoder El codificador Base64 URL-safe a usar
+     */
+    constructor(algorithm: RsaAlgorithm, encoder: Base64UrlEncoder);
+    /**
+     * Firma digitalmente los datos usando la clave privada RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param privateKey La clave privada para firmar
+     * @returns La firma digital como string codificado
+     */
+    sign(data: string, privateKey: string): string;
+    /**
+     * Verifica si una firma es válida para los datos dados usando la clave pública RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param publicKey La clave pública para verificar
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data: string, signature: string, publicKey: string): boolean;
+    /**
+     * Retorna el algoritmo que soporta esta estrategia específica.
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm(): string;
+    /**
+     * Convierte el algoritmo JWT RSA (como 'RS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'RSA-SHA256').
+     * @returns El algoritmo hash correspondiente
+     * @throws Error si el algoritmo RSA no es soportado
+     */
+    private getHashAlgorithm;
+}

package/dist/src/infrastructure/jwt/strategies/rsa-signature-strategy.js

@@ -0,0 +1,124 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsaSignatureStrategy = void 0;
+const crypto = __importStar(require("crypto"));
+const shared_1 = require("../../../shared");
+/**
+ *Esta clase implementa la estrategia de firma digital usando RSA (Rivest-Shamir-Adleman) para JWT.
+ *Maneja la firma y verificación de tokens JWT usando algoritmos RSA con funciones hash SHA, que utilizan claves asimétricas (privada para firmar, pública para verificar).
+ */
+class RsaSignatureStrategy {
+    /**
+     * Crea una nueva instancia de RsaSignatureStrategy
+     * @param algorithm El algoritmo RSA a usar (por ejemplo, 'RS256')
+     * @param encoder El codificador Base64 URL-safe a usar
+     */
+    constructor(algorithm, encoder) {
+        this.algorithm = algorithm;
+        this.encoder = encoder;
+    }
+    /**
+     * Firma digitalmente los datos usando la clave privada RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param privateKey La clave privada para firmar
+     * @returns La firma digital como string codificado
+     */
+    sign(data, privateKey) {
+        // Obtiene el algoritmo hash correspondiente (RSA-SHA256, RSA-SHA384, RSA-SHA512)
+        const hashAlgorithm = this.getHashAlgorithm();
+        // Crea un firmador
+        const sign = crypto.createSign(hashAlgorithm);
+        // Alimenta los datos al firmador
+        sign.update(data);
+        // Genera la firma usando la clave privada RSA
+        const signature = sign.sign(privateKey, "base64");
+        // Codifica en Base64URL para JWT
+        return this.encoder.encode(signature);
+    }
+    /**
+     * Verifica si una firma es válida para los datos dados usando la clave pública RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param publicKey La clave pública para verificar
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data, signature, publicKey) {
+        try {
+            // Decodifica la firma desde Base64URL
+            const hashAlgorithm = this.getHashAlgorithm();
+            // Crea un verificador
+            const verify = crypto.createVerify(hashAlgorithm);
+            // Alimenta los datos originales
+            verify.update(data);
+            // Verifica usando la clave pública RSA
+            const decodedSignature = this.encoder.decode(signature);
+            // Retorna true si válida, false si no
+            return verify.verify(publicKey, decodedSignature, "base64");
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Retorna el algoritmo que soporta esta estrategia específica.
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm() {
+        return this.algorithm;
+    }
+    /**
+     * Convierte el algoritmo JWT RSA (como 'RS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'RSA-SHA256').
+     * @returns El algoritmo hash correspondiente
+     * @throws Error si el algoritmo RSA no es soportado
+     */
+    getHashAlgorithm() {
+        const hashAlgorithm = RsaSignatureStrategy.ALGORITHM_MAP[this.algorithm];
+        if (!hashAlgorithm) {
+            throw new Error(`Unsupported RSA algorithm: ${this.algorithm}`);
+        }
+        return hashAlgorithm;
+    }
+}
+exports.RsaSignatureStrategy = RsaSignatureStrategy;
+/**
+ * Mapea los algoritmos JWT RSA a los algoritmos hash de Node.js crypto.
+ * Por ejemplo, 'RS256' → 'RSA-SHA256'
+ */
+RsaSignatureStrategy.ALGORITHM_MAP = {
+    [shared_1.algorithms.rsa.RS256]: "RSA-SHA256",
+    [shared_1.algorithms.rsa.RS384]: "RSA-SHA384",
+    [shared_1.algorithms.rsa.RS512]: "RSA-SHA512",
+};

package/dist/src/infrastructure/jwt/strategies/rsa-signature.strategy.d.ts

@@ -0,0 +1,47 @@
+import { ISignatureStrategy } from "../../../domain/ports";
+import { Base64UrlEncoder, RsaAlgorithm, AlgorithmName } from "../../../shared";
+/**
+ *Esta clase implementa la estrategia de firma digital usando RSA (Rivest-Shamir-Adleman) para JWT.
+ *Maneja la firma y verificación de tokens JWT usando algoritmos RSA con funciones hash SHA, que utilizan claves asimétricas (privada para firmar, pública para verificar).
+ */
+export declare class RsaSignatureStrategy implements ISignatureStrategy {
+    private readonly algorithm;
+    private readonly encoder;
+    /**
+     * Mapea los algoritmos JWT RSA a los algoritmos hash de Node.js crypto.
+     * Por ejemplo, 'RS256' → 'RSA-SHA256'
+     */
+    private static readonly ALGORITHM_MAP;
+    /**
+     * Crea una nueva instancia de RsaSignatureStrategy
+     * @param algorithm El algoritmo RSA a usar (por ejemplo, 'RS256')
+     * @param encoder El codificador Base64 URL-safe a usar
+     */
+    constructor(algorithm: RsaAlgorithm, encoder: Base64UrlEncoder);
+    /**
+     * Firma digitalmente los datos usando la clave privada RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param privateKey La clave privada para firmar
+     * @returns La firma digital como string codificado
+     */
+    sign(data: string, privateKey: string): string;
+    /**
+     * Verifica si una firma es válida para los datos dados usando la clave pública RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param publicKey La clave pública para verificar
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data: string, signature: string, publicKey: string): boolean;
+    /**
+     * Retorna el algoritmo que soporta esta estrategia específica.
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm(): AlgorithmName;
+    /**
+     * Convierte el algoritmo JWT RSA (como 'RS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'RSA-SHA256').
+     * @returns El algoritmo hash correspondiente
+     * @throws Error si el algoritmo RSA no es soportado
+     */
+    private getHashAlgorithm;
+}

package/dist/src/infrastructure/jwt/strategies/rsa-signature.strategy.js

@@ -0,0 +1,124 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RsaSignatureStrategy = void 0;
+const crypto = __importStar(require("crypto"));
+const shared_1 = require("../../../shared");
+/**
+ *Esta clase implementa la estrategia de firma digital usando RSA (Rivest-Shamir-Adleman) para JWT.
+ *Maneja la firma y verificación de tokens JWT usando algoritmos RSA con funciones hash SHA, que utilizan claves asimétricas (privada para firmar, pública para verificar).
+ */
+class RsaSignatureStrategy {
+    /**
+     * Crea una nueva instancia de RsaSignatureStrategy
+     * @param algorithm El algoritmo RSA a usar (por ejemplo, 'RS256')
+     * @param encoder El codificador Base64 URL-safe a usar
+     */
+    constructor(algorithm, encoder) {
+        this.algorithm = algorithm;
+        this.encoder = encoder;
+    }
+    /**
+     * Firma digitalmente los datos usando la clave privada RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param privateKey La clave privada para firmar
+     * @returns La firma digital como string codificado
+     */
+    sign(data, privateKey) {
+        // Obtiene el algoritmo hash correspondiente (RSA-SHA256, RSA-SHA384, RSA-SHA512)
+        const hashAlgorithm = this.getHashAlgorithm();
+        // Crea un firmador
+        const sign = crypto.createSign(hashAlgorithm);
+        // Alimenta los datos al firmador
+        sign.update(data);
+        // Genera la firma usando la clave privada RSA
+        const signature = sign.sign(privateKey, "base64");
+        // Codifica en Base64URL para JWT
+        return this.encoder.encode(signature);
+    }
+    /**
+     * Verifica si una firma es válida para los datos dados usando la clave pública RSA
+     * @param data Los datos a firmar (normalmente el header + payload del JWT)
+     * @param signature La firma digital a verificar
+     * @param publicKey La clave pública para verificar
+     * @returns true si la firma es válida, false si no
+     */
+    verify(data, signature, publicKey) {
+        try {
+            // Decodifica la firma desde Base64URL
+            const hashAlgorithm = this.getHashAlgorithm();
+            // Crea un verificador
+            const verify = crypto.createVerify(hashAlgorithm);
+            // Alimenta los datos originales
+            verify.update(data);
+            // Verifica usando la clave pública RSA
+            const decodedSignature = this.encoder.decode(signature);
+            // Retorna true si válida, false si no
+            return verify.verify(publicKey, decodedSignature, "base64");
+        }
+        catch (error) {
+            return false;
+        }
+    }
+    /**
+     * Retorna el algoritmo que soporta esta estrategia específica.
+     * @returns El nombre del algoritmo soportado
+     */
+    getSupportedAlgorithm() {
+        return this.algorithm;
+    }
+    /**
+     * Convierte el algoritmo JWT RSA (como 'RS256') al algoritmo hash correspondiente que entiende Node.js crypto (como 'RSA-SHA256').
+     * @returns El algoritmo hash correspondiente
+     * @throws Error si el algoritmo RSA no es soportado
+     */
+    getHashAlgorithm() {
+        const hashAlgorithm = RsaSignatureStrategy.ALGORITHM_MAP[this.algorithm];
+        if (!hashAlgorithm) {
+            throw new Error(`Unsupported RSA algorithm: ${this.algorithm}`);
+        }
+        return hashAlgorithm;
+    }
+}
+exports.RsaSignatureStrategy = RsaSignatureStrategy;
+/**
+ * Mapea los algoritmos JWT RSA a los algoritmos hash de Node.js crypto.
+ * Por ejemplo, 'RS256' → 'RSA-SHA256'
+ */
+RsaSignatureStrategy.ALGORITHM_MAP = {
+    [shared_1.algorithms.rsa.RS256]: "RSA-SHA256",
+    [shared_1.algorithms.rsa.RS384]: "RSA-SHA384",
+    [shared_1.algorithms.rsa.RS512]: "RSA-SHA512",
+};

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

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

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