@jmlq/logger 0.1.0-alpha.2 → 0.1.0-alpha.21

package/architecture.md

@@ -0,0 +1,193 @@
+# Arquitectura del Paquete @jmlq/logger
+
+## Visión General
+
+El paquete `@jmlq/logger` implementa **Clean Architecture** (Arquitectura Limpia), proporcionando un sistema de logging modular que permite registrar logs en múltiples destinos y enmascarar datos sensibles (PII).
+
+### Principios Aplicados
+
+- **Separación de responsabilidades**: Cada capa tiene una función específica
+- **Inversión de dependencias**: Las capas internas no conocen las externas
+- **Extensibilidad**: Sistema de plugins para diferentes adaptadores
+- **Testabilidad**: Contratos claros facilitan las pruebas
+
+---
+
+## Estructura de Capas
+
+### 📁 Domain (Capa de Dominio)
+
+_La capa más interna - lógica de negocio pura_
+
+#### **Value Objects**
+
+- [`log-level.vo.ts`](src/domain/value-objects/log-level.vo.ts): Enumeración de niveles de logging (TRACE, DEBUG, INFO, WARN, ERROR, FATAL)
+
+#### **Models**
+
+- [`log-entry.model.ts`](src/domain/model/log-entry.model.ts): Estructura de datos de un log
+- [`pii-options.model.ts`](src/domain/model/pii-options.model.ts): Configuración para enmascarado PII
+- [`pii-replacement-rule.ts`](src/domain/model/pii-replacement-rule.ts): Reglas de reemplazo para datos sensibles
+
+#### **Ports (Contratos)**
+
+- [`logger.port.ts`](src/domain/ports/logger.port.ts): Interfaz principal del logger (`ILogger`)
+- [`log-datasource.port.ts`](src/domain/ports/log-datasource.port.ts): Contrato para persistencia (`ILogDatasource`)
+- [`pii-redactor.port.ts`](src/domain/ports/pii-redactor.port.ts): Contrato para enmascarado (`IPiiRedactor`)
+- [`create-logger-options.port.ts`](src/domain/ports/create-logger-options.port.ts): Configuración del factory
+
+#### **Services (Servicios de Dominio)**
+
+- [`pii-redactor.service.ts`](src/domain/services/pii-redactor.service.ts): Implementación del enmascarado de datos sensibles
+
+#### **Request/Response**
+
+- [`log-filter.request.ts`](src/domain/request/log-filter.request.ts): Filtros para consultas (`LogFilterRequest`)
+- [`log.response.ts`](src/domain/response/log.response.ts): Formato de respuesta (`ILogResponse`)
+
+#### **Types & Utils**
+
+- [`log-message.type.ts`](src/domain/types/log-message.type.ts): Tipo para mensajes de log
+- [`normalize-message.util.ts`](src/domain/utils/normalize-message.util.ts): Normalización de mensajes
+- [`parse-log-level.util.ts`](src/domain/utils/parse-log-level.util.ts): Conversión de strings a LogLevel
+- [`pii-regex.util.ts`](src/domain/utils/pii-regex.util.ts): Generación de expresiones regulares para PII
+
+---
+
+### 📁 Application (Capa de Aplicación)
+
+_Orquesta casos de uso y coordina la lógica de negocio_
+
+#### **Factory**
+
+- [`logger.factory.ts`](src/application/factory/logger.factory.ts): **Punto de entrada principal** - crea instancias del logger con configuración completa
+
+#### **Use Cases**
+
+- [`save-log.use-case.ts`](src/application/use-cases/save-log.use-case.ts): Guarda logs aplicando filtros y PII
+- [`get-logs.use-case.ts`](src/application/use-cases/get-logs.use-case.ts): Recupera logs con filtros avanzados
+- [`flush-buffers.use-case.ts`](src/application/use-cases/flush-buffers.use-case.ts): Vacía buffers de los datasources
+
+#### **Dependencies**
+
+- [`save-log.props.ts`](src/application/use-cases/save-log/save-log.props.ts): Dependencias para SaveLogUseCase
+
+#### **Types**
+
+- [`logger-factory-config.type.ts`](src/application/types/logger-factory-config.type.ts): Configuración del factory (`ILoggerFactoryConfig`)
+
+---
+
+### 📁 Infrastructure (Capa de Infraestructura)
+
+_Implementaciones concretas y adaptadores externos_
+
+#### **Services**
+
+- [`datasource.service.ts`](src/infrastructure/services/datasource.service.ts): Implementación del patrón Composite para múltiples datasources
+
+#### **Types**
+
+- [`on-data-source-error.type.ts`](src/infrastructure/types/on-data-source-error.type.ts): Manejo de errores de datasources
+
+---
+
+## Flujo de Dependencias
+
+```txt
+Infrastructure → Application → Domain
+```
+
+- **Domain**: Contiene la lógica pura, sin dependencias externas
+- **Application**: Usa el Domain, coordina casos de uso
+- **Infrastructure**: Implementa contratos del Domain
+
+---
+
+## Patrones Implementados
+
+### **Factory Pattern**
+
+[`logger.factory.ts`](src/application/factory/logger.factory.ts) centraliza la creación del logger y sus dependencias.
+
+### **Port-Adapter Pattern**
+
+Los ports en Domain definen contratos implementados por adaptadores externos (plugins).
+
+### **Use Case Pattern**
+
+Cada operación principal tiene un caso de uso con método `execute()`.
+
+### **Composite Pattern**
+
+[`datasource.service.ts`](src/infrastructure/services/datasource.service.ts) maneja múltiples datasources como uno solo.
+
+---
+
+## Características Principales
+
+### **Niveles de Log**
+
+- `TRACE` (10), `DEBUG` (20), `INFO` (30), `WARN` (40), `ERROR` (50), `FATAL` (60)
+- Configuración de nivel mínimo por entorno
+
+### **Enmascarado PII**
+
+- Patrones configurables para emails, tarjetas, teléfonos, etc.
+- Procesamiento profundo en objetos anidados
+- Whitelist/blacklist de campos
+
+### **Múltiples Datasources**
+
+- Soporte simultáneo para archivos, MongoDB, PostgreSQL
+- Fan-out automático a todos los datasources configurados
+
+### **Sistema de Plugins**
+
+- **Filesystem**: `@jmlq/logger-plugin-fs`
+- **MongoDB**: `@jmlq/logger-plugin-mongo`
+- **PostgreSQL**: `@jmlq/logger-plugin-postgresql`
+
+---
+
+## Punto de Entrada
+
+```typescript
+import { createLogger } from "@jmlq/logger";
+
+const logger = createLogger({
+  datasources: [fsAdapter, mongoAdapter],
+  minLevel: LogLevel.INFO,
+  redactorOptions: {
+    enabled: true,
+    patterns: [
+      /* reglas PII */
+    ],
+  },
+});
+
+await logger.info("User logged in", { userId: "123" });
+```
+
+---
+
+## Flujo de Datos
+
+1. **Cliente** → llama método del logger (`info`, `error`, etc.)
+2. **Factory** → crea logger con casos de uso configurados
+3. **SaveLogUseCase** → aplica filtros de nivel y PII
+4. **DataSourceService** → distribuye a múltiples datasources
+5. **Plugins** → persisten en destino final (archivo, BD, etc.)
+
+---
+
+## Testing
+
+La arquitectura facilita testing mediante:
+
+- Interfaces bien definidas para mocking
+- Casos de uso aislados
+- Servicios desacoplados
+- Inyección de dependencias explícita
+
+Esta arquitectura asegura **mantenibilidad**, **extensibilidad** y **testabilidad** siguiendo principios SOLID y Clean Architecture.

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

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

