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

package/dist/tests/application/use-cases/logout-use-case.spec.js

@@ -1,40 +0,0 @@
-"use strict";
-// tests/application/use-cases/logout.usecase.spec.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-const application_1 = require("src/application");
-const domain_1 = require("../../../src/domain");
-describe("LogoutUseCase", () => {
-    let tokenSessionMock;
-    let useCase;
-    beforeEach(() => {
-        tokenSessionMock = {
-            revokeSession: jest.fn(),
-        };
-        // Solo necesitamos revokeSession para este caso de uso,
-        // así que casteamos al tipo completo de ITokenSession.
-        useCase = new application_1.LogoutUseCase(tokenSessionMock);
-    });
-    it("debería cerrar sesión correctamente cuando revokeSession no lanza error", async () => {
-        // Arrange
-        const request = { refreshToken: "valid-refresh-token" };
-        tokenSessionMock.revokeSession.mockResolvedValueOnce(); // Promise<void>
-        // Act
-        const response = await useCase.execute(request);
-        // Assert
-        expect(tokenSessionMock.revokeSession).toHaveBeenCalledTimes(1);
-        expect(tokenSessionMock.revokeSession).toHaveBeenCalledWith("valid-refresh-token");
-        expect(response).toEqual({
-            success: true,
-            message: "Successfully logged out",
-        });
-    });
-    it("debería lanzar LogoutError cuando revokeSession lanza un error", async () => {
-        // Arrange
-        const request = { refreshToken: "invalid-refresh-token" };
-        tokenSessionMock.revokeSession.mockRejectedValueOnce(new Error("Some low-level error"));
-        // Act & Assert
-        await expect(useCase.execute(request)).rejects.toEqual(new domain_1.LogoutError("Failed to logout: invalid refresh token"));
-        expect(tokenSessionMock.revokeSession).toHaveBeenCalledTimes(1);
-        expect(tokenSessionMock.revokeSession).toHaveBeenCalledWith("invalid-refresh-token");
-    });
-});

package/dist/tests/application/use-cases/refresh-token-use-case.spec.d.ts

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

package/dist/tests/application/use-cases/refresh-token-use-case.spec.js

