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

package/dist/src/domain/types/log-message.type.d.ts

@@ -0,0 +1 @@
+export type LogMessage = string | Record<string, unknown> | (() => string | Record<string, unknown>);

package/dist/src/domain/types/log-message.type.js

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

package/dist/src/domain/value-objects/index.d.ts

@@ -0,0 +1 @@
+export * from "./log-level.vo";

package/dist/src/domain/value-objects/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("./log-level.vo"), exports);

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

@@ -0,0 +1,8 @@
+export declare enum LogLevel {
+    TRACE = 10,
+    DEBUG = 20,
+    INFO = 30,
+    WARN = 40,
+    ERROR = 50,
+    FATAL = 60
+}

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/index.d.ts

@@ -0,0 +1 @@
+export * from "./services";

package/dist/src/infrastructure/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("./services"), 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 {};