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

package/dist/examples/pii-redactor.example.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PiiRedactorExample = void 0;
+const services_1 = require("../src/domain/services");
+class PiiRedactorExample {
+    static Main() {
+        console.log("=== 🔐 Ejemplo de uso: PiiRedactor ===\n");
+        // -----------------------------------------------------------------------
+        // 1️⃣ Definir patrones PII (emails, teléfonos, tarjetas)
+        // -----------------------------------------------------------------------
+        const patterns = [
+            {
+                pattern: "[\\w.-]+@[\\w.-]+\\.[A-Za-z]{2,}",
+                replaceWith: "[EMAIL]",
+            },
+            {
+                pattern: "\\b\\d{10}\\b", // teléfonos de 10 dígitos
+                replaceWith: "[PHONE]",
+            },
+            {
+                pattern: "\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b", // tarjeta simple
+                replaceWith: "[CARD]",
+            },
+        ];
+        const options = {
+            enabled: true,
+            deep: true,
+            patterns,
+            whitelistKeys: ["publicInfo"],
+            blacklistKeys: ["password", "token"],
+        };
+        const redactor = new services_1.PiiRedactor(options);
+        // -----------------------------------------------------------------------
+        // 2️⃣ Redactar un string plano
+        // -----------------------------------------------------------------------
+        const rawText = "Usuario juan@example.com pagó con tarjeta 4111-1111-1111-1111 y llamó desde 0987654321";
+        const redactedText = redactor.redact(rawText);
+        console.log("→ String con PII:");
+        console.log("  Entrada :", rawText);
+        console.log("  Salida  :", redactedText, "\n");
+        // -----------------------------------------------------------------------
+        // 3️⃣ Redactar un objeto anidado (deep=true)
+        // -----------------------------------------------------------------------
+        const rawObject = {
+            userId: 123,
+            email: "cliente@test.com",
+            phone: "0987654321",
+            password: "super-secret-password",
+            token: "eyJhbGciOi...",
+            publicInfo: "Este campo debe permanecer intacto 12345",
+            profile: {
+                address: "Calle Falsa 123",
+                contact: {
+                    altEmail: "otro@test.com",
+                    altPhone: "0999999999",
+                },
+            },
+            payments: [
+                {
+                    card: "4111-1111-1111-1111",
+                    amount: "150",
+                },
+            ],
+        };
+        const clonedForComparison = JSON.parse(JSON.stringify(rawObject));
+        const redactedObject = redactor.redact(rawObject);
+        console.log("→ Objeto con PII (deep=true):");
+        console.log("  Entrada (original):");
+        console.log(JSON.stringify(clonedForComparison, null, 2));
+        console.log("\n  Salida (redactado):");
+        console.log(JSON.stringify(redactedObject, null, 2));
+        console.log("\n  Verificación (no mutado):");
+        console.log("  ¿Original === Clonado? ", JSON.stringify(rawObject) === JSON.stringify(clonedForComparison)
+            ? "✅ Sin mutación visible"
+            : "⚠ Cambió (revisar implementación)");
+        console.log();
+        // -----------------------------------------------------------------------
+        // 4️⃣ Demostración de whitelistKeys y blacklistKeys
+        // -----------------------------------------------------------------------
+        console.log("→ Comportamiento con whitelist / blacklist:\n");
+        console.log("  - whitelistKeys: publicInfo (no se toca)");
+        console.log("  - blacklistKeys: password, token (se fuerza [REDACTED])\n");
+        console.log("  Campo publicInfo :", redactedObject.publicInfo);
+        console.log("  Campo password   :", redactedObject.password);
+        console.log("  Campo token      :", redactedObject.token, "\n");
+        // -----------------------------------------------------------------------
+        // 5️⃣ Actualizar opciones en caliente (updateOptions)
+        // -----------------------------------------------------------------------
+        console.log("→ Actualizando opciones en caliente (updateOptions):\n");
+        redactor.updateOptions({
+            enabled: true,
+            deep: false, // ahora no bajamos a objetos anidados
+            patterns: [
+                {
+                    pattern: "\\d+",
+                    replaceWith: "[NUM]",
+                },
+            ],
+        });
+        const afterUpdate = redactor.redact({
+            level1: {
+                innerCode: "12345",
+            },
+            topLevel: "Código 999",
+        });
+        console.log("  Entrada:");
+        console.log(JSON.stringify({
+            level1: { innerCode: "12345" },
+            topLevel: "Código 999",
+        }, null, 2));
+        console.log("\n  Salida con deep=false y patrón \\d+ → [NUM]:");
+        console.log(JSON.stringify(afterUpdate, null, 2));
+        console.log("\n  Observa que 'topLevel' se redactor, pero 'level1.innerCode' no.");
+        // -----------------------------------------------------------------------
+        // 6️⃣ Desactivar el redactor (enabled=false)
+        // -----------------------------------------------------------------------
+        redactor.updateOptions({ enabled: false });
+        const disabledResult = redactor.redact("Email test2@example.com y teléfono 0912345678");
+        console.log("\n→ Redactor desactivado (enabled=false):");
+        console.log("  Salida debe ser igual a la entrada:");
+        console.log("  Resultado:", disabledResult, "\n");
+        console.log("=== ✔ Fin del ejemplo PiiRedactor ===");
+    }
+}
+exports.PiiRedactorExample = PiiRedactorExample;
+// Ejecución directa: ts-node / tsx examples/pii-redactor.example.ts
+if (require.main === module) {
+    PiiRedactorExample.Main();
+}

