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

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

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../../src/domain/errors");
-const id_1 = require("../../../src/domain/object-values/id");
-describe("Id (Value Object)", () => {
-    describe("constructor", () => {
-        it.each([null, undefined, "", "   "])("lanza error si id es inválido (%p)", (invalid) => {
-            expect(() => new id_1.Id(invalid)).toThrowError(new errors_1.InvalidIdError("User ID cannot be empty"));
-        });
-        it("trimea espacios y guarda el valor limpio", () => {
-            const id = new id_1.Id("   user-123   ");
-            expect(id.getValue()).toBe("user-123");
-            expect(id.toString()).toBe("user-123");
-        });
-    });
-    describe("equals", () => {
-        it("retorna true para Id con mismo valor", () => {
-            const a = new id_1.Id("abc123");
-            const b = new id_1.Id("abc123");
-            expect(a.equals(b)).toBe(true);
-        });
-        it("retorna false para Id con valores diferentes", () => {
-            const a = new id_1.Id("abc123");
-            const b = new id_1.Id("xyz789");
-            expect(a.equals(b)).toBe(false);
-        });
-    });
-    describe("generate", () => {
-        it("crea un Id válido no vacío", () => {
-            const id = id_1.Id.generate();
-            const value = id.getValue();
-            expect(typeof value).toBe("string");
-            expect(value.length).toBeGreaterThan(0);
-            expect(id).toBeInstanceOf(id_1.Id);
-        });
-        it("genera IDs distintos en llamadas separadas", () => {
-            const id1 = id_1.Id.generate().getValue();
-            const id2 = id_1.Id.generate().getValue();
-            expect(id1).not.toBe(id2);
-        });
-        it("el formato incluye timestamp y parte aleatoria", () => {
-            const id = id_1.Id.generate().getValue();
-            const [timestamp, random] = id.split("-");
-            expect(!isNaN(Number(timestamp))).toBe(true);
-            expect(random).toMatch(/^[a-z0-9]+$/);
-        });
-    });
-});

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

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

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

@@ -1,75 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../../src/domain/errors");
-const permission_1 = require("../../../src/domain/object-values/permission");
-describe("Permission (Value Object)", () => {
-    describe("constructor/crear", () => {
-        it.each([null, undefined])("lanza si es %p", (input) => {
-            expect(() => new permission_1.Permission(input)).toThrow(new errors_1.InvalidPermissionError("Permission cannot be null or undefined"));
-        });
-        it("lanza si no es string", () => {
-            expect(() => new permission_1.Permission(123)).toThrow(new errors_1.InvalidPermissionError("Permission must be a string"));
-        });
-        it("lanza si está vacío tras trim", () => {
-            expect(() => new permission_1.Permission("   ")).toThrow(new errors_1.InvalidPermissionError("Permission cannot be empty"));
-        });
-        it("normaliza a minúsculas y trim", () => {
-            const p = new permission_1.Permission("  READ:Users  ");
-            expect(p.getValue()).toBe("read:users");
-            expect(p.toString()).toBe("read:users");
-        });
-        it("create es un alias del constructor", () => {
-            const p = permission_1.Permission.create("Write:Posts");
-            expect(p.getValue()).toBe("write:posts");
-            expect(p).toBeInstanceOf(permission_1.Permission);
-        });
-    });
-    describe("equals", () => {
-        it("compara por valor normalizado", () => {
-            const a = new permission_1.Permission("read:users");
-            const b = new permission_1.Permission("READ:USERS");
-            const c = new permission_1.Permission("read:posts");
-            expect(a.equals(b)).toBe(true);
-            expect(a.equals(c)).toBe(false);
-        });
-    });
-    describe("isWildcard", () => {
-        it("true solo para '*'", () => {
-            expect(new permission_1.Permission("*").isWildcard()).toBe(true);
-            expect(new permission_1.Permission("read:*").isWildcard()).toBe(false);
-            expect(new permission_1.Permission("read:users").isWildcard()).toBe(false);
-        });
-    });
-    describe("matches", () => {
-        it("comodín total '*' hace match con cualquier target", () => {
-            const p = new permission_1.Permission("*");
-            expect(p.matches("read:users")).toBe(true);
-            expect(p.matches("WRITE:POSTS")).toBe(true);
-        });
-        it("match exacto", () => {
-            const p = new permission_1.Permission("read:users");
-            expect(p.matches("read:users")).toBe(true);
-            expect(p.matches("READ:USERS")).toBe(true); // case-insensitive en target
-            expect(p.matches("read:posts")).toBe(false);
-        });
-        it("prefijo 'read:*' coincide con 'read:algo'", () => {
-            const p = new permission_1.Permission("read:*");
-            expect(p.matches("read:users")).toBe(true);
-            expect(p.matches("read:posts")).toBe(true);
-            expect(p.matches("write:users")).toBe(false);
-        });
-        it("no coincide cuando el prefijo no aplica", () => {
-            const p = new permission_1.Permission("admin:*");
-            expect(p.matches("admin")).toBe(false); // requiere 'admin:...'
-            expect(p.matches("administrator:users")).toBe(false);
-        });
-        it("target inválido (no string o vacío) devuelve false", () => {
-            const p = new permission_1.Permission("read:*");
-            expect(p.matches("")).toBe(false);
-            expect(p.matches("   ")).toBe(false);
-            expect(p.matches(null)).toBe(false);
-            expect(p.matches(undefined)).toBe(false);
-            expect(p.matches(123)).toBe(false);
-        });
-    });
-});

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

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

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

