@jmlq/logger 0.1.0-alpha.6 → 0.1.0-alpha.8

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_logs_use_case_1 = require("../../../src/application/use-cases/get-logs.use-case");
+const value_objects_1 = require("../../../src/domain/value-objects");
+describe("GetLogsUseCase", () => {
+    it("debe retornar [] si el datasource no implementa find", async () => {
+        const dsSinFind = {
+            save: jest.fn().mockResolvedValue(undefined),
+            name: "no-find-ds",
+            // sin find
+        };
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(dsSinFind);
+        const result = await useCase.execute();
+        expect(result).toEqual([]);
+    });
+    it("debe llamar a ds.find con undefined cuando no se pasa filtro y find está implementado", async () => {
+        const logsSimulados = [
+            {
+                level: value_objects_1.LogLevel.INFO,
+                message: "log 1",
+                timestamp: Date.now(),
+            },
+        ];
+        const findMock = jest.fn(async () => logsSimulados);
+        const dsMock = {
+            save: jest.fn().mockResolvedValue(undefined),
+            find: findMock,
+            name: "memory",
+        };
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(dsMock);
+        const result = await useCase.execute();
+        expect(findMock).toHaveBeenCalledTimes(1);
+        expect(findMock).toHaveBeenCalledWith(undefined);
+        expect(result).toBe(logsSimulados);
+    });
+    it("debe sanitizar limit (tope 5000, ignora <= 0) y offset (solo >= 0) antes de llamar a ds.find", async () => {
+        let capturedFilter;
+        const findMock = jest.fn(async (filter) => {
+            capturedFilter = filter;
+            return [];
+        });
+        const dsMock = {
+            save: jest.fn().mockResolvedValue(undefined),
+            find: findMock,
+            name: "memory",
+        };
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(dsMock);
+        const rawFilter = {
+            levelMin: value_objects_1.LogLevel.WARN,
+            since: 1000,
+            until: 2000,
+            limit: 10000, // debería ser recortado a 5000
+            offset: -5, // debería convertirse en undefined
+            query: "error",
+        };
+        await useCase.execute(rawFilter);
+        expect(findMock).toHaveBeenCalledTimes(1);
+        expect(capturedFilter).toBeDefined();
+        const safe = capturedFilter;
+        expect(safe.levelMin).toBe(value_objects_1.LogLevel.WARN);
+        expect(safe.since).toBe(1000);
+        expect(safe.until).toBe(2000);
+        expect(safe.query).toBe("error");
+        // Sanitización:
+        expect(safe.limit).toBe(5000);
+        expect(safe.offset).toBeUndefined();
+    });
+    it("debe eliminar limit cuando es <= 0 y offset cuando es negativo o 0 (según implementación actual)", async () => {
+        let capturedFilter;
+        const findMock = jest.fn(async (filter) => {
+            capturedFilter = filter;
+            return [];
+        });
+        const dsMock = {
+            save: jest.fn().mockResolvedValue(undefined),
+            find: findMock,
+            name: "memory",
+        };
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(dsMock);
+        const filter = {
+            limit: 0, // <= 0 → undefined
+            offset: 0, // por la condición actual, también termina como undefined
+        };
+        await useCase.execute(filter);
+        expect(findMock).toHaveBeenCalledTimes(1);
+        expect(capturedFilter).toBeDefined();
+        const safe = capturedFilter;
+        expect(safe.limit).toBeUndefined();
+        expect(safe.offset).toBeUndefined();
+    });
+    it("debe mantener limit y offset válidos cuando están en rango aceptable", async () => {
+        let capturedFilter;
+        const findMock = jest.fn(async (filter) => {
+            capturedFilter = filter;
+            return [];
+        });
+        const dsMock = {
+            save: jest.fn().mockResolvedValue(undefined),
+            find: findMock,
+            name: "memory",
+        };
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(dsMock);
+        const filter = {
+            limit: 100,
+            offset: 10,
+        };
+        await useCase.execute(filter);
+        expect(findMock).toHaveBeenCalledTimes(1);
+        expect(capturedFilter).toBeDefined();
+        const safe = capturedFilter;
+        expect(safe.limit).toBe(100);
+        expect(safe.offset).toBe(10);
+    });
+});

