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

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./domain";
+export * from "./application";
+export * from "./infrastructure";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// Re-exporta la API pública del paquete
+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("./domain"), exports);
+__exportStar(require("./application"), exports);
+__exportStar(require("./infrastructure"), exports);

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@jmlq/logger",
   "description": "logger package with clean architecture",
-  "version": "0.1.0-alpha.10",
+  "version": "0.1.0-alpha.12",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "dev": "rimraf dist && mkdir dist && tsc -p tsconfig.json",
+    "build": "rimraf dist && mkdir dist && tsc -p tsconfig.build.json",
     "prepublishOnly": "npm run build",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
@@ -31,11 +32,13 @@
     "@types/jest": "^29.5.8",
     "@types/node": "^20.8.10",
     "jest": "^29.7.0",
+    "rimraf": "^6.1.2",
     "tsx": "^4.1.4",
     "typescript": "^5.2.2"
   },
   "files": [
     "dist",
+    "README.md",
     "architecture.md",
     "install.md"
   ]

package/dist/examples/data-source-service.example.d.ts

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

package/dist/examples/data-source-service.example.js

@@ -1,174 +0,0 @@
-"use strict";
-// ============================================================================
-// 🧩 Ejemplo realista de cómo un cliente podría integrar DataSourceService
-// ============================================================================
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataSourceServiceExample = void 0;
-const src_1 = require("src");
-const infrastructure_1 = require("src/infrastructure");
-/**
- * InMemoryLogDatasource
- *
- * Implementación simple de ILogDatasource que almacena los logs en memoria.
- * Útil para:
- *  - Tests
- *  - Ejemplos / demos
- *  - Entornos de desarrollo
- */
-class InMemoryLogDatasource {
-    constructor() {
-        this.name = "in-memory";
-        this.logs = [];
-    }
-    /**
-     * Guarda un log en memoria.
-     * No aplica lógica especial, solo hace push al arreglo interno.
-     */
-    async save(log) {
-        // Suponemos que ILogResponse es compatible con ILogProps.
-        // Si en tu dominio ILogResponse tiene campos extra (ej: id),
-        // aquí podrías generarlos.
-        this.logs.push(log);
-    }
-    /**
-     * Devuelve los logs almacenados en memoria.
-     * Por simplicidad, se ignora el filtro. Puedes adaptar esta parte cuando
-     * tengas definido el shape completo de IGetLogsFilterProps.
-     */
-    async find(_filter) {
-        // Retornamos una copia para evitar mutación externa.
-        return [...this.logs];
-    }
-    /**
-     * Limpia todos los logs almacenados.
-     */
-    async flush() {
-        this.logs.length = 0;
-    }
-    /**
-     * Libera recursos.
-     * En este caso es equivalente a flush(), pero queda listo
-     * por si en el futuro necesitas lógica adicional.
-     */
-    async dispose() {
-        await this.flush();
-    }
-}
-/**
- * AppLoggerService
- *
- * Servicio de logging de la aplicación que:
- * - Usa DataSourceService (composite) debajo.
- * - Configura múltiples datasources.
- * - Centraliza el manejo de errores del logger vía errorHandler.
- */
-class AppLoggerService {
-    constructor() {
-        // 1️⃣ Definimos los datasources que usará la app
-        const datasources = [
-            new InMemoryLogDatasource(), // para debugging / tests / fallback
-            new HttpLogDatasource(// datasource custom del cliente
-            process.env.LOG_API_URL ?? "https://logs.my-api.com/events"),
-        ];
-        // 2️⃣ Definimos un error handler centralizado para errores del logger
-        const errorHandler = (info) => {
-            // Aquí el cliente podría usar su propio logger de infra (pino, winston, etc).
-            // En este ejemplo usamos console.error por simplicidad.
-            // IMPORTANTE: este logger NO debe depender de @jmlq/logger para evitar ciclos.
-            console.error("[AppLoggerService] Error en datasource de logger", {
-                op: info.operation,
-                datasource: info.datasourceName,
-                error: info.reason,
-            });
-        };
-        // 3️⃣ Creamos el DataSourceService composite con los datasources y el handler
-        this.dataSourceService = new infrastructure_1.DataSourceService(datasources, errorHandler);
-    }
-    // ----------------------------------------------------------------------------
-    // API pública del logger de la app (lo que realmente usa el cliente)
-    // ----------------------------------------------------------------------------
-    async info(message, meta) {
-        await this.log(src_1.LogLevel.INFO, message, meta);
-    }
-    async warn(message, meta) {
-        await this.log(src_1.LogLevel.WARN, message, meta);
-    }
-    async error(message, meta) {
-        await this.log(src_1.LogLevel.ERROR, message, meta);
-    }
-    async debug(message, meta) {
-        await this.log(src_1.LogLevel.DEBUG, message, meta);
-    }
-    async log(level, message, meta) {
-        const log = {
-            level,
-            message,
-            timestamp: Date.now(),
-            meta,
-        };
-        await this.dataSourceService.save(log);
-    }
-    /**
-     * Métodos opcionales para flush/dispose (por ejemplo, en shutdown de la app).
-     */
-    async flush() {
-        await this.dataSourceService.flush();
-    }
-    async dispose() {
-        await this.dataSourceService.dispose();
-    }
-}
-// ============================================================================
-// 🌐 Ejemplo de datasource HTTP implementado por el cliente
-//    (no forma parte del core, lo crea el consumidor usando ILogDatasource)
-// ============================================================================
-class HttpLogDatasource {
-    constructor(endpoint) {
-        this.endpoint = endpoint;
-        this.name = "http";
-    }
-    async save(log) {
-        // Aquí el cliente puede usar fetch, axios, got, etc.
-        // Lo dejamos como pseudo-código para no acoplar dependencias reales.
-        const body = JSON.stringify(log);
-        await fetch(this.endpoint, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body,
-        });
-    }
-}
-// ============================================================================
-// 🚀 Example runner: cómo el cliente lo usaría en su app
-// ============================================================================
-class DataSourceServiceExample {
-    static async Main() {
-        console.log("=== 🧩 Ejemplo REAL de uso: AppLoggerService sobre DataSourceService ===\n");
-        // 1️⃣ Crear instancia de logger de aplicación
-        const logger = new AppLoggerService();
-        // 2️⃣ Loguear eventos típicos de una app
-        console.log("📝 Enviando logs de ejemplo...\n");
-        await logger.info("Servidor iniciado", {
-            port: 3000,
-            env: process.env.NODE_ENV ?? "development",
-        });
-        await logger.info("Usuario autenticado", {
-            userId: "12345",
-            method: "password",
-        });
-        await logger.error("Error al procesar pedido", {
-            orderId: "ORD-999",
-            reason: "Stock insuficiente",
-        });
-        await logger.warn("Latencia alta detectada en /payments", {
-            p95_ms: 850,
-        });
-        console.log("✅ Logs enviados. Si algún datasource falla, el error handler los captura.\n");
-        // 3️⃣ Ejemplo de uso en shutdown de la app
-        console.log("🧹 Realizando flush() y dispose() del logger...\n");
-        await logger.flush();
-        await logger.dispose();
-        console.log("🏁 Ejemplo real completado.\n");
-    }
-}
-exports.DataSourceServiceExample = DataSourceServiceExample;

package/dist/examples/flush-buffers-use-case.example.d.ts

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

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

@@ -1,60 +0,0 @@
-"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

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

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

@@ -1,110 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,116 +0,0 @@
-"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

@@ -1,39 +0,0 @@
-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>;
-}