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

package/dist/examples/flush-buffers-use-case.example.js

@@ -0,0 +1,60 @@
+"use strict";
+// examples/flush-buffers-use-case.example.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlushBuffersUseCaseExample = void 0;
+const flush_buffers_use_case_1 = require("../src/application/use-cases/flush-buffers.use-case");
+const value_objects_1 = require("../src/domain/value-objects");
+// ---------------------------------------------------------------------------
+// Ejemplo de un datasource simple con buffer en memoria
+// ---------------------------------------------------------------------------
+class BufferedInMemoryDatasource {
+    constructor() {
+        this.name = "buffered-memory";
+        this.buffer = [];
+        this.store = [];
+    }
+    async save(log) {
+        // Guarda en buffer para escritura diferida
+        this.buffer.push(log);
+    }
+    async flush() {
+        // Simula un flush: vacía buffer hacia el almacenamiento persistente
+        this.store.push(...this.buffer);
+        this.buffer = [];
+        console.log("🧹 Buffer flushed →", this.store.length, "eventos persistidos");
+    }
+    async find() {
+        return this.store;
+    }
+}
+// ---------------------------------------------------------------------------
+// Ejemplo de uso real del caso de uso FlushBuffersUseCase
+// ---------------------------------------------------------------------------
+class FlushBuffersUseCaseExample {
+    static async Main() {
+        console.log("\n=== 🧪 Ejemplo de uso: FlushBuffersUseCase ===\n");
+        // 1️⃣ Creamos un datasource con buffer
+        const ds = new BufferedInMemoryDatasource();
+        // 2️⃣ Creamos el caso de uso
+        const flushUseCase = new flush_buffers_use_case_1.FlushBuffersUseCase(ds);
+        // 3️⃣ Simulamos guardar logs antes del flush
+        console.log("➕ Guardando eventos en buffer...\n");
+        await ds.save({
+            level: value_objects_1.LogLevel.INFO,
+            message: "Primer evento",
+            timestamp: Date.now(),
+        });
+        await ds.save({
+            level: value_objects_1.LogLevel.ERROR,
+            message: { error: "Algo falló" },
+            timestamp: Date.now(),
+        });
+        // 4️⃣ Ejecutamos el flush manualmente (ej: al cerrar la app)
+        console.log("🚀 Ejecutando flush...\n");
+        await flushUseCase.execute();
+        // 5️⃣ Verificamos que los eventos están persistidos
+        const logs = await ds.find();
+        console.log("📦 Logs almacenados:", logs);
+    }
+}
+exports.FlushBuffersUseCaseExample = FlushBuffersUseCaseExample;

package/dist/examples/get-logs-use-case.example.d.ts

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

package/dist/examples/get-logs-use-case.example.js

