@jmlq/logger 0.1.0-alpha.1 → 0.1.0-alpha.10

package/dist/src/domain/value-objects/log-level.vo.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+var LogLevel;
+(function (LogLevel) {
+    // Orden creciente permite comparar por severidad (trace < debug < ...)
+    LogLevel[LogLevel["TRACE"] = 10] = "TRACE";
+    LogLevel[LogLevel["DEBUG"] = 20] = "DEBUG";
+    LogLevel[LogLevel["INFO"] = 30] = "INFO";
+    LogLevel[LogLevel["WARN"] = 40] = "WARN";
+    LogLevel[LogLevel["ERROR"] = 50] = "ERROR";
+    LogLevel[LogLevel["FATAL"] = 60] = "FATAL";
+})(LogLevel || (exports.LogLevel = LogLevel = {}));

package/dist/src/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./application/factory/logger.factory";
+export type { ILoggerService, ILoggerFactoryConfig } from "./domain/ports";
+export type { LogMessage } from "./domain/types";
+export type { IGetLogsFilterProps } from "./domain/request";
+export type { ILogResponse } from "./domain/response";
+export { LogLevel } from "./domain/value-objects";

package/dist/src/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+// API principal de @jmlq/logger
+__exportStar(require("./application/factory/logger.factory"), exports);
+// Enums
+var value_objects_1 = require("./domain/value-objects");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return value_objects_1.LogLevel; } });

package/dist/src/infrastructure/datasources/in-memory-log.datasource.d.ts

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

package/dist/src/infrastructure/datasources/in-memory-log.datasource.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/infrastructure/datasources/index.d.ts

@@ -0,0 +1 @@
+export * from "./in-memory-log.datasource";

package/dist/src/infrastructure/datasources/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./in-memory-log.datasource"), exports);

package/dist/src/infrastructure/services/data-source-error-handler.type.d.ts

@@ -0,0 +1,5 @@
+export type DataSourceErrorHandler = (info: {
+    operation: "save" | "find" | "flush" | "dispose";
+    datasourceName: string;
+    reason: any;
+}) => void;

package/dist/src/infrastructure/services/data-source-error-handler.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/infrastructure/services/datasource.service.d.ts

@@ -0,0 +1,15 @@
+import { DataSourceErrorHandler } from ".";
+import { ILogDatasource } from "../../domain/ports";
+import { IGetLogsFilterProps, ILogProps } from "../../domain/request";
+import { ILogResponse } from "../../domain/response";
+export declare class DataSourceService implements ILogDatasource {
+    private readonly targets;
+    private readonly onError?;
+    readonly name = "composite";
+    constructor(targets: ILogDatasource[], onError?: DataSourceErrorHandler | undefined);
+    private handleError;
+    save(log: ILogProps): Promise<void>;
+    find(filter?: IGetLogsFilterProps): Promise<ILogResponse[]>;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/src/infrastructure/services/datasource.service.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataSourceService = void 0;
+class DataSourceService {
+    constructor(targets, onError) {
+        this.targets = targets;
+        this.onError = onError;
+        this.name = "composite";
+        this.targets = (targets ?? []).filter(Boolean);
+    }
+    handleError(op, i, reason) {
+        const datasourceName = this.targets[i]?.name ?? "unknown";
+        if (this.onError) {
+            this.onError({
+                operation: op,
+                datasourceName,
+                reason,
+            });
+            return;
+        }
+        // fallback por simplicidad
+        console.warn(`[DataSourceService] ${op} error in ds#${i} (${datasourceName})`, reason);
+    }
+    async save(log) {
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.save(log)));
+        results.forEach((r, i) => {
+            if (r.status === "rejected") {
+                this.handleError("save", i, r.reason);
+            }
+        });
+    }
+    async find(filter) {
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.find?.(filter)));
+        const logs = [];
+        results.forEach((r, i) => {
+            if (r.status === "fulfilled" && Array.isArray(r.value)) {
+                logs.push(...r.value);
+            }
+            else if (r.status === "rejected") {
+                this.handleError("find", i, r.reason);
+            }
+        });
+        logs.sort((a, b) => b.timestamp - a.timestamp);
+        return logs;
+    }
+    async flush() {
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.flush?.()));
+        results.forEach((r, i) => {
+            if (r.status === "rejected") {
+                this.handleError("flush", i, r.reason);
+            }
+        });
+    }
+    async dispose() {
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.dispose?.()));
+        results.forEach((r, i) => {
+            if (r.status === "rejected") {
+                this.handleError("dispose", i, r.reason);
+            }
+        });
+    }
+}
+exports.DataSourceService = DataSourceService;

