@jmlq/logger 0.1.0-alpha.7 → 0.1.0-alpha.9

package/architecture.md

@@ -0,0 +1,171 @@
+# Arquitectura del Paquete @jmlq/logger
+
+## Visión General
+
+El paquete `@jmlq/logger` está diseñado siguiendo los principios de **Arquitectura Limpia**, proporcionando un sistema de logging extensible y desacoplado que permite registrar logs en múltiples destinos mediante plugins y soporta enmascarado de datos sensibles (PII - Personally Identifiable Information).
+
+## Principios de Diseño
+
+- **Separación de responsabilidades**: Cada capa tiene una responsabilidad específica
+- **Inversión de dependencias**: Las capas internas no dependen de las externas
+- **Extensibilidad**: Sistema de plugins para diferentes adaptadores de persistencia
+- **Testabilidad**: Arquitectura que facilita la creación de pruebas unitarias
+- **Configurabilidad**: Múltiples opciones de configuración mediante variables de entorno
+
+## Estructura de Capas
+
+### 📁 Domain (Capa de Dominio)
+
+La capa más interna que contiene la lógica de negocio pura, sin dependencias externas.
+
+#### **Entities & Value Objects**
+
+- [`LogLevelVo`](src/domain/value-objects/log-level.vo.ts): Objeto de valor que representa los niveles de log
+
+#### **Ports (Interfaces)**
+
+- [`ILoggerPort`](src/domain/ports/logger.port.ts): Contrato principal del logger
+- [`ILogDatasourcePort`](src/domain/ports/log-datasource.port.ts): Contrato para fuentes de datos
+- [`ILoggerServicePort`](src/domain/ports/logger-service.port.ts): Contrato para servicios de logging
+- [`IPiiRedactorPort`](src/domain/ports/pii-redactor.port.ts): Contrato para enmascarado PII
+- [`ILoggerFactoryConfigPort`](src/domain/ports/logger-factory-config.port.ts): Contrato de configuración del factory
+
+#### **Services (Servicios de Dominio)**
+
+- [`LogLevelService`](src/domain/services/log-level.service.ts): Lógica para manejo de niveles de log
+- [`MessageNormalizerService`](src/domain/services/message-normalizer.service.ts): Normalización de mensajes
+- [`PiiPatternService`](src/domain/services/pii-pattern.service.ts): Gestión de patrones PII
+- [`PiiRedactorService`](src/domain/services/pii-redactor.service.ts): Enmascarado de datos sensibles
+
+#### **Types & DTOs**
+
+- **Request**: [`SaveLogProps`](src/domain/request/save-log.props.ts), [`GetLogsFilterProps`](src/domain/request/get-logs-filter.props.ts), [`PiiOptionsProps`](src/domain/request/pii-options.props.ts)
+- **Response**: [`LogResponse`](src/domain/response/log.response.ts)
+- **Types**: [`LogMessageType`](src/domain/types/log-message.type.ts)
+
+### 📁 Application (Capa de Aplicación)
+
+Orquesta la lógica de negocio y coordina los casos de uso.
+
+#### **Use Cases**
+
+- [`SaveLogUseCase`](src/application/use-cases/save-log.use-case.ts): Guarda logs en los datasources configurados
+- [`GetLogsUseCase`](src/application/use-cases/get-logs.use-case.ts): Recupera logs con filtros
+- [`FlushBuffersUseCase`](src/application/use-cases/flush-buffers.use-case.ts): Vacía buffers de los datasources
+
+#### **Factory**
+
+- [`LoggerFactory`](src/application/factory/logger.factory.ts): Factory para crear instancias del logger
+
+### 📁 Infrastructure (Capa de Infraestructura)
+
+Implementaciones concretas de los contratos definidos en el dominio.
+
+#### **Services**
+
+- [`DatasourceService`](src/infrastructure/services/datasource.service.ts): Implementación del servicio de datasource
+- [`DataSourceErrorHandlerType`](src/infrastructure/services/data-source-error-handler.type.ts): Manejo de errores de datasources
+
+## Flujo de Dependencias
+
+```txt
+Infrastructure → Application → Domain
+```
+
+- **Domain**: No depende de nada, contiene la lógica de negocio pura
+- **Application**: Depende solo del Domain, orquesta los casos de uso
+- **Infrastructure**: Depende del Domain y Application, implementa los contratos
+
+## Patrones Implementados
+
+### **Factory Pattern**
+
+El [`LoggerFactory`](src/application/factory/logger.factory.ts) centraliza la creación de instancias del logger con las configuraciones apropiadas.
+
+### **Port-Adapter Pattern**
+
+Los ports en el domain definen contratos que son implementados por adaptadores en infrastructure.
+
+### **Use Case Pattern**
+
+Cada operación principal está encapsulada en un caso de uso específico con un método `execute()`.
+
+### **Dependency Injection**
+
+Las dependencias se inyectan a través de constructores, facilitando el testing y la flexibilidad.
+
+## Sistema de Plugins
+
+El logger soporta múltiples adaptadores de persistencia:
+
+- **Filesystem**: `@jmlq/logger-plugin-fs`
+- **MongoDB**: `@jmlq/logger-plugin-mongo`
+- **PostgreSQL**: `@jmlq/logger-plugin-postgresql`
+
+Cada plugin implementa los ports definidos en el domain.
+
+## Características Principales
+
+### **PII (Personally Identifiable Information)**
+
+- Enmascarado automático de datos sensibles
+- Patrones configurables y extensibles
+- Soporte para patrones por defecto y personalizados
+
+### **Niveles de Log**
+
+- debug, info, warn, error, fatal
+- Configuración de nivel mínimo por entorno
+
+### **Múltiples Datasources**
+
+- Soporte simultáneo para múltiples backends
+- Configuración opcional de cada adaptador
+
+### **Configuración Flexible**
+
+- Variables de entorno
+- Configuración programática
+- Políticas de retención de datos
+
+## Ejemplo de Uso
+
+```typescript
+import { LoggerBootstrap } from "@jmlq/logger";
+
+const logger = await LoggerBootstrap.create({
+  minLevel: "debug",
+  pii: {
+    enabled: true,
+    includeDefaults: true,
+    deep: true,
+  },
+  adapters: {
+    fs: { basePath: "./logs" },
+    mongo: { url: "mongodb://localhost:27017", dbName: "logs" },
+  },
+});
+
+await logger.info("User logged in", {
+  userId: "12345",
+  email: "user@example.com",
+});
+```
+
+## Testing
+
+La arquitectura facilita el testing mediante:
+
+> - Interfaces claramente definidas
+> - Servicios desacoplados
+> - Casos de uso aislados
+> - Mocks sencillos de implementar
+
+## Consideraciones de Rendimiento
+
+> - Buffers para escritura asíncrona
+> - Políticas de rotación de archivos
+> - Retención configurable de datos
+> - Procesamiento asíncrono de logs
+
+Esta arquitectura asegura mantenibilidad, extensibilidad y testabilidad del sistema de logging, siguiendo las mejores prácticas de clean architecture.

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

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

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

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

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

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;