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

package/dist/tests/infrastructure/jwt/token/tools/jwt-token-parser.spec.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-const token_1 = require("src/infrastructure/jwt/token");
-// ───────────────────────────────────────────────────────────────────────────────
-// Helpers: Base64URL encode/decode (solo para el fake encoder y payloads)
-// ───────────────────────────────────────────────────────────────────────────────
-const b64urlEncode = (utf8) => {
-    const b64 = Buffer.from(utf8, "utf8").toString("base64");
-    return b64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/g, "");
-};
-const b64urlDecode = (b64url) => {
-    let base64 = b64url.replace(/-/g, "+").replace(/_/g, "/");
-    const pad = base64.length % 4;
-    if (pad)
-        base64 += "=".repeat(4 - pad);
-    return Buffer.from(base64, "base64").toString("utf8");
-};
-// Fake encoder mínimo que respeta la firma esperada
-class FakeBase64UrlEncoder {
-    decode(input) {
-        return b64urlDecode(input);
-    }
-}
-describe("JwtTokenParser", () => {
-    let parser;
-    beforeEach(() => {
-        parser = new token_1.JwtTokenParser(new FakeBase64UrlEncoder());
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // extractParts
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("extractParts", () => {
-        test("devuelve [header, payload, signature] con 3 segmentos", () => {
-            const token = "aaa.bbb.ccc";
-            expect(parser.extractParts(token)).toEqual(["aaa", "bbb", "ccc"]);
-        });
-        test("con puntos de más, retorna los 3 primeros segmentos", () => {
-            const token = "a.b.c.d.e";
-            expect(parser.extractParts(token)).toEqual(["a", "b", "c"]);
-        });
-        test("con menos de 3 segmentos, rellena con undefined", () => {
-            const token = "a.b";
-            const [h, p, s] = parser.extractParts(token);
-            expect(h).toBe("a");
-            expect(p).toBe("b");
-            expect(s).toBeUndefined(); // comportamiento actual del método
-        });
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // parsePayload
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("parsePayload", () => {
-        test("decodifica y parsea el payload a objeto (sin verificar firma/tiempos)", () => {
-            const payloadObj = { sub: "123", exp: 1700000000 };
-            const header = b64urlEncode(JSON.stringify({ alg: "HS256", typ: "JWT" }));
-            const payload = b64urlEncode(JSON.stringify(payloadObj));
-            const signature = "signaturePartNoCheck";
-            const token = `${header}.${payload}.${signature}`;
-            const result = parser.parsePayload(token);
-            expect(result).toEqual(payloadObj);
-        });
-        test("si el payload no es JSON válido, lanza (propaga error de JSON.parse)", () => {
-            // payloadPart inválido (decodifica a texto no-JSON)
-            const header = "aaa";
-            const payload = b64urlEncode("not-a-json");
-            const signature = "ccc";
-            const token = `${header}.${payload}.${signature}`;
-            expect(() => parser.parsePayload(token)).toThrow(SyntaxError);
-        });
-    });
-    // ────────────────────────────────────────────────────────────────────────────
-    // parseAndValidatePayload
-    // ────────────────────────────────────────────────────────────────────────────
-    describe("parseAndValidatePayload", () => {
-        test("retorna objeto para payload válido", () => {
-            const payloadObj = { userId: "u1", roles: ["admin"] };
-            const payloadPart = b64urlEncode(JSON.stringify(payloadObj));
-            const result = parser.parseAndValidatePayload(payloadPart);
-            expect(result).toEqual(payloadObj);
-        });
-        test("si el encoding/JSON es inválido, lanza InvalidTokenFormatError (mensaje: Invalid token payload encoding)", () => {
-            // Usamos un fragmento que al decodificar no produce JSON válido
-            const payloadPart = b64urlEncode("not-json-here");
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(domain_1.InvalidTokenFormatError);
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/invalid token payload encoding/i);
-        });
-        test('si el payload es string ("hola"), lanza InvalidTokenFormatError (must be an object)', () => {
-            const payloadPart = b64urlEncode(JSON.stringify("hola"));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es número (123), lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode(JSON.stringify(123));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es array ([]), lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode(JSON.stringify([]));
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("si el payload es null, lanza InvalidTokenFormatError", () => {
-            const payloadPart = b64urlEncode("null");
-            expect(() => parser.parseAndValidatePayload(payloadPart)).toThrow(/payload must be an object/i);
-        });
-        test("llama al encoder.decode con el payloadPart recibido", () => {
-            const spyDecode = jest.spyOn(FakeBase64UrlEncoder.prototype, "decode");
-            const obj = { a: 1 };
-            const payloadPart = b64urlEncode(JSON.stringify(obj));
-            const localParser = new token_1.JwtTokenParser(new FakeBase64UrlEncoder());
-            const result = localParser.parseAndValidatePayload(payloadPart);
-            expect(result).toEqual(obj);
-            expect(spyDecode).toHaveBeenCalledTimes(1);
-            expect(spyDecode).toHaveBeenCalledWith(payloadPart);
-            spyDecode.mockRestore();
-        });
-    });
-});

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

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

package/dist/tests/infrastructure/jwt/token/tools/jwt-token-validator.spec.js

@@ -1,88 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-// tests/infrastructure/jwt/token/jwt-token-validator.spec.ts
-const errors_1 = require("src/domain/errors");
-const token_1 = require("src/infrastructure/jwt/token");
-describe("JwtTokenValidator.validateTokenInput", () => {
-    let validator;
-    beforeEach(() => {
-        validator = new token_1.JwtTokenValidator();
-    });
-    const expectInvalid = (token, message) => {
-        const act = () => validator.validateTokenInput(token);
-        expect(act).toThrow(errors_1.InvalidTokenFormatError);
-        if (message)
-            expect(act).toThrow(message);
-    };
-    // Casos válidos
-    describe("casos válidos", () => {
-        test("acepta un JWT bien formado (Base64URL, 3 segmentos, 2 puntos)", () => {
-            const validJwt = "eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjM0In0.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk";
-            expect(() => validator.validateTokenInput(validJwt)).not.toThrow();
-        });
-        test("acepta tokens largos con guiones y guiones bajos válidos", () => {
-            const validJwt = "abc_DEF-123.ghi_JKL-456.mno_PQR-789xyz";
-            expect(() => validator.validateTokenInput(validJwt)).not.toThrow();
-        });
-    });
-    // Casos inválidos básicos
-    describe("validateBasicFormat", () => {
-        test("lanza si token es null", () => {
-            expectInvalid(null, /cannot be null or undefined/i);
-        });
-        test("lanza si token es undefined", () => {
-            expectInvalid(undefined, /cannot be null or undefined/i);
-        });
-        test("lanza si token no es string (number)", () => {
-            expectInvalid(123, /Token must be a string/i);
-        });
-        test("lanza si token no es string (objeto)", () => {
-            expectInvalid({}, /Token must be a string/i);
-        });
-        test("lanza si cadena está vacía", () => {
-            expectInvalid("", /cannot be empty/i);
-        });
-        test("lanza si solo contiene espacios", () => {
-            expectInvalid("   ", /only whitespace/i);
-        });
-        test("lanza si tiene espacios al inicio o final", () => {
-            expectInvalid(" abc.def.ghi ", /leading or trailing whitespace/i);
-        });
-    });
-    // Casos inválidos de estructura JWT
-    describe("validateJwtStructure", () => {
-        test("lanza si longitud < 10", () => {
-            expectInvalid("a.b.c", /too short/i);
-        });
-        test("lanza si no tiene puntos", () => {
-            expectInvalid("abcdefghijk", /expected 2 dots, found 0/i);
-        });
-        test("lanza si tiene solo 1 punto", () => {
-            expectInvalid("abcdefghij.klmnop", /expected 2 dots, found 1/i);
-        });
-        test("lanza si tiene más de 2 puntos", () => {
-            expectInvalid("abcd.efgh.ijkl.mnop", /expected 2 dots, found 3/i);
-        });
-    });
-    // Casos inválidos de caracteres Base64URL
-    describe("validateCharacters (Base64URL)", () => {
-        test("lanza si contiene '+'", () => {
-            expectInvalid("abcde+123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si contiene '/'", () => {
-            expectInvalid("abcde/123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si contiene '=' (padding)", () => {
-            expectInvalid("abcde=123.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si algún segmento está vacío (..)", () => {
-            expectInvalid("abcde..klmnopqr", /invalid characters/i);
-        });
-        test("lanza si hay espacios internos", () => {
-            expectInvalid("abcde .fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-        test("lanza si hay caracteres fuera del alfabeto Base64URL", () => {
-            expectInvalid("abcde%.fghi_JKL.mnop-QR", /invalid characters/i);
-        });
-    });
-});

package/dist/tests/infrastructure/security/security/bcrypt-password-hasher.spec.d.ts

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

package/dist/tests/infrastructure/security/security/bcrypt-password-hasher.spec.js

@@ -1,37 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const bcryptjs_1 = __importDefault(require("bcryptjs"));
-const infrastructure_1 = require("src/infrastructure");
-jest.mock("bcryptjs");
-describe("BcryptPasswordHasher", () => {
-    let hasher;
-    beforeEach(() => {
-        hasher = new infrastructure_1.BcryptPasswordHasher();
-        jest.clearAllMocks();
-    });
-    describe("hash", () => {
-        it("debería generar un hash usando bcrypt con 10 saltRounds", async () => {
-            const mockHash = "$2a$10$abcdefghijklmnopqrstuv1234567890abcdefghi";
-            bcryptjs_1.default.hash.mockResolvedValue(mockHash);
-            const result = await hasher.hash("password123");
-            expect(bcryptjs_1.default.hash).toHaveBeenCalledWith("password123", 10);
-            expect(result).toBe(mockHash);
-        });
-    });
-    describe("compare", () => {
-        it("debería retornar true cuando las contraseñas coinciden", async () => {
-            bcryptjs_1.default.compare.mockResolvedValue(true);
-            const result = await hasher.compare("password123", "hashed");
-            expect(bcryptjs_1.default.compare).toHaveBeenCalledWith("password123", "hashed");
-            expect(result).toBe(true);
-        });
-        it("debería retornar false cuando las contraseñas no coinciden", async () => {
-            bcryptjs_1.default.compare.mockResolvedValue(false);
-            const result = await hasher.compare("wrongPassword", "hashed");
-            expect(result).toBe(false);
-        });
-    });
-});

package/dist/tests/infrastructure/services/jwt-token-service.spec.d.ts

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

package/dist/tests/infrastructure/services/jwt-token-service.spec.js

@@ -1,145 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const jwt_token_service_1 = require("../../../src/infrastructure/services/jwt-token.service");
-describe("JwtTokenService", () => {
-    let config;
-    let jwtGenerator;
-    let jwtVerifier;
-    let jwtValidator;
-    let service;
-    beforeEach(() => {
-        // ⚠️ Rellena/ajusta según tu definición real de IAuthConfig["info"]
-        config = {
-            accessTokenSecret: "access-secret",
-            refreshTokenSecret: "refresh-secret",
-            accessTokenExpirationMs: 15 * 60 * 1000,
-            refreshTokenExpirationMs: 7 * 24 * 60 * 60 * 1000,
-            issuer: "test-issuer",
-            audience: "test-audience",
-            appName: "test-app",
-        };
-        jwtGenerator = {
-            generateAccessToken: jest.fn(),
-            generateRefreshToken: jest.fn(),
-        };
-        jwtVerifier = {
-            verifyAccessToken: jest.fn(),
-            verifyRefreshToken: jest.fn(),
-            getTokenExpiration: jest.fn(),
-        };
-        jwtValidator = {
-            validateTokenInput: jest.fn(),
-        };
-        service = new jwt_token_service_1.JwtTokenService(config, jwtGenerator, jwtVerifier, jwtValidator);
-    });
-    describe("generateAccessToken", () => {
-        it("debería delegar en JwtTokenGenerator.generateAccessToken y retornar el token", async () => {
-            const props = {
-                userId: "user-123",
-            };
-            const expectedToken = "access.token.value";
-            jwtGenerator.generateAccessToken.mockResolvedValue(expectedToken);
-            const result = await service.generateAccessToken(props);
-            expect(jwtGenerator.generateAccessToken).toHaveBeenCalledTimes(1);
-            expect(jwtGenerator.generateAccessToken).toHaveBeenCalledWith(props);
-            expect(result).toBe(expectedToken);
-        });
-    });
-    describe("generateRefreshToken", () => {
-        it("debería delegar en JwtTokenGenerator.generateRefreshToken y retornar el token", async () => {
-            const props = {
-                userId: "user-123",
-            };
-            const expectedToken = "refresh.token.value";
-            jwtGenerator.generateRefreshToken.mockResolvedValue(expectedToken);
-            const result = await service.generateRefreshToken(props);
-            expect(jwtGenerator.generateRefreshToken).toHaveBeenCalledTimes(1);
-            expect(jwtGenerator.generateRefreshToken).toHaveBeenCalledWith(props);
-            expect(result).toBe(expectedToken);
-        });
-    });
-    describe("verifyAccessToken", () => {
-        it("debería validar el token y delegar en JwtTokenVerifier.verifyAccessToken", async () => {
-            const token = "access.token.value";
-            const payload = {
-                sub: "user-123",
-                roles: [
-                    {
-                        role: "user",
-                    },
-                ],
-                customClaims: {},
-                jti: "unique-jwt-id",
-                iss: "test-issuer",
-                aud: "test-audience",
-                iat: Date.now() / 1000,
-                exp: (Date.now() + 1000) / 1000,
-            };
-            jwtVerifier.verifyAccessToken.mockResolvedValue(payload);
-            const result = await service.verifyAccessToken(token);
-            // Primero se valida la entrada
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledTimes(1);
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledWith(token);
-            // Luego se delega al verificador con el token y la config
-            expect(jwtVerifier.verifyAccessToken).toHaveBeenCalledTimes(1);
-            expect(jwtVerifier.verifyAccessToken).toHaveBeenCalledWith(token, config);
-            expect(result).toBe(payload);
-        });
-        it("debería propagar el error si validateTokenInput lanza una excepción", async () => {
-            const token = "invalid.token";
-            jwtValidator.validateTokenInput.mockImplementation(() => {
-                throw new Error("Invalid token format");
-            });
-            await expect(service.verifyAccessToken(token)).rejects.toThrow("Invalid token format");
-            // Si falla la validación, no debería llamar al verificador
-            expect(jwtVerifier.verifyAccessToken).not.toHaveBeenCalled();
-        });
-    });
-    describe("verifyRefreshToken", () => {
-        it("debería validar el token y delegar en JwtTokenVerifier.verifyRefreshToken", async () => {
-            const token = "refresh.token.value";
-            const payload = {
-                sub: "user-123",
-                roles: [
-                    {
-                        role: "user",
-                    },
-                ],
-                customClaims: {},
-                jti: "unique-jwt-id",
-                iss: "test-issuer",
-                aud: "test-audience",
-                iat: Date.now() / 1000,
-                exp: (Date.now() + 1000) / 1000,
-            };
-            jwtVerifier.verifyRefreshToken.mockResolvedValue(payload);
-            const result = await service.verifyRefreshToken(token);
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledTimes(1);
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledWith(token);
-            expect(jwtVerifier.verifyRefreshToken).toHaveBeenCalledTimes(1);
-            expect(jwtVerifier.verifyRefreshToken).toHaveBeenCalledWith(token, config);
-            expect(result).toBe(payload);
-        });
-    });
-    describe("getTokenExpiration", () => {
-        it("debería validar el token y delegar en JwtTokenVerifier.getTokenExpiration", async () => {
-            const token = "any.token.value";
-            const expectedDate = new Date(Date.now() + 10000);
-            jwtVerifier.getTokenExpiration.mockResolvedValue(expectedDate);
-            const result = await service.getTokenExpiration(token);
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledTimes(1);
-            expect(jwtValidator.validateTokenInput).toHaveBeenCalledWith(token);
-            expect(jwtVerifier.getTokenExpiration).toHaveBeenCalledTimes(1);
-            expect(jwtVerifier.getTokenExpiration).toHaveBeenCalledWith(token);
-            expect(result).toBe(expectedDate);
-        });
-        it("debería propagar el error si validateTokenInput lanza una excepción", async () => {
-            const token = "invalid.token";
-            jwtValidator.validateTokenInput.mockImplementation(() => {
-                throw new Error("Invalid token");
-            });
-            await expect(service.getTokenExpiration(token)).rejects.toThrow("Invalid token");
-            expect(jwtVerifier.getTokenExpiration).not.toHaveBeenCalled();
-        });
-    });
-});

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

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