@jmlq/logger 0.0.1-beta.1

package/README.es.md

@@ -0,0 +1,140 @@
+# @jmlq/logger 🧩
+
+## 🎯 Objetivo
+
+Proveer un **logger desacoplado del framework** (Express hoy, otro mañana) que:
+
+- Expone una API simple (`trace|debug|info|warn|error|fatal`).
+- Persiste logs a través de uno o varios **datasources** (`ILogDatasource`).
+- Permite **redacción de PII** (datos sensibles) antes de persistir.
+
+## ⭐ Importancia
+
+- **Clean Architecture real**: el core no depende de Express, Mongo, Postgres ni filesystem.
+- **Fan-out** (multi-datasource) sin que el host tenga que duplicar lógica.
+- **PII-by-design**: el mensaje y los metadatos pueden pasar por un redactor antes de salir del proceso.
+
+## 🏗️ Arquitectura (visión rápida)
+
+➡️ Ver detalle en: [architecture.md](./docs/es/architecture.md)
+
+## 🔧 Implementación
+
+### 5.1 Instalación
+
+```bash
+npm i @jmlq/logger
+```
+
+Para persistencia real, instala un plugin datasource (opcional):
+
+```bash
+npm i @jmlq/logger-plugin-fs
+# o
+npm i @jmlq/logger-plugin-mongo
+# o
+npm i @jmlq/logger-plugin-postgresql
+```
+
+### 5.2 Dependencias
+
+- **Runtime**: el core se mantiene minimalista (no integra I/O directamente).
+- **Plugins**: integran con filesystem / MongoDB / PostgreSQL y exponen un `ILogDatasource` compatible.
+
+### 5.3 Quickstart (implementación rápida)
+
+Ejemplo funcional usando el plugin de filesystem (datasource real):
+
+```ts
+import { createLogger, LogLevel, type PiiRedactorOptions } from "@jmlq/logger";
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+const pii: PiiRedactorOptions = {
+  enabled: true,
+  blacklistKeys: ["password", "token"],
+  patterns: [
+    // email
+    {
+      pattern: "[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}",
+      flags: "ig",
+      replaceWith: "[EMAIL]",
+    },
+  ],
+  deep: true,
+};
+
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  mkdir: true,
+  rotation: { by: "day" },
+});
+
+const logger = createLogger({
+  datasources: fsDatasource,
+  minLevel: LogLevel.INFO,
+  redactorOptions: pii,
+});
+
+await logger.info("server.started", {
+  port: 3000,
+  adminEmail: "admin@example.com",
+});
+await logger.warn(() => ({ msg: "suspicious.payload", token: "secret" }));
+```
+
+### 5.4 Variables de entorno (.env) 📦
+
+`@jmlq/logger` **no lee variables de entorno internamente**. La configuración se hace con código, pasando `ILoggerFactoryConfig` a `createLogger()`.
+
+Si tu host prefiere configurar por `.env`, un patrón típico es mapear `process.env` → `LoggerFactoryConfig`:
+
+```ts
+import { createLogger, LoggerUtils, LogLevel } from "@jmlq/logger";
+
+const minLevel: LogLevel = LoggerUtils.parseLogLevel(
+  process.env.LOG_LEVEL,
+  LogLevel.INFO,
+);
+
+// ...construye uno o más datasources según tu host
+```
+
+### 5.5 Helpers y funcionalidades clave
+
+- **Fan-out multi-datasource**
+  - Si pasas `datasources: ILogDatasource[]`, el core compone un datasource “composite” (`DataSourceService`) y hace fan-out a todos los destinos.
+  - Además, indexa en memoria lo escrito para soportar `getLogs()` incluso si algún datasource no implementa `find()`.
+
+- **PII Redaction (PiiRedactor)**
+  - Redacta `message` y `meta`.
+  - Soporta `patterns` (RegExp serializable), `whitelistKeys`, `blacklistKeys` y `deep`.
+
+- **Mensaje perezoso (lazy message)**
+  - `logger.info(() => ({ ... }))` evalúa el mensaje solo si el nivel pasa el filtro.
+
+## ✅ Checklist (pasos rápidos)
+
+- [Instalar](#51-instalación)
+- [Elegir un datasource](./docs/es/configuration.md#datasources-y-plugins)
+- [Configurar PII](./docs/es/configuration.md#pii-redaction)
+- [Integrar en Express](./docs/es/integration-express.md)
+- [Checklist de troubleshooting](./docs/es/troubleshooting.md)
+
+## 📌 Menú
+
+- [Arquitectura](./docs/es/architecture.md)
+- [Configuración](./docs/es/configuration.md)
+- [Integración Express](./docs/es/integration-express.md)
+- [Troubleshooting](./docs/es/troubleshooting.md)
+
+## 🔗 Referencias
+
+Plugins de persistencia:
+
+- [`@jmlq/logger-plugin-fs`](https://github.com/MLahuasi/jmlq-logger-plugin-fs#readme)
+- [`@jmlq/logger-plugin-mongo`](https://github.com/MLahuasi/jmlq-logger-plugin-mongo#readme)
+- [`@jmlq/logger-plugin-postgresql`](https://github.com/MLahuasi/jmlq-logger-plugin-postgresql#readme)
+
+## ⬅️ 🌐 Ecosistema
+
+- [`@jmlq`](https://github.com/MLahuasi/jmlq-ecosystem#readme)

package/README.md

@@ -0,0 +1,140 @@
+# @jmlq/logger 🧩
+
+## 🎯 Objective
+
+Provide a **framework-agnostic logger** (Express today, something else tomorrow) that:
+
+- Exposes a simple API (`trace|debug|info|warn|error|fatal`)
+- Persists logs through one or more **datasources** (`ILogDatasource`)
+- Supports **PII redaction** (sensitive data) before persisting
+
+## ⭐ Importance
+
+- **Real Clean Architecture**: the core does not depend on Express, Mongo, Postgres, or filesystem
+- **Fan-out** (multi-datasource) without duplicating logic in the host
+- **PII-by-design**: message and metadata can be processed by a redactor before leaving the process
+
+## 🏗️ Architecture (quick view)
+
+➡️ See details: [architecture.md](./docs/en/architecture.md)
+
+## 🔧 Implementation
+
+### 5.1 Installation
+
+```bash
+npm i @jmlq/logger
+```
+
+For real persistence, install a datasource plugin (optional):
+
+```bash
+npm i @jmlq/logger-plugin-fs
+# or
+npm i @jmlq/logger-plugin-mongo
+# or
+npm i @jmlq/logger-plugin-postgresql
+```
+
+### 5.2 Dependencies
+
+- **Runtime**: the core remains minimal (no direct I/O integration)
+- **Plugins**: integrate with filesystem / MongoDB / PostgreSQL and expose a compatible `ILogDatasource`
+
+### 5.3 Quickstart (rapid implementation)
+
+Example using the filesystem plugin (real datasource):
+
+```ts
+import { createLogger, LogLevel, type PiiRedactorOptions } from "@jmlq/logger";
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+const pii: PiiRedactorOptions = {
+  enabled: true,
+  blacklistKeys: ["password", "token"],
+  patterns: [
+    // email
+    {
+      pattern: "[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,}",
+      flags: "ig",
+      replaceWith: "[EMAIL]",
+    },
+  ],
+  deep: true,
+};
+
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  mkdir: true,
+  rotation: { by: "day" },
+});
+
+const logger = createLogger({
+  datasources: fsDatasource,
+  minLevel: LogLevel.INFO,
+  redactorOptions: pii,
+});
+
+await logger.info("server.started", {
+  port: 3000,
+  adminEmail: "admin@example.com",
+});
+await logger.warn(() => ({ msg: "suspicious.payload", token: "secret" }));
+```
+
+### 5.4 Environment variables (.env) 📦
+
+`@jmlq/logger` **does not read environment variables internally**. Configuration is done in code by passing `ILoggerFactoryConfig` to `createLogger()`.
+
+If your host prefers `.env`, a typical pattern is mapping `process.env` → `LoggerFactoryConfig`:
+
+```ts
+import { createLogger, LoggerUtils, LogLevel } from "@jmlq/logger";
+
+const minLevel: LogLevel = LoggerUtils.parseLogLevel(
+  process.env.LOG_LEVEL,
+  LogLevel.INFO,
+);
+
+// ...build one or more datasources depending on your host
+```
+
+### 5.5 Helpers and key features
+
+- **Multi-datasource fan-out**
+  - If you pass `datasources: ILogDatasource[]`, the core composes a “composite” datasource (`DataSourceService`) and fans out to all targets
+  - It also keeps an in-memory index of written logs to support `getLogs()` even if a datasource does not implement `find()`
+
+- **PII Redaction (PiiRedactor)**
+  - Redacts `message` and `meta`
+  - Supports `patterns` (serializable RegExp), `whitelistKeys`, `blacklistKeys`, and `deep`
+
+- **Lazy message**
+  - `logger.info(() => ({ ... }))` evaluates the message only if the level passes the filter
+
+## ✅ Checklist (quick steps)
+
+- [Install](#51-installation)
+- [Choose a datasource](./docs/en/configuration.md#datasources-and-plugins)
+- [Configure PII](./docs/en/configuration.md#pii-redaction)
+- [Integrate with Express](./docs/en/integration-express.md)
+- [Troubleshooting checklist](./docs/en/troubleshooting.md)
+
+## 📌 Menu
+
+- [Architecture](./docs/en/architecture.md)
+- [Configuration](./docs/en/configuration.md)
+- [Express Integration](./docs/en/integration-express.md)
+- [Troubleshooting](./docs/en/troubleshooting.md)
+
+## 🔗 References
+
+Persistence plugins:
+
+- [`@jmlq/logger-plugin-fs`](https://github.com/MLahuasi/jmlq-logger-plugin-fs#readme)
+- [`@jmlq/logger-plugin-mongo`](https://github.com/MLahuasi/jmlq-logger-plugin-mongo#readme)
+- [`@jmlq/logger-plugin-postgresql`](https://github.com/MLahuasi/jmlq-logger-plugin-postgresql#readme)
+
+## ⬅️ 🌐 Ecosystem
+
+- [`@jmlq`](https://github.com/MLahuasi/jmlq-ecosystem#readme)

package/dist/application/factory/index.d.ts

@@ -0,0 +1 @@
+export * from "./logger.factory";

package/dist/application/factory/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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("./logger.factory"), exports);

package/dist/application/factory/logger.factory.d.ts

@@ -0,0 +1,11 @@
+import { ILogger } from "../../domain/ports";
+import { ILoggerFactoryConfig } from "../types";
+/**
+ * Factory principal de @jmlq/logger.
+ * Se encarga de:
+ *  - Componer datasources (fan-out si hay varios)
+ *  - Construir el redactor de PII
+ *  - Instanciar y conectar los casos de uso
+ *  - Exponer un servicio de logger de alto nivel
+ */
+export declare function createLogger(config: ILoggerFactoryConfig, source?: string): ILogger;

package/dist/application/factory/logger.factory.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLogger = createLogger;
+const value_objects_1 = require("../../domain/value-objects");
+const pii_redactor_service_1 = require("../../domain/services/pii-redactor.service");
+const services_1 = require("../../infrastructure/services");
+const use_cases_1 = require("../use-cases");
+/**
+ * Factory principal de @jmlq/logger.
+ * Se encarga de:
+ *  - Componer datasources (fan-out si hay varios)
+ *  - Construir el redactor de PII
+ *  - Instanciar y conectar los casos de uso
+ *  - Exponer un servicio de logger de alto nivel
+ */
+function createLogger(config, source = "app-logger") {
+    // 1) Normalizar config
+    const minLevel = config.minLevel ?? value_objects_1.LogLevel.INFO;
+    const datasources = Array.isArray(config.datasources)
+        ? config.datasources
+        : [config.datasources];
+    // 2) Componer datasource (si hay varios) con DataSourceService
+    const ds = datasources.length === 1
+        ? datasources[0]
+        : new services_1.DataSourceService(datasources);
+    // 3) Crear/usar redactor de PII
+    const redactor = config.redactor ?? new pii_redactor_service_1.PiiRedactor(config.redactorOptions);
+    // 4) Construir casos de uso de Application
+    const saveLogUseCase = new use_cases_1.SaveLogUseCase({
+        ds,
+        minLevel,
+        redactor,
+    });
+    const getLogsUseCase = new use_cases_1.GetLogsUseCase(ds);
+    const flushBuffersUseCase = new use_cases_1.FlushBuffersUseCase(ds);
+    // 5) Construir facade de servicio de logging
+    const service = {
+        // Método genérico de logging
+        async log(level, message, meta) {
+            await saveLogUseCase.execute("app-logger", level, message, meta);
+        },
+        // Helpers por nivel
+        trace(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.TRACE, message, meta);
+        },
+        debug(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.DEBUG, message, meta);
+        },
+        info(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.INFO, message, meta);
+        },
+        warn(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.WARN, message, meta);
+        },
+        error(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.ERROR, message, meta);
+        },
+        fatal(message, meta) {
+            return saveLogUseCase.execute(source, value_objects_1.LogLevel.FATAL, message, meta);
+        },
+        // Lectura de logs con filtros
+        async getLogs(filter) {
+            return getLogsUseCase.execute(filter);
+        },
+        // Flush explícito (si el datasource lo soporta)
+        async flush() {
+            await flushBuffersUseCase.execute();
+        },
+    };
+    return service;
+}

package/dist/application/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./factory";
+export * from "./use-cases";

package/dist/application/index.js

@@ -0,0 +1,18 @@
+"use strict";
+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("./factory"), exports);
+__exportStar(require("./use-cases"), exports);

package/dist/application/types/index.d.ts

@@ -0,0 +1 @@
+export * from "./logger-factory-config.type";

package/dist/application/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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("./logger-factory-config.type"), exports);

package/dist/application/types/logger-factory-config.type.d.ts

@@ -0,0 +1,28 @@
+import { ILogDatasource, IPiiRedactor } from "../../domain/ports";
+import { PiiOptions } from "../../domain/model";
+import { LogLevel } from "../../domain/value-objects";
+/**
+ * Configuración de alto nivel para construir el logger.
+ * Es lo que recibe el usuario del paquete npm.
+ */
+export interface ILoggerFactoryConfig {
+    /**
+     * Datasource(s) concretos donde se van a persistir los logs.
+     * Pueden venir uno o varios; si hay más de uno se compone con DataSourceService (fan-out).
+     */
+    datasources: ILogDatasource | ILogDatasource[];
+    /**
+     * Nivel mínimo de logging. Por defecto: INFO.
+     */
+    minLevel?: LogLevel;
+    /**
+     * Instancia de redactor de PII personalizada.
+     * Si no se proporciona, se creará internamente un PiiRedactor con las opciones dadas.
+     */
+    redactor?: IPiiRedactor;
+    /**
+     * Opciones para el redactor de PII interno.
+     * Solo se usan si no se pasa `redactor` explícito.
+     */
+    redactorOptions?: PiiOptions;
+}

package/dist/application/types/logger-factory-config.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/application/use-cases/flush-buffers.use-case.d.ts

@@ -0,0 +1,6 @@
+import { ILogDatasource } from "../../domain/ports";
+export declare class FlushBuffersUseCase {
+    private readonly ds;
+    constructor(ds: ILogDatasource);
+    execute(): Promise<void>;
+}

package/dist/application/use-cases/flush-buffers.use-case.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlushBuffersUseCase = void 0;
+class FlushBuffersUseCase {
+    constructor(ds) {
+        this.ds = ds;
+    }
+    async execute() {
+        // flush es opcional; si no está implementado, no hace nada
+        await this.ds.flush?.();
+    }
+}
+exports.FlushBuffersUseCase = FlushBuffersUseCase;

package/dist/application/use-cases/get-logs.use-case.d.ts

@@ -0,0 +1,8 @@
+import { ILogDatasource } from "../../domain/ports";
+import { LogFilterRequest } from "../../domain/request";
+import { ILogResponse } from "../../domain/response";
+export declare class GetLogsUseCase {
+    private readonly ds;
+    constructor(ds: ILogDatasource);
+    execute(filter?: LogFilterRequest): Promise<ILogResponse[]>;
+}

package/dist/application/use-cases/get-logs.use-case.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetLogsUseCase = void 0;
+class GetLogsUseCase {
+    constructor(ds) {
+        this.ds = ds;
+    }
+    async execute(filter) {
+        if (!this.ds.find)
+            return []; // si el datasource no lo soporta, retorna vacío
+        // Sanitiza límites (evita valores negativos o absurdos)
+        const safe = filter
+            ? {
+                ...filter,
+                limit: filter.limit && filter.limit > 0
+                    ? Math.min(filter.limit, 5000)
+                    : undefined,
+                offset: filter.offset && filter.offset >= 0 ? filter.offset : undefined,
+            }
+            : undefined;
+        return this.ds.find(safe);
+    }
+}
+exports.GetLogsUseCase = GetLogsUseCase;

package/dist/application/use-cases/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./save-log.use-case";
+export * from "./get-logs.use-case";
+export * from "./flush-buffers.use-case";

package/dist/application/use-cases/index.js

@@ -0,0 +1,19 @@
+"use strict";
+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("./save-log.use-case"), exports);
+__exportStar(require("./get-logs.use-case"), exports);
+__exportStar(require("./flush-buffers.use-case"), exports);

package/dist/application/use-cases/save-log/index.d.ts

@@ -0,0 +1 @@
+export * from "./save-log.props";

package/dist/application/use-cases/save-log/index.js

@@ -0,0 +1,17 @@
+"use strict";
+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("./save-log.props"), exports);

package/dist/application/use-cases/save-log/save-log.props.d.ts

@@ -0,0 +1,7 @@
+import { LogLevel } from "../../../domain/value-objects";
+import { ILogDatasource, IPiiRedactor } from "../../../domain/ports";
+export interface SaveLogDependencies {
+    ds: ILogDatasource;
+    minLevel: LogLevel;
+    redactor: IPiiRedactor;
+}

package/dist/application/use-cases/save-log/save-log.props.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/application/use-cases/save-log.use-case.d.ts

@@ -0,0 +1,8 @@
+import { LogMessage } from "../../domain/types";
+import { LogLevel } from "../../domain/value-objects";
+import { SaveLogDependencies } from "./save-log";
+export declare class SaveLogUseCase {
+    private readonly props;
+    constructor(props: SaveLogDependencies);
+    execute(source: string, level: LogLevel, message: LogMessage, meta?: unknown): Promise<void>;
+}

package/dist/application/use-cases/save-log.use-case.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveLogUseCase = void 0;
+const utils_1 = require("../../domain/utils");
+class SaveLogUseCase {
+    constructor(props) {
+        this.props = props;
+    }
+    async execute(source, level, message, meta) {
+        // 1) Filtro por nivel (evita hacer trabajo innecesario)
+        if (level < this.props.minLevel)
+            return; // no se loggea
+        // 2) Normalización + PII
+        const normalized = (0, utils_1.normalizeMessage)(message, this.props.redactor);
+        // 3) Construcción del evento
+        const log = {
+            source,
+            level,
+            message: normalized,
+            meta: meta === undefined ? undefined : this.props.redactor.redact(meta),
+            timestamp: Date.now(),
+        };
+        // 4) Persistencia (fan-out lo maneja el ds si es composite)
+        await this.props.ds.save(log);
+    }
+}
+exports.SaveLogUseCase = SaveLogUseCase;

package/dist/domain/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./ports";
+export * from "./request";
+export * from "./response";
+export * from "./services";
+export * from "./types";
+export * from "./value-objects";
+export * from "./model";
+export * from "./utils";

package/dist/domain/index.js

@@ -0,0 +1,24 @@
+"use strict";
+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("./ports"), exports);
+__exportStar(require("./request"), exports);
+__exportStar(require("./response"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./value-objects"), exports);
+__exportStar(require("./model"), exports);
+__exportStar(require("./utils"), exports);

package/dist/domain/model/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./log-entry.model";
+export * from "./pii-options.model";
+export * from "./pii-replacement-rule";