@@ -1,116 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const application_1 = require("src/application");
-const refresh_token_use_case_1 = require("src/application/use-cases/refresh-token.use-case");
-const domain_1 = require("src/domain");
-const infrastructure_1 = require("src/infrastructure");
-const shared_1 = require("src/shared");
-describe("RefreshTokenUseCase", () => {
-    let userRepo;
-    let credentialRepo;
-    let passwordHasher;
-    let jwtSigner;
-    let tokenGenerator;
-    let tokenSessionService;
-    const jwtConfig = {
-        accessTokenSecret: "access_secret_key_123",
-        refreshTokenSecret: "refresh_secret_key_123",
-        accessTokenExpirationMs: 1000 * 60 * 15, // 15 minutos
-        refreshTokenExpirationMs: 1000 * 60 * 60 * 24, // 1 día,
-        algorithm: "HS256",
-    };
-    // Hash válido de "Password123!" (cost 10)
-    const VALID_BCRYPT = "$2b$10$CwTycUXWue0Thq9StjUM0uJ8rS8o9VZqvE8G9W9C6q7CwTycUXWu2";
-    beforeEach(() => {
-        userRepo = new infrastructure_1.InMemoryUserRepository();
-        credentialRepo = new infrastructure_1.InMemoryCredentialRepository();
-        passwordHasher = new infrastructure_1.BcryptPasswordHasher();
-        jwtSigner = new infrastructure_1.JwtSigner(new shared_1.Base64UrlEncoder());
-        // 👇 Ajuste: orden típico (signer, encoder). Mantén tu firma real si difiere.
-        tokenGenerator = new infrastructure_1.JwtTokenGenerator(new shared_1.Base64UrlEncoder(), jwtSigner);
-        // TokenSessionJWT implementa ITokenSession
-        class TokenSessionJWT {
-            constructor(tokenGen, credentialRepo) {
-                this.tokenGen = tokenGen;
-                this.credentialRepo = credentialRepo;
-            }
-            validateSession(_accessToken) {
-                throw new Error("Method not implemented.");
-            }
-            async createSession(user) {
-                const accessToken = this.tokenGen.generateAccessToken({
-                    user: {
-                        id: user.id.getValue(),
-                        email: user.email.toString(),
-                        roles: user.roles.map((r) => ({ role: r.getValuePublic().role })),
-                    },
-                    config: jwtConfig,
-                });
-                const refreshToken = this.tokenGen.generateRefreshToken({
-                    user: {
-                        id: user.id.getValue(),
-                        email: user.email.toString(),
-                        roles: user.roles.map((r) => ({ role: r.getValuePublic().role })),
-                    },
-                    config: jwtConfig,
-                });
-                const credential = new domain_1.Credential({
-                    userId: new domain_1.Id(user.id.getValue()),
-                    accessToken,
-                    refreshToken,
-                    expiresAt: new Date(Date.now() + jwtConfig.accessTokenExpirationMs),
-                    createdAt: new Date(),
-                });
-                await this.credentialRepo.save(credential);
-                return credential;
-            }
-            async refreshSession(refreshToken) {
-                const found = await this.credentialRepo.findByRefreshToken(refreshToken);
-                if (!found)
-                    throw new domain_1.InvalidOrExpiredRefreshTokenError();
-                // ✅ (opcional) rotar: revocar el refresh anterior para evitar reutilización
-                await this.credentialRepo.deleteByRefreshToken(refreshToken);
-                const user = new domain_1.User({
-                    id: new domain_1.Id(found.userId.getValue()),
-                    email: new domain_1.Email("user@example.com"),
-                    roles: [new domain_1.Role("USER")],
-                    password: new domain_1.HashedPassword(VALID_BCRYPT),
-                    isActive: true,
-                    createdAt: new Date(),
-                    updatedAt: new Date(),
-                });
-                return this.createSession(user);
-            }
-            async revokeSession(refreshToken) {
-                await this.credentialRepo.deleteByRefreshToken(refreshToken);
-            }
-        }
-        tokenSessionService = new TokenSessionJWT(tokenGenerator, credentialRepo);
-    });
-    it("debería crear un usuario, loguearlo y refrescar su token", async () => {
-        // 1️⃣ Registrar usuario
-        const passwordPolicy = new domain_1.DefaultPasswordPolicy();
-        const registerUser = new application_1.RegisterUserUseCase(userRepo, passwordHasher, passwordPolicy);
-        const email = "user@example.com";
-        const password = "Password123!";
-        const roles = [{ role: "USER" }];
-        await registerUser.execute({ email, password, roles });
-        // 2️⃣ Loguear usuario
-        const login = new application_1.LoginWithPasswordUseCase(userRepo, passwordHasher, tokenSessionService);
-        const loginResponse = await login.execute({ email, password });
-        expect(loginResponse.accessToken).toBeDefined();
-        expect(loginResponse.refreshToken).toBeDefined();
-        // 3️⃣ Refrescar Token
-        const refreshTokenUseCase = new refresh_token_use_case_1.RefreshTokenUseCase(tokenSessionService);
-        const refreshed = await refreshTokenUseCase.execute({
-            refreshToken: loginResponse.refreshToken,
-        });
-        expect(refreshed.accessToken).toBeDefined();
-        expect(refreshed.refreshToken).toBeDefined();
-        expect(refreshed.refreshToken).not.toEqual(loginResponse.refreshToken);
-    });
-    it("debería lanzar InvalidOrExpiredRefreshTokenError si el token no existe", async () => {
-        const refreshTokenUseCase = new refresh_token_use_case_1.RefreshTokenUseCase(tokenSessionService);
-        await expect(refreshTokenUseCase.execute({ refreshToken: "invalid.token" })).rejects.toThrow(domain_1.InvalidOrExpiredRefreshTokenError);
-    });
-});

package/dist/tests/application/use-cases/register-user.usecase.spec.d.ts

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

package/dist/tests/application/use-cases/register-user.usecase.spec.js

