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

package/dist/tests/infrastructure/jwt/strategies/ecdsa-signature-strategy.spec.js

@@ -1,157 +0,0 @@
-"use strict";
-// tests/infrastructure/jwt/strategies/EcdsaSignatureStrategy.spec.ts
-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 });
-const crypto = __importStar(require("crypto"));
-const strategies_1 = require("src/infrastructure/jwt/strategies");
-const shared_1 = require("src/shared");
-describe("EcdsaSignatureStrategy", () => {
-    // Función auxiliar para generar par de claves ECDSA
-    const makeKeys = (curve) => crypto.generateKeyPairSync("ec", {
-        namedCurve: curve,
-        publicKeyEncoding: { type: "spki", format: "pem" },
-        privateKeyEncoding: { type: "pkcs8", format: "pem" },
-    });
-    // Datos base para firmar
-    const baseData = "header.payload";
-    // Vectores de prueba para cada algoritmo ECDSA
-    const vectors = [
-        { alg: shared_1.algorithms.ecdsa.ES256, curve: "P-256" },
-        { alg: shared_1.algorithms.ecdsa.ES384, curve: "P-384" },
-        { alg: shared_1.algorithms.ecdsa.ES512, curve: "P-521" },
-    ];
-    // Casos positivos
-    it.each(vectors)("sign/verify OK para %s", ({ alg, curve }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys(curve);
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Debe ser Base64URL (sin +, /, =)
-        expect(sig).toMatch(/^[A-Za-z0-9\-_]+$/);
-        // verify OK con los mismos datos/clave
-        expect(strat.verify(baseData, sig, publicKey)).toBe(true);
-    });
-    // Casos negativos
-    it.each(vectors)("verify=false si los datos se alteran (%s)", ({ alg, curve }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys(curve);
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // verify debe fallar si se alteran los datos
-        expect(strat.verify(baseData + ".tampered", sig, publicKey)).toBe(false);
-    });
-    // Casos negativos - firma alterada
-    it.each(vectors)("verify=false si la firma se altera (%s)", ({ alg, curve }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys(curve);
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Decodificamos a base64 estándar y luego a bytes
-        const stdB64 = encoder.decode(sig);
-        const buf = Buffer.from(stdB64, "base64");
-        // Flip de un byte en el medio (afecta r/s con alta probabilidad)
-        const i = Math.floor(buf.length / 2);
-        buf[i] ^= 0x01;
-        // Re-encode a base64url para pasar por la API pública de la estrategia
-        const tampered = encoder.encode(Buffer.from(buf).toString("base64"));
-        expect(strat.verify(baseData, tampered, publicKey)).toBe(false);
-    });
-    // Pruebas adicionales
-    it("getSupportedAlgorithm() devuelve el algoritmo configurado", () => {
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(shared_1.algorithms.ecdsa.ES256, encoder);
-        // Debe devolver el algoritmo configurado
-        expect(strat.getSupportedAlgorithm()).toBe("ES256");
-    });
-    // Casos de error - algoritmo no soportado
-    it("sign lanza y verify devuelve false para algoritmo no soportado", () => {
-        // Crea la estrategia con un algoritmo inválido
-        const badAlg = "ES999";
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(badAlg, encoder);
-        // Genera par de claves válidas
-        const { publicKey, privateKey } = makeKeys("P-256");
-        // sign debe lanzar error
-        expect(() => strat.sign(baseData, privateKey)).toThrow(/Unsupported ECDSA algorithm/i);
-        // verify debe devolver false
-        expect(strat.verify(baseData, "abc", publicKey)).toBe(false);
-    });
-    // Prueba que se usa el encoder correctamente
-    it("usa el encoder para encode (sign) y decode (verify)", () => {
-        // Mocks del encoder
-        const encoder = {
-            encode: jest.fn((b64) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")),
-            decode: jest.fn((b64url) => {
-                const pad = b64url.length % 4;
-                let std = b64url.replace(/-/g, "+").replace(/_/g, "/");
-                if (pad)
-                    std += "=".repeat(4 - pad);
-                return std;
-            }),
-        };
-        // Genera par de claves válidas
-        const { publicKey, privateKey } = makeKeys("P-256");
-        // Crea la estrategia
-        const strat = new strategies_1.EcdsaSignatureStrategy(shared_1.algorithms.ecdsa.ES256, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Verifica que se llamó al encoder
-        expect(encoder.encode).toHaveBeenCalledTimes(1);
-        // El resultado debe ser string
-        expect(typeof sig).toBe("string");
-        // Verifica
-        const ok = strat.verify(baseData, sig, publicKey);
-        // Verifica que se llamó al decoder
-        expect(encoder.decode).toHaveBeenCalledTimes(1);
-        // El resultado debe ser true
-        expect(ok).toBe(true);
-    });
-});

package/dist/tests/infrastructure/jwt/strategies/hmac-signature-strategy.spec.d.ts

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

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

@@ -1,150 +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 __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 });
-const crypto = __importStar(require("crypto"));
-const infrastructure_1 = require("src/infrastructure");
-const shared_1 = require("src/shared");
-describe("HmacSignatureStrategy", () => {
-    // 🔑 Clave simétrica compartida
-    const makeSecret = (length = 32) => crypto.randomBytes(length).toString("base64url");
-    // Datos base para firmar
-    const baseData = "header.payload";
-    // Vectores de prueba para cada algoritmo HMAC
-    const vectors = [
-        { alg: shared_1.algorithms.hmac.HS256, hash: "sha256" },
-        { alg: shared_1.algorithms.hmac.HS384, hash: "sha384" },
-        { alg: shared_1.algorithms.hmac.HS512, hash: "sha512" },
-    ];
-    // Casos positivos
-    it.each(vectors)("firma y verifica correctamente con %s", ({ alg }) => {
-        // Genera clave secreta
-        const secret = makeSecret();
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        const strategy = new infrastructure_1.HmacSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strategy.sign(baseData, secret);
-        // Debe ser Base64URL (sin +, /, =)
-        const valid = strategy.verify(baseData, sig, secret);
-        // Debe ser válido
-        expect(valid).toBe(true);
-    });
-    //   Casos negativos
-    it.each(vectors)("verify=false si los datos se alteran (%s)", ({ alg }) => {
-        // Genera clave secreta
-        const secret = makeSecret();
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        const strategy = new infrastructure_1.HmacSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strategy.sign(baseData, secret);
-        // verify debe fallar si se alteran los datos
-        expect(strategy.verify(baseData + ".tampered", sig, secret)).toBe(false);
-    });
-    // Casos negativos - firma alterada
-    it.each(vectors)("verify=false si la firma se altera (%s)", ({ alg }) => {
-        // Genera clave secreta
-        const secret = makeSecret();
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        const strategy = new infrastructure_1.HmacSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strategy.sign(baseData, secret);
-        // Decodificamos a base64 estándar y luego a bytes
-        const stdB64 = encoder.decode(sig);
-        const buf = Buffer.from(stdB64, "base64");
-        // Flip de un byte en el medio (afecta r/s con alta probabilidad)
-        const i = Math.floor(buf.length / 2);
-        buf[i] ^= 0x01;
-        // Re-encode a base64url para pasar por la API pública de la estrategia
-        const tampered = encoder.encode(Buffer.from(buf).toString("base64"));
-        expect(strategy.verify(baseData, tampered, secret)).toBe(false);
-    });
-    // Pruebas adicionales
-    it("getSupportedAlgorithm() devuelve el algoritmo configurado", () => {
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.HmacSignatureStrategy(shared_1.algorithms.hmac.HS256, encoder);
-        // Debe devolver el algoritmo configurado
-        expect(strat.getSupportedAlgorithm()).toBe("HS256");
-    });
-    // Casos de error - algoritmo no soportado
-    it("sign lanza y verify devuelve false para algoritmo no soportado", () => {
-        // Crea la estrategia con un algoritmo inválido
-        const badAlg = "HS999";
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.HmacSignatureStrategy(badAlg, encoder);
-        // Genera par de claves válidas
-        const secret = makeSecret();
-        // sign debe lanzar error
-        expect(() => strat.sign(baseData, secret)).toThrow(/Unsupported HMAC algorithm/i);
-        // verify debe devolver false
-        expect(strat.verify(baseData, "abc", secret)).toBe(false);
-    });
-    // Prueba que se usa el encoder correctamente
-    it("usa el encoder para encode (sign) y decode (verify)", () => {
-        // Mocks del encoder
-        const encoder = {
-            encode: jest.fn((b64) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")),
-            decode: jest.fn((b64url) => {
-                const pad = b64url.length % 4;
-                let std = b64url.replace(/-/g, "+").replace(/_/g, "/");
-                if (pad)
-                    std += "=".repeat(4 - pad);
-                return std;
-            }),
-        };
-        // Genera clave secreta
-        const secret = makeSecret();
-        // Crea la estrategia
-        // Crea la estrategia
-        const strat = new infrastructure_1.HmacSignatureStrategy(shared_1.algorithms.hmac.HS256, encoder);
-        // Firma
-        const sig = strat.sign(baseData, secret);
-        // Verifica que se llamó al encoder
-        expect(encoder.encode).toHaveBeenCalledTimes(1);
-        // El resultado debe ser string
-        expect(typeof sig).toBe("string");
-        // Verifica
-        const ok = strat.verify(baseData, sig, secret);
-        // Verifica que se no se llamó al decoder (no lo necesita HMAC)
-        expect(encoder.decode).toHaveBeenCalledTimes(0);
-        // El resultado debe ser true
-        expect(ok).toBe(true);
-    });
-});

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

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

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

@@ -1,156 +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 __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 });
-const crypto = __importStar(require("crypto"));
-const infrastructure_1 = require("src/infrastructure");
-const shared_1 = require("src/shared");
-describe("RcaSignatureStrategy", () => {
-    // 🔑 Función auxiliar para generar un par de claves RSA
-    const makeKeys = (modulusLength = 2048) => crypto.generateKeyPairSync("rsa", {
-        modulusLength, // Tamaño de la clave (bits)
-        publicKeyEncoding: { type: "spki", format: "pem" },
-        privateKeyEncoding: { type: "pkcs8", format: "pem" },
-    });
-    // Datos base para firmar
-    const baseData = "header.payload";
-    // Vectores de prueba para cada algoritmo HMAC
-    const vectors = [
-        { alg: shared_1.algorithms.rsa.RS256, hash: "sha256" },
-        { alg: shared_1.algorithms.rsa.RS384, hash: "sha384" },
-        { alg: shared_1.algorithms.rsa.RS512, hash: "sha512" },
-    ];
-    // Casos positivos
-    it.each(vectors)("sign/verify OK para %s", ({ alg }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys(2048);
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Debe ser Base64URL (sin +, /, =)
-        expect(sig).toMatch(/^[A-Za-z0-9\-_]+$/);
-        // verify OK con los mismos datos/clave
-        expect(strat.verify(baseData, sig, publicKey)).toBe(true);
-    });
-    // Casos negativos
-    it.each(vectors)("verify=false si los datos se alteran (%s)", ({ alg }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys();
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // verify debe fallar si se alteran los datos
-        expect(strat.verify(baseData + ".tampered", sig, publicKey)).toBe(false);
-    });
-    // Casos negativos - firma alterada
-    it.each(vectors)("verify=false si la firma se altera (%s)", ({ alg }) => {
-        // Genera par de claves
-        const { publicKey, privateKey } = makeKeys();
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(alg, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Decodificamos a base64 estándar y luego a bytes
-        const stdB64 = encoder.decode(sig);
-        const buf = Buffer.from(stdB64, "base64");
-        // Flip de un byte en el medio (afecta r/s con alta probabilidad)
-        const i = Math.floor(buf.length / 2);
-        buf[i] ^= 0x01;
-        // Re-encode a base64url para pasar por la API pública de la estrategia
-        const tampered = encoder.encode(Buffer.from(buf).toString("base64"));
-        expect(strat.verify(baseData, tampered, publicKey)).toBe(false);
-    });
-    // Pruebas adicionales
-    it("getSupportedAlgorithm() devuelve el algoritmo configurado", () => {
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(shared_1.algorithms.rsa.RS256, encoder);
-        // Debe devolver el algoritmo configurado
-        expect(strat.getSupportedAlgorithm()).toBe("RS256");
-    });
-    // Casos de error - algoritmo no soportado
-    it("sign lanza y verify devuelve false para algoritmo no soportado", () => {
-        // Crea la estrategia con un algoritmo inválido
-        const badAlg = "RS999";
-        // Crea la estrategia
-        const encoder = new shared_1.Base64UrlEncoder();
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(badAlg, encoder);
-        // Genera par de claves válidas
-        const { publicKey, privateKey } = makeKeys(2048);
-        // sign debe lanzar error
-        expect(() => strat.sign(baseData, privateKey)).toThrow(/Unsupported RSA algorithm/i);
-        // verify debe devolver false
-        expect(strat.verify(baseData, "abc", publicKey)).toBe(false);
-    });
-    // Prueba que se usa el encoder correctamente
-    it("usa el encoder para encode (sign) y decode (verify)", () => {
-        // Mocks del encoder
-        const encoder = {
-            encode: jest.fn((b64) => b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "")),
-            decode: jest.fn((b64url) => {
-                const pad = b64url.length % 4;
-                let std = b64url.replace(/-/g, "+").replace(/_/g, "/");
-                if (pad)
-                    std += "=".repeat(4 - pad);
-                return std;
-            }),
-        };
-        // Genera par de claves válidas
-        const { publicKey, privateKey } = makeKeys(2048);
-        // Crea la estrategia
-        const strat = new infrastructure_1.RsaSignatureStrategy(shared_1.algorithms.rsa.RS256, encoder);
-        // Firma
-        const sig = strat.sign(baseData, privateKey);
-        // Verifica que se llamó al encoder
-        expect(encoder.encode).toHaveBeenCalledTimes(1);
-        // El resultado debe ser string
-        expect(typeof sig).toBe("string");
-        // Verifica
-        const ok = strat.verify(baseData, sig, publicKey);
-        // Verifica que se llamó al decoder
-        expect(encoder.decode).toHaveBeenCalledTimes(1);
-        // El resultado debe ser true
-        expect(ok).toBe(true);
-    });
-});

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

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

