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

package/dist/src/domain/services/pii-redactor.d.ts

@@ -0,0 +1,10 @@
+import { IPiiRedactor } from "../ports";
+import { IPiiOptionsProps } from "../request";
+export declare class PiiRedactor implements IPiiRedactor {
+    private props;
+    constructor(props?: IPiiOptionsProps);
+    updateOptions(opts: IPiiOptionsProps): void;
+    redact<T = unknown>(value: T): T;
+    private applyPatterns;
+    private redactDeep;
+}

package/dist/{domain → src/domain}/services/pii-redactor.js

@@ -1,26 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PiiRedactor = void 0;
-// Utilidad local: crea RegExp segura desde {pattern, flags}
-function toRegex(p) {
-    // new RegExp lanza si el patrón es inválido → try/catch para robustez
-    try {
-        return new RegExp(p.pattern, p.flags ?? "g");
-    }
-    catch {
-        return /$a/; /* patrón imposible */
-    }
-}
+const pii_pattern_service_1 = require("./pii-pattern.service");
 class PiiRedactor {
-    constructor(options = {}) {
-        this.options = options;
+    constructor(props = {}) {
+        this.props = props;
     }
     updateOptions(opts) {
         // merge superficial de opciones; no muta referencias externas
-        this.options = { ...this.options, ...opts };
+        this.props = { ...this.props, ...opts };
     }
     redact(value) {
-        if (!this.options.enabled)
+        if (!this.props.enabled)
             return value; // early exit si PII apagado
         if (value == null)
             return value;
@@ -36,10 +27,10 @@ class PiiRedactor {
         return value;
     }
     applyPatterns(input) {
-        const patterns = this.options.patterns ?? [];
+        const patterns = this.props.patterns ?? [];
         let out = input;
         for (const p of patterns) {
-            const rx = toRegex(p);
+            const rx = (0, pii_pattern_service_1.toPiiRegex)(p);
             // replace con patrón RegExp
             out = out.replace(rx, p.replaceWith);
         }
@@ -50,7 +41,7 @@ class PiiRedactor {
         const clone = Array.isArray(obj)
             ? [...obj]
             : { ...obj };
-        const { whitelistKeys = [], blacklistKeys = [], deep = true, } = this.options;
+        const { whitelistKeys = [], blacklistKeys = [], deep = true } = this.props;
         for (const key of Object.keys(clone)) {
             const val = clone[key];
             // Si está en whitelist, se respeta siempre

package/dist/src/domain/services/pii-redactor.service.d.ts

@@ -0,0 +1,10 @@
+import { IPiiRedactor } from "../ports";
+import { IPiiOptionsProps } from "../request";
+export declare class PiiRedactor implements IPiiRedactor {
+    private props;
+    constructor(props?: IPiiOptionsProps);
+    updateOptions(opts: IPiiOptionsProps): void;
+    redact<T = unknown>(value: T): T;
+    private applyPatterns;
+    private redactDeep;
+}

package/dist/src/domain/services/pii-redactor.service.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiiRedactor = void 0;
+const pii_pattern_service_1 = require("./pii-pattern.service");
+class PiiRedactor {
+    constructor(props = {}) {
+        this.props = props;
+    }
+    updateOptions(opts) {
+        // merge superficial de opciones; no muta referencias externas
+        this.props = { ...this.props, ...opts };
+    }
+    redact(value) {
+        if (!this.props.enabled)
+            return value; // early exit si PII apagado
+        if (value == null)
+            return value;
+        // Si es string → aplicar patrones
+        if (typeof value === "string") {
+            return this.applyPatterns(value);
+        }
+        // Si es objeto/array → redacción profunda si corresponde
+        if (typeof value === "object") {
+            return this.redactDeep(value);
+        }
+        // Otros tipos (number, boolean, function) no se redactan
+        return value;
+    }
+    applyPatterns(input) {
+        const patterns = this.props.patterns ?? [];
+        let out = input;
+        for (const p of patterns) {
+            const rx = (0, pii_pattern_service_1.toPiiRegex)(p);
+            // replace con patrón RegExp
+            out = out.replace(rx, p.replaceWith);
+        }
+        return out;
+    }
+    redactDeep(obj) {
+        // Evita mutar el objeto original → copia superficial
+        const clone = Array.isArray(obj)
+            ? [...obj]
+            : { ...obj };
+        const { whitelistKeys = [], blacklistKeys = [], deep = true } = this.props;
+        for (const key of Object.keys(clone)) {
+            const val = clone[key];
+            // Si está en whitelist, se respeta siempre
+            if (whitelistKeys.includes(key))
+                continue;
+            // Si está en blacklist y es string → reemplazar completamente
+            if (blacklistKeys.includes(key)) {
+                clone[key] = "[REDACTED]"; // fuerza redacción total de claves sensibles
+                continue;
+            }
+            // Para strings comunes → aplicar patrones
+            if (typeof val === "string") {
+                clone[key] = this.applyPatterns(val);
+                continue;
+            }
+            // Para objetos/arrays y deep===true → recursión
+            if (deep && val && typeof val === "object") {
+                clone[key] = this.redactDeep(val);
+            }
+        }
+        return clone;
+    }
+}
+exports.PiiRedactor = PiiRedactor;

package/dist/src/domain/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./log-message.type";

package/dist/src/domain/types/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-message.type"), exports);

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/{domain/services → src/domain/value-objects}/index.js

@@ -14,4 +14,4 @@ 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("./pii-redactor"), exports);
+__exportStar(require("./log-level.vo"), exports);

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

@@ -6,4 +6,3 @@ export declare enum LogLevel {
     ERROR = 50,
     FATAL = 60
 }
-export declare function toLogLevel(level: string | number | undefined, def?: LogLevel): LogLevel;

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/{infrastructure/adapters → src/infrastructure/datasources}/index.js

@@ -14,4 +14,4 @@ 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("./composite.datasource"), exports);
+__exportStar(require("./in-memory-log.datasource"), exports);

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

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

package/dist/{domain/types → src/infrastructure}/index.js

@@ -14,4 +14,4 @@ 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.types"), exports);
+__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 {};