@jmlq/logger 0.1.0-alpha.3 → 0.1.0-alpha.4

package/README.md

@@ -18,6 +18,14 @@ npm i @jmlq/logger-plugin-postgres
 
 ```
 
+Si usas Mongo o Postgres en tu app cliente, instala además:
+
+```bash
+npm i mongodb@^6.19.0
+npm i pg@^8.16.3
+
+```
+
 ### DOCUMENTACION
 
 > - [`@jmlq/logger-plugin-fs`](https://www.npmjs.com/package/@jmlq/logger-plugin-fs)
@@ -28,33 +36,38 @@ npm i @jmlq/logger-plugin-postgres
 
 ## 🧱 Estructura del paquete
 
-```txt
-src/
-  composite/
-    index.ts        # Implementa CompositeDatasource para fan-out de logs a múltiples destinos
-  config/
-    interfaces/
-      index.ts      # Define contratos/puertos (ILogDatasource, ILogRepository)
-    types/
-      index.ts      # Tipos y utilidades comunes (filtros de logs, opciones de logger, etc.)
-  domain/
-    services/
-      index.ts      # Servicio PiiRedactor: enmascara datos sensibles
-  presentation/
-    factory/
-      index.ts      # Factory createLogger: construye la API final del logger
-  index.ts          # Punto de entrada que re-exporta contratos, utilidades y createLogger
+### 📝 Resumen rápido
 
-```
+> - **`src/domain/`** — Reglas del negocio (sin dependencias de frameworks).
+>   > - **`value-objects/`**
+>   >   > - `log-level.ts` — Define niveles (`TRACE…FATAL`) y `toLogLevel()` para convertir strings a nivel.
+>   > - **`types/`**
+>   >   > - `log.types.ts` — Tipos puros del dominio: `ILog`, `IGetLogsFilter`, `PiiOptions`, etc.
+>   > - **`contracts/`**
+>   >   > - `log.datasource.ts` — Puerto que debe implementar cualquier destino de logs (`save/find/flush/dispose`).
+>   >   > - `logger.ts` — Contrato del logger público (`ILogger`, `ICreateLoggerOptions`).
+>   >   > - `pii.ts` — Contrato del redactor de PII.
+>   > - **`services/`**
+>   >   > - `pii-redactor.ts` — Enmascarado de datos sensibles (whitelist/blacklist, patrones, modo profundo).
+
+> - **`src/application/`** — Orquestación de casos de uso (no depende de infraestructura).
+>   > - **`use-cases/`**
+>   >   > - `save-log.ts` — Aplica `minLevel` + PII y delega a `datasource.save()`.
+>   >   > - `get-logs.ts` — Recupera logs con filtros/paginación si el datasource lo soporta.
+>   >   > - `flush-buffers.ts` — Ejecuta `flush()` en el datasource cuando exista.
+
+> - **`src/infrastructure/`** — Adaptadores concretos (tecnología).
+>   > - **`adapters/`**
+>   >   > - `composite.datasource.ts` — Fan-out: envía el log a varios datasources y no falla el todo si uno cae (avisa con `console.warn`).
 
-## 📝 Resumen rápido
+> - **`src/presentation/`** — API pública y fábricas (cara del paquete).
+>   > - **`factory/`**
+>   >   > - `create-logger.ts` — Crea el logger listo para usar (`trace…fatal`, `flush`, `dispose`) conectando casos de uso + PII.
 
-> - **composite** → Combinación de múltiples datasources para persistir en paralelo.
-> - **config/interfaces** → Contratos base (ILogDatasource) que los plugins deben implementar.
-> - **config/types** → Tipos auxiliares (`LogLevel`, `GetLogsFilter`, etc.).
-> - **domain/services** → Lógica de dominio (PII redaction).
-> - **presentation/factory** → `createLogger`, expone la API (`trace`, `debug`, `info`, `warn`, `error`, `fatal`).
-> - **index.ts** → Punto de entrada limpio para el consumidor.
+> - **`src/index.ts`** — Barrel.
+>   > - Re-exporta lo público: `createLogger`, `LogLevel`, tipos/contratos y `CompositeDatasource`.
+
+### [](./ARQUITECTURA.md)
 
 ---
 
@@ -280,19 +293,6 @@ async function main() {
 main();
 ```
 
-### 📦 Dependencias adicionales en el cliente
-
-```bash
-# Si se va a usar MongoDB
-npm i mongodb@^6.19.0
-
-# Si se va a usar PostgreSQL
-npm i pg@^8.16.3
-
-```
-
-`mongodb` y `pg` son **peerDependencies**: `@jmlq/logger` no las instala por sí mismo para mantener el core desacoplado.
-
 ### 🔎 Notas importantes
 
 > - `loggerReady` es una Promise → debe resolverse con `await`.

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

@@ -0,0 +1,6 @@
+import { ILogDatasource } from "../../domain/contracts";
+export declare class FlushBuffers {
+    private readonly ds;
+    constructor(ds: ILogDatasource);
+    execute(): Promise<void>;
+}