package/dist/tests/infrastructure/jwt/token/actions/jwt-token-generator.spec.js

@@ -1,179 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// Mocks
-jest.mock("src/shared", () => {
-    // Mantiene el resto del módulo original
-    const actual = jest.requireActual("src/shared");
-    return {
-        // Mantiene todo lo anterior
-        ...actual,
-        // Mockeamos solo TimeParser
-        TimeParser: {
-            parseToMilliseconds: jest.fn(),
-        },
-    };
-});
-const infrastructure_1 = require("src/infrastructure");
-const shared_1 = require("src/shared");
-const make_jwt_user_1 = require("../../../../helpers/make-jwt-user");
-// Types:  Simplificados para test no necesitamos toda la implementación solo la firma del método sign()
-// y el encoder Base64UrlEncoder
-// type JwtSigner = { sign: (input: string, secret: string) => string };
-// type Base64UrlEncoder = { encode: (input: string) => string };
-// Config type para los tests
-// type JwtTokenServiceConfig = {
-//   accessTokenSecret: string;
-//   refreshTokenSecret: string;
-//   accessTokenExpirationMs: number;
-//   refreshTokenExpirationMs: number;
-//   issuer: string;
-//   audience: string;
-//   algorithm?: string;
-// };
-const FIXED_NOW_MS = Date.UTC(2025, 0, 1, 0, 0, 0, 0);
-const FIXED_NOW_SECONDS = Math.floor(FIXED_NOW_MS / 1000);
-// encoder como jest.fn para poder leer mock.calls
-const encoderMock = {
-    encode: jest.fn((input) => {
-        if (input.includes('"typ":"JWT"'))
-            return "encodedHeader";
-        return "encodedPayload";
-    }),
-    decode: function (str) {
-        throw new Error("Function not implemented.");
-    },
-};
-// signer como jest.fn para poder leer mock.calls
-const signerMock = {
-    sign: jest.fn().mockImplementation((data, key, algorithm) => {
-        return `signed(${data})`;
-    }),
-    verifySignature: jest.fn().mockImplementation((data, signature, key) => {
-        return signature === `signed(${data})`;
-    }),
-};
-// Config base para los tests
-const baseConfig = {
-    accessTokenSecret: "ACCESS_SECRET_ABC",
-    refreshTokenSecret: "REFRESH_SECRET_DEF",
-    accessTokenExpirationMs: 60 * 60 * 1000, // 1h
-    refreshTokenExpirationMs: 7 * 24 * 60 * 60 * 1000, // 7d
-    issuer: "my-issuer",
-    audience: "my-audience",
-    algorithm: "HS256",
-};
-// Util: normaliza roles a string[]
-function normalizeRole(r) {
-    if (typeof r === "string")
-        return r;
-    if (r && typeof r === "object") {
-        const o = r;
-        return String(o.role ?? o.name ?? o.value);
-    }
-    return String(r);
-}
-// Regex simple para UUID v4 (aceptable para test)
-const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-describe("JwtTokenGenerator", () => {
-    // la instancia a testear
-    let generator;
-    // fija la fecha actual para tests consistentes
-    beforeAll(() => {
-        jest.useFakeTimers().setSystemTime(FIXED_NOW_MS);
-    });
-    // resetea mocks y crea nueva instancia antes de cada test
-    beforeEach(() => {
-        jest.clearAllMocks();
-        generator = new infrastructure_1.JwtTokenGenerator(encoderMock, signerMock);
-    });
-    // restaura timers reales
-    afterAll(() => {
-        jest.useRealTimers();
-    });
-    // Testea generación de Access Token
-    test("generateAccessToken: usa accessTokenSecret y expiración por defecto del config cuando no hay expiresIn", () => {
-        // crea un user de prueba
-        const user = (0, make_jwt_user_1.makeJwtSubject)();
-        // genera el token
-        const token = generator.generateAccessToken({
-            user: user,
-            config: { ...baseConfig, algorithm: "HS256" },
-        });
-        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.accessTokenSecret, baseConfig.algorithm);
-        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
-        const encodeCalls = encoderMock.encode.mock.calls;
-        const payloadJson = encodeCalls[1][0];
-        const payload = JSON.parse(payloadJson);
-        // jti no debe ser fijo: validamos que sea string y UUID-ish
-        expect(typeof payload.jti).toBe("string");
-        // Si tu runtime no garantiza v4, cambia a expect.any(String)
-        expect(payload.jti).toMatch(UUID_V4);
-        // normalizamos roles y comparamos
-        const roleNames = payload.roles.map(normalizeRole);
-        expect(roleNames).toEqual(["ADMIN", "USER"]);
-        expect(payload).toMatchObject({
-            sub: "user-123",
-            customClaims: {},
-            iat: FIXED_NOW_SECONDS,
-            exp: FIXED_NOW_SECONDS + 60 * 60,
-            iss: "my-issuer",
-            aud: "my-audience",
-        });
-        const headerJson = encodeCalls[0][0];
-        const header = JSON.parse(headerJson);
-        expect(header).toEqual({ alg: "HS256", typ: "JWT" });
-    });
-    test("generateAccessToken: respeta expiresIn string (usa TimeParser.parseToMilliseconds)", () => {
-        const user = (0, make_jwt_user_1.makeJwtSubject)();
-        shared_1.TimeParser.parseToMilliseconds.mockReturnValueOnce(15 * 60 * 1000); // 15m
-        const token = generator.generateAccessToken({
-            user: user,
-            config: baseConfig,
-            expiresIn: "15m",
-            customClaims: { plan: "pro" },
-        });
-        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
-        expect(shared_1.TimeParser.parseToMilliseconds).toHaveBeenCalledWith("15m");
-        const payloadJson = encoderMock.encode.mock.calls[1][0];
-        const payload = JSON.parse(payloadJson);
-        const roleNames = payload.roles.map(normalizeRole);
-        expect(roleNames).toEqual(["ADMIN", "USER"]);
-        expect(payload.exp).toBe(FIXED_NOW_SECONDS + 15 * 60);
-        expect(payload.customClaims).toEqual({ plan: "pro" });
-    });
-    test("generateRefreshToken: usa refreshTokenSecret y expiración por defecto de refresh", () => {
-        const user = (0, make_jwt_user_1.makeJwtSubject)();
-        const token = generator.generateRefreshToken({
-            user: user,
-            config: { ...baseConfig, algorithm: "ES256" },
-        });
-        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.refreshTokenSecret, "ES256");
-        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
-        const headerJson = encoderMock.encode.mock.calls[0][0];
-        const header = JSON.parse(headerJson);
-        expect(header).toEqual({ alg: "ES256", typ: "JWT" });
-        const payloadJson = encoderMock.encode.mock.calls[1][0];
-        const payload = JSON.parse(payloadJson);
-        expect(payload.exp).toBe(FIXED_NOW_SECONDS + 7 * 24 * 60 * 60);
-    });
-    test("cuando no hay customClaims en props, se usa {}", () => {
-        const user = (0, make_jwt_user_1.makeJwtSubject)();
-        generator.generateAccessToken({
-            user: user,
-            config: baseConfig,
-        });
-        const payloadJson = encoderMock.encode.mock.calls[1][0];
-        const payload = JSON.parse(payloadJson);
-        expect(payload.customClaims).toEqual({});
-    });
-    test("firma exactamente 'header.payload' y concatena '.signature'", () => {
-        const user = (0, make_jwt_user_1.makeJwtSubject)();
-        const token = generator.generateAccessToken({
-            user: user,
-            config: baseConfig,
-        });
-        expect(signerMock.sign).toHaveBeenCalledTimes(1);
-        expect(signerMock.sign).toHaveBeenCalledWith("encodedHeader.encodedPayload", baseConfig.accessTokenSecret, baseConfig.algorithm);
-        expect(token).toBe("encodedHeader.encodedPayload.signed(encodedHeader.encodedPayload)");
-    });
-});

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

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