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

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.2",
+  "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;