package/dist/{config → application/factory}/index.js

@@ -14,5 +14,4 @@ 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("./interfaces"), exports);
-__exportStar(require("./types"), exports);
+__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/{presentation → application}/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 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/{config/interfaces/index.js → application/types/logger-factory-config.type.js}

@@ -1,3 +1,2 @@
 "use strict";
-// ---- Contratos ----
 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

@@ -1 +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

@@ -14,4 +14,11 @@ 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";

package/dist/domain/model/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("./log-entry.model"), exports);
+__exportStar(require("./pii-options.model"), exports);
+__exportStar(require("./pii-replacement-rule"), exports);

package/dist/domain/model/log-entry.model.d.ts

@@ -0,0 +1,8 @@
+import { LogLevel } from "../value-objects";
+export interface LogEntry {
+    source: string;
+    level: LogLevel;
+    message: string | Record<string, unknown>;
+    meta?: unknown;
+    timestamp: number;
+}

package/dist/domain/model/log-entry.model.js

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

package/dist/domain/model/pii-options.model.d.ts

@@ -0,0 +1,8 @@
+import { PiiReplacementRule } from ".";
+export interface PiiOptions {
+    enabled?: boolean;
+    whitelistKeys?: string[];
+    blacklistKeys?: string[];
+    patterns?: PiiReplacementRule[];
+    deep?: boolean;
+}

package/dist/domain/model/pii-options.model.js

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

package/dist/domain/model/pii-replacement-rule.d.ts

@@ -0,0 +1,5 @@
+export interface PiiReplacementRule {
+    pattern: string;
+    flags?: string;
+    replaceWith: string;
+}

package/dist/domain/model/pii-replacement-rule.js

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

package/dist/domain/ports/create-logger-options.port.d.ts

@@ -0,0 +1,7 @@
+import { PiiOptions } from "../model";
+import { LogLevel } from "../value-objects";
+export interface ICreateLoggerOptions {
+    minLevel?: LogLevel;
+    redactPII?: boolean;
+    pii?: PiiOptions;
+}

package/dist/domain/ports/create-logger-options.port.js

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

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

@@ -0,0 +1,4 @@
+export * from "./log-datasource.port";
+export * from "./logger.port";
+export * from "./pii-redactor.port";
+export * from "./create-logger-options.port";

package/dist/domain/ports/index.js

@@ -0,0 +1,20 @@
+"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("./log-datasource.port"), exports);
+__exportStar(require("./logger.port"), exports);
+__exportStar(require("./pii-redactor.port"), exports);
+__exportStar(require("./create-logger-options.port"), exports);

package/dist/domain/ports/log-datasource.port.d.ts

@@ -0,0 +1,10 @@
+import { LogEntry } from "../model";
+import { LogFilterRequest } from "../request";
+import { ILogResponse } from "../response";
+export interface ILogDatasource {
+    save(log: LogEntry): Promise<void>;
+    find?(filter?: LogFilterRequest): Promise<ILogResponse[]>;
+    flush?(): Promise<void>;
+    dispose?(): Promise<void>;
+    readonly name?: string;
+}