package/dist/application/use-cases/flush-buffers.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlushBuffers = void 0;
+class FlushBuffers {
+    constructor(ds) {
+        this.ds = ds;
+    }
+    async execute() {
+        // flush es opcional; si no está implementado, no hace nada
+        await this.ds.flush?.();
+    }
+}
+exports.FlushBuffers = FlushBuffers;

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

@@ -0,0 +1,7 @@
+import { ILogDatasource } from "../../domain/contracts";
+import { IGetLogsFilter, ILog } from "../../domain/types";
+export declare class GetLogs {
+    private readonly ds;
+    constructor(ds: ILogDatasource);
+    execute(filter?: IGetLogsFilter): Promise<ILog[]>;
+}

package/dist/application/use-cases/get-logs.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetLogs = void 0;
+class GetLogs {
+    constructor(ds) {
+        this.ds = ds;
+    }
+    async execute(filter) {
+        if (!this.ds.find)
+            return []; // si el datasource no lo soporta, retorna vacío
+        // Sanitiza límites (evita valores negativos o absurdos)
+        const safe = filter
+            ? {
+                ...filter,
+                limit: filter.limit && filter.limit > 0
+                    ? Math.min(filter.limit, 5000)
+                    : undefined,
+                offset: filter.offset && filter.offset >= 0 ? filter.offset : undefined,
+            }
+            : undefined;
+        return this.ds.find(safe);
+    }
+}
+exports.GetLogs = GetLogs;

package/dist/application/use-cases/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./save-log";
+export * from "./get-logs";
+export * from "./flush-buffers";

package/dist/application/use-cases/index.js

@@ -0,0 +1,19 @@
+"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("./save-log"), exports);
+__exportStar(require("./get-logs"), exports);
+__exportStar(require("./flush-buffers"), exports);

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

@@ -0,0 +1,13 @@
+import { ILogDatasource, IPiiRedactor } from "../../domain/contracts";
+import { LogMessage } from "../../domain/types";
+import { LogLevel } from "../../domain/value-objects";
+export interface SaveLogDeps {
+    ds: ILogDatasource;
+    minLevel: LogLevel;
+    redactor: IPiiRedactor;
+}
+export declare class SaveLog {
+    private readonly deps;
+    constructor(deps: SaveLogDeps);
+    execute(level: LogLevel, message: LogMessage, meta?: unknown): Promise<void>;
+}

package/dist/application/use-cases/save-log.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveLog = void 0;
+// Normaliza el mensaje: si es función, la evalúa; si es objeto, se redacta; si es string, se redacta
+function normalizeMessage(message, redactor) {
+    const resolved = typeof message === "function" ? message() : message; // eval laziness
+    return redactor.redact(resolved);
+}
+class SaveLog {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async execute(level, message, meta) {
+        // 1) Filtro por nivel (evita hacer trabajo innecesario)
+        if (level < this.deps.minLevel)
+            return; // no se loggea
+        // 2) Normalización + PII
+        const normalized = normalizeMessage(message, this.deps.redactor);
+        // 3) Construcción del evento
+        const log = {
+            level,
+            message: normalized,
+            meta: meta === undefined ? undefined : this.deps.redactor.redact(meta),
+            timestamp: Date.now(),
+        };
+        // 4) Persistencia (fan-out lo maneja el ds si es composite)
+        await this.deps.ds.save(log);
+    }
+}
+exports.SaveLog = SaveLog;

package/dist/domain/contracts/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./log.datasource";
+export * from "./logger";
+export * from "./pii";

package/dist/domain/contracts/index.js

@@ -0,0 +1,19 @@
+"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.datasource"), exports);
+__exportStar(require("./logger"), exports);
+__exportStar(require("./pii"), exports);

package/dist/domain/contracts/log.datasource.d.ts

@@ -0,0 +1,8 @@
+import { IGetLogsFilter, ILog } from "../types";
+export interface ILogDatasource {
+    save(log: ILog): Promise<void>;
+    find?(filter?: IGetLogsFilter): Promise<ILog[]>;
+    flush?(): Promise<void>;
+    dispose?(): Promise<void>;
+    readonly name?: string;
+}

package/dist/{config/interfaces/index.js → domain/contracts/log.datasource.js}

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

package/dist/domain/contracts/logger.d.ts

@@ -0,0 +1,19 @@
+import { ILogDatasource } from ".";
+import { PiiOptions } from "../types";
+import { LogLevel } from "../value-objects";
+export interface ICreateLoggerOptions {
+    minLevel?: LogLevel;
+    redactPII?: boolean;
+    pii?: PiiOptions;
+}
+export interface ILogger {
+    trace: (message: unknown, meta?: unknown) => void | Promise<void>;
+    debug: (message: unknown, meta?: unknown) => void | Promise<void>;
+    info: (message: unknown, meta?: unknown) => void | Promise<void>;
+    warn: (message: unknown, meta?: unknown) => void | Promise<void>;
+    error: (message: unknown, meta?: unknown) => void | Promise<void>;
+    fatal: (message: unknown, meta?: unknown) => void | Promise<void>;
+    flush?: () => Promise<void>;
+    dispose?: () => Promise<void>;
+}
+export type { ILogDatasource as LogDatasourcePort };