package/dist/tests/application/use-cases/save-log.use-case.spec.d.ts

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

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

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const use_cases_1 = require("../../../src/application/use-cases");
+const value_objects_1 = require("../../../src/domain/value-objects");
+const services_1 = require("../../../src/domain/services");
+const create_pii_redactor_mock_1 = require("../../test-utils/create-pii-redactor-mock");
+// Mock explícito del servicio de normalización/PII del mensaje
+jest.mock("../../../src/domain/services", () => ({
+    normalizeMessage: jest.fn(),
+}));
+describe("SaveLogUseCase", () => {
+    let dsMock;
+    let redactorMock;
+    let props;
+    let useCase;
+    let fixedNow;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        fixedNow = 1700000000000; // número fijo para timestamp
+        jest.spyOn(Date, "now").mockReturnValue(fixedNow);
+        dsMock = {
+            save: jest.fn().mockResolvedValue(undefined),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+            name: "test-datasource",
+        };
+        redactorMock = (0, create_pii_redactor_mock_1.createPiiRedactorMock)();
+        props = {
+            ds: dsMock,
+            minLevel: value_objects_1.LogLevel.INFO,
+            redactor: redactorMock,
+        };
+        useCase = new use_cases_1.SaveLogUseCase(props);
+    });
+    afterEach(() => {
+        // restaurar Date.now si hay otros tests en el proyecto
+        Date.now.mockRestore?.();
+    });
+    it("no debe guardar el log si el nivel es menor que el minLevel (filtro por nivel)", async () => {
+        const level = value_objects_1.LogLevel.DEBUG; // < INFO
+        const message = "Mensaje de debug que no debería guardarse";
+        await useCase.execute(level, message);
+        // No se normaliza ni se redacta nada
+        expect(services_1.normalizeMessage).not.toHaveBeenCalled();
+        expect(redactorMock.redact).not.toHaveBeenCalled();
+        // No se persiste el log
+        expect(dsMock.save).not.toHaveBeenCalled();
+    });
+    it("debe guardar el log si el nivel es igual al minLevel", async () => {
+        const level = value_objects_1.LogLevel.INFO; // == minLevel
+        const message = "Mensaje de info";
+        services_1.normalizeMessage.mockReturnValue("mensaje-normalizado");
+        await useCase.execute(level, message);
+        expect(services_1.normalizeMessage).toHaveBeenCalledTimes(1);
+        expect(services_1.normalizeMessage).toHaveBeenCalledWith(message, redactorMock);
+        expect(dsMock.save).toHaveBeenCalledTimes(1);
+        const savedLog = dsMock.save.mock.calls[0][0];
+        expect(savedLog.level).toBe(level);
+        expect(savedLog.message).toBe("mensaje-normalizado");
+        expect(savedLog.meta).toBeUndefined();
+        expect(savedLog.timestamp).toBe(fixedNow);
+    });
+    it("debe normalizar el mensaje, redactar meta y guardar el log cuando level >= minLevel (ejemplo de PII)", async () => {
+        const level = value_objects_1.LogLevel.ERROR;
+        const rawMessage = "Error al procesar tarjeta 4111-1111-1111-1111 del usuario john.doe@example.com";
+        const metaConPii = {
+            user: {
+                email: "john.doe@example.com",
+                card: "4111-1111-1111-1111",
+            },
+        };
+        // Simulamos que normalizeMessage aplica cierta redacción básica de PII
+        services_1.normalizeMessage.mockImplementation((msg, _redactor) => {
+            if (typeof msg === "string") {
+                return msg
+                    .replace(/\d{4}-\d{4}-\d{4}-\d{4}/g, "****-****-****-****")
+                    .replace(/[\w.-]+@[\w.-]+/g, "***@***");
+            }
+            return msg;
+        });
+        // Simulamos que el redactor también actúa sobre meta (ejemplo PII)
+        redactorMock.redact.mockImplementation((value) => {
+            if (value?.user) {
+                return {
+                    ...value,
+                    user: {
+                        ...value.user,
+                        email: "***@***",
+                        card: "****-****-****-****",
+                    },
+                };
+            }
+            return value;
+        });
+        await useCase.execute(level, rawMessage, metaConPii);
+        // 1) Se debe normalizar el mensaje con el redactor
+        expect(services_1.normalizeMessage).toHaveBeenCalledTimes(1);
+        expect(services_1.normalizeMessage).toHaveBeenCalledWith(rawMessage, redactorMock);
+        // 2) Se debe redactar la meta
+        expect(redactorMock.redact).toHaveBeenCalledTimes(1);
+        expect(redactorMock.redact).toHaveBeenCalledWith(metaConPii);
+        // 3) Se debe llamar a save con el log ya procesado
+        expect(dsMock.save).toHaveBeenCalledTimes(1);
+        const savedLog = dsMock.save.mock.calls[0][0];
+        expect(savedLog.level).toBe(level);
+        expect(savedLog.timestamp).toBe(fixedNow);
+        // Mensaje con PII de tarjeta + email redactado por normalizeMessage simulado
+        expect(savedLog.message).toBe("Error al procesar tarjeta ****-****-****-**** del usuario ***@***");
+        // Meta con PII redactado por redactorMock
+        expect(savedLog.meta).toEqual({
+            user: {
+                email: "***@***",
+                card: "****-****-****-****",
+            },
+        });
+    });
+    it("debe llamar a redact(meta) solo cuando meta está definido", async () => {
+        const level = value_objects_1.LogLevel.WARN;
+        const message = "Advertencia con y sin meta";
+        services_1.normalizeMessage.mockReturnValue("msg-warn");
+        // 1️⃣ Llamada SIN meta
+        await useCase.execute(level, message);
+        expect(redactorMock.redact).not.toHaveBeenCalled();
+        expect(dsMock.save).toHaveBeenCalledTimes(1);
+        const logSinMeta = dsMock.save.mock.calls[0][0];
+        expect(logSinMeta.meta).toBeUndefined();
+        // 2️⃣ Llamada CON meta
+        const meta = { foo: "bar" };
+        await useCase.execute(level, message, meta);
+        // Ahora sí debe haber sido llamada para la segunda ejecución
+        expect(redactorMock.redact).toHaveBeenCalledTimes(1);
+        expect(redactorMock.redact).toHaveBeenCalledWith(meta);
+        expect(dsMock.save).toHaveBeenCalledTimes(2);
+        const logConMeta = dsMock.save.mock.calls[1][0];
+        expect(logConMeta.meta).toBe(meta); // como redactorMock.redact devuelve el mismo valor
+    });
+});