@@ -0,0 +1,110 @@
+"use strict";
+// examples/get-logs-use-case.example.ts
+// 🔧 Ajusta los imports según tu estructura
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetLogsUseCaseExample = void 0;
+const get_logs_use_case_1 = require("../src/application/use-cases/get-logs.use-case");
+const value_objects_1 = require("../src/domain/value-objects");
+// -----------------------------------------------------------------------------
+// 1️⃣ Implementación simple de un datasource en memoria con soporte de find()
+// -----------------------------------------------------------------------------
+class InMemoryLogDatasource {
+    constructor() {
+        this.name = "in-memory-ds";
+        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;
+            });
+        }
+        const offset = filter?.offset ?? 0;
+        const limit = filter?.limit ?? results.length;
+        return results.slice(offset, offset + limit);
+    }
+}
+// -----------------------------------------------------------------------------
+// 2️⃣ Ejemplo de uso real de GetLogsUseCase
+// -----------------------------------------------------------------------------
+class GetLogsUseCaseExample {
+    static async Main() {
+        console.log("\n=== 📜 Ejemplo de uso: GetLogsUseCase ===\n");
+        const ds = new InMemoryLogDatasource();
+        const useCase = new get_logs_use_case_1.GetLogsUseCase(ds);
+        // Seed de logs de ejemplo
+        const now = Date.now();
+        await ds.save({
+            level: value_objects_1.LogLevel.INFO,
+            message: "Servicio iniciado correctamente",
+            timestamp: now - 60000, // hace 1 minuto
+        });
+        await ds.save({
+            level: value_objects_1.LogLevel.WARN,
+            message: "Latencia alta en endpoint /api/users",
+            timestamp: now - 30000, // hace 30s
+        });
+        await ds.save({
+            level: value_objects_1.LogLevel.ERROR,
+            message: "Error al conectar con base de datos",
+            timestamp: now - 10000, // hace 10s
+            meta: { retryCount: 3 },
+        });
+        // 1) Obtener todos los logs sin filtro
+        console.log("🔹 1) Todos los logs (sin filtro):\n");
+        const allLogs = await useCase.execute();
+        console.dir(allLogs, { depth: 5 });
+        // 2) Filtrar por nivel mínimo (levelMin = WARN)
+        console.log("\n🔹 2) Logs con level >= WARN:\n");
+        const warnAndAbove = await useCase.execute({
+            levelMin: value_objects_1.LogLevel.WARN,
+        });
+        console.dir(warnAndAbove, { depth: 5 });
+        // 3) Filtrar por ventana de tiempo (since / until)
+        console.log("\n🔹 3) Logs en los últimos 20 segundos:\n");
+        const last20Seconds = await useCase.execute({
+            since: now - 20000,
+            until: now,
+        });
+        console.dir(last20Seconds, { depth: 5 });
+        // 4) Búsqueda por texto (query)
+        console.log('\n🔹 4) Logs que contienen "error":\n');
+        const errorLogs = await useCase.execute({
+            query: "error",
+            levelMin: value_objects_1.LogLevel.INFO,
+        });
+        console.dir(errorLogs, { depth: 5 });
+        // 5) Paginación simple (limit / offset)
+        console.log("\n🔹 5) Primer log (limit = 1):\n");
+        const page1 = await useCase.execute({
+            limit: 1,
+            offset: 0,
+        });
+        console.dir(page1, { depth: 5 });
+        console.log("\n🔹 6) Segundo log (limit = 1, offset = 1):\n");
+        const page2 = await useCase.execute({
+            limit: 1,
+            offset: 1,
+        });
+        console.dir(page2, { depth: 5 });
+        console.log("\n✅ Ejemplo GetLogsUseCase finalizado.\n");
+    }
+}
+exports.GetLogsUseCaseExample = GetLogsUseCaseExample;

package/dist/examples/index.example.d.ts

@@ -0,0 +1,8 @@
+export declare class MainExample {
+    runExampleUseCases(): Promise<void>;
+    runExampleDomainServices(): Promise<void>;
+    runExampleServices(): Promise<void>;
+    runExampleFactories(): Promise<void>;
+    runAllExamples(): Promise<void>;
+}
+export default MainExample;