package/dist/domain/contracts/logger.js

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

package/dist/domain/contracts/pii.d.ts

@@ -0,0 +1,5 @@
+import { PiiOptions } from "../types";
+export interface IPiiRedactor {
+    redact<T = unknown>(value: T): T;
+    updateOptions?(opts: PiiOptions): void;
+}

package/dist/domain/contracts/pii.js

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

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

@@ -1,27 +1,10 @@
-/**
- * Domain Service: PiiRedactor
- *
- * Propósito:
- * - Redactar/anonimizar PII en strings, objetos y arrays (deep).
- * - Permitir que el cliente pase patrones adicionales/propios.
- * - Controlar redacción por nombre de clave (whitelist/blacklist).
- */
-import { IPiiPattern, IPiiRedactorOptions } from "../../config";
-export declare class PiiRedactor {
-    private readonly enabled;
-    private readonly patterns;
-    private readonly redactKeys;
-    private readonly preserveKeys;
-    constructor(opts?: IPiiRedactorOptions);
-    /** Patrones por defecto (seguros y genéricos). Ajusta según tu dominio/región si lo deseas. */
-    static defaultPatterns(): IPiiPattern[];
-    /** Punto de entrada público: redacción deep de cualquier estructura */
+import { IPiiRedactor } from "../contracts";
+import { PiiOptions } from "../types";
+export declare class PiiRedactor implements IPiiRedactor {
+    private options;
+    constructor(options?: PiiOptions);
+    updateOptions(opts: PiiOptions): void;
     redact<T = unknown>(value: T): T;
-    /** === Internos === */
-    private redactValue;
     private applyPatterns;
-    private isRedactedKey;
-    private isPreservedKey;
-    private keyRedactionReplacement;
-    private clone;
+    private redactDeep;
 }

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

@@ -1,139 +1,77 @@
 "use strict";
-/**
- * Domain Service: PiiRedactor
- *
- * Propósito:
- * - Redactar/anonimizar PII en strings, objetos y arrays (deep).
- * - Permitir que el cliente pase patrones adicionales/propios.
- * - Controlar redacción por nombre de clave (whitelist/blacklist).
- */
 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 */
+    }
+}
 class PiiRedactor {
-    constructor(opts = {}) {
-        const { enabled = true, includeDefaultPatterns = true, patterns = [], redactKeys = [], preserveKeys = [], } = opts;
-        this.enabled = enabled;
-        this.patterns = includeDefaultPatterns
-            ? [...PiiRedactor.defaultPatterns(), ...patterns]
-            : [...patterns];
-        this.redactKeys = redactKeys;
-        this.preserveKeys = preserveKeys;
+    constructor(options = {}) {
+        this.options = options;
     }
-    /** Patrones por defecto (seguros y genéricos). Ajusta según tu dominio/región si lo deseas. */
-    static defaultPatterns() {
-        return [
-            // Tarjetas (13–19 dígitos con espacios o guiones) — patrón simple
-            {
-                name: "credit_card",
-                regex: /\b(?:\d[ -]*?){13,19}\b/g,
-                replacement: "[REDACTED_CARD]",
-            },
-            // Emails
-            {
-                name: "email",
-                regex: /\b[\w._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g,
-                replacement: "[REDACTED_EMAIL]",
-            },
-            // Teléfonos: 10+ dígitos (ajusta a tu región si hace falta)
-            {
-                name: "phone",
-                regex: /\b\d{10,}\b/g,
-                replacement: "[REDACTED_PHONE]",
-            },
-            // Documento genérico: ABC-123456… o similar
-            {
-                name: "document_id",
-                regex: /\b[A-Z]{1,3}-?\d{6,10}\b/g,
-                replacement: "[REDACTED_ID]",
-            },
-            // IPv4
-            {
-                name: "ipv4",
-                regex: /\b(?:(?:25[0-5]|2[0-4]\d|1?\d?\d)(?:\.|$)){4}\b/g,
-                replacement: "[REDACTED_IP]",
-            },
-        ];
+    updateOptions(opts) {
+        // merge superficial de opciones; no muta referencias externas
+        this.options = { ...this.options, ...opts };
     }
-    /** Punto de entrada público: redacción deep de cualquier estructura */
     redact(value) {
-        if (!this.enabled)
+        if (!this.options.enabled)
+            return value; // early exit si PII apagado
+        if (value == null)
             return value;
-        return this.redactValue(value, []);
-    }
-    /** === Internos === */
-    redactValue(value, keyPath) {
-        // Strings → aplicar patrones
+        // Si es string → aplicar patrones
         if (typeof value === "string") {
-            return this.applyPatterns(value, keyPath);
-        }
-        // Números / boolean / null / undefined → retornar tal cual
-        if (typeof value === "number" ||
-            typeof value === "boolean" ||
-            value === null ||
-            typeof value === "undefined") {
-            return value;
-        }
-        // Arrays → deep
-        if (Array.isArray(value)) {
-            return value.map((v, i) => this.redactValue(v, [...keyPath, String(i)]));
+            return this.applyPatterns(value);
         }
-        // Objetos → deep + reglas por nombre de clave
+        // Si es objeto/array → redacción profunda si corresponde
         if (typeof value === "object") {
-            const src = value;
-            const out = {};
-            for (const [k, v] of Object.entries(src)) {
-                const path = [...keyPath, k];
-                if (this.isPreservedKey(k)) {
-                    out[k] = this.clone(v); // explícitamente preservado
-                    continue;
-                }
-                if (this.isRedactedKey(k)) {
-                    out[k] = this.keyRedactionReplacement(k, path);
-                    continue;
-                }
-                out[k] = this.redactValue(v, path);
-            }
-            return out;
+            return this.redactDeep(value);
         }
-        // funciones, símbolos, etc.
+        // Otros tipos (number, boolean, function) no se redactan
         return value;
     }
-    applyPatterns(text, keyPath) {
-        let result = text;
-        for (const p of this.patterns) {
-            const replacement = p.replacement ?? "[REDACTED]";
-            // Soporta función de reemplazo con contexto (ruta de claves)
-            if (typeof replacement === "function") {
-                result = result.replace(p.regex, (m) => replacement(m, keyPath));
-            }
-            else {
-                result = result.replace(p.regex, replacement);
-            }
+    applyPatterns(input) {
+        const patterns = this.options.patterns ?? [];
+        let out = input;
+        for (const p of patterns) {
+            const rx = toRegex(p);
+            // replace con patrón RegExp
+            out = out.replace(rx, p.replaceWith);
         }
-        return result;
-    }
-    isRedactedKey(key) {
-        return this.redactKeys.some((r) => typeof r === "string" ? r === key : r.test(key));
+        return out;
     }
-    isPreservedKey(key) {
-        return this.preserveKeys.some((r) => typeof r === "string" ? r === key : r.test(key));
-    }
-    keyRedactionReplacement(_key, _path) {
-        return "[REDACTED]";
-    }
-    clone(v) {
-        if (v && typeof v === "object") {
-            try {
-                return JSON.parse(JSON.stringify(v));
+    redactDeep(obj) {
+        // Evita mutar el objeto original → copia superficial
+        const clone = Array.isArray(obj)
+            ? [...obj]
+            : { ...obj };
+        const { whitelistKeys = [], blacklistKeys = [], deep = true, } = this.options;
+        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;
             }
-            catch {
-                // fallback shallow
-                if (Array.isArray(v))
-                    return [...v];
-                return { ...v };
+            // Para objetos/arrays y deep===true → recursión
+            if (deep && val && typeof val === "object") {
+                clone[key] = this.redactDeep(val);
             }
         }
-        return v;
+        return clone;
     }
 }
 exports.PiiRedactor = PiiRedactor;

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

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

package/dist/{presentation → domain/types}/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("./factory"), exports);
+__exportStar(require("./log.types"), exports);

package/dist/domain/types/log.types.d.ts

@@ -0,0 +1,28 @@
+import { LogLevel } from "../value-objects";
+export type LogMessage = string | Record<string, unknown> | (() => string | Record<string, unknown>);
+export interface ILog {
+    level: LogLevel;
+    message: string | Record<string, unknown>;
+    meta?: unknown;
+    timestamp: number;
+}
+export interface IGetLogsFilter {
+    levelMin?: LogLevel;
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+    query?: string;
+}
+export interface PiiReplacement {
+    pattern: string;
+    flags?: string;
+    replaceWith: string;
+}
+export interface PiiOptions {
+    enabled?: boolean;
+    whitelistKeys?: string[];
+    blacklistKeys?: string[];
+    patterns?: PiiReplacement[];
+    deep?: boolean;
+}

package/dist/domain/types/log.types.js

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

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

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

package/dist/domain/{index.js → 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("./services"), exports);
+__exportStar(require("./log-level"), exports);

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

@@ -0,0 +1,9 @@
+export declare enum LogLevel {
+    TRACE = 10,
+    DEBUG = 20,
+    INFO = 30,
+    WARN = 40,
+    ERROR = 50,
+    FATAL = 60
+}
+export declare function toLogLevel(level: string | number | undefined, def?: LogLevel): LogLevel;

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+exports.toLogLevel = toLogLevel;
+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 = {}));
+// Convierte string a LogLevel con fallback seguro
+function toLogLevel(level, def = LogLevel.INFO) {
+    if (typeof level === "number")
+        return (Object.values(LogLevel).includes(level) ? level : def);
+    if (!level)
+        return def;
+    switch (String(level).toLowerCase()) {
+        case "trace":
+            return LogLevel.TRACE;
+        case "debug":
+            return LogLevel.DEBUG;
+        case "info":
+            return LogLevel.INFO;
+        case "warn":
+            return LogLevel.WARN;
+        case "error":
+            return LogLevel.ERROR;
+        case "fatal":
+            return LogLevel.FATAL;
+        default:
+            return def; // evita lanzar excepción por valores inesperados
+    }
+}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-export * from "./composite";
-export * from "./domain";
-export * from "./presentation";
-export * from "./config";
+export { LogLevel, toLogLevel } from "./domain/value-objects";
+export type { LogMessage, ILog, IGetLogsFilter, PiiOptions, PiiReplacement, } from "./domain/types";
+export type { LogDatasourcePort, ILogger, ICreateLoggerOptions, ILogDatasource, } from "./domain/contracts";
+export { createLogger } from "./presentation/factory";
+export { CompositeDatasource } from "./infrastructure/adapters";

package/dist/index.js

@@ -1,20 +1,10 @@
 "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("./composite"), exports);
-__exportStar(require("./domain"), exports);
-__exportStar(require("./presentation"), exports);
-__exportStar(require("./config"), exports);
+exports.CompositeDatasource = exports.createLogger = exports.toLogLevel = exports.LogLevel = void 0;
+var value_objects_1 = require("./domain/value-objects");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return value_objects_1.LogLevel; } });
+Object.defineProperty(exports, "toLogLevel", { enumerable: true, get: function () { return value_objects_1.toLogLevel; } });
+var factory_1 = require("./presentation/factory");
+Object.defineProperty(exports, "createLogger", { enumerable: true, get: function () { return factory_1.createLogger; } });
+var adapters_1 = require("./infrastructure/adapters");
+Object.defineProperty(exports, "CompositeDatasource", { enumerable: true, get: function () { return adapters_1.CompositeDatasource; } });

package/dist/infrastructure/adapters/composite.datasource.d.ts

@@ -0,0 +1,11 @@
+import { ILogDatasource } from "../../domain/contracts";
+import { IGetLogsFilter, ILog } from "../../domain/types";
+export declare class CompositeDatasource implements ILogDatasource {
+    private readonly targets;
+    readonly name = "composite";
+    constructor(targets: ILogDatasource[]);
+    save(log: ILog): Promise<void>;
+    find(filter?: IGetLogsFilter): Promise<ILog[]>;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/infrastructure/adapters/composite.datasource.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeDatasource = void 0;
+// CompositeDatasource: fan-out hacia múltiples datasources
+class CompositeDatasource {
+    constructor(targets) {
+        this.targets = targets;
+        this.name = "composite";
+        // Filtro targets válidos (defensivo). Evita null/undefined
+        this.targets = (targets ?? []).filter(Boolean);
+    }
+    async save(log) {
+        // Ejecuta todos en paralelo y NO falla el todo si uno falla
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.save(log)));
+        // Log de errores silencioso (el logger real no debe auto-dependerse)
+        for (let i = 0; i < results.length; i++) {
+            const r = results[i];
+            if (r.status === "rejected") {
+                // Preferible: exponer un hook externo; aquí solo console.warn por simplicidad
+                // eslint-disable-next-line no-console
+                console.warn(`[CompositeDatasource] save error in ds#${i} (${this.targets[i]?.name ?? "unknown"})`, r.reason);
+            }
+        }
+    }
+    async find(filter) {
+        // Si varios ds soportan find, se concatena y ordena por timestamp desc
+        const results = await Promise.allSettled(this.targets.map((ds) => ds.find?.(filter)));
+        const logs = [];
+        for (const r of results) {
+            if (r.status === "fulfilled" && Array.isArray(r.value))
+                logs.push(...r.value);
+        }
+        // Orden descendente por timestamp (más recientes primero)
+        logs.sort((a, b) => b.timestamp - a.timestamp);
+        return logs;
+    }
+    async flush() {
+        // Ejecuta flush donde esté disponible
+        await Promise.allSettled(this.targets.map((ds) => ds.flush?.()));
+    }
+    async dispose() {
+        // Libera recursos en todos los ds
+        await Promise.allSettled(this.targets.map((ds) => ds.dispose?.()));
+    }
+}
+exports.CompositeDatasource = CompositeDatasource;

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

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