package/dist/src/infrastructure/services/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./datasource.service";
+export * from "./data-source-error-handler.type";

package/dist/src/infrastructure/services/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./datasource.service"), exports);
+__exportStar(require("./data-source-error-handler.type"), exports);

package/dist/tests/application/factory/logger-factory.spec.d.ts

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

package/dist/tests/application/factory/logger-factory.spec.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_factory_1 = require("../../../src/application/factory/logger.factory");
+const value_objects_1 = require("../../../src/domain/value-objects");
+describe("LoggerFactory (behavioral)", () => {
+    it("debe respetar el minLevel por defecto (INFO): no guardar DEBUG, sí INFO y ERROR", async () => {
+        const savedLogs = [];
+        const ds = {
+            name: "single-ds",
+            save: jest.fn(async (log) => {
+                savedLogs.push(log);
+            }),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        // No pasamos minLevel → debe usar LogLevel.INFO
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: ds,
+            // sin redactor ni opciones, usa PiiRedactor por defecto
+        });
+        await logger.debug("debug ignorado");
+        await logger.info("info guardado");
+        await logger.error("error guardado");
+        // Se debe haber llamado save solo 2 veces (INFO y ERROR)
+        expect(ds.save.mock.calls.length).toBe(2);
+        expect(savedLogs[0].level).toBe(value_objects_1.LogLevel.INFO);
+        expect(savedLogs[0].message).toBe("info guardado");
+        expect(savedLogs[1].level).toBe(value_objects_1.LogLevel.ERROR);
+        expect(savedLogs[1].message).toBe("error guardado");
+    });
+    it("debe respetar un minLevel personalizado (por ejemplo ERROR)", async () => {
+        const savedLogs = [];
+        const ds = {
+            name: "single-ds",
+            save: jest.fn(async (log) => {
+                savedLogs.push(log);
+            }),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: ds,
+            minLevel: value_objects_1.LogLevel.ERROR,
+        });
+        await logger.info("esto NO debería loggearse");
+        await logger.error("esto SÍ debería loggearse");
+        expect(ds.save.mock.calls.length).toBe(1);
+        expect(savedLogs[0].level).toBe(value_objects_1.LogLevel.ERROR);
+        expect(savedLogs[0].message).toBe("esto SÍ debería loggearse");
+    });
+    it("debe componer múltiples datasources (fan-out) y enviar el log a todos", async () => {
+        const dsA = {
+            name: "A",
+            save: jest.fn(),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        const dsB = {
+            name: "B",
+            save: jest.fn(),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: [dsA, dsB],
+            minLevel: value_objects_1.LogLevel.TRACE, // para que no filtre nada
+        });
+        await logger.info("mensaje fan-out");
+        expect(dsA.save).toHaveBeenCalledTimes(1);
+        expect(dsB.save).toHaveBeenCalledTimes(1);
+        const logA = dsA.save.mock.calls[0][0];
+        const logB = dsB.save.mock.calls[0][0];
+        expect(logA.message).toBe("mensaje fan-out");
+        expect(logB.message).toBe("mensaje fan-out");
+    });
+    it("debe usar el redactor proporcionado en config para procesar meta", async () => {
+        const savedLogs = [];
+        const ds = {
+            name: "ds",
+            save: jest.fn(async (log) => {
+                savedLogs.push(log);
+            }),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        // Redactor custom que marca la meta
+        const redactor = {
+            redact: jest.fn((value) => {
+                if (value && typeof value === "object") {
+                    return {
+                        ...value,
+                        __redacted: true,
+                    };
+                }
+                return value;
+            }),
+            updateOptions: jest.fn(),
+        };
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: ds,
+            minLevel: value_objects_1.LogLevel.INFO,
+            redactor,
+        });
+        const metaOriginal = { userId: "123" };
+        await logger.info("mensaje con meta", metaOriginal);
+        expect(redactor.redact).toHaveBeenCalledWith(metaOriginal);
+        const logGuardado = savedLogs[0];
+        expect(logGuardado.meta).toEqual({
+            userId: "123",
+            __redacted: true,
+        });
+    });
+    it("getLogs debe delegar a find del datasource con el filtro adecuado y retornar el resultado", async () => {
+        const logsSimulados = [
+            {
+                level: value_objects_1.LogLevel.ERROR,
+                message: "falló algo",
+                timestamp: Date.now(),
+            },
+        ];
+        const ds = {
+            name: "ds",
+            save: jest.fn(),
+            find: jest.fn().mockResolvedValue(logsSimulados),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: ds,
+            minLevel: value_objects_1.LogLevel.INFO,
+        });
+        const filter = {
+            levelMin: value_objects_1.LogLevel.ERROR,
+            query: "falló",
+        };
+        const result = await logger.getLogs(filter);
+        expect(ds.find).toHaveBeenCalledTimes(1);
+        expect(ds.find).toHaveBeenCalledWith(filter);
+        expect(result).toBe(logsSimulados);
+    });
+    it("flush debe delegar al flush del datasource (o composite) si existe", async () => {
+        const ds = {
+            name: "ds",
+            save: jest.fn(),
+            find: jest.fn(),
+            flush: jest.fn(),
+            dispose: jest.fn(),
+        };
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: ds,
+            minLevel: value_objects_1.LogLevel.INFO,
+        });
+        await logger.flush();
+        expect(ds.flush).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/tests/application/use-cases/flush-buffers.use-case.spec.d.ts

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

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const use_cases_1 = require("../../../src/application/use-cases");
+describe("FlushBuffersUseCase", () => {
+    it("debe llamar a ds.flush cuando está implementado", async () => {
+        const flushMock = jest.fn().mockResolvedValue(undefined);
+        const ds = {
+            name: "memory",
+            save: jest.fn().mockResolvedValue(undefined),
+            flush: flushMock,
+        };
+        const useCase = new use_cases_1.FlushBuffersUseCase(ds);
+        await useCase.execute();
+        expect(flushMock).toHaveBeenCalledTimes(1);
+        expect(flushMock).toHaveBeenCalledWith(); // sin argumentos
+    });
+    it("no debe fallar cuando el datasource no implementa flush", async () => {
+        const ds = {
+            name: "memory",
+            save: jest.fn().mockResolvedValue(undefined),
+            // flush NO definido
+        };
+        const useCase = new use_cases_1.FlushBuffersUseCase(ds);
+        // execute simplemente debería resolverse sin lanzar error
+        await expect(useCase.execute()).resolves.toBeUndefined();
+    });
+    it("debe propagar el error si ds.flush rechaza", async () => {
+        const error = new Error("flush failed");
+        const flushMock = jest.fn().mockRejectedValue(error);
+        const ds = {
+            name: "memory",
+            save: jest.fn().mockResolvedValue(undefined),
+            flush: flushMock,
+        };
+        const useCase = new use_cases_1.FlushBuffersUseCase(ds);
+        await expect(useCase.execute()).rejects.toBe(error);
+    });
+});

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

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

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 {};