package/dist/examples/index.example.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MainExample = void 0;
+const data_source_service_example_1 = require("./data-source-service.example");
+const flush_buffers_use_case_example_1 = require("./flush-buffers-use-case.example");
+const get_logs_use_case_example_1 = require("./get-logs-use-case.example");
+const logger_factory_example_1 = require("./logger-factory.example");
+const normalize_message_example_1 = require("./normalize-message.example");
+const pii_redactor_example_1 = require("./pii-redactor.example");
+const save_log_use_case_example_1 = require("./save-log-use-case.example");
+const to_log_level_example_1 = require("./to-log-level.example");
+const to_pii_regex_example_1 = require("./to-pii-regex.example");
+class MainExample {
+    async runExampleUseCases() {
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Use Case: FlushBuffersUseCase que empuja a almacenamiento final lo que ya está en un buffer interno.s\n");
+        await flush_buffers_use_case_example_1.FlushBuffersUseCaseExample.Main();
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Use Case: SaveLogUseCase (guarda logs con filtros)\n");
+        await save_log_use_case_example_1.SaveLogUseCaseExample.Main();
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Use Case: GetLogsUseCase (recupera logs con filtros)\n");
+        await get_logs_use_case_example_1.GetLogsUseCaseExample.Main();
+        console.log("-".repeat(80) + "\n");
+    }
+    async runExampleDomainServices() {
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Service: ToLogLevel (valida el nivel de log)\n");
+        to_log_level_example_1.ToLogLevelExample.Main();
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Service: NormalizeMessage\n");
+        normalize_message_example_1.NormalizeMessageExample.Main();
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Service: ToPiiRegex (genera regex para PII)\n");
+        to_pii_regex_example_1.ToPiiRegexExample.Main();
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Service: PiiRedactor (redacta información sensible)\n");
+        pii_redactor_example_1.PiiRedactorExample.Main();
+        console.log("-".repeat(80) + "\n");
+    }
+    //
+    async runExampleServices() {
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Service: DataSourceService (Composite Logger):\n");
+        await data_source_service_example_1.DataSourceServiceExample.Main();
+        console.log("-".repeat(80) + "\n");
+    }
+    async runExampleFactories() {
+        console.log("-".repeat(80) + "\n");
+        console.log("🎯 Ejecutando Factory: LoggerFactory\n");
+        await logger_factory_example_1.LoggerFactoryExample.Main();
+        console.log("-".repeat(80) + "\n");
+    }
+    async runAllExamples() {
+        try {
+            console.log("-".repeat(80) + "\n");
+            console.log("🚀 Domain Services - Ejemplos Completos\n");
+            await this.runExampleDomainServices();
+            console.log("-".repeat(80) + "\n");
+            console.log("🚀 Services - Ejemplos Completos\n");
+            await this.runExampleServices();
+            console.log("-".repeat(80) + "\n");
+            console.log("🚀 Use Cases - Ejemplos Completos\n");
+            await this.runExampleUseCases();
+            console.log("-".repeat(80) + "\n");
+            console.log("🚀 Factories - Ejemplos Completos\n");
+            await this.runExampleFactories();
+            console.log("-".repeat(80) + "\n");
+            console.log("🎉 ¡Todos los ejemplos completados exitosamente!");
+            console.log("\n📚 Para más información consulta el README.md");
+            console.log("-".repeat(80) + "\n");
+        }
+        catch (error) {
+            console.error("❌ Error ejecutando ejemplos:", error);
+        }
+    }
+}
+exports.MainExample = MainExample;
+// Función de ayuda para mostrar opciones
+function showHelp() {
+    console.log("📖 JWT Auth Package - Ejemplos Disponibles\n");
+    console.log("Comandos disponibles:");
+    console.log("  npm run example:domain-services     - Ejemplos uso domain services");
+    console.log("  npm run example:services     - Ejemplos uso services");
+    console.log("  npm run example:use-cases      - Ejemplos uso use-cases");
+    console.log("  npm run example:factories     - Ejemplos uso factories");
+    console.log("  npm run example:all        - Todos los ejemplos");
+    console.log("\nO ejecuta directamente:");
+    console.log("  tsx examples/jwt.examples.ts");
+    console.log("  tsx examples/index.example.ts");
+}
+// Ejecutar según el argumento
+if (require.main === module) {
+    const mainExample = new MainExample();
+    const command = process.argv[2];
+    switch (command) {
+        case "domain-services":
+            mainExample.runExampleDomainServices();
+            break;
+        case "use-cases":
+            mainExample.runExampleUseCases();
+            break;
+        case "services":
+            mainExample.runExampleServices();
+            break;
+        case "factories":
+            mainExample.runExampleFactories();
+            break;
+        case "help":
+            showHelp();
+            break;
+        default:
+            mainExample.runAllExamples();
+    }
+}
+exports.default = MainExample;

package/dist/examples/logger-factory.example.d.ts

@@ -0,0 +1,39 @@
+import { ILogResponse } from "../src/domain/response";
+import { ILogDatasource } from "../src/domain/ports";
+import { IGetLogsFilterProps, ILogProps } from "../src/domain/request";
+/**
+ * InMemoryLogDatasource
+ *
+ * Implementación **completa** y **visual** para demos, tests e integración.
+ * Aplica todos los filtros definidos en IGetLogsFilterProps.
+ */
+export declare class InMemoryLogDatasource implements ILogDatasource {
+    readonly name: string;
+    private logs;
+    private idCounter;
+    constructor(name?: string);
+    /**
+     * 🔵 Guarda un log en memoria con un ID incremental.
+     */
+    save(log: ILogProps): Promise<void>;
+    /**
+     * 🔍 Aplica todos los filtros para recuperar logs:
+     *  - levelMin
+     *  - since / until
+     *  - query
+     *  - limit
+     *  - offset
+     */
+    find(filter?: IGetLogsFilterProps): Promise<ILogResponse[]>;
+    /**
+     * 🧹 Limpia todos los logs almacenados.
+     */
+    flush(): Promise<void>;
+    /**
+     * 🗑 Libera recursos (igual que flush, pero preparado para crecer).
+     */
+    dispose(): Promise<void>;
+}
+export declare class LoggerFactoryExample {
+    static Main(): Promise<void>;
+}

package/dist/examples/logger-factory.example.js