package/dist/{config → infrastructure/adapters}/index.js

@@ -14,5 +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("./interfaces"), exports);
-__exportStar(require("./types"), exports);
+__exportStar(require("./composite.datasource"), exports);

package/dist/presentation/factory/create-logger.d.ts

@@ -0,0 +1,2 @@
+import { ICreateLoggerOptions, ILogDatasource, ILogger } from "../../domain/contracts";
+export declare function createLogger(ds: ILogDatasource, opts?: ICreateLoggerOptions): ILogger;

package/dist/presentation/factory/create-logger.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const use_cases_1 = require("../../application/use-cases");
+const services_1 = require("../../domain/services");
+const value_objects_1 = require("../../domain/value-objects");
+// Factoría de logger. Encapsula composición de casos de uso y servicios
+function createLogger(ds, opts = {}) {
+    // Resolve minLevel con un default razonable (INFO)
+    const minLevel = opts.minLevel ?? value_objects_1.LogLevel.INFO;
+    // Mantén compatibilidad con redactPII
+    const piiEnabled = opts.pii?.enabled ?? opts.redactPII ?? false;
+    const redactor = new services_1.PiiRedactor({ enabled: piiEnabled, ...opts.pii });
+    const save = new use_cases_1.SaveLog({ ds, minLevel, redactor });
+    const flushUC = new use_cases_1.FlushBuffers(ds);
+    // Helper emisor; si en el futuro se necesita encolar, aquí es el lugar
+    const emit = (lvl, message, meta) => save.execute(lvl, message, meta);
+    return {
+        trace: (m, meta) => emit(value_objects_1.LogLevel.TRACE, m, meta),
+        debug: (m, meta) => emit(value_objects_1.LogLevel.DEBUG, m, meta),
+        info: (m, meta) => emit(value_objects_1.LogLevel.INFO, m, meta),
+        warn: (m, meta) => emit(value_objects_1.LogLevel.WARN, m, meta),
+        error: (m, meta) => emit(value_objects_1.LogLevel.ERROR, m, meta),
+        fatal: (m, meta) => emit(value_objects_1.LogLevel.FATAL, m, meta),
+        // Gestión de ciclo de vida → delega en caso de uso / puerto
+        flush: () => flushUC.execute(),
+        dispose: () => ds.dispose?.() ?? Promise.resolve(),
+    };
+}