@@ -1,139 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const errors_1 = require("../../../src/domain/errors");
-const permission_1 = require("../../../src/domain/object-values/permission");
-const role_1 = require("../../../src/domain/object-values/role");
-describe("Role (Value Object)", () => {
-    const P = {
-        READ_USERS: permission_1.Permission.create("read:users"),
-        READ_ANY: permission_1.Permission.create("read:*"),
-        WRITE_POSTS: permission_1.Permission.create("write:posts"),
-        STAR: permission_1.Permission.create("*"),
-    };
-    describe("constructor & validRoles", () => {
-        it.each([null, undefined])("lanza si role es %p", (input) => {
-            expect(() => new role_1.Role(input)).toThrow(new errors_1.InvalidRoleError("Role cannot be null or undefined"));
-        });
-        it("lanza si role no es string", () => {
-            // @ts-expect-error (intencional para probar runtime)
-            expect(() => new role_1.Role(123)).toThrow(new errors_1.InvalidRoleError("Role must be a string"));
-        });
-        it("lanza si role está vacío tras trim", () => {
-            expect(() => new role_1.Role("   ")).toThrow(new errors_1.InvalidRoleError("Role cannot be empty"));
-        });
-        it("acepta cualquier role no vacío cuando no se provee validRoles", () => {
-            const r = new role_1.Role("  Admin  ");
-            expect(r.toString()).toBe("admin");
-        });
-        it("valida role contra validRoles (case-insensitive) y lanza si no está incluido", () => {
-            expect(() => new role_1.Role("manager", [], ["Admin", "User"])).toThrow(new errors_1.InvalidRoleError("Invalid role: manager. Valid roles are: Admin, User"));
-        });
-        it("valida role contra validRoles (case-insensitive) y permite si está incluido", () => {
-            const r = new role_1.Role("ADMIN", [], ["admin", "user"]);
-            expect(r.toString()).toBe("admin");
-        });
-        it("lanza si algún validRole no es string", () => {
-            expect(() => new role_1.Role("admin", [], ["user", null])).toThrow(new errors_1.InvalidRoleError("Valid roles must be strings"));
-        });
-    });
-    describe("permissions input", () => {
-        it("lanza si algún permission no es instancia de Permission", () => {
-            expect(() => new role_1.Role("admin", [P.READ_USERS, "write:posts"])).toThrow(new errors_1.InvalidPermissionError("Permissions must be Permission instances"));
-        });
-        it("almacena permisos normalizados y sin duplicados", () => {
-            const r = new role_1.Role("admin", [
-                permission_1.Permission.create("READ:USERS"),
-                permission_1.Permission.create("read:users"),
-            ]);
-            const { permissions } = r.getValue();
-            // Un solo elemento y normalizado
-            expect(permissions).toEqual(["read:users"]);
-        });
-        it("getPermissions devuelve nuevas instancias de Permission", () => {
-            const r = new role_1.Role("admin", [P.READ_USERS, P.WRITE_POSTS]);
-            const perms = r.getPermissions();
-            expect(perms).toHaveLength(2);
-            expect(perms[0]).toBeInstanceOf(permission_1.Permission);
-            expect(perms.map((p) => p.getValue())).toEqual(expect.arrayContaining(["read:users", "write:posts"]));
-        });
-    });
-    describe("consultas de permisos", () => {
-        it("hasPermission true para match exacto (string y Permission)", () => {
-            const r = new role_1.Role("user", [P.READ_USERS]);
-            expect(r.hasPermission("read:users")).toBe(true);
-            expect(r.hasPermission(permission_1.Permission.create("READ:USERS"))).toBe(true);
-            expect(r.hasPermission("read:posts")).toBe(false);
-        });
-        it("soporta comodín total '*'", () => {
-            const r = new role_1.Role("user", [P.STAR]);
-            expect(r.hasPermission("cualquier:cosa")).toBe(true);
-            expect(r.hasPermission("otra")).toBe(true);
-        });
-        it("soporta prefijo 'read:*'", () => {
-            const r = new role_1.Role("user", [P.READ_ANY]);
-            expect(r.hasPermission("read:users")).toBe(true);
-            expect(r.hasPermission("read:posts")).toBe(true);
-            expect(r.hasPermission("write:users")).toBe(false);
-        });
-        it("hasAnyPermission true si al menos uno coincide", () => {
-            const r = new role_1.Role("user", [P.READ_USERS]);
-            expect(r.hasAnyPermission(["read:posts", "read:users"])).toBe(true);
-            expect(r.hasAnyPermission(["write:posts", "write:users"])).toBe(false);
-        });
-        it("hasAllPermissions true si todos coinciden", () => {
-            const r = new role_1.Role("user", [P.READ_USERS, P.WRITE_POSTS]);
-            expect(r.hasAllPermissions(["read:users", "write:posts"])).toBe(true);
-            expect(r.hasAllPermissions(["read:users", "write:users"])).toBe(false);
-        });
-    });
-    describe("utilidades y estáticos", () => {
-        it("equals compara por nombre normalizado", () => {
-            const a = new role_1.Role("ADMIN");
-            const b = new role_1.Role("admin");
-            const c = new role_1.Role("user");
-            expect(a.equals(b)).toBe(true);
-            expect(a.equals(c)).toBe(false);
-        });
-        it("hasRole es case-insensitive", () => {
-            const r = new role_1.Role("manager");
-            expect(r.hasRole("  MANAGER ")).toBe(true);
-            expect(r.hasRole("user")).toBe(false);
-        });
-        it("toString devuelve el nombre del rol", () => {
-            expect(new role_1.Role("Admin").toString()).toBe("admin");
-        });
-        it("create crea sin validRoles, withValidRoles valida", () => {
-            const a = role_1.Role.create("User", [P.READ_USERS]);
-            expect(a.getValue()).toEqual({
-                role: "user",
-                permissions: ["read:users"],
-            });
-            const b = role_1.Role.withValidRoles("User", [P.READ_USERS], ["admin", "user"]);
-            expect(b.getValuePublic()).toEqual({ role: "user" });
-        });
-    });
-    describe("withPermissions y canPerform", () => {
-        it("withPermissions retorna un NUEVO Role sin mutar el original", () => {
-            const base = new role_1.Role("user", [P.READ_USERS]);
-            const added = base.withPermissions([P.WRITE_POSTS]);
-            // original intacto
-            expect(base.getValue().permissions).toEqual(["read:users"]);
-            // nuevo con ambos
-            expect(added.getValue().permissions).toEqual(expect.arrayContaining(["read:users", "write:posts"]));
-            // y siguen sin duplicados si se repiten
-            const again = added.withPermissions([permission_1.Permission.create("WRITE:POSTS")]);
-            expect(again.getValue().permissions).toEqual(expect.arrayContaining(["read:users", "write:posts"]));
-            expect(again.getValue().permissions).toHaveLength(2);
-        });
-        it("canPerform(action) delega a hasPermission con acción simple", () => {
-            const r = new role_1.Role("user", [permission_1.Permission.create("export")]);
-            expect(r.canPerform("export")).toBe(true);
-            expect(r.canPerform("import")).toBe(false);
-        });
-        it("canPerform(action, resource) compone 'action:resource'", () => {
-            const r = new role_1.Role("user", [permission_1.Permission.create("read:*")]);
-            expect(r.canPerform("read", "users")).toBe(true);
-            expect(r.canPerform("write", "users")).toBe(false);
-        });
-    });
-});