@@ -1,151 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const application_1 = require("src/application");
-const domain_1 = require("src/domain");
-describe("RegisterUserUseCase", () => {
-    let userRepository;
-    let passwordHasher;
-    let passwordPolicy;
-    let useCase;
-    beforeEach(() => {
-        userRepository = {
-            findByEmail: jest.fn(),
-            save: jest.fn(),
-            // agrega otros métodos del repo si existen, con jest.fn()
-        };
-        passwordHasher = {
-            hash: jest.fn(),
-        };
-        passwordPolicy = {
-            validateStrength: jest.fn(),
-            getRequirements: jest.fn(),
-        };
-        useCase = new application_1.RegisterUserUseCase(userRepository, passwordHasher, passwordPolicy);
-        jest.clearAllMocks();
-    });
-    it("debería lanzar PasswordPolicyViolationError si la contraseña no cumple la política", async () => {
-        const weakPasswordErrors = ["Too short", "No number"];
-        passwordPolicy.validateStrength.mockReturnValue({
-            isValid: false,
-            errors: weakPasswordErrors,
-        });
-        const request = {
-            email: "test@example.com",
-            password: "weak",
-            roles: [],
-        };
-        await expect(useCase.execute(request)).rejects.toBeInstanceOf(domain_1.PasswordPolicyViolationError);
-        expect(passwordPolicy.validateStrength).toHaveBeenCalledWith(request.password);
-        expect(userRepository.findByEmail).not.toHaveBeenCalled();
-        expect(passwordHasher.hash).not.toHaveBeenCalled();
-        expect(userRepository.save).not.toHaveBeenCalled();
-    });
-    it("debería lanzar EmailAlreadyInUseError si el email ya existe", async () => {
-        passwordPolicy.validateStrength.mockReturnValue({
-            isValid: true,
-            errors: [],
-        });
-        // No necesitamos un User real, basta con algo truthy
-        const existingUser = {};
-        userRepository.findByEmail.mockResolvedValue(existingUser);
-        const request = {
-            email: "used@example.com",
-            password: "StrongP@ss1",
-            roles: [],
-        };
-        await expect(useCase.execute(request)).rejects.toBeInstanceOf(domain_1.EmailAlreadyInUseError);
-        expect(passwordPolicy.validateStrength).toHaveBeenCalledWith(request.password);
-        expect(userRepository.findByEmail).toHaveBeenCalledTimes(1);
-        expect(passwordHasher.hash).not.toHaveBeenCalled();
-        expect(userRepository.save).not.toHaveBeenCalled();
-    });
-    it("debería registrar un usuario, guardar en el repositorio y retornar la respuesta correcta", async () => {
-        passwordPolicy.validateStrength.mockReturnValue({
-            isValid: true,
-            errors: [],
-        });
-        userRepository.findByEmail.mockResolvedValue(null);
-        const hashedPassword = "hashed-password-123";
-        passwordHasher.hash.mockResolvedValue(hashedPassword);
-        const request = {
-            email: "newuser@example.com",
-            password: "StrongP@ss1",
-            roles: [
-                {
-                    role: "ADMIN",
-                    permissions: ["user.read", "user.write"],
-                },
-            ],
-        };
-        // Fake user que retornará User.create
-        const fakeUserIdValue = "generated-user-id";
-        const fakePublicRoles = [
-            {
-                role: "ADMIN",
-                permissions: ["user.read", "user.write"],
-            },
-        ];
-        const fakeUser = {
-            id: {
-                getValue: jest.fn().mockReturnValue(fakeUserIdValue),
-            },
-            roles: [
-                {
-                    getValuePublic: jest.fn().mockReturnValue(fakePublicRoles[0]),
-                },
-            ],
-            isActive: true,
-        };
-        const createSpy = jest
-            .spyOn(domain_1.User, "create")
-            .mockReturnValue(fakeUser);
-        const result = await useCase.execute(request);
-        // Validar interacción con passwordPolicy y repos
-        expect(passwordPolicy.validateStrength).toHaveBeenCalledWith(request.password);
-        expect(userRepository.findByEmail).toHaveBeenCalledTimes(1);
-        expect(passwordHasher.hash).toHaveBeenCalledWith(request.password);
-        // Validar que se llama User.create con los argumentos esperados
-        expect(createSpy).toHaveBeenCalledWith(request.email, expect.arrayContaining([
-            expect.objectContaining({}), // aquí solo validamos que se pasó al menos un Role
-        ]), hashedPassword);
-        // Validar que se persiste el usuario
-        expect(userRepository.save).toHaveBeenCalledWith(fakeUser);
-        const expectedResponse = {
-            id: fakeUserIdValue,
-            roles: fakePublicRoles,
-            isActive: true,
-        };
-        expect(result).toEqual(expectedResponse);
-    });
-    it("debería permitir registrar usuario sin roles (array vacío por defecto)", async () => {
-        passwordPolicy.validateStrength.mockReturnValue({
-            isValid: true,
-            errors: [],
-        });
-        userRepository.findByEmail.mockResolvedValue(null);
-        const hashedPassword = "hashed-no-roles";
-        passwordHasher.hash.mockResolvedValue(hashedPassword);
-        const request = {
-            email: "noroles@example.com",
-            password: "StrongP@ss1",
-            // roles: undefined
-        };
-        const fakeUser = {
-            id: {
-                getValue: jest.fn().mockReturnValue("no-roles-id"),
-            },
-            roles: [],
-            isActive: true,
-        };
-        jest.spyOn(domain_1.User, "create").mockReturnValue(fakeUser);
-        const result = await useCase.execute(request);
-        expect(userRepository.findByEmail).toHaveBeenCalledTimes(1);
-        expect(passwordHasher.hash).toHaveBeenCalledWith(request.password);
-        expect(userRepository.save).toHaveBeenCalledWith(fakeUser);
-        expect(result).toEqual({
-            id: "no-roles-id",
-            roles: [],
-            isActive: true,
-        });
-    });
-});