package/dist/tests/domain/services/log-level.service.spec.d.ts

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

package/dist/tests/domain/services/log-level.service.spec.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const domain_1 = require("src/domain");
+describe("toLogLevel()", () => {
+    // --------------------------------------------------------------------------
+    // 1. Strings válidos
+    // --------------------------------------------------------------------------
+    it("debe convertir strings válidos al LogLevel correcto", () => {
+        expect((0, domain_1.toLogLevel)("trace")).toBe(domain_1.LogLevel.TRACE);
+        expect((0, domain_1.toLogLevel)("debug")).toBe(domain_1.LogLevel.DEBUG);
+        expect((0, domain_1.toLogLevel)("info")).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)("warn")).toBe(domain_1.LogLevel.WARN);
+        expect((0, domain_1.toLogLevel)("error")).toBe(domain_1.LogLevel.ERROR);
+        expect((0, domain_1.toLogLevel)("fatal")).toBe(domain_1.LogLevel.FATAL);
+    });
+    // --------------------------------------------------------------------------
+    // 2. Insensibilidad a mayúsculas/minúsculas
+    // --------------------------------------------------------------------------
+    it("debe aceptar strings en cualquier tipo de casing", () => {
+        expect((0, domain_1.toLogLevel)("TRACE")).toBe(domain_1.LogLevel.TRACE);
+        expect((0, domain_1.toLogLevel)("DeBuG")).toBe(domain_1.LogLevel.DEBUG);
+        expect((0, domain_1.toLogLevel)("Warn")).toBe(domain_1.LogLevel.WARN);
+    });
+    // --------------------------------------------------------------------------
+    // 3. Valores numéricos válidos
+    // --------------------------------------------------------------------------
+    it("debe aceptar valores numéricos válidos del enum", () => {
+        expect((0, domain_1.toLogLevel)(domain_1.LogLevel.TRACE)).toBe(domain_1.LogLevel.TRACE);
+        expect((0, domain_1.toLogLevel)(domain_1.LogLevel.FATAL)).toBe(domain_1.LogLevel.FATAL);
+    });
+    // --------------------------------------------------------------------------
+    // 4. Valores numéricos inválidos
+    // --------------------------------------------------------------------------
+    it("debe retornar el valor por defecto si el número no pertenece al enum", () => {
+        expect((0, domain_1.toLogLevel)(999)).toBe(domain_1.LogLevel.INFO); // default implícito
+        expect((0, domain_1.toLogLevel)(999, domain_1.LogLevel.ERROR)).toBe(domain_1.LogLevel.ERROR); // default explícito
+    });
+    // --------------------------------------------------------------------------
+    // 5. Valores undefined o null
+    // --------------------------------------------------------------------------
+    it("debe usar el valor por defecto si el valor es undefined o null", () => {
+        expect((0, domain_1.toLogLevel)(undefined)).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)(null)).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)(undefined, domain_1.LogLevel.WARN)).toBe(domain_1.LogLevel.WARN);
+    });
+    // --------------------------------------------------------------------------
+    // 6. Strings desconocidos
+    // --------------------------------------------------------------------------
+    it("debe retornar el default si recibe un string no reconocido", () => {
+        expect((0, domain_1.toLogLevel)("unknown")).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)("invalid-level", domain_1.LogLevel.ERROR)).toBe(domain_1.LogLevel.ERROR);
+    });
+    // --------------------------------------------------------------------------
+    // 7. Otros tipos no soportados
+    // --------------------------------------------------------------------------
+    it("debe retornar el default si recibe objetos, booleanos u otros tipos", () => {
+        expect((0, domain_1.toLogLevel)({})).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)([])).toBe(domain_1.LogLevel.INFO);
+        expect((0, domain_1.toLogLevel)(true)).toBe(domain_1.LogLevel.INFO);
+    });
+    // --------------------------------------------------------------------------
+    // 8. Verifica que el default param funciona correctamente
+    // --------------------------------------------------------------------------
+    it("debe aplicar correctamente el default proporcionado", () => {
+        expect((0, domain_1.toLogLevel)("something", domain_1.LogLevel.WARN)).toBe(domain_1.LogLevel.WARN);
+        expect((0, domain_1.toLogLevel)(undefined, domain_1.LogLevel.FATAL)).toBe(domain_1.LogLevel.FATAL);
+    });
+});