package/dist/presentation/factory/index.d.ts

@@ -1,2 +1 @@
-import { ICreateLoggerOptions, ILogDatasource, ILogger } from "../..";
-export declare function createLogger(ds: ILogDatasource, opts?: ICreateLoggerOptions): ILogger;
+export * from "./create-logger";

package/dist/presentation/factory/index.js

@@ -1,74 +1,17 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = createLogger;
-const __1 = require("../..");
-/**
- * Normaliza cualquier LogMessage a string, aplicando PII (si procede) ANTES de serializar.
- */
-function normalizeLogMessage(value, redactEnabled, redactor) {
-    const v = redactEnabled ? redactor.redact(value) : value;
-    if (typeof v === "string")
-        return v;
-    // Si soportas Error en LogMessage, lo serializamos “bonito”
-    if (v instanceof Error) {
-        const err = v;
-        const obj = {
-            error: err.name || "Error",
-            message: err.message,
-            stack: err.stack,
-            code: err.code,
-            cause: err.cause,
-        };
-        try {
-            return JSON.stringify(obj);
-        }
-        catch {
-            return `${obj.error}: ${obj.message}`;
-        }
-    }
-    // Objeto → JSON
-    try {
-        return JSON.stringify(v);
+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]; } };
     }
-    catch {
-        // fallback ultra defensivo
-        return String(v);
-    }
-}
-function createLogger(ds, opts = {}) {
-    const minLevel = opts.minLevel ?? __1.LogLevel.INFO;
-    // Compatibilidad: redactPII (boolean) o pii.enabled
-    const redactEnabled = (opts.redactPII ?? false) || (opts.pii?.enabled ?? false);
-    // Inicializa redactor con opciones del cliente (incluye defaults por defecto)
-    const redactor = new __1.PiiRedactor({
-        enabled: redactEnabled,
-        includeDefaultPatterns: opts.pii?.includeDefaultPatterns ?? true,
-        patterns: opts.pii?.patterns,
-        redactKeys: opts.pii?.redactKeys,
-        preserveKeys: opts.pii?.preserveKeys,
-    });
-    const emit = async (level, message, meta) => {
-        if (level < minLevel)
-            return;
-        const msgStr = normalizeLogMessage(message, redactEnabled, redactor);
-        const metaVal = redactEnabled ? redactor.redact(meta) : meta;
-        const payload = {
-            level,
-            timestamp: Date.now(),
-            message: msgStr, // <- garantizamos string
-            meta: metaVal,
-        };
-        await ds.save(payload);
-    };
-    const logger = {
-        trace: (m, meta) => emit(__1.LogLevel.TRACE, m, meta),
-        debug: (m, meta) => emit(__1.LogLevel.DEBUG, m, meta),
-        info: (m, meta) => emit(__1.LogLevel.INFO, m, meta),
-        warn: (m, meta) => emit(__1.LogLevel.WARN, m, meta),
-        error: (m, meta) => emit(__1.LogLevel.ERROR, m, meta),
-        fatal: (m, meta) => emit(__1.LogLevel.FATAL, m, meta),
-        flush: () => ds.flush?.() ?? Promise.resolve(),
-        dispose: () => ds.dispose?.() ?? Promise.resolve(),
-    };
-    return logger;
-}
+    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("./create-logger"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmlq/logger",
-  "version": "0.1.0-alpha.3",
+  "version": "0.1.0-alpha.4",
   "author": "MLahuasi",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,11 +9,23 @@
   ],
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "test": "jest --passWithNoTests",
+    "test:watch": "jest --watch",
+    "test:cov": "jest --coverage"
   },
   "devDependencies": {
+    "@swc/core": "^1.13.5",
+    "@swc/jest": "^0.2.39",
+    "@types/jest": "^30.0.0",
     "@types/node": "^24.3.0",
+    "jest": "^30.1.3",
     "tsx": "^4.20.5",
     "typescript": "^5.9.2"
+  },
+  "overrides": {
+    "test-exclude": "^7.0.1",
+    "glob": "^10.4.5",
+    "minimatch": "^9.0.5"
   }
 }