package/dist/tests/domain/entities/credential.spec.d.ts

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

package/dist/tests/domain/entities/credential.spec.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const credential_entity_1 = require("../../../src/domain/entities/credential.entity");
-const object_values_1 = require("../../../src/domain/object-values");
-describe("Credential", () => {
-    const ACCESS = "access.jwt.token.mock";
-    const REFRESH = "refresh.jwt.token.mock";
-    beforeAll(() => {
-        // Controlamos el tiempo del sistema para pruebas deterministas
-        jest.useFakeTimers();
-    });
-    afterAll(() => {
-        // Restauramos el tiempo real
-        jest.useRealTimers();
-    });
-    test("create(): crea credenciales válidas con timestamps correctos", () => {
-        const now = new Date("2025-01-01T10:00:00.000Z");
-        jest.setSystemTime(now);
-        const userId = new object_values_1.Id("user-123");
-        const expiresAt = new Date(now.getTime() + 60 * 60 * 1000); // +1h
-        const cred = credential_entity_1.Credential.create(userId, ACCESS, REFRESH, expiresAt);
-        expect(cred.userId.equals(userId)).toBe(true);
-        expect(cred.accessToken).toBe(ACCESS);
-        expect(cred.refreshToken).toBe(REFRESH);
-        // createdAt debe ser ~ now, y expiresAt exactamente el pasado
-        expect(cred.createdAt.toISOString()).toBe(now.toISOString());
-        expect(cred.expiresAt.toISOString()).toBe(expiresAt.toISOString());
-        // Estado
-        expect(cred.isExpired()).toBe(false);
-        expect(cred.isValid()).toBe(true);
-    });
-    test("isExpired(): expira cuando now > expiresAt", () => {
-        const base = new Date("2025-01-01T10:00:00.000Z");
-        const expires = new Date("2025-01-01T10:10:00.000Z");
-        jest.setSystemTime(base);
-        const cred = credential_entity_1.Credential.create(new object_values_1.Id("u-1"), ACCESS, REFRESH, expires);
-        // Antes de expirar
-        jest.setSystemTime(new Date("2025-01-01T10:09:59.000Z"));
-        expect(cred.isExpired()).toBe(false);
-        expect(cred.isValid()).toBe(true);
-        // Justo en el borde (now === expiresAt) → NO está expirado (usa >, no >=)
-        jest.setSystemTime(new Date("2025-01-01T10:10:00.000Z"));
-        expect(cred.isExpired()).toBe(false);
-        expect(cred.isValid()).toBe(true);
-        // Después de expirar
-        jest.setSystemTime(new Date("2025-01-01T10:10:01.000Z"));
-        expect(cred.isExpired()).toBe(true);
-        expect(cred.isValid()).toBe(false);
-    });
-    test("getters de Date devuelven copias (no exponen estado interno)", () => {
-        const now = new Date("2025-01-01T12:00:00.000Z");
-        jest.setSystemTime(now);
-        const expires = new Date(now.getTime() + 5 * 60 * 1000); // +5m
-        const cred = credential_entity_1.Credential.create(new object_values_1.Id("u-2"), ACCESS, REFRESH, expires);
-        const createdAtCopy = cred.createdAt;
-        const expiresAtCopy = cred.expiresAt;
-        // Mutamos las copias
-        createdAtCopy.setFullYear(1999);
-        expiresAtCopy.setFullYear(1999);
-        // El estado interno debe mantenerse intacto
-        expect(cred.createdAt.toISOString()).toBe(now.toISOString());
-        expect(cred.expiresAt.toISOString()).toBe(expires.toISOString());
-    });
-    test("reconstitute(): reconstruye desde props sin alterar valores", () => {
-        const propsNow = new Date("2025-02-02T08:00:00.000Z");
-        const propsExp = new Date("2025-02-02T09:00:00.000Z");
-        const userId = new object_values_1.Id("user-xyz");
-        const cred = credential_entity_1.Credential.reconstitute({
-            userId,
-            accessToken: ACCESS,
-            refreshToken: REFRESH,
-            createdAt: propsNow,
-            expiresAt: propsExp,
-        });
-        expect(cred.userId.equals(userId)).toBe(true);
-        expect(cred.accessToken).toBe(ACCESS);
-        expect(cred.refreshToken).toBe(REFRESH);
-        expect(cred.createdAt.toISOString()).toBe(propsNow.toISOString());
-        expect(cred.expiresAt.toISOString()).toBe(propsExp.toISOString());
-        expect(cred.isExpired()).toBe(false);
-        expect(cred.isValid()).toBe(true);
-    });
-    test("soporta IDs generados", () => {
-        const id = object_values_1.Id.generate();
-        const exp = new Date(Date.now() + 1000);
-        const cred = credential_entity_1.Credential.create(id, ACCESS, REFRESH, exp);
-        // Simple smoke tests
-        expect(typeof cred.userId.getValue).toBe("function");
-        expect(cred.accessToken).toBe(ACCESS);
-        expect(cred.refreshToken).toBe(REFRESH);
-        expect(cred.isValid()).toBe(true);
-    });
-});