@@ -0,0 +1,158 @@
+"use strict";
+// examples/logger-factory.example.ts
+// Ajusta los imports según tu estructura real
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoggerFactoryExample = exports.InMemoryLogDatasource = void 0;
+const logger_factory_1 = require("../src/application/factory/logger.factory");
+const value_objects_1 = require("../src/domain/value-objects");
+/**
+ * InMemoryLogDatasource
+ *
+ * Implementación **completa** y **visual** para demos, tests e integración.
+ * Aplica todos los filtros definidos en IGetLogsFilterProps.
+ */
+class InMemoryLogDatasource {
+    constructor(name = "in-memory") {
+        this.logs = [];
+        this.idCounter = 1;
+        this.name = name;
+    }
+    /**
+     * 🔵 Guarda un log en memoria con un ID incremental.
+     */
+    async save(log) {
+        this.logs.push({
+            id: this.idCounter++,
+            ...log,
+        });
+    }
+    /**
+     * 🔍 Aplica todos los filtros para recuperar logs:
+     *  - levelMin
+     *  - since / until
+     *  - query
+     *  - limit
+     *  - offset
+     */
+    async find(filter) {
+        let results = [...this.logs];
+        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) => {
+                const msg = typeof log.message === "string"
+                    ? log.message.toLowerCase()
+                    : JSON.stringify(log.message).toLowerCase();
+                return msg.includes(q);
+            });
+        }
+        // Ordenar por timestamp ascendente (opcional pero útil para visualizar)
+        results.sort((a, b) => a.timestamp - b.timestamp);
+        // Paginación
+        const offset = filter?.offset ?? 0;
+        const limit = filter?.limit ?? results.length;
+        return results.slice(offset, offset + limit);
+    }
+    /**
+     * 🧹 Limpia todos los logs almacenados.
+     */
+    async flush() {
+        this.logs = [];
+        this.idCounter = 1;
+    }
+    /**
+     * 🗑 Libera recursos (igual que flush, pero preparado para crecer).
+     */
+    async dispose() {
+        await this.flush();
+    }
+}
+exports.InMemoryLogDatasource = InMemoryLogDatasource;
+class LoggerFactoryExample {
+    static async Main() {
+        console.log("=== 🧪 Ejemplo real de uso: LoggerFactory ===\n");
+        // -------------------------------------------------------------------------
+        // 1️⃣ Crear datasources
+        // -------------------------------------------------------------------------
+        const dsA = new InMemoryLogDatasource();
+        const dsB = new InMemoryLogDatasource();
+        // -------------------------------------------------------------------------
+        // 2️⃣ Construir logger vía Factory
+        // -------------------------------------------------------------------------
+        const logger = logger_factory_1.LoggerFactory.create({
+            datasources: [dsA, dsB], // fan-out
+            minLevel: value_objects_1.LogLevel.INFO, // DEBUG/TRACE serán ignorados
+            redactorOptions: {
+                enabled: true,
+                deep: true,
+                patterns: [
+                    {
+                        pattern: "\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b",
+                        replaceWith: "****-****-****-****",
+                    },
+                    {
+                        pattern: "[\\w.-]+@[\\w.-]+",
+                        replaceWith: "***@***",
+                    },
+                ],
+            },
+        });
+        console.log("✅ Logger creado correctamente.\n");
+        // -------------------------------------------------------------------------
+        // 3️⃣ Generar algunos logs de ejemplo
+        // -------------------------------------------------------------------------
+        console.log("→ DEBUG (no debe persistirse por minLevel=INFO)");
+        await logger.debug("Debug interno que NO debería guardarse");
+        console.log("→ INFO");
+        await logger.info("Servicio iniciado correctamente");
+        console.log("→ WARN");
+        await logger.warn("Latencia alta en /api/orders", {
+            endpoint: "/api/orders",
+            durationMs: 987,
+        });
+        console.log("→ ERROR con PII en message + meta");
+        await logger.error("Error al procesar tarjeta 4111-1111-1111-1111 para john.doe@example.com", {
+            userId: "u-123",
+            email: "john.doe@example.com",
+            card: "4111-1111-1111-1111",
+            nested: {
+                phone: "0999999999",
+            },
+        });
+        // -------------------------------------------------------------------------
+        // 4️⃣ Consultar logs usando getLogs
+        // -------------------------------------------------------------------------
+        console.log("\n=== 📄 getLogs(): todos los logs ===");
+        const all = await logger.getLogs();
+        console.dir(all, { depth: 10 });
+        console.log("\n=== 📄 getLogs({ levelMin: ERROR }) ===");
+        const errors = await logger.getLogs({ levelMin: value_objects_1.LogLevel.ERROR });
+        console.dir(errors, { depth: 10 });
+        console.log("\n=== 📄 getLogs({ query: 'tarjeta' }) ===");
+        const tarjeta = await logger.getLogs({ query: "tarjeta" });
+        console.dir(tarjeta, { depth: 10 });
+        // -------------------------------------------------------------------------
+        // 5️⃣ Flush explícito (útil si algún datasource usa buffers / batch)
+        // -------------------------------------------------------------------------
+        console.log("\n=== 🧹 flush() ===");
+        await logger.flush();
+        console.log("Flush completado.\n");
+        // -------------------------------------------------------------------------
+        // 6️⃣ Ver estado interno de cada datasource (fan-out)
+        // -------------------------------------------------------------------------
+        console.log("\n=== 🗂 Logs en dsA (memory-A) ===");
+        console.dir(await dsA.find(), { depth: 10 });
+        console.log("\n=== 🗂 Logs en dsB (memory-B) ===");
+        console.dir(await dsB.find(), { depth: 10 });
+        console.log("\n✔ LoggerFactoryExample finalizado.\n");
+    }
+}
+exports.LoggerFactoryExample = LoggerFactoryExample;

