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

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;
+}

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

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

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

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

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

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

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

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

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

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

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

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