package/dist/tests/domain/services/default-password-policy.spec.d.ts

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

package/dist/tests/domain/services/default-password-policy.spec.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const domain_1 = require("src/domain");
-describe("DefaultPasswordPolicy", () => {
-    let policy;
-    beforeEach(() => {
-        policy = new domain_1.DefaultPasswordPolicy();
-    });
-    it("debe aceptar una contraseña que cumple todos los requisitos", () => {
-        const password = "Str0ng!Pass";
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(true);
-        expect(result.errors).toHaveLength(0);
-    });
-    it("debe rechazar contraseñas demasiado cortas", () => {
-        const password = "S1!aB"; // < 8
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        expect(result.errors).toContain("Password must be at least 8 characters long");
-    });
-    it("debe rechazar contraseñas sin mayúsculas", () => {
-        const password = "str0ng!pass";
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        expect(result.errors).toContain("Password must include at least one uppercase letter");
-    });
-    it("debe rechazar contraseñas sin minúsculas", () => {
-        const password = "STR0NG!PASS";
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        expect(result.errors).toContain("Password must include at least one lowercase letter");
-    });
-    it("debe rechazar contraseñas sin número", () => {
-        const password = "Strong!Pass";
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        expect(result.errors).toContain("Password must include at least one number");
-    });
-    it("debe rechazar contraseñas sin carácter especial", () => {
-        const password = "Str0ngPass";
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        expect(result.errors).toContain("Password must include at least one special character (!@#$%^&*)");
-    });
-    it("debe reportar múltiples errores si faltan varias reglas", () => {
-        const password = "short"; // corto, sin mayúscula, sin número, sin especial
-        const result = policy.validateStrength(password);
-        expect(result.isValid).toBe(false);
-        // esperar al menos 3 errores: length, uppercase, number, special, lowercase may also fail depending on input
-        expect(result.errors.length).toBeGreaterThanOrEqual(3);
-        expect(result.errors).toEqual(expect.arrayContaining([
-            "Password must be at least 8 characters long",
-            "Password must include at least one uppercase letter",
-            "Password must include at least one number",
-            "Password must include at least one special character (!@#$%^&*)",
-        ]));
-    });
-    it("getRequirements debe devolver la lista de requisitos legible", () => {
-        const req = policy.getRequirements();
-        expect(Array.isArray(req)).toBe(true);
-        expect(req).toEqual(expect.arrayContaining([
-            "Minimum 8 characters",
-            "At least one uppercase letter",
-            "At least one lowercase letter",
-            "At least one number",
-            "At least one special character (!@#$%^&*)",
-        ]));
-    });
-});

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

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

package/dist/tests/doman/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/doman/entities/user.spec.d.ts

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

package/dist/tests/doman/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/doman/object-values/email.spec.d.ts

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

package/dist/tests/doman/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/doman/object-values/hashed-password.spec.d.ts

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