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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,75 +0,0 @@
-"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();
-}