package/dist/tests/domain/entities/user.spec.d.ts

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

package/dist/tests/domain/entities/user.spec.js

@@ -1,93 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-describe("User (Entity)", () => {
-    // Genera la cola EXACTA de 53 caracteres válidos para bcrypt
-    const makeBcrypt = (cost = 10) => `$2b$${String(cost).padStart(2, "0")}$${"A".repeat(53)}`;
-    let mockId;
-    let mockEmail;
-    let mockPassword;
-    let mockRole;
-    let baseDate;
-    let baseProps;
-    beforeEach(() => {
-        mockId = new domain_1.Id("user-123");
-        mockEmail = new domain_1.Email("test@example.com");
-        mockPassword = new domain_1.HashedPassword(makeBcrypt(10)); // ✅ válido: $2b$10$ + 53 chars
-        mockRole = new domain_1.Role("admin", [domain_1.Permission.create("read:*")]);
-        baseDate = new Date("2025-01-01T00:00:00.000Z");
-        baseProps = {
-            id: mockId,
-            email: mockEmail,
-            roles: [mockRole],
-            password: mockPassword,
-            isActive: true,
-            createdAt: baseDate,
-            updatedAt: baseDate,
-        };
-    });
-    describe("constructor & getters", () => {
-        it("crea correctamente una instancia con todas las propiedades", () => {
-            const user = new domain_1.User(baseProps);
-            expect(user.id).toBe(mockId);
-            expect(user.email).toBe(mockEmail);
-            expect(user.roles).toEqual([mockRole]);
-            expect(user.password).toBe(mockPassword);
-            expect(user.isActive).toBe(true);
-            expect(user.createdAt).toEqual(baseDate);
-            expect(user.updatedAt).toEqual(baseDate);
-        });
-        it("devuelve nuevas instancias de fecha (copia defensiva)", () => {
-            const user = new domain_1.User(baseProps);
-            const c1 = user.createdAt;
-            const c2 = user.createdAt;
-            const u1 = user.updatedAt;
-            const u2 = user.updatedAt;
-            expect(c1).not.toBe(c2);
-            expect(u1).not.toBe(u2);
-            expect(c1.getTime()).toBe(c2.getTime());
-            expect(u1.getTime()).toBe(u2.getTime());
-        });
-    });
-    describe("business methods", () => {
-        it("activate() cambia isActive a true y actualiza updatedAt", () => {
-            const user = new domain_1.User({ ...baseProps, isActive: false });
-            const before = user.updatedAt.getTime();
-            user.activate();
-            expect(user.isActive).toBe(true);
-            expect(user.updatedAt.getTime()).toBeGreaterThan(before);
-        });
-        it("deactivate() cambia isActive a false y actualiza updatedAt", () => {
-            const user = new domain_1.User({ ...baseProps, isActive: true });
-            const before = user.updatedAt.getTime();
-            user.deactivate();
-            expect(user.isActive).toBe(false);
-            expect(user.updatedAt.getTime()).toBeGreaterThan(before);
-        });
-        it("canLogin() refleja el estado activo", () => {
-            expect(new domain_1.User({ ...baseProps, isActive: true }).canLogin()).toBe(true);
-            expect(new domain_1.User({ ...baseProps, isActive: false }).canLogin()).toBe(false);
-        });
-    });
-    describe("factory methods", () => {
-        it("create() genera valores válidos", () => {
-            const roles = [new domain_1.Role("user")];
-            const user = domain_1.User.create("person@example.com", roles, makeBcrypt(12));
-            expect(user).toBeInstanceOf(domain_1.User);
-            expect(user.id).toBeInstanceOf(domain_1.Id);
-            expect(user.email.getValue()).toBe("person@example.com");
-            expect(user.roles).toEqual(roles);
-            expect(user.password).toBeInstanceOf(domain_1.HashedPassword);
-            expect(user.isActive).toBe(true);
-            expect(user.createdAt).toBeInstanceOf(Date);
-            expect(user.updatedAt).toBeInstanceOf(Date);
-        });
-        it("reconstitute() reconstruye desde props", () => {
-            const user = domain_1.User.reconstitute(baseProps);
-            expect(user.id).toBe(mockId);
-            expect(user.email).toBe(mockEmail);
-            expect(user.roles[0]).toBe(mockRole);
-            expect(user.password).toBe(mockPassword);
-        });
-    });
-});