package/dist/examples/normalize-message.example.d.ts

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

package/dist/examples/normalize-message.example.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NormalizeMessageExample = void 0;
+const services_1 = require("src/domain/services");
+// -----------------------------------------------------------------------------
+// Mock simple de redactor PII para demostrar comportamiento real
+// En una aplicación real este sería reemplazado por un redactor robusto.
+// -----------------------------------------------------------------------------
+class SimplePiiRedactor {
+    redact(value) {
+        if (typeof value === "string") {
+            // Ejemplo tonto: censura emails y números
+            return value
+                .replace(/\b[\w.-]+@[\w.-]+\.\w+\b/g, "[REDACTED_EMAIL]")
+                .replace(/\d+/g, "[NUM]");
+        }
+        if (typeof value === "object" && value !== null) {
+            const clone = {};
+            for (const key of Object.keys(value)) {
+                const v = value[key];
+                clone[key] = typeof v === "string" ? v.replace(/\d+/g, "[NUM]") : v;
+            }
+            return clone;
+        }
+        return value;
+    }
+}
+// -----------------------------------------------------------------------------
+// Clase Example tal como lo haría un cliente del paquete
+// -----------------------------------------------------------------------------
+class NormalizeMessageExample {
+    static Main() {
+        console.log("=== 🧩 Ejemplo de uso: normalizeMessage ===\n");
+        const redactor = new SimplePiiRedactor();
+        // -------------------------------------------------------------------------
+        // 1️⃣ Mensaje de tipo string
+        // -------------------------------------------------------------------------
+        const msg1 = "Usuario juan@example.com realizó pago 12345";
+        const norm1 = (0, services_1.normalizeMessage)(msg1, redactor);
+        console.log("→ String redactado:");
+        console.log("  Entrada:", msg1);
+        console.log("  Salida:", norm1, "\n");
+        // -------------------------------------------------------------------------
+        // 2️⃣ Mensaje de tipo objeto
+        // -------------------------------------------------------------------------
+        const msg2 = {
+            user: "john@example.com",
+            amount: "1500",
+            action: "login",
+        };
+        const norm2 = (0, services_1.normalizeMessage)(msg2, redactor);
+        console.log("→ Objeto redactado:");
+        console.log("  Entrada:", msg2);
+        console.log("  Salida:", norm2, "\n");
+        // -------------------------------------------------------------------------
+        // 3️⃣ Mensaje como función (lazy evaluation)
+        // -------------------------------------------------------------------------
+        const msg3 = () => ({
+            email: "cliente@test.com",
+            phone: "0987654321",
+        });
+        const norm3 = (0, services_1.normalizeMessage)(msg3, redactor);
+        console.log("→ Función perezosa redactada:");
+        console.log("  Entrada: función que retorna datos sensibles");
+        console.log("  Salida:", norm3, "\n");
+        // -------------------------------------------------------------------------
+        // 4️⃣ Escenario real de logging
+        // -------------------------------------------------------------------------
+        const logMessage = () => `Intento de acceso por usuario admin@example.com desde IP 192.168.50.10`;
+        const result = (0, services_1.normalizeMessage)(logMessage, redactor);
+        console.log("→ Caso real de logging:");
+        console.log("  Log con PII:", result, "\n");
+        console.log("=== ✔ Fin del ejemplo normalizeMessage ===");
+    }
+}
+exports.NormalizeMessageExample = NormalizeMessageExample;
+// Ejecutar directamente: ts-node src/examples/normalize-message.example.ts
+if (require.main === module) {
+    NormalizeMessageExample.Main();
+}

package/dist/examples/pii-redactor.example.d.ts

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