package/dist/examples/save-log-use-case.example.d.ts

@@ -0,0 +1,3 @@
+export declare class SaveLogUseCaseExample {
+    static Main(): Promise<void>;
+}

package/dist/examples/save-log-use-case.example.js

@@ -0,0 +1,150 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveLogUseCaseExample = void 0;
+const use_cases_1 = require("../src/application/use-cases");
+const value_objects_1 = require("../src/domain/value-objects");
+// -----------------------------------------------------------------------------
+// 1️⃣ Implementación simple de un IPiiRedactor con PII de ejemplo
+//    - Redacta emails, tarjetas y teléfonos en strings
+//    - Aplica redacción a strings dentro de objetos (meta) de forma superficial
+// -----------------------------------------------------------------------------
+class SimplePiiRedactor {
+    redact(value) {
+        if (typeof value === "string") {
+            return this.redactString(value);
+        }
+        if (value && typeof value === "object") {
+            // redacción superficial de propiedades string
+            const clone = Array.isArray(value)
+                ? [...value]
+                : { ...value };
+            for (const key of Object.keys(clone)) {
+                const v = clone[key];
+                if (typeof v === "string") {
+                    clone[key] = this.redactString(v);
+                }
+            }
+            return clone;
+        }
+        // otros tipos se devuelven tal cual
+        return value;
+    }
+    // Opcional: podrías implementar updateOptions si quieres hacerla configurable
+    updateOptions() { }
+    redactString(input) {
+        return (input
+            // tarjetas de crédito (muy simple)
+            .replace(/\b\d{4}-\d{4}-\d{4}-\d{4}\b/g, "****-****-****-****")
+            // emails
+            .replace(/[\w.-]+@[\w.-]+/g, "***@***")
+            // teléfonos simples (10 dígitos)
+            .replace(/\b\d{10}\b/g, "**********"));
+    }
+}
+// -----------------------------------------------------------------------------
+// 2️⃣ Implementación de un ILogDatasource en memoria con soporte de filtros
+//    - save: guarda en un array interno
+//    - find: aplica IGetLogsFilterProps (levelMin, since, until, query, limit, offset)
+// -----------------------------------------------------------------------------
+class InMemoryLogDatasource {
+    constructor() {
+        this.name = "in-memory";
+        this.store = [];
+    }
+    async save(log) {
+        this.store.push(log);
+    }
+    async find(filter) {
+        let results = [...this.store];
+        if (filter?.levelMin !== undefined) {
+            results = results.filter((log) => log.level >= filter.levelMin);
+        }
+        if (filter?.since !== undefined) {
+            results = results.filter((log) => log.timestamp >= filter.since);
+        }
+        if (filter?.until !== undefined) {
+            results = results.filter((log) => log.timestamp <= filter.until);
+        }
+        if (filter?.query) {
+            const q = filter.query.toLowerCase();
+            results = results.filter((log) => {
+                if (typeof log.message === "string") {
+                    return log.message.toLowerCase().includes(q);
+                }
+                return false;
+            });
+        }
+        // paginación simple
+        const offset = filter?.offset ?? 0;
+        const limit = filter?.limit ?? results.length;
+        return results.slice(offset, offset + limit);
+    }
+}
+// -----------------------------------------------------------------------------
+// 3️⃣ Ejemplo de uso real de SaveLogUseCase
+//    - Configura minLevel (filtro de entrada)
+//    - Usa PII redactor en message + meta
+//    - Demuestra búsquedas filtradas
+// -----------------------------------------------------------------------------
+class SaveLogUseCaseExample {
+    static async Main() {
+        console.log("\n=== 🧪 Ejemplo de uso: SaveLogUseCase ===\n");
+        // 1) Creamos datasource + redactor
+        const ds = new InMemoryLogDatasource();
+        const redactor = new SimplePiiRedactor();
+        // 2) Configuramos el caso de uso con un minLevel = INFO
+        const useCase = new use_cases_1.SaveLogUseCase({
+            ds,
+            minLevel: value_objects_1.LogLevel.INFO,
+            redactor,
+        });
+        console.log("📌 minLevel configurado en:", value_objects_1.LogLevel[value_objects_1.LogLevel.INFO], "\n");
+        // 3) Intentamos loggear algo por debajo del umbral (DEBUG → debe ser ignorado)
+        console.log("➖ Log DEBUG (debe SER IGNORADO por el filtro):");
+        await useCase.execute(value_objects_1.LogLevel.DEBUG, "Debug interno con detalles que no queremos en producción");
+        // 4) Log INFO simple, sin PII
+        console.log("\n➕ Log INFO (debe SER GUARDADO):");
+        await useCase.execute(value_objects_1.LogLevel.INFO, "Servicio iniciado correctamente");
+        // 5) Log ERROR con PII en message y meta
+        console.log("\n❌ Log ERROR con PII en message y meta (debe ser REDACTADO):");
+        const rawMessage = "Error al procesar pago con tarjeta 4111-1111-1111-1111 del usuario john.doe@example.com";
+        const metaConPii = {
+            userId: "123",
+            email: "john.doe@example.com",
+            card: "4111-1111-1111-1111",
+            phone: "0998765432",
+        };
+        await useCase.execute(value_objects_1.LogLevel.ERROR, rawMessage, metaConPii);
+        // 6) Log WARN con PII solo en meta
+        console.log("\n⚠ Log WARN con PII solo en meta:");
+        await useCase.execute(value_objects_1.LogLevel.WARN, "Intento de acceso sospechoso", {
+            ip: "192.168.0.10",
+            email: "evil.hacker@example.com",
+        });
+        // 7) Consultamos todos los logs con level >= INFO
+        console.log("\n📂 Recuperando logs con filtro: levelMin = INFO\n");
+        const allInfoOrHigher = await ds.find({
+            levelMin: value_objects_1.LogLevel.INFO,
+        });
+        console.log("➡ Resultado (level >= INFO):");
+        console.dir(allInfoOrHigher, { depth: 5 });
+        // 8) Consultamos solo errores que contengan la palabra "pago"
+        console.log("\n📂 Recuperando logs con filtro: levelMin = ERROR, query = 'pago'\n");
+        const errorPayments = await ds.find({
+            levelMin: value_objects_1.LogLevel.ERROR,
+            query: "pago",
+        });
+        console.log("➡ Resultado (ERROR + 'pago'):");
+        console.dir(errorPayments, { depth: 5 });
+        // 9) Consultamos logs con límite/paginación
+        console.log("\n📂 Recuperando máximo 2 logs (limit = 2):\n");
+        const limited = await ds.find({
+            levelMin: value_objects_1.LogLevel.INFO,
+            limit: 2,
+        });
+        console.log("➡ Resultado (primeros 2 logs):");
+        console.dir(limited, { depth: 5 });
+        console.log("\n✅ Ejemplo SaveLogUseCase finalizado.\n");
+    }
+}
+exports.SaveLogUseCaseExample = SaveLogUseCaseExample;