package/dist/tests/domain/object-values/email.spec.d.ts

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

package/dist/tests/domain/object-values/email.spec.js

@@ -1,77 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("src/domain/errors");
-const email_1 = require("src/domain/object-values/email");
-describe("Email Value Object", () => {
-    // 1️⃣ Casos válidos
-    describe("creación válida", () => {
-        test("crea correctamente un email bien formado", () => {
-            const email = new email_1.Email("User@Test.COM");
-            expect(email.getValue()).toBe("user@test.com");
-        });
-        test("elimina espacios al inicio y final y convierte a minúsculas", () => {
-            const email = new email_1.Email("   MyMail@Example.COM   ");
-            expect(email.getValue()).toBe("mymail@example.com");
-        });
-        test("toString devuelve el mismo valor normalizado", () => {
-            const email = new email_1.Email("Example@Mail.COM");
-            expect(email.toString()).toBe("example@mail.com");
-        });
-    });
-    // 2️⃣ Casos inválidos de formato
-    describe("formato inválido", () => {
-        test("lanza InvalidEmailError si falta el símbolo '@'", () => {
-            expect(() => new email_1.Email("invalidemail.com")).toThrow(errors_1.InvalidEmailError);
-        });
-        test("lanza InvalidEmailError si falta dominio", () => {
-            expect(() => new email_1.Email("user@")).toThrow(errors_1.InvalidEmailError);
-        });
-        test("lanza InvalidEmailError si falta usuario", () => {
-            expect(() => new email_1.Email("@domain.com")).toThrow(errors_1.InvalidEmailError);
-        });
-        test("lanza InvalidEmailError si el dominio no tiene punto", () => {
-            expect(() => new email_1.Email("user@domain")).toThrow(errors_1.InvalidEmailError);
-        });
-        test("lanza InvalidEmailError si hay caracteres inválidos", () => {
-            expect(() => new email_1.Email("user@@domain.com")).toThrow(errors_1.InvalidEmailError);
-            expect(() => new email_1.Email("user domain@com")).toThrow(errors_1.InvalidEmailError);
-        });
-        test("lanza InvalidEmailError si excede 254 caracteres", () => {
-            const longLocalPart = "a".repeat(245);
-            const tooLong = `${longLocalPart}@example.com`;
-            expect(() => new email_1.Email(tooLong)).toThrow(errors_1.InvalidEmailError);
-        });
-    });
-    // 3️⃣ Igualdad
-    describe("equals", () => {
-        test("devuelve true si los valores normalizados coinciden", () => {
-            const a = new email_1.Email("User@Test.com");
-            const b = new email_1.Email("user@test.com");
-            expect(a.equals(b)).toBe(true);
-        });
-        test("devuelve false si los valores son distintos", () => {
-            const a = new email_1.Email("user1@test.com");
-            const b = new email_1.Email("user2@test.com");
-            expect(a.equals(b)).toBe(false);
-        });
-    });
-    // 4️⃣ Robustez ante espacios y casos mixtos
-    describe("normalización", () => {
-        test("ignora espacios extra y respeta minúsculas", () => {
-            const email = new email_1.Email("  TestUser@Example.COM  ");
-            expect(email.getValue()).toBe("testuser@example.com");
-        });
-    });
-    // 5️⃣ Mensaje de error (opcional)
-    describe("mensaje de error", () => {
-        test("incluye el valor original en el mensaje del InvalidEmailError", () => {
-            try {
-                new email_1.Email("bad-email");
-            }
-            catch (err) {
-                expect(err).toBeInstanceOf(errors_1.InvalidEmailError);
-                expect(err.message).toMatch(/bad-email/);
-            }
-        });
-    });
-});

