@jmlq/logger-plugin-fs 0.0.1-beta.1

package/README.es.md

@@ -0,0 +1,224 @@
+# @jmlq/logger-plugin-fs 🧩
+
+## 🎯 Objetivo
+
+`@jmlq/logger-plugin-fs` es el plugin de persistencia en filesystem para `@jmlq/logger`.  
+Su responsabilidad es construir un `ILogDatasource` compatible con el core del logger para:
+
+- escribir logs en archivos,
+- rotar archivos según política configurada,
+- buscar logs históricos desde archivos `.log`,
+- exponer `flush()` sobre el writer del datasource.
+
+El punto de entrada recomendado del paquete es `createFsDatasource(...)`.
+
+## ⭐ Importancia
+
+Este plugin resuelve un escenario muy común en aplicaciones Node.js:
+
+- persistencia local en disco,
+- operación simple sin depender de MongoDB o PostgreSQL,
+- trazabilidad por archivo diario o por tamaño,
+- integración directa con `@jmlq/logger` sin acoplar el host a detalles de `fs`, `path` o streams.
+
+Además, mantiene separación clara entre dominio, casos de uso y adaptadores de Node.js.
+
+## 🏗️ Arquitectura (visión rápida)
+
+- `createFsDatasource(...)` construye el grafo completo del plugin.
+- El plugin usa value objects como `FileNamePattern` y `FileRotationPolicy`.
+- La escritura real ocurre vía `LogStreamWriterAdapter`.
+- La lectura histórica ocurre con `FileSystemLogFileEnumeratorAdapter` y `FileSystemLogFileLineReaderAdapter`.
+- El adapter público que se entrega al core es `FsDatasourceAdapter`.
+
+➡️ Ver detalle en: [architecture.md](./docs/es/architecture.md)
+
+## 🔧 Implementación
+
+### 5.1 Instalación
+
+```bash
+npm i @jmlq/logger @jmlq/logger-plugin-fs
+```
+
+### 5.2 Dependencias
+
+Dependencia directa del plugin:
+
+- `@jmlq/logger`
+
+El plugin usa internamente APIs de Node.js para filesystem/streams, pero esas dependencias no se exponen como configuración del consumidor.
+
+### 5.3 Quickstart (implementación rápida)
+
+Uso directo del plugin:
+
+```ts
+import { createLogger } from "@jmlq/logger";
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+  rotation: { by: "day" },
+  mkdir: true,
+});
+
+const logger = createLogger({
+  datasources: fsDatasource,
+});
+```
+
+En una capa `infrastructure` del host, una implementación típica queda así:
+
+```ts
+import {
+  createFsDatasource,
+  type IFilesystemDatasourceOptions,
+} from "@jmlq/logger-plugin-fs";
+import type { ILogDatasource } from "@jmlq/logger";
+
+export class FsAdapter {
+  private constructor(private readonly ds: ILogDatasource) {}
+
+  static create(opts: IFilesystemDatasourceOptions): FsAdapter | undefined {
+    try {
+      const ds = createFsDatasource(opts);
+      console.log("[logger] Conectado a FS para logs");
+      return new FsAdapter(ds);
+    } catch (e: any) {
+      console.warn("[logger] FS deshabilitado:", e?.message ?? e);
+    }
+  }
+
+  get datasource(): ILogDatasource {
+    return this.ds;
+  }
+}
+```
+
+### 5.4 Variables de entorno (.env) 📦
+
+El plugin no consume variables de entorno por sí mismo.  
+En el host, la configuración real puede resolverse desde `envs.logger`.
+
+Ejemplo de consumo real en un bootstrap del logger:
+
+```ts
+fs: envs.logger.LOGGER_FS_PATH
+  ? {
+      basePath: envs.logger.LOGGER_FS_PATH,
+      fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+      rotation: { by: "day" },
+      mkdir: true,
+      onRotate: (oldPath, newPath) => {
+        console.log(
+          `   [Rotate] Rotación completada: ${oldPath.absolutePath} → ${newPath.absolutePath}`,
+        );
+      },
+      onError: (err) => {
+        console.error("   [Error Handler]", err.message);
+      },
+    }
+  : undefined,
+```
+
+Variables usadas por ese host para este plugin:
+
+```ts
+process.env.LOGGER_FS_PATH;
+process.env.LOG_LEVEL;
+process.env.LOGGER_PII_ENABLED;
+process.env.LOGGER_PII_INCLUDE_DEFAULTS;
+```
+
+### 5.5 Helpers y funcionalidades clave
+
+#### `IFilesystemDatasourceOptions`
+
+Configuración pública real del datasource:
+
+```ts
+export interface IFilesystemDatasourceOptions {
+  basePath: string;
+  mkdir?: boolean;
+  fileNamePattern?: string;
+  rotation?: IFileSystemRotationConfig;
+  onRotate?: (oldPath: FilePath, newPath: FilePath) => void | Promise<void>;
+  onError?: (error: Error) => void | Promise<void>;
+}
+```
+
+#### Rotación
+
+El plugin soporta estas políticas:
+
+- `none`
+- `day`
+- `size`
+
+Ejemplo:
+
+```ts
+rotation: { by: "day" }
+rotation: { by: "size", maxSizeMB: 50, maxFiles: 10 }
+rotation: { by: "none" }
+```
+
+#### Patrón de nombre de archivo
+
+El plugin usa `FileNamePattern` y soporta tokens de fecha como:
+
+- `{yyyy}`
+- `{MM}`
+- `{dd}`
+
+Ejemplo:
+
+```ts
+fileNamePattern: "app-{yyyy}{MM}{dd}.log";
+```
+
+#### Hooks útiles
+
+- `onRotate`: notificación después de la rotación
+- `onError`: centraliza errores del datasource
+
+#### Lectura histórica
+
+El datasource también expone búsqueda de logs usando `find(...)`, apoyado en:
+
+- enumeración de archivos `.log`,
+- lectura línea por línea,
+- filtrado por nivel, fechas y query textual.
+
+### 5.7 Escenario actual
+
+La integración documentada está orientada a Express y a un bootstrap de infraestructura similar al que ya usas con `@jmlq/logger`, pero el plugin se mantiene desacoplado del framework HTTP.
+
+## ✅ Checklist (pasos rápidos)
+
+- [Instalar](#51-instalación)
+- [Crear el datasource con `createFsDatasource`](./docs/es/configuration.md#crear-el-datasource-con-createfsdatasource)
+- [Configurar rotación y patrón de nombre](./docs/es/configuration.md#configuración-real-del-datasource)
+- [Integrar el datasource en el bootstrap del logger](./docs/es/integration-express.md#bootstrap-del-logger-en-el-host)
+- [Adjuntar logger a Express](./docs/es/integration-express.md#adjuntar-logger-al-request)
+- [Revisar problemas comunes](./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
+
+- [`@jmlq/logger`](https://github.com/MLahuasi/jmlq-logger#readme)
+- Plugins relacionados del ecosistema:
+  - [`@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,224 @@
+# @jmlq/logger-plugin-fs 🧩
+
+## 🎯 Objective
+
+`@jmlq/logger-plugin-fs` is the filesystem persistence plugin for `@jmlq/logger`.
+Its responsibility is to build an `ILogDatasource` compatible with the logger core to:
+
+- write logs to files,
+- rotate files based on a configured policy,
+- search historical logs from `.log` files,
+- expose `flush()` over the datasource writer.
+
+The recommended entry point of the package is `createFsDatasource(...)`.
+
+## ⭐ Importance
+
+This plugin solves a very common scenario in Node.js applications:
+
+- local disk persistence,
+- simple operation without depending on MongoDB or PostgreSQL,
+- traceability by daily file or by size,
+- direct integration with `@jmlq/logger` without coupling the host to `fs`, `path`, or streams details.
+
+It also maintains a clear separation between domain, use cases, and Node.js adapters.
+
+## 🏗️ Architecture (quick view)
+
+- `createFsDatasource(...)` builds the full plugin graph.
+- The plugin uses value objects such as `FileNamePattern` and `FileRotationPolicy`.
+- Actual writing is performed via `LogStreamWriterAdapter`.
+- Historical reading is handled by `FileSystemLogFileEnumeratorAdapter` and `FileSystemLogFileLineReaderAdapter`.
+- The public adapter exposed to the core is `FsDatasourceAdapter`.
+
+➡️ See details: [architecture.md](./docs/en/architecture.md)
+
+## 🔧 Implementation
+
+### 5.1 Installation
+
+```bash id="q1c8rt"
+npm i @jmlq/logger @jmlq/logger-plugin-fs
+```
+
+### 5.2 Dependencies
+
+Direct dependency of the plugin:
+
+- `@jmlq/logger`
+
+The plugin internally uses Node.js APIs for filesystem/streams, but those dependencies are not exposed as configuration for the consumer.
+
+### 5.3 Quickstart (rapid implementation)
+
+Direct plugin usage:
+
+```ts id="u8z3pw"
+import { createLogger } from "@jmlq/logger";
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+  rotation: { by: "day" },
+  mkdir: true,
+});
+
+const logger = createLogger({
+  datasources: fsDatasource,
+});
+```
+
+In a host `infrastructure` layer, a typical implementation looks like this:
+
+```ts id="v5m2kl"
+import {
+  createFsDatasource,
+  type IFilesystemDatasourceOptions,
+} from "@jmlq/logger-plugin-fs";
+import type { ILogDatasource } from "@jmlq/logger";
+
+export class FsAdapter {
+  private constructor(private readonly ds: ILogDatasource) {}
+
+  static create(opts: IFilesystemDatasourceOptions): FsAdapter | undefined {
+    try {
+      const ds = createFsDatasource(opts);
+      console.log("[logger] Connected to FS for logs");
+      return new FsAdapter(ds);
+    } catch (e: any) {
+      console.warn("[logger] FS disabled:", e?.message ?? e);
+    }
+  }
+
+  get datasource(): ILogDatasource {
+    return this.ds;
+  }
+}
+```
+
+### 5.4 Environment variables (.env) 📦
+
+The plugin does not consume environment variables by itself.
+In the host, the actual configuration can be resolved from `envs.logger`.
+
+Example of real usage in a logger bootstrap:
+
+```ts id="t3n9qx"
+fs: envs.logger.LOGGER_FS_PATH
+  ? {
+      basePath: envs.logger.LOGGER_FS_PATH,
+      fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+      rotation: { by: "day" },
+      mkdir: true,
+      onRotate: (oldPath, newPath) => {
+        console.log(
+          `   [Rotate] Rotation completed: ${oldPath.absolutePath} → ${newPath.absolutePath}`,
+        );
+      },
+      onError: (err) => {
+        console.error("   [Error Handler]", err.message);
+      },
+    }
+  : undefined,
+```
+
+Variables used by that host for this plugin:
+
+```ts id="x7q4yb"
+process.env.LOGGER_FS_PATH;
+process.env.LOG_LEVEL;
+process.env.LOGGER_PII_ENABLED;
+process.env.LOGGER_PII_INCLUDE_DEFAULTS;
+```
+
+### 5.5 Helpers and key features
+
+#### `IFilesystemDatasourceOptions`
+
+Public datasource configuration:
+
+```ts id="p2z8rk"
+export interface IFilesystemDatasourceOptions {
+  basePath: string;
+  mkdir?: boolean;
+  fileNamePattern?: string;
+  rotation?: IFileSystemRotationConfig;
+  onRotate?: (oldPath: FilePath, newPath: FilePath) => void | Promise<void>;
+  onError?: (error: Error) => void | Promise<void>;
+}
+```
+
+#### Rotation
+
+The plugin supports the following policies:
+
+- `none`
+- `day`
+- `size`
+
+Example:
+
+```ts id="k9m1hd"
+rotation: { by: "day" }
+rotation: { by: "size", maxSizeMB: 50, maxFiles: 10 }
+rotation: { by: "none" }
+```
+
+#### File name pattern
+
+The plugin uses `FileNamePattern` and supports date tokens such as:
+
+- `{yyyy}`
+- `{MM}`
+- `{dd}`
+
+Example:
+
+```ts id="n4t6zx"
+fileNamePattern: "app-{yyyy}{MM}{dd}.log";
+```
+
+#### Useful hooks
+
+- `onRotate`: notification after rotation
+- `onError`: centralizes datasource errors
+
+#### Historical reading
+
+The datasource also exposes log search via `find(...)`, supported by:
+
+- `.log` file enumeration,
+- line-by-line reading,
+- filtering by level, dates, and text query.
+
+### 5.7 Current scenario
+
+The documented integration is oriented toward Express and an infrastructure bootstrap similar to what you already use with `@jmlq/logger`, but the plugin remains decoupled from any HTTP framework.
+
+## ✅ Checklist (quick steps)
+
+- [Install](#51-installation)
+- [Create datasource with `createFsDatasource`](./docs/en/configuration.md#create-the-datasource-with-createfsdatasource)
+- [Configure rotation and file name pattern](./docs/en/configuration.md#datasource-configuration)
+- [Integrate datasource into logger bootstrap](./docs/en/integration-express.md#logger-bootstrap-in-the-host)
+- [Attach logger to Express](./docs/en/integration-express.md#attach-logger-to-request)
+- [Review common issues](./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
+
+- [`@jmlq/logger`](https://github.com/MLahuasi/jmlq-logger#readme)
+- Related ecosystem plugins:
+  - [`@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/dto/index.d.ts

@@ -0,0 +1 @@
+export * from "./rotate-if-needed.request";

package/dist/application/dto/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("./rotate-if-needed.request"), exports);

package/dist/application/dto/rotate-if-needed.request.d.ts

@@ -0,0 +1,10 @@
+import { FileRotationPolicy } from "../../domain/value-objects";
+/**
+ * DTO de entrada para el caso de uso RotateIfNeeded.
+ * - currentDate: fecha/hora actual (inyectada desde un clock para tests deterministas)
+ * - rotationPolicy: política de rotación (VO de dominio)
+ */
+export interface RotateIfNeededRequest {
+    currentDate: Date;
+    rotationPolicy: FileRotationPolicy;
+}

package/dist/application/dto/rotate-if-needed.request.js

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

package/dist/application/factory/create-fs-datasource.factory.d.ts

@@ -0,0 +1,16 @@
+import { ILogDatasource } from "../../domain/ports";
+import { IFilesystemDatasourceOptions } from "../types";
+/**
+ * createFsDatasource
+ * -----------------------------------------------------------------------------
+ * Composition Root del plugin FS.
+ *
+ * Responsabilidad:
+ * - Construir el grafo de dependencias (VOs, adapters, use-cases)
+ * - Exponer un ILogDatasource compatible con @jmlq/logger
+ *
+ * Clean Architecture:
+ * - Vive en infraestructura porque integra con el core externo (@jmlq/logger)
+ * - Application/domain permanecen sin dependencias externas.
+ */
+export declare function createFsDatasource(options: IFilesystemDatasourceOptions): ILogDatasource;

package/dist/application/factory/create-fs-datasource.factory.js

@@ -0,0 +1,51 @@
+"use strict";
+// import type { ILogDatasource } from "@jmlq/logger";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFsDatasource = createFsDatasource;
+const adapters_1 = require("../../infrastructure/adapters");
+const use_cases_1 = require("../../application/use-cases");
+const value_objects_1 = require("../../domain/value-objects");
+/**
+ * createFsDatasource
+ * -----------------------------------------------------------------------------
+ * Composition Root del plugin FS.
+ *
+ * Responsabilidad:
+ * - Construir el grafo de dependencias (VOs, adapters, use-cases)
+ * - Exponer un ILogDatasource compatible con @jmlq/logger
+ *
+ * Clean Architecture:
+ * - Vive en infraestructura porque integra con el core externo (@jmlq/logger)
+ * - Application/domain permanecen sin dependencias externas.
+ */
+function createFsDatasource(options) {
+    // ---------------------------------------------------------------------------
+    // 1) Value Objects (dominio)
+    // ---------------------------------------------------------------------------
+    const fileNamePattern = new value_objects_1.FileNamePattern(options.fileNamePattern || "app-{yyyy}{MM}{dd}.log");
+    const rotationPolicy = new value_objects_1.FileRotationPolicy(options.rotation?.by || "day", options.rotation?.maxSizeMB, options.rotation?.maxFiles);
+    // ---------------------------------------------------------------------------
+    // 2) Adapters (infraestructura)
+    // ---------------------------------------------------------------------------
+    const clock = new adapters_1.SystemClockAdapter();
+    const filePath = new adapters_1.SystemFilePathAdapter();
+    const fsProvider = new adapters_1.FileSystemProviderAdapter();
+    const writer = new adapters_1.LogStreamWriterAdapter();
+    const fileRotator = new adapters_1.FileRotatorAdapter(fsProvider, filePath, fileNamePattern, options.basePath);
+    // ---------------------------------------------------------------------------
+    // 3) Use-cases (application)
+    //    Nota: no se "exponen" fuera; PersistLog orquesta todo.
+    // ---------------------------------------------------------------------------
+    const ensureDirectoryUseCase = new use_cases_1.EnsureDirectoryUseCase(fsProvider, options.basePath, options.mkdir);
+    const appendLogUseCase = new use_cases_1.AppendLogUseCase(writer);
+    const rotateIfNeededUseCase = new use_cases_1.RotateIfNeededUseCase(fileRotator, writer, options.onRotate);
+    const persistLogUseCase = new use_cases_1.PersistLogUseCase(clock, fileRotator, writer, rotationPolicy, rotateIfNeededUseCase, appendLogUseCase, ensureDirectoryUseCase, options.onError);
+    // 3.x) FindLogs use-case + IO
+    const fileEnumerator = new adapters_1.FileSystemLogFileEnumeratorAdapter(options.basePath);
+    const lineReader = new adapters_1.FileSystemLogFileLineReaderAdapter();
+    const findLogsUseCase = new use_cases_1.FindLogsUseCase({ fileEnumerator, lineReader });
+    // ---------------------------------------------------------------------------
+    // 4) Adapter que expone el contrato del core (@jmlq/logger)
+    // ---------------------------------------------------------------------------
+    return new adapters_1.FsDatasourceAdapter(persistLogUseCase, writer, findLogsUseCase);
+}

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

@@ -0,0 +1 @@
+export * from "./create-fs-datasource.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("./create-fs-datasource.factory"), exports);

package/dist/application/types/filesystem-datasource-options.type.d.ts

@@ -0,0 +1,45 @@
+import { FilePath } from "../../domain/value-objects";
+import { IFileSystemRotationConfig } from "../../infrastructure/filesystem/types";
+/**
+ * Opciones de configuración para la fuente de datos del sistema de archivos.
+ * Es el objeto de configuración para un datasource de logs basado en filesystem
+ */
+export interface IFilesystemDatasourceOptions {
+    /**
+     * Directorio base donde se van a crear/leer los archivos de log.
+     */
+    basePath: string;
+    /**
+     * Indica si se deben crear los directorios padres si no existen
+     * Si es true, la implementación puede crear el basePath (con fs.mkdir({ recursive: true })) si no existe.
+     * Si es false o undefined, o no lo crea o depende de tu implementación.
+     */
+    mkdir?: boolean;
+    /**
+     * Patrón de nombre del archivo de log
+     */
+    fileNamePattern?: string;
+    /**
+     * Conecta con la política de rotación: "none" | "day" | "size", tamaño máximo, número de archivos, etc
+     */
+    rotation?: IFileSystemRotationConfig;
+    /**
+     * Hook que se dispara cuando se rota un archivo de log. Útil para:
+     * - Notificar a otro sistema.
+     * - Enviar el archivo rotado a S3.
+     * - Hacer limpieza adicional.
+     * @param oldPath Ruta del archivo de log antes de la rotación
+     * @param newPath Ruta del archivo de log después de la rotación
+     * @returns
+     */
+    onRotate?: (oldPath: FilePath, newPath: FilePath) => void | Promise<void>;
+    /**
+     * Hook centralizado para manejar errores del datasource:
+     * - Loggear en otro canal.
+     * - Enviar métricas / alertas.
+     * - Evitar que el logger “reviente” la app.
+     * @param error Error ocurrido en el datasource
+     * @returns
+     */
+    onError?: (error: Error) => void | Promise<void>;
+}

package/dist/application/types/filesystem-datasource-options.type.js

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

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

@@ -0,0 +1 @@
+export * from "./filesystem-datasource-options.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("./filesystem-datasource-options.type"), exports);

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

@@ -0,0 +1,30 @@
+import { SaveLogRequest } from "../../domain/request";
+import { ILogStreamWriterPort } from "../../domain/ports";
+/**
+ * Contrato del caso de uso: permite ejecutar la operación "append log".
+ * Útil si quieres mockearlo en tests o exponerlo vía facade.
+ */
+export interface IAppendLogUseCase {
+    execute(dto: SaveLogRequest): Promise<void>;
+}
+/**
+ * AppendLogUseCase
+ * -----------------------------------------------------------------------------
+ * Caso de uso de Application que:
+ * - toma un log (request model),
+ * - lo serializa (serializer opcional o JSON por defecto),
+ * - asegura salto de línea,
+ * - lo escribe a través de un port (writer por stream).
+ *
+ * Clean Architecture:
+ * - depende de puertos del dominio (ILogStreamWriterPort)
+ * - NO depende de infraestructura directamente.
+ */
+export declare class AppendLogUseCase implements IAppendLogUseCase {
+    private readonly logStreamWriter;
+    constructor(logStreamWriter: ILogStreamWriterPort);
+    /**
+     * Ejecuta el caso de uso "append log".
+     */
+    execute(dto: SaveLogRequest): Promise<void>;
+}