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

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

@@ -1,42 +1,100 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PersistLogUseCase = void 0;
+/**
+ * PersistLogUseCase
+ * -----------------------------------------------------------------------------
+ * Caso de uso de Application que orquesta el flujo completo:
+ * - asegura el directorio base
+ * - decide si rota según política y fecha actual
+ * - garantiza que el stream está abierto en el archivo correcto
+ * - escribe el log (append)
+ *
+ * Nota (Clean Architecture):
+ * - No hace IO directamente: todo IO va por ports/use-cases delegados.
+ * - Centraliza la secuencia y manejo de errores del flujo.
+ */
 class PersistLogUseCase {
-    constructor(clockPort, fileRotatorPort, streamWriterPort, rotationPolicy, rotateIfNeededUseCase, appendLogUseCase, ensureDirectoryUseCase, onError) {
-        this.clockPort = clockPort;
-        this.fileRotatorPort = fileRotatorPort;
-        this.streamWriterPort = streamWriterPort;
+    constructor(
+    /**
+     * Port para obtener la hora actual
+     */
+    systemClock, 
+    /**
+     * Port relacionado con rotación/naming (según diseño actual).
+     * Idealmente: la parte de naming debería estar separada en un "namer".
+     */
+    fileRotator, 
+    /**
+     * Writer por stream
+     */
+    streamWriter, 
+    /**
+     * Política de rotación (VO de dominio).
+     */
+    rotationPolicy, 
+    /**
+     * Use-case que ejecuta rotación si corresponde
+     */
+    rotateIfNeededUseCase, 
+    /**
+     * Use-case que serializa y escribe el log al stream.
+     */
+    appendLogUseCase, 
+    /**
+     * Use-case que asegura que el directorio base exista.
+     */
+    ensureDirectoryUseCase, 
+    /**
+     * Hook opcional para reportar/registrar errores antes de relanzarlos.
+     */
+    onError) {
+        this.systemClock = systemClock;
+        this.fileRotator = fileRotator;
+        this.streamWriter = streamWriter;
         this.rotationPolicy = rotationPolicy;
         this.rotateIfNeededUseCase = rotateIfNeededUseCase;
         this.appendLogUseCase = appendLogUseCase;
         this.ensureDirectoryUseCase = ensureDirectoryUseCase;
         this.onError = onError;
     }
+    /**
+     * Ejecuta el flujo principal de persistencia del log.
+     */
     async execute(dto) {
         try {
-            // Asegurar que el directorio existe
+            // 1) Asegurar que el directorio base existe (si está habilitado)
             await this.ensureDirectoryUseCase.execute();
-            const currentDate = this.clockPort.now();
-            // Verificar si necesitamos rotar
+            // 2) Obtener "ahora" desde un port (testable)
+            const currentDate = this.systemClock.now();
+            // 3) Verificar si corresponde rotar según política/fecha
             await this.rotateIfNeededUseCase.execute({
                 currentDate,
                 rotationPolicy: this.rotationPolicy,
             });
-            // Asegurar que el stream está abierto en la ruta correcta
-            const expectedPath = this.fileRotatorPort.getExpectedPathForDate(currentDate);
-            const currentPath = this.streamWriterPort.getCurrentPath();
-            if (!this.streamWriterPort.isOpen() ||
+            // 4) Asegurar que el stream esté abierto en la ruta esperada
+            const expectedPath = this.fileRotator.getExpectedPathForDate(currentDate);
+            const currentPath = this.streamWriter.getCurrentPath();
+            // Reabrir si:
+            // - no está abierto
+            // - no hay path actual
+            // - el path actual no coincide con el esperado (por fecha/patrón)
+            if (
+            // Cerrar si estaba abierto (evita handles colgando)
+            !this.streamWriter.isOpen() ||
                 !currentPath ||
                 !currentPath.equals(expectedPath)) {
-                if (this.streamWriterPort.isOpen()) {
-                    await this.streamWriterPort.close();
+                if (this.streamWriter.isOpen()) {
+                    await this.streamWriter.close();
                 }
-                await this.streamWriterPort.open(expectedPath);
+                // Abrir stream al archivo esperado
+                await this.streamWriter.open(expectedPath);
             }
-            // Escribir el log
+            // 5) Escribir el log (serialización + newline + write)
             await this.appendLogUseCase.execute(dto);
         }
         catch (error) {
+            // Hook opcional (log/metrics), pero se relanza el error para no ocultarlo
             if (this.onError) {
                 await this.onError(error);
             }

package/dist/application/use-cases/rotate-if-needed.use-case.d.ts

@@ -1,17 +1,55 @@
-import { IFileRotatorPort, RotationPolicy } from "../../infrastructure/filesystem";
-import { IStreamWriterPort } from "../../domain/ports";
+import { ILogStreamWriterPort, IFileRotatorPort } from "../../domain/ports";
 import { FilePath } from "../../domain/value-objects";
-export interface IRotateIfNeededDto {
-    currentDate: Date;
-    rotationPolicy: RotationPolicy;
-}
+import { RotateIfNeededRequest } from "../dto";
+/**
+ * Contrato del caso de uso: retorna el nuevo path si rotó, o null si no rotó.
+ */
 export interface IRotateIfNeededUseCase {
-    execute(dto: IRotateIfNeededDto): Promise<FilePath | null>;
+    execute(dto: RotateIfNeededRequest): Promise<FilePath | null>;
 }
+/**
+ * RotateIfNeededUseCase
+ * -----------------------------------------------------------------------------
+ * Caso de uso de Application que:
+ * - determina si se debe rotar (según policy + fecha)
+ * - si aplica, cambia el writer al nuevo archivo (close/open)
+ * - ejecuta un hook opcional onRotate(oldPath, newPath)
+ *
+ * Nota:
+ * - Depende de ports (IO indirecto).
+ * - Existe potencial de duplicidad si otro use-case también asegura open/close.
+ */
 export declare class RotateIfNeededUseCase implements IRotateIfNeededUseCase {
-    private readonly fileRotatorPort;
-    private readonly streamWriterPort;
+    /**
+     * Componente de rotación/naming (según diseño actual).
+     */
+    private readonly fileRotator;
+    /**
+     * Writer por stream usado para cerrar/abrir el archivo activo.
+     */
+    private readonly fileSystemWriter;
+    /**
+     * Hook opcional ejecutado cuando efectivamente se rota.
+     */
     private readonly onRotate?;
-    constructor(fileRotatorPort: IFileRotatorPort, streamWriterPort: IStreamWriterPort, onRotate?: ((oldPath: FilePath, newPath: FilePath) => void | Promise<void>) | undefined);
-    execute(dto: IRotateIfNeededDto): Promise<FilePath | null>;
+    constructor(
+    /**
+     * Componente de rotación/naming (según diseño actual).
+     */
+    fileRotator: IFileRotatorPort, 
+    /**
+     * Writer por stream usado para cerrar/abrir el archivo activo.
+     */
+    fileSystemWriter: ILogStreamWriterPort, 
+    /**
+     * Hook opcional ejecutado cuando efectivamente se rota.
+     */
+    onRotate?: ((oldPath: FilePath, newPath: FilePath) => void | Promise<void>) | undefined);
+    /**
+     * Ejecuta el flujo "rotar si hace falta".
+     * Retorna:
+     * - null si no corresponde rotar
+     * - newPath si rotó (o si el expected path es el nuevo destino)
+     */
+    execute(dto: RotateIfNeededRequest): Promise<FilePath | null>;
 }

package/dist/application/use-cases/rotate-if-needed.use-case.js

@@ -1,23 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RotateIfNeededUseCase = void 0;
+/**
+ * RotateIfNeededUseCase
+ * -----------------------------------------------------------------------------
+ * Caso de uso de Application que:
+ * - determina si se debe rotar (según policy + fecha)
+ * - si aplica, cambia el writer al nuevo archivo (close/open)
+ * - ejecuta un hook opcional onRotate(oldPath, newPath)
+ *
+ * Nota:
+ * - Depende de ports (IO indirecto).
+ * - Existe potencial de duplicidad si otro use-case también asegura open/close.
+ */
 class RotateIfNeededUseCase {
-    constructor(fileRotatorPort, streamWriterPort, onRotate) {
-        this.fileRotatorPort = fileRotatorPort;
-        this.streamWriterPort = streamWriterPort;
+    constructor(
+    /**
+     * Componente de rotación/naming (según diseño actual).
+     */
+    fileRotator, 
+    /**
+     * Writer por stream usado para cerrar/abrir el archivo activo.
+     */
+    fileSystemWriter, 
+    /**
+     * Hook opcional ejecutado cuando efectivamente se rota.
+     */
+    onRotate) {
+        this.fileRotator = fileRotator;
+        this.fileSystemWriter = fileSystemWriter;
         this.onRotate = onRotate;
     }
+    /**
+     * Ejecuta el flujo "rotar si hace falta".
+     * Retorna:
+     * - null si no corresponde rotar
+     * - newPath si rotó (o si el expected path es el nuevo destino)
+     */
     async execute(dto) {
         const { currentDate, rotationPolicy } = dto;
-        const shouldRotate = await this.fileRotatorPort.shouldRotate(rotationPolicy, currentDate);
+        // Decide si corresponde rotar (según implementación actual del port)
+        const shouldRotate = await this.fileRotator.shouldRotate(rotationPolicy, currentDate);
         if (!shouldRotate) {
             return null;
         }
-        const oldPath = this.fileRotatorPort.getCurrentPath();
-        const newPath = this.fileRotatorPort.getExpectedPathForDate(currentDate);
+        // Path anterior (si existe) y path esperado para la fecha actual
+        const oldPath = this.fileRotator.getCurrentPath();
+        const newPath = this.fileRotator.getExpectedPathForDate(currentDate);
+        // Solo si hay cambio real de archivo, se reabre el writer
         if (oldPath && !oldPath.equals(newPath)) {
-            await this.streamWriterPort.close();
-            await this.streamWriterPort.open(newPath);
+            await this.fileSystemWriter.close();
+            await this.fileSystemWriter.open(newPath);
             if (this.onRotate) {
                 await this.onRotate(oldPath, newPath);
             }

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

@@ -0,0 +1 @@
+export * from "./log-entry.model";

package/dist/{infrastructure/filesystem/value-objects → domain/model}/index.js

@@ -14,4 +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("./file-name-pattern.vo"), exports);
+__exportStar(require("./log-entry.model"), 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/ports/file/file-path.port.d.ts

@@ -0,0 +1,38 @@
+import { FilePath } from "../../value-objects";
+/**
+ * IFilePathPort
+ * -----------------------------------------------------------------------------
+ * Puerto de dominio para:
+ *  1) Construir un FilePath (Value Object) desde entradas string externas.
+ *  2) Componer rutas a partir de un FilePath existente.
+ *
+ * Motivación (Clean Architecture):
+ * - El dominio/aplicación NO dependen de `node:path` ni de reglas de OS.
+ * - Infraestructura provee un adapter (ej. SystemFilePathAdapter) que implementa esto.
+ *
+ * Nota de consistencia:
+ * - Define y respeta si FilePath en tu dominio es SIEMPRE absoluto o puede ser relativo.
+ *   (Si es siempre absoluto, fromRaw debería resolver a absoluto.)
+ */
+export interface IFilePathPort {
+    /**
+     * Construye un FilePath a partir de una ruta cruda (relativa o absoluta).
+     *
+     * Responsabilidades del adapter:
+     * - Validar input mínimo (string no vacío).
+     * - Normalizar separadores / limpiar.
+     * - (Opcional según tu modelo) Resolver a ruta absoluta.
+     */
+    fromRaw(inputPath: string): FilePath;
+    /**
+     * Une segmentos a partir de un FilePath base y retorna un nuevo FilePath (inmutable).
+     *
+     * Caso típico:
+     * - basePath (FilePath) + "subdir" + "file.log"
+     *
+     * Responsabilidades del adapter:
+     * - Validar segmentos (no vacíos si aplica).
+     * - Normalizar la ruta resultante.
+     */
+    join(filePath: FilePath, ...segments: string[]): FilePath;
+}

package/dist/domain/ports/file/file-rotator.port.d.ts

@@ -0,0 +1,42 @@
+import { FileSize, FilePath, FileRotationPolicy } from "../../value-objects";
+/**
+ * IFileRotatorPort
+ * -----------------------------------------------------------------------------
+ * Puerto de dominio para consultar información del filesystem necesaria
+ * para implementar rotación de archivos (logs) en casos de uso/servicios.
+ *
+ * Importante (Clean Architecture):
+ * - Este port NO debe contener reglas de negocio (p. ej. decidir si rotar).
+ * - Debe limitarse a capacidades del mundo externo (filesystem).
+ *
+ * La decisión de rotación (por fecha/tamaño/política) debe vivir en:
+ * - un Domain Service (reglas), o
+ * - un Use Case (orquestación), pero no dentro del port.
+ */
+export interface IFileRotatorPort {
+    /**
+     * Obtiene el archivo de log "actual" si existe/está determinado
+     * por la implementación (por ejemplo, por configuración).
+     *
+     * Nota:
+     * - Si el "current" depende solo de config, considera eliminar esto
+     *   y que el caso de uso lo derive desde config/naming.
+     */
+    getCurrentPath(): FilePath | null;
+    /**
+     * Calcular cómo se va a llamar el archivo según una fecha
+     * @param date Fecha para la que se quiere el path
+     */
+    getExpectedPathForDate(date: Date): FilePath;
+    /**
+     * Consulta el tamaño del archivo en filesystem.
+     * (IO puro; ideal para políticas de rotación por tamaño).
+     */
+    getFileSize(filePath: FilePath): Promise<FileSize>;
+    /**
+     * Decidir si corresponde rotar de acuerdo a una RotationPolicy y la fecha actual
+     * @param policy Política de rotación
+     * @param currentDate Fecha actual
+     */
+    shouldRotate(policy: FileRotationPolicy, currentDate: Date): Promise<boolean>;
+}

package/dist/{infrastructure/filesystem/ports → domain/ports/file}/index.d.ts

@@ -1 +1,2 @@
+export * from "./file-path.port";
 export * from "./file-rotator.port";

package/dist/{infrastructure/filesystem/ports → domain/ports/file}/index.js

@@ -14,4 +14,5 @@ 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("./file-path.port"), exports);
 __exportStar(require("./file-rotator.port"), exports);

package/dist/domain/ports/file/log-stream-writer.port.d.ts

@@ -0,0 +1,70 @@
+import { FilePath } from "../../value-objects";
+/**
+ * IFileSystemWriterPort
+ * -----------------------------------------------------------------------------
+ * Puerto de salida (Outbound Port) que abstrae un writer basado en stream.
+ *
+ * Uso típico:
+ *  - open(path)
+ *  - write(line)
+ *  - flush() (opcional, antes de rotar o cerrar)
+ *  - close() (cerrar el stream actual, con posibilidad de reabrir)
+ *  - end()   (finalizar definitivamente / liberar recursos)
+ *
+ * Implementación típica en infraestructura:
+ *  - Node.js fs.createWriteStream + manejo de backpressure ("drain")
+ */
+export interface ILogStreamWriterPort {
+    /**
+     * Escribe datos al stream actual.
+     *
+     * Retorna:
+     * - true: la escritura fue aceptada sin saturar el buffer
+     * - false: hay backpressure (buffer lleno) y conviene esperar antes de seguir
+     *
+     * Nota de diseño:
+     * - Si la implementación "await" internamente hasta que drene, el boolean pierde valor.
+     *   En ese caso considera devolver Promise<void> y ocultar backpressure.
+     */
+    write(data: string): Promise<boolean>;
+    /**
+     * Abre un stream para un archivo específico.
+     * Debe dejar el writer listo para recibir write().
+     */
+    open(filePath: FilePath): Promise<void>;
+    /**
+     * Cierra el stream actual (si existe) SIN implicar "dispose definitivo".
+     * Útil para rotación: cerrar -> renombrar -> open(nuevo).
+     *
+     * Recomendación:
+     * - Define claramente si close() es idempotente (llamar dos veces no falla).
+     */
+    close(): Promise<void>;
+    /**
+     * Fuerza a que todo lo pendiente se escriba antes de continuar.
+     *
+     * Importante:
+     * - Define qué garantiza: ¿solo vaciar buffer en memoria? ¿fsync a disco?
+     * - Es clave si la rotación requiere consistencia antes de renombrar/mover.
+     */
+    flush(): Promise<void>;
+    /**
+     * Indica si el writer está abierto y listo para recibir escrituras.
+     * Útil para evitar errores por write() sin open().
+     */
+    isOpen(): boolean;
+    /**
+     * Devuelve el FilePath actualmente abierto para escritura, o null si no hay.
+     * Útil para diagnóstico o para decidir rotación desde la aplicación.
+     */
+    getCurrentPath(): FilePath | null;
+    /**
+     * Finaliza definitivamente el writer.
+     * Debe liberar recursos y dejar el objeto en estado no reutilizable
+     * (o al menos documentar si se puede reabrir).
+     *
+     * Recomendación:
+     * - Aclara la diferencia exacta con close().
+     */
+    end(): Promise<void>;
+}

package/dist/domain/ports/{fs-provider.port.d.ts → filesystem-provider.port.d.ts}

@@ -1,7 +1,7 @@
 /**
  * Es una abstracción del sistema de archivos (fs) que la capa de dominio puede solicitar sin depender directamente del módulo fs de Node
  */
-export interface IFsProviderPort {
+export interface IFileSystemProviderPort {
     /**
      * Permite saber si un archivo o carpeta existe
      * @param path Ruta del archivo o directorio

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

@@ -1,4 +1,5 @@
-export * from "./clock.port";
-export * from "./fs-provider.port";
-export * from "./stream-writer.port";
-export * from "./file-path-adapter.port";
+export * from "./system-clock.port";
+export * from "./filesystem-provider.port";
+export * from "./file/log-stream-writer.port";
+export * from "./file";
+export * from "./logs";

package/dist/domain/ports/index.js

@@ -14,7 +14,8 @@ 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("./clock.port"), exports);
-__exportStar(require("./fs-provider.port"), exports);
-__exportStar(require("./stream-writer.port"), exports);
-__exportStar(require("./file-path-adapter.port"), exports);
+__exportStar(require("./system-clock.port"), exports);
+__exportStar(require("./filesystem-provider.port"), exports);
+__exportStar(require("./file/log-stream-writer.port"), exports);
+__exportStar(require("./file"), exports);
+__exportStar(require("./logs"), exports);

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

@@ -0,0 +1,2 @@
+export * from "./log-file-line-reader.port";
+export * from "./log-file-numerator.port";

package/dist/domain/ports/logs/find/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("./log-file-line-reader.port"), exports);
+__exportStar(require("./log-file-numerator.port"), exports);

package/dist/domain/ports/logs/find/log-file-line-reader.port.d.ts

@@ -0,0 +1,3 @@
+export interface ILogFileLineReaderPort {
+    readLines(filePath: string): AsyncIterable<string>;
+}

package/dist/domain/ports/logs/find/log-file-numerator.port.d.ts

@@ -0,0 +1,3 @@
+export interface ILogFileEnumeratorPort {
+    listLogFiles(): Promise<string[]>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./find";
+export * from "./log-datasource.port";

package/dist/domain/ports/logs/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("./find"), exports);
+__exportStar(require("./log-datasource.port"), exports);

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

@@ -0,0 +1,10 @@
+import { LogFilterRequest } from "../../request";
+import { LogEntry } from "../../model";
+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;
+}

package/dist/domain/ports/{clock.port.d.ts → system-clock.port.d.ts}

@@ -3,6 +3,6 @@
  * Su único propósito es permitir que el dominio pueda obtener la hora actual
  * sin depender directamente de new Date() ni de Date.now()
  */
-export interface IClockPort {
+export interface ISystemClockPort {
     now(): Date;
 }

package/dist/domain/ports/system-clock.port.js

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

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

@@ -0,0 +1,2 @@
+export * from "./log-filter.request";
+export * from "./save-log.request";

package/dist/domain/request/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("./log-filter.request"), exports);
+__exportStar(require("./save-log.request"), exports);

package/dist/domain/request/log-filter.request.d.ts

@@ -0,0 +1,9 @@
+import { LogLevel } from "../value-objects";
+export interface LogFilterRequest {
+    levelMin?: LogLevel;
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+    query?: string;
+}

package/dist/domain/request/log-filter.request.js

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

package/dist/domain/request/save-log.request.d.ts

@@ -0,0 +1,7 @@
+import { LogEntry } from "../model";
+/**
+ * Request model del caso de uso SaveLog.
+ */
+export interface SaveLogRequest {
+    log: LogEntry;
+}

package/dist/domain/request/save-log.request.js

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

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

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

package/dist/{application/services → domain/response}/index.js

@@ -14,4 +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("./fs-datasource.service"), exports);
+__exportStar(require("./log.response"), exports);

package/dist/domain/response/log.response.d.ts

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

package/dist/domain/response/log.response.js

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

package/dist/domain/types/fs-rotation-by.type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Es un tipo discriminado que define cómo se realizará la rotación de logs dentro del sistema.
+ * Los valores significan:
+ * "none" → Sin rotación. El archivo crece indefinidamente.
+ * "day"  → Rotación diaria (por fecha).
+ * "size" → Rotación por tamaño (normalmente basado en maxSizeMB).
+ */
+export type FsRotationBy = "none" | "day" | "size";

package/dist/domain/types/fs-rotation-by.type.js

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

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

@@ -0,0 +1 @@
+export * from "./fs-rotation-by.type";