package/dist/Composite/index.d.ts

@@ -1,9 +0,0 @@
-import { IGetLogsFilter, ILogDatasource, ILog } from "../config";
-export declare class CompositeDatasource implements ILogDatasource {
-    private readonly datasources;
-    constructor(datasources: ILogDatasource[]);
-    save(log: ILog): Promise<void>;
-    find(filter?: IGetLogsFilter): Promise<ILog[]>;
-    flush(): Promise<void>;
-    dispose(): Promise<void>;
-}

package/dist/Composite/index.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeDatasource = void 0;
-// ---- Composite fan-out ----
-class CompositeDatasource {
-    constructor(datasources) {
-        this.datasources = datasources;
-    }
-    async save(log) {
-        const results = await Promise.allSettled(this.datasources.map((ds) => ds.save(log)));
-        for (const r of results) {
-            if (r.status === "rejected") {
-                // Evita romper el flujo si un destino falla.
-                // Aquí podrías enrutar a "dead-letter", métricas, etc.
-                // eslint-disable-next-line no-console
-                console.warn("[CompositeDatasource] save failed:", r.reason);
-            }
-        }
-    }
-    async find(filter = {}) {
-        for (const ds of this.datasources) {
-            if (typeof ds.find === "function") {
-                try {
-                    return await ds.find(filter);
-                }
-                catch (e) {
-                    // eslint-disable-next-line no-console
-                    console.warn("[CompositeDatasource] find failed on a datasource:", e);
-                    // probar siguiente datasource
-                }
-            }
-        }
-        return [];
-    }
-    async flush() {
-        const results = await Promise.allSettled(this.datasources.map((ds) => ds.flush?.() ?? Promise.resolve()));
-        for (const r of results) {
-            if (r.status === "rejected") {
-                // eslint-disable-next-line no-console
-                console.warn("[CompositeDatasource] flush failed:", r.reason);
-            }
-        }
-    }
-    async dispose() {
-        const results = await Promise.allSettled(this.datasources.map((ds) => ds.dispose?.() ?? Promise.resolve()));
-        for (const r of results) {
-            if (r.status === "rejected") {
-                // eslint-disable-next-line no-console
-                console.warn("[CompositeDatasource] dispose failed:", r.reason);
-            }
-        }
-    }
-}
-exports.CompositeDatasource = CompositeDatasource;