package/dist/examples/to-log-level.example.d.ts

@@ -0,0 +1,3 @@
+export declare class ToLogLevelExample {
+    static Main(): void;
+}

package/dist/examples/to-log-level.example.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToLogLevelExample = void 0;
+const domain_1 = require("src/domain");
+class ToLogLevelExample {
+    static Main() {
+        console.log("=== 🔎 Ejemplo de uso: toLogLevel ===\n");
+        // ------------------------------------------------------------------------
+        // 1️⃣ Conversión básica desde string
+        // ------------------------------------------------------------------------
+        console.log("→ Conversión desde strings:");
+        const str1 = (0, domain_1.toLogLevel)("debug");
+        const str2 = (0, domain_1.toLogLevel)("ERROR");
+        const str3 = (0, domain_1.toLogLevel)("unknown"); // fallback
+        console.log(`   "debug"  → ${str1}`);
+        console.log(`   "ERROR"  → ${str2}`);
+        console.log(`   "unknown" → ${str3} (fallback)\n`);
+        // ------------------------------------------------------------------------
+        // 2️⃣ Conversión desde números
+        // ------------------------------------------------------------------------
+        console.log("→ Conversión desde números:");
+        const num1 = (0, domain_1.toLogLevel)(domain_1.LogLevel.WARN);
+        const num2 = (0, domain_1.toLogLevel)(999); // no existe → fallback
+        console.log(`   LogLevel.WARN → ${num1}`);
+        console.log(`   999 → ${num2} (fallback)\n`);
+        // ------------------------------------------------------------------------
+        // 3️⃣ Uso del parámetro 'default'
+        // ------------------------------------------------------------------------
+        console.log("→ Uso de valor por defecto personalizado:");
+        const def1 = (0, domain_1.toLogLevel)(undefined, domain_1.LogLevel.FATAL);
+        const def2 = (0, domain_1.toLogLevel)("invalid", domain_1.LogLevel.DEBUG);
+        console.log(`   undefined, default FATAL → ${def1}`);
+        console.log(`   "invalid", default DEBUG → ${def2}\n`);
+        // ------------------------------------------------------------------------
+        // 4️⃣ Uso en un caso real (ejemplo típico)
+        // ------------------------------------------------------------------------
+        console.log("→ Caso real: leer LOG_LEVEL desde variables de entorno");
+        const rawEnvLogLevel = process.env.LOG_LEVEL; // ej: "warn"
+        const resolvedLevel = (0, domain_1.toLogLevel)(rawEnvLogLevel, domain_1.LogLevel.INFO);
+        console.log(`   LOG_LEVEL raw: ${rawEnvLogLevel}`);
+        console.log(`   LOG_LEVEL resolved: ${resolvedLevel}\n`);
+        console.log("=== ✔ Fin del ejemplo toLogLevel ===");
+    }
+}
+exports.ToLogLevelExample = ToLogLevelExample;
+// Ejecutar si se ejecuta directamente con ts-node/tsx
+if (require.main === module) {
+    ToLogLevelExample.Main();
+}