package/dist/tests/domain/object-values/hashed-password.spec.d.ts

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

package/dist/tests/domain/object-values/hashed-password.spec.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../../src/domain/errors");
-const hashed_password_1 = require("../../../src/domain/object-values/hashed-password");
-// Tests para HashedPassword
-describe("HashedPassword", () => {
-    // Genera la cola de 53 caracteres válidos para bcrypt
-    const makePayload = (c = "A") => c.repeat(53);
-    // Genera un hash bcrypt válido con cost y prefijo dados
-    const makeHash = (cost, prefix = "2b") => `$${prefix}$${String(cost).padStart(2, "0")}$${makePayload()}`;
-    // Casos de prueba
-    it("lanza error si el hash es null", () => {
-        // Prueba para null
-        expect(() => new hashed_password_1.HashedPassword(null)).toThrow(new errors_1.InvalidHashedPasswordError("Hashed password cannot be null or undefined"));
-    });
-    // Prueba para undefined
-    it("lanza error si el hash es undefined", () => {
-        expect(() => new hashed_password_1.HashedPassword(undefined)).toThrow(new errors_1.InvalidHashedPasswordError("Hashed password cannot be null or undefined"));
-    });
-    // Prueba para cadena vacía
-    it("lanza error si el hash está vacío", () => {
-        expect(() => new hashed_password_1.HashedPassword("   ")).toThrow(new errors_1.InvalidHashedPasswordError("Hashed password cannot be empty"));
-    });
-    // Prueba para formato inválido
-    it("lanza error si el hash no tiene formato bcrypt válido", () => {
-        // Falta un carácter (52 en lugar de 53) → rompe el regex
-        const invalidFormat = `$2b$10$${"A".repeat(52)}`;
-        // Ejecutar prueba
-        expect(() => new hashed_password_1.HashedPassword(invalidFormat)).toThrow(new errors_1.InvalidHashedPasswordError("Invalid bcrypt hash format"));
-    });
-    // Prueba para cost factor inválido (menor a 4)
-    it("lanza error si el cost factor es menor a 4", () => {
-        // Generar hash con cost factor 3
-        const lowCost = makeHash(3); // "03"
-        // Ejecutar prueba
-        expect(() => new hashed_password_1.HashedPassword(lowCost)).toThrow(new errors_1.InvalidHashedPasswordError("Invalid bcrypt cost factor"));
-    });
-    // Prueba para cost factor inválido (mayor a 31)
-    it("lanza error si el cost factor es mayor a 31", () => {
-        const highCost = makeHash(32); // "32"
-        // Ejecutar prueba
-        expect(() => new hashed_password_1.HashedPassword(highCost)).toThrow(new errors_1.InvalidHashedPasswordError("Invalid bcrypt cost factor"));
-    });
-    it("crea instancia válida con hash correcto", () => {
-        const valid = makeHash(10); // dentro de [4..31]
-        const hashed = new hashed_password_1.HashedPassword(valid);
-        expect(hashed.value).toBe(valid);
-    });
-    it("trimea espacios y sigue válido", () => {
-        const valid = `  ${makeHash(12)}  `;
-        const hashed = new hashed_password_1.HashedPassword(valid);
-        expect(hashed.value).toBe(valid.trim());
-    });
-});

package/dist/tests/domain/object-values/id.spec.d.ts

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