package/dist/Factory/index.d.ts

@@ -1,5 +0,0 @@
-import { ILogDatasource, Logger, LogLevel } from "..";
-export declare function createLogger(ds: ILogDatasource, opts: {
-    minLevel: LogLevel;
-    redactPII?: boolean;
-}): Logger;

package/dist/Factory/index.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = createLogger;
-const __1 = require("..");
-function createLogger(ds, opts) {
-    const write = async (level, message, meta) => {
-        if (level < opts.minLevel)
-            return;
-        // (Opcional) redactor PII aquí si opts.redactPII === true
-        await ds.save({ level, message, meta, timestamp: Date.now() });
-    };
-    const logger = {
-        trace: (m, meta) => write(__1.LogLevel.TRACE, m, meta),
-        debug: (m, meta) => write(__1.LogLevel.DEBUG, m, meta),
-        info: (m, meta) => write(__1.LogLevel.INFO, m, meta),
-        warn: (m, meta) => write(__1.LogLevel.WARN, m, meta),
-        error: (m, meta) => write(__1.LogLevel.ERROR, m, meta),
-        fatal: (m, meta) => write(__1.LogLevel.FATAL, m, meta),
-        flush: () => ds.flush?.() ?? Promise.resolve(),
-        dispose: () => ds.dispose?.() ?? Promise.resolve(),
-    };
-    return logger;
-}

package/dist/config/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./interfaces";
-export * from "./types";

package/dist/config/interfaces/index.d.ts