package/dist/examples/to-pii-regex.example.d.ts

@@ -0,0 +1,3 @@
+export declare class ToPiiRegexExample {
+    static Main(): void;
+}

package/dist/examples/to-pii-regex.example.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToPiiRegexExample = void 0;
+const services_1 = require("../src/domain/services");
+class ToPiiRegexExample {
+    static Main() {
+        console.log("=== 🔍 Ejemplo de uso: toPiiRegex ===\n");
+        // -----------------------------------------------------------------------
+        // 1️⃣ Crear un regex para detectar números (por ejemplo montos o IDs)
+        // -----------------------------------------------------------------------
+        const digitsRule = {
+            pattern: "\\d+",
+            replaceWith: "[NUM]",
+        };
+        const digitsRegex = (0, services_1.toPiiRegex)(digitsRule);
+        console.log("→ Regla para números:");
+        console.log("  Pattern:", digitsRule.pattern);
+        console.log("  Flags:", digitsRegex.flags);
+        console.log("  Regex generado:", digitsRegex);
+        console.log("  Aplicación:", "Pedido 12345 procesado".replace(digitsRegex, digitsRule.replaceWith), "\n");
+        // -----------------------------------------------------------------------
+        // 2️⃣ Crear un regex para emails con flags personalizados
+        // -----------------------------------------------------------------------
+        const emailRule = {
+            pattern: "[\\w.-]+@[\\w.-]+\\.[A-Za-z]{2,}",
+            flags: "gi",
+            replaceWith: "[EMAIL]",
+        };
+        const emailRegex = (0, services_1.toPiiRegex)(emailRule);
+        console.log("→ Regla para emails:");
+        console.log("  Pattern:", emailRule.pattern);
+        console.log("  Flags:", emailRegex.flags);
+        console.log("  Regex generado:", emailRegex);
+        console.log("  Aplicación:", "Usuario juan@example.com inició sesión".replace(emailRegex, emailRule.replaceWith), "\n");
+        // -----------------------------------------------------------------------
+        // 3️⃣ Caso real: varias reglas aplicadas para redactor PII
+        // -----------------------------------------------------------------------
+        const rules = [
+            {
+                pattern: "\\d{10}", // teléfonos
+                replaceWith: "[PHONE]",
+            },
+            {
+                pattern: "[\\w.-]+@[\\w.-]+\\.[A-Za-z]{2,}",
+                replaceWith: "[EMAIL]",
+            },
+        ];
+        const sampleLog = "Cliente mario@test.com llamó desde 0987654321 para confirmar su pedido.";
+        let redacted = sampleLog;
+        for (const rule of rules) {
+            const regex = (0, services_1.toPiiRegex)(rule);
+            redacted = redacted.replace(regex, rule.replaceWith);
+        }
+        console.log("→ Caso real con múltiples reglas:");
+        console.log("  Entrada:", sampleLog);
+        console.log("  Salida:", redacted, "\n");
+        // -----------------------------------------------------------------------
+        // 4️⃣ Caso con patrón inválido (fallback seguro /$a/)
+        // -----------------------------------------------------------------------
+        const invalidRule = {
+            pattern: "[unclosed", // inválido
+            replaceWith: "***",
+        };
+        const invalidRegex = (0, services_1.toPiiRegex)(invalidRule);
+        console.log("→ Patrón inválido, debería producir fallback /$a/:");
+        console.log("  Regex generado:", invalidRegex);
+        console.log("  Hace match?:", invalidRegex.test("cualquier cosa"), "\n");
+        console.log("=== ✔ Fin del ejemplo toPiiRegex ===");
+    }
+}
+exports.ToPiiRegexExample = ToPiiRegexExample;
+// Permite ejecución directa con ts-node / tsx
+if (require.main === module) {
+    ToPiiRegexExample.Main();
+}