package/dist/tests/domain/services/normalize-message.spec.d.ts

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

package/dist/tests/domain/services/normalize-message.spec.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const domain_1 = require("src/domain");
+describe("normalizeMessage()", () => {
+    let redactorMock;
+    beforeEach(() => {
+        redactorMock = {
+            redact: jest.fn((value) => value), // por defecto retorna lo mismo
+        };
+    });
+    // -----------------------------------------------------------------------
+    // 1️⃣ Si el mensaje es string
+    // -----------------------------------------------------------------------
+    it("debe redactor un mensaje tipo string", () => {
+        const msg = "hello world";
+        const result = (0, domain_1.normalizeMessage)(msg, redactorMock);
+        expect(redactorMock.redact).toHaveBeenCalledWith("hello world");
+        expect(result).toBe("hello world");
+    });
+    // -----------------------------------------------------------------------
+    // 2️⃣ Si el mensaje es objeto
+    // -----------------------------------------------------------------------
+    it("debe redactor un objeto", () => {
+        const msg = { user: "test", email: "a@b.com" };
+        const redactedObj = { user: "test", email: "***" };
+        // Redactor retorna un valor distinto
+        redactorMock.redact.mockReturnValue(redactedObj);
+        const result = (0, domain_1.normalizeMessage)(msg, redactorMock);
+        expect(redactorMock.redact).toHaveBeenCalledWith(msg);
+        expect(result).toEqual(redactedObj);
+    });
+    // -----------------------------------------------------------------------
+    // 3️⃣ Si el mensaje es una función perezosa
+    // -----------------------------------------------------------------------
+    it("debe evaluar funciones perezosas y redactor su resultado", () => {
+        const lazyFn = jest.fn(() => "lazy-result");
+        const result = (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
+        expect(lazyFn).toHaveBeenCalledTimes(1);
+        expect(redactorMock.redact).toHaveBeenCalledWith("lazy-result");
+        expect(result).toBe("lazy-result");
+    });
+    // -----------------------------------------------------------------------
+    // 4️⃣ Función perezosa retornando un objeto
+    // -----------------------------------------------------------------------
+    it("debe procesar funciones perezosas que retornan objetos", () => {
+        const lazyObj = jest.fn(() => ({ ok: true }));
+        const result = (0, domain_1.normalizeMessage)(lazyObj, redactorMock);
+        expect(lazyObj).toHaveBeenCalledTimes(1);
+        expect(redactorMock.redact).toHaveBeenCalledWith({ ok: true });
+        expect(result).toEqual({ ok: true });
+    });
+    // -----------------------------------------------------------------------
+    // 5️⃣ El redactor puede transformar el valor
+    // -----------------------------------------------------------------------
+    it("debe retornar el valor transformado por el redactor", () => {
+        redactorMock.redact.mockReturnValue("***redacted***");
+        const result = (0, domain_1.normalizeMessage)("secret", redactorMock);
+        expect(result).toBe("***redacted***");
+    });
+    // -----------------------------------------------------------------------
+    // 6️⃣ Verifica que no ejecuta funciones más de una vez
+    // -----------------------------------------------------------------------
+    it("solo debe evaluar una vez la función perezosa", () => {
+        const lazyFn = jest.fn(() => "value");
+        (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
+        (0, domain_1.normalizeMessage)(lazyFn, redactorMock);
+        // Cada llamada a normalizeMessage ejecuta UNA vez la función
+        expect(lazyFn).toHaveBeenCalledTimes(2);
+    });
+    // -----------------------------------------------------------------------
+    // 7️⃣ Mensajes complejos
+    // -----------------------------------------------------------------------
+    it("debe soportar objetos complejos anidados", () => {
+        const complexObj = {
+            user: {
+                id: 1,
+                profile: { email: "a@b.com", phone: "12345" },
+            },
+        };
+        (0, domain_1.normalizeMessage)(complexObj, redactorMock);
+        expect(redactorMock.redact).toHaveBeenCalledWith(complexObj);
+    });
+});

package/dist/tests/domain/services/pii-redactor.spec.d.ts

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

package/dist/tests/domain/services/pii-redactor.spec.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const services_1 = require("../../../src/domain/services");
+describe("PiiRedactor", () => {
+    // -------------------------------------------------------------------------
+    // 1️⃣ Desactivado: debe retornar el valor sin modificar
+    // -------------------------------------------------------------------------
+    it("debe retornar el valor original si enabled=false", () => {
+        const redactor = new services_1.PiiRedactor({ enabled: false });
+        expect(redactor.redact("secret 123")).toBe("secret 123");
+        expect(redactor.redact({ email: "a@b.com" })).toEqual({
+            email: "a@b.com",
+        });
+    });
+    // -------------------------------------------------------------------------
+    // 2️⃣ Aplicación de patrones sobre strings
+    // -------------------------------------------------------------------------
+    it("debe aplicar patrones sobre strings cuando está enabled", () => {
+        const patterns = [
+            { pattern: "\\d+", replaceWith: "[NUM]" },
+            { pattern: "[\\w.-]+@[\\w.-]+\\.[A-Za-z]{2,}", replaceWith: "[EMAIL]" },
+        ];
+        const redactor = new services_1.PiiRedactor({ enabled: true, patterns });
+        const result = redactor.redact("Pago 123 por usuario test@example.com");
+        expect(result).toBe("Pago [NUM] por usuario [EMAIL]");
+    });
+    // -------------------------------------------------------------------------
+    // 3️⃣ Redacción profunda con objetos anidados
+    // -------------------------------------------------------------------------
+    it("debe aplicar redacción profunda en objetos con deep=true", () => {
+        const patterns = [
+            { pattern: "\\d{10}", replaceWith: "[PHONE]" },
+        ];
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            deep: true,
+            patterns,
+        });
+        const input = {
+            level1: {
+                phone: "0987654321",
+                nested: {
+                    phone2: "0987654321",
+                },
+            },
+        };
+        const output = redactor.redact(input);
+        expect(output.level1.phone).toBe("[PHONE]");
+        expect(output.level1.nested.phone2).toBe("[PHONE]");
+        // Verifica que no muta el objeto original
+        expect(input.level1.phone).toBe("0987654321");
+    });
+    // -------------------------------------------------------------------------
+    // 4️⃣ whitelistKeys debe impedir redacción
+    // -------------------------------------------------------------------------
+    it("whitelistKeys debe evitar la redacción de claves específicas", () => {
+        const patterns = [
+            { pattern: "\\d+", replaceWith: "*" },
+        ];
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            patterns,
+            whitelistKeys: ["safeField"],
+        });
+        const input = {
+            safeField: "12345",
+            normalField: "12345",
+        };
+        const result = redactor.redact(input);
+        expect(result.safeField).toBe("12345"); // No redactor
+        expect(result.normalField).toBe("*"); // Sí redactor
+    });
+    // -------------------------------------------------------------------------
+    // 5️⃣ blacklistKeys debe forzar redacción total
+    // -------------------------------------------------------------------------
+    it("blacklistKeys debe forzar '[REDACTED]'", () => {
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            blacklistKeys: ["password"],
+        });
+        const input = {
+            password: "super-secret",
+            other: "hello",
+        };
+        const result = redactor.redact(input);
+        expect(result.password).toBe("[REDACTED]");
+        expect(result.other).toBe("hello");
+    });
+    // -------------------------------------------------------------------------
+    // 6️⃣ Redacción profunda con arrays
+    // -------------------------------------------------------------------------
+    it("debe procesar arrays de forma profunda", () => {
+        const patterns = [
+            { pattern: "\\d+", replaceWith: "X" },
+        ];
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            deep: true,
+            patterns,
+        });
+        const input = {
+            arr: ["123", "abc", { phone: "456" }],
+        };
+        const result = redactor.redact(input);
+        expect(result.arr[0]).toBe("X");
+        expect(result.arr[1]).toBe("abc");
+        expect(result.arr[2]).toEqual({ phone: "X" });
+    });
+    // -------------------------------------------------------------------------
+    // 7️⃣ deep=false → no debe entrar a objetos anidados
+    // -------------------------------------------------------------------------
+    it("deep=false no debe redactor objetos anidados", () => {
+        const patterns = [
+            { pattern: "\\d+", replaceWith: "*" },
+        ];
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            deep: false,
+            patterns,
+        });
+        const input = {
+            inner: {
+                code: "123",
+            },
+        };
+        const result = redactor.redact(input);
+        expect(result.inner.code).toBe("123"); // No redactor en objetos internos
+    });
+    // -------------------------------------------------------------------------
+    // 8️⃣ Patrón inválido → no debe romper procesamiento
+    // -------------------------------------------------------------------------
+    it("si un patrón es inválido debe usar fallback y no romper redacción", () => {
+        const patterns = [
+            { pattern: "[invalid", replaceWith: "X" }, // inválido
+            { pattern: "\\d+", replaceWith: "#" },
+        ];
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            patterns,
+        });
+        const result = redactor.redact("abc123");
+        expect(result).toBe("abc#"); // Se aplicó el patrón válido
+    });
+    // -------------------------------------------------------------------------
+    // 9️⃣ updateOptions debe fusionar superficialmente props
+    // -------------------------------------------------------------------------
+    it("updateOptions debe fusionar opciones sin mutar referencia previa", () => {
+        const redactor = new services_1.PiiRedactor({
+            enabled: true,
+            deep: false,
+        });
+        redactor.updateOptions({
+            deep: true,
+            whitelistKeys: ["email"],
+        });
+        const after = redactor.props;
+        expect(after.enabled).toBe(true);
+        expect(after.deep).toBe(true);
+        expect(after.whitelistKeys).toEqual(["email"]);
+    });
+    // -------------------------------------------------------------------------
+    // 🔟 Tipos no soportados (number, boolean, function) no se redactan
+    // -------------------------------------------------------------------------
+    it("no debe redactor tipos primitivos no string/objeto", () => {
+        const redactor = new services_1.PiiRedactor({ enabled: true });
+        expect(redactor.redact(123)).toBe(123);
+        expect(redactor.redact(true)).toBe(true);
+        expect(redactor.redact(() => "hi")).toBeInstanceOf(Function);
+    });
+});

package/dist/tests/domain/services/to-pii-regex.spec.d.ts

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