@@ -1,67 +0,0 @@
-import { LogLevel, LogMessage, PiiReplacement } from "..";
-export interface ILog {
-    level: LogLevel;
-    message: string;
-    meta?: unknown;
-    timestamp: number;
-}
-export interface IGetLogsFilter {
-    levelMin?: LogLevel;
-    since?: number;
-    until?: number;
-}
-export interface ILogDatasource {
-    save(log: ILog): Promise<void>;
-    find?(filter?: IGetLogsFilter): Promise<ILog[]>;
-    flush?(): Promise<void>;
-    dispose?(): Promise<void>;
-}
-export interface ILogger {
-    trace: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    debug: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    info: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    warn: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    error: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    fatal: (msg: LogMessage, meta?: unknown) => Promise<void>;
-    flush?: () => Promise<void>;
-    dispose?: () => Promise<void>;
-}
-export interface IPiiPattern {
-    /** (Opcional) Nombre del patrón para debug/telemetría */
-    name?: string;
-    /** Expresión regular a aplicar sobre strings */
-    regex: RegExp;
-    /** Reemplazo, por defecto "[REDACTED]" si no se provee */
-    replacement?: PiiReplacement;
-}
-export interface IPiiRedactorOptions {
-    /** Habilita/deshabilita redacción (permite control fino además del flag redactPII) */
-    enabled?: boolean;
-    /**
-     * Incluye patrones default (true) y fusiona con los custom. Si false, usa solo los personalizados
-     * por el cliente.
-     */
-    includeDefaultPatterns?: boolean;
-    /** Patrones adicionales o propios del cliente */
-    patterns?: IPiiPattern[];
-    /**
-     * Redactar por nombre de clave (deep). Cualquier key que haga match será redacatada
-     * con "[REDACTED]". Acepta exacto o RegExp.
-     */
-    redactKeys?: Array<string | RegExp>;
-    /**
-     * Claves que NO se deben redactar aunque coincidan con patrones o redactKeys.
-     * Prioridad: preserveKeys > redactKeys > patterns.
-     */
-    preserveKeys?: Array<string | RegExp>;
-}
-export interface ICreateLoggerOptions {
-    minLevel?: LogLevel;
-    /** compatibilidad con lo que ya tienes */
-    redactPII?: boolean;
-    /** NUEVO: bloque de configuración PII */
-    pii?: IPiiRedactorOptions & {
-        /** atajo para permitir que el cliente mande solo patterns sin escribir PiiRedactorOptions */
-        patterns?: IPiiPattern[];
-    };
-}

package/dist/config/types/index.d.ts

@@ -1,10 +0,0 @@
-export declare enum LogLevel {
-    TRACE = 0,
-    DEBUG = 1,
-    INFO = 2,
-    WARN = 3,
-    ERROR = 4,
-    FATAL = 5
-}
-export type PiiReplacement = string | ((match: string, keyPath: string[]) => string);
-export type LogMessage = string | Record<string, unknown> | Error;

package/dist/config/types/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLevel = void 0;
-// ---- Types ----
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
-    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["WARN"] = 3] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
-    LogLevel[LogLevel["FATAL"] = 5] = "FATAL";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));

package/dist/domain/index.d.ts

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

package/dist/interfaces/index.d.ts

@@ -1,35 +0,0 @@
-export declare enum LogLevel {
-    TRACE = 0,
-    DEBUG = 1,
-    INFO = 2,
-    WARN = 3,
-    ERROR = 4,
-    FATAL = 5
-}
-export interface Log {
-    level: LogLevel;
-    message: string;
-    meta?: unknown;
-    timestamp: number;
-}
-export interface GetLogsFilter {
-    levelMin?: LogLevel;
-    since?: number;
-    until?: number;
-}
-export interface ILogDatasource {
-    save(log: Log): Promise<void>;
-    find?(filter?: GetLogsFilter): Promise<Log[]>;
-    flush?(): Promise<void>;
-    dispose?(): Promise<void>;
-}
-export interface Logger {
-    trace: (msg: string, meta?: unknown) => Promise<void>;
-    debug: (msg: string, meta?: unknown) => Promise<void>;
-    info: (msg: string, meta?: unknown) => Promise<void>;
-    warn: (msg: string, meta?: unknown) => Promise<void>;
-    error: (msg: string, meta?: unknown) => Promise<void>;
-    fatal: (msg: string, meta?: unknown) => Promise<void>;
-    flush?: () => Promise<void>;
-    dispose?: () => Promise<void>;
-}

package/dist/interfaces/index.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LogLevel = void 0;
-// ---- Types & contratos ----
-var LogLevel;
-(function (LogLevel) {
-    LogLevel[LogLevel["TRACE"] = 0] = "TRACE";
-    LogLevel[LogLevel["DEBUG"] = 1] = "DEBUG";
-    LogLevel[LogLevel["INFO"] = 2] = "INFO";
-    LogLevel[LogLevel["WARN"] = 3] = "WARN";
-    LogLevel[LogLevel["ERROR"] = 4] = "ERROR";
-    LogLevel[LogLevel["FATAL"] = 5] = "FATAL";
-})(LogLevel || (exports.LogLevel = LogLevel = {}));

package/dist/presentation/index.d.ts

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