package/dist/src/application/factory/create-logger.d.ts

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

package/dist/src/application/factory/create-logger.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const services_1 = require("../../domain/services");
+const value_objects_1 = require("../../domain/value-objects");
+const use_cases_1 = require("../use-cases");
+// 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.SaveLogUseCase({ ds, minLevel, redactor });
+    const flushUC = new use_cases_1.FlushBuffersUseCase(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/src/application/factory/index.d.ts

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

package/dist/{index.js → src/application/factory/index.js}

@@ -14,6 +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("./Factory"), exports);
-__exportStar(require("./Composite"), exports);
+__exportStar(require("./logger.factory"), exports);

package/dist/src/application/factory/logger.factory.d.ts

@@ -0,0 +1,12 @@
+import { ILoggerFactoryConfig, ILoggerService } from "../../domain/ports";
+/**
+ * Factory principal de @jmlq/logger.
+ * Se encarga de:
+ *  - Componer datasources (fan-out si hay varios)
+ *  - Construir el redactor de PII
+ *  - Instanciar y conectar los casos de uso
+ *  - Exponer un servicio de logger de alto nivel
+ */
+export declare class LoggerFactory {
+    static create(config: ILoggerFactoryConfig): ILoggerService;
+}

package/dist/src/application/factory/logger.factory.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactory = void 0;
+const value_objects_1 = require("../../domain/value-objects");
+const pii_redactor_service_1 = require("../../domain/services/pii-redactor.service");
+const datasource_service_1 = require("../../infrastructure/services/datasource.service");
+const use_cases_1 = require("../use-cases");
+/**
+ * Factory principal de @jmlq/logger.
+ * Se encarga de:
+ *  - Componer datasources (fan-out si hay varios)
+ *  - Construir el redactor de PII
+ *  - Instanciar y conectar los casos de uso
+ *  - Exponer un servicio de logger de alto nivel
+ */
+class LoggerFactory {
+    static create(config) {
+        // 1) Normalizar config
+        const minLevel = config.minLevel ?? value_objects_1.LogLevel.INFO;
+        const datasources = Array.isArray(config.datasources)
+            ? config.datasources
+            : [config.datasources];
+        // 2) Componer datasource (si hay varios) con DataSourceService
+        const ds = datasources.length === 1
+            ? datasources[0]
+            : new datasource_service_1.DataSourceService(datasources);
+        // 3) Crear/usar redactor de PII
+        const redactor = config.redactor ?? new pii_redactor_service_1.PiiRedactor(config.redactorOptions);
+        // 4) Construir casos de uso de Application
+        const saveLogUseCase = new use_cases_1.SaveLogUseCase({
+            ds,
+            minLevel,
+            redactor,
+        });
+        const getLogsUseCase = new use_cases_1.GetLogsUseCase(ds);
+        const flushBuffersUseCase = new use_cases_1.FlushBuffersUseCase(ds);
+        // 5) Construir facade de servicio de logging
+        const service = {
+            // Método genérico de logging
+            async log(level, message, meta) {
+                await saveLogUseCase.execute(level, message, meta);
+            },
+            // Helpers por nivel
+            trace(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.TRACE, message, meta);
+            },
+            debug(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.DEBUG, message, meta);
+            },
+            info(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.INFO, message, meta);
+            },
+            warn(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.WARN, message, meta);
+            },
+            error(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.ERROR, message, meta);
+            },
+            fatal(message, meta) {
+                return saveLogUseCase.execute(value_objects_1.LogLevel.FATAL, message, meta);
+            },
+            // Lectura de logs con filtros
+            async getLogs(filter) {
+                return getLogsUseCase.execute(filter);
+            },
+            // Flush explícito (si el datasource lo soporta)
+            async flush() {
+                await flushBuffersUseCase.execute();
+            },
+        };
+        return service;
+    }
+}
+exports.LoggerFactory = LoggerFactory;

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

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

package/dist/src/application/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("./factory"), exports);
+__exportStar(require("./use-cases"), exports);

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

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

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

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

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

@@ -0,0 +1,8 @@
+import { ILogDatasource } from "../../domain/ports";
+import { IGetLogsFilterProps } from "../../domain/request";
+import { ILogResponse } from "../../domain/response";
+export declare class GetLogsUseCase {
+    private readonly ds;
+    constructor(ds: ILogDatasource);
+    execute(filter?: IGetLogsFilterProps): Promise<ILogResponse[]>;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetLogsUseCase = void 0;
+class GetLogsUseCase {
+    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.GetLogsUseCase = GetLogsUseCase;

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

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