@jmlq/logger-plugin-fs 0.1.0-alpha.0 → 0.1.0-alpha.10

package/README.md

@@ -0,0 +1,229 @@
+# @jmlq/logger-plugin-fs
+
+Plugin de **sistema de archivos** para [`@jmlq/logger`](https://www.npmjs.com/package/@jmlq/logger). Permite persistir logs en archivos con soporte para rotación automática, manejo de backpressure y configuración flexible de formato y estructura de archivos.
+
+## 📦 Instalación
+
+```bash
+npm install @jmlq/logger @jmlq/logger-plugin-fs
+```
+
+### Dependencias
+
+El plugin requiere como peer dependency:
+
+- `@jmlq/logger` >= 0.1.0-alpha.12
+
+> **Nota:** Este plugin requiere [`@jmlq/logger`](https://www.npmjs.com/package/@jmlq/logger) como dependencia principal.
+
+## 🚀 Uso rápido
+
+```typescript
+import { LoggerFactory } from "@jmlq/logger";
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+// Crear datasource de filesystem
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+  rotation: { by: "day" },
+});
+
+// Crear logger usando la factory
+const logger = LoggerFactory.create([fsDatasource]);
+
+// Usar el logger
+logger.info("Aplicación iniciada", { timestamp: new Date(), pid: process.pid });
+logger.error("Error de conexión", { service: "database", retries: 3 });
+
+// Cierre elegante
+process.on("SIGTERM", async () => {
+  await logger.flush();
+  await logger.dispose();
+  process.exit(0);
+});
+```
+
+## ⚙️ Configuración del datasource
+
+El datasource de filesystem acepta las siguientes opciones de configuración:
+
+### Opciones principales
+
+| Opción            | Tipo             | Descripción                                            | Por defecto                 |
+| ----------------- | ---------------- | ------------------------------------------------------ | --------------------------- |
+| `basePath`        | `string`         | Directorio base donde se guardarán los archivos de log | `"./logs"`                  |
+| `fileNamePattern` | `string`         | Patrón para nombrar archivos con tokens de fecha       | `"app-{yyyy}{MM}{dd}.log"`  |
+| `rotation`        | `RotationConfig` | Configuración de política de rotación                  | `{ by: "day" }`             |
+| `mkdir`           | `boolean`        | Crear directorio base si no existe                     | `true`                      |
+| `serializer`      | `LogSerializer`  | Serializador personalizado para el formato de líneas   | Serializer JSON por defecto |
+
+### Configuración de rotación
+
+```typescript
+interface RotationConfig {
+  by: "none" | "day" | "size";
+  maxSizeMB?: number; // Para rotación por tamaño
+  maxFiles?: number; // Límite de archivos rotados
+}
+```
+
+### Patrones de nombre de archivo
+
+Utiliza tokens que se reemplazan con valores de fecha (UTC):
+
+- `{yyyy}` - Año completo (ej: 2024)
+- `{MM}` - Mes con ceros (ej: 01, 12)
+- `{dd}` - Día con ceros (ej: 01, 31)
+
+**Ejemplos:**
+
+- `"app-{yyyy}{MM}{dd}.log"` → `app-20241201.log`
+- `"service-{yyyy}-{MM}-{dd}.log"` → `service-2024-12-01.log`
+- `"application.log"` → `application.log` (sin rotación por fecha)
+
+## 🔁 Políticas de rotación
+
+### Rotación por fecha
+
+Crea un archivo nuevo cada día basado en fecha UTC:
+
+```typescript
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+
+const datasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+  rotation: { by: "day" },
+  onRotate: (oldPath, newPath) => {
+    console.log(
+      `Log rotado: ${oldPath.absolutePath} → ${newPath.absolutePath}`
+    );
+  },
+});
+```
+
+### Rotación por tamaño
+
+Rota cuando el archivo alcanza el tamaño máximo especificado:
+
+```typescript
+const datasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app.log",
+  rotation: {
+    by: "size",
+    maxSizeMB: 50, // Rota al alcanzar 50MB
+    maxFiles: 10, // Mantiene máximo 10 archivos rotados
+  },
+  onRotate: (oldPath, newPath) => {
+    console.log(
+      `Archivo rotado por tamaño: ${oldPath.absolutePath} → ${newPath.absolutePath}`
+    );
+  },
+});
+```
+
+### Sin rotación
+
+Mantiene un único archivo que crece indefinidamente:
+
+```typescript
+const datasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "application.log",
+  rotation: { by: "none" },
+});
+```
+
+## 🧩 Ejemplo completo
+
+```typescript
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+import { LogLevel } from "@jmlq/logger";
+
+const datasource = createFsDatasource({
+  basePath: "./logs",
+  fileNamePattern: "app-{yyyy}-{MM}-{dd}.log",
+  rotation: { by: "day" },
+  mkdir: true,
+  serializer: {
+    serialize(log: any) {
+      return JSON.stringify(log, null, 2);
+    },
+  },
+  onRotate: (oldPath, newPath) => {
+    console.log(`Rotación: ${oldPath.absolutePath} → ${newPath.absolutePath}`);
+  },
+  onError: (err) => {
+    console.error("Error en datasource:", err.message);
+  },
+});
+
+// Guardar logs
+await datasource.save({
+  level: LogLevel.INFO,
+  message: "Servidor iniciado correctamente",
+  timestamp: Date.now(),
+});
+
+await datasource.save({
+  level: LogLevel.DEBUG,
+  message: "Conectando a base de datos...",
+  timestamp: Date.now(),
+});
+
+// Cierre
+await datasource.flush();
+await datasource.dispose();
+```
+
+## 🧪 Testing
+
+```typescript
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+import * as fs from "fs";
+import * as path from "path";
+
+describe("FileSystem Datasource", () => {
+  const testLogsPath = "./test-logs";
+
+  beforeEach(() => {
+    if (fs.existsSync(testLogsPath)) {
+      fs.rmSync(testLogsPath, { recursive: true });
+    }
+  });
+
+  test("debe crear archivo de log", async () => {
+    const datasource = createFsDatasource({
+      basePath: testLogsPath,
+      fileNamePattern: "test.log",
+      rotation: { by: "none" },
+    });
+
+    await datasource.save({
+      level: "info",
+      message: "Test message",
+      timestamp: new Date(),
+    });
+
+    await datasource.flush();
+
+    const logFile = path.join(testLogsPath, "test.log");
+    expect(fs.existsSync(logFile)).toBe(true);
+
+    const content = fs.readFileSync(logFile, "utf8");
+    expect(content).toContain("Test message");
+  });
+});
+```
+
+## 📄 Más Información
+
+- **[Arquitectura Detallada](./architecture.md)** - Documentación técnica completa
+- **[Guía de Instalación](./install.md)** - Configuración paso a paso
+- **[Ejemplos](./examples/)** - Códigos de ejemplo funcionales
+
+## 📄 Licencia
+
+MIT © Mauricio Lahuasi

package/architecture.md

@@ -0,0 +1,426 @@
+# Arquitectura del Plugin - @jmlq/logger-plugin-fs
+
+## Visión General del Plugin
+
+`@jmlq/logger-plugin-fs` es un plugin datasource especializado que resuelve la persistencia de logs en sistema de archivos para el ecosistema `@jmlq/logger`. Su arquitectura está diseñada bajo principios de Clean Architecture, proporcionando un sistema robusto de escritura de logs con capacidades avanzadas de rotación automática.
+
+El plugin aporta al ecosistema `@jmlq/logger` la capacidad de persistir logs en archivos con gestión inteligente de rotación, asegurando que las aplicaciones puedan mantener historial de logs sin comprometer el rendimiento ni el espacio en disco. Su diseño modular permite diferentes estrategias de rotación y serialización según las necesidades específicas de cada aplicación.
+
+Como datasource, el plugin implementa la interfaz `ILogDatasource` de `@jmlq/logger`, actuando como un adaptador entre el logger principal y el sistema de archivos, encapsulando toda la complejidad de gestión de archivos, rotación y escritura asíncrona.
+
+## Principios de Arquitectura
+
+### Clean Architecture
+
+El plugin implementa Clean Architecture con separación clara de responsabilidades en capas concéntricas, donde las dependencias fluyen hacia adentro (Infrastructure → Application → Domain).
+
+### Ports & Adapters (Hexagonal Architecture)
+
+Utiliza el patrón Ports & Adapters para aislar la lógica de negocio de las implementaciones concretas del filesystem, permitiendo testabilidad y flexibilidad en las implementaciones.
+
+### Separation of Concerns
+
+Cada componente tiene una responsabilidad específica y bien definida, desde la gestión de Value Objects hasta la escritura física de archivos.
+
+### Dependency Inversion
+
+Las capas internas definen interfaces (ports) que las capas externas implementan, invirtiendo las dependencias y manteniendo la independencia del dominio.
+
+## Estructura del Proyecto
+
+### `/src/domain/` - Capa de Dominio
+
+**Responsabilidad**: Contiene la lógica de negocio pura y las abstracciones fundamentales del plugin.
+
+**Contenido**:
+
+- `/ports/` - Interfaces que definen contratos con infraestructura
+- `/value-objects/` - Objetos de valor inmutables del dominio
+
+### `/src/application/` - Capa de Aplicación
+
+**Responsabilidad**: Orquesta los casos de uso del plugin y coordina entre dominio e infraestructura.
+
+**Contenido**:
+
+- `/dto/` - Data Transfer Objects para casos de uso
+- `/factory/` - Factories para creación de componentes
+- `/services/` - Servicios de aplicación que implementan `ILogDatasource`
+- `/use-cases/` - Casos de uso específicos del plugin
+
+### `/src/infrastructure/` - Capa de Infraestructura
+
+**Responsabilidad**: Implementaciones concretas de los ports del dominio y adaptadores específicos.
+
+**Contenido**:
+
+- `/adapters/` - Implementaciones concretas de ports del dominio
+- `/filesystem/` - Tipos, políticas y ports específicos del filesystem
+
+### `/src/shared/` - Utilitarios Compartidos
+
+**Responsabilidad**: Errores y utilidades transversales al plugin.
+
+**Contenido**:
+
+- `/errors/` - Jerarquía de errores específicos del plugin
+
+## Componentes Internos
+
+### Value Objects del Dominio
+
+#### FilePath
+
+```typescript
+class FilePath {
+  constructor(props: IFilePathProps);
+  get absolutePath(): string;
+  get directory(): string;
+  get filename(): string;
+  get extension(): string;
+  get basename(): string;
+  equals(other: FilePath): boolean;
+}
+```
+
+**Responsabilidad**: Encapsula una ruta de archivo completa como objeto inmutable, garantizando consistencia en la representación de paths a través del sistema.
+
+#### FileSize
+
+```typescript
+class FileSize {
+  constructor(bytes: number);
+  get bytes(): number;
+  get megabytes(): number;
+  isGreaterThan(other: FileSize): boolean;
+  equals(other: FileSize): boolean;
+}
+```
+
+**Responsabilidad**: Representa el tamaño de archivos como concepto del dominio, proporcionando métodos de comparación y conversión de unidades.
+
+### Value Objects de Infraestructura
+
+#### FileNamePattern
+
+```typescript
+class FileNamePattern {
+  constructor(pattern: string);
+  get pattern(): string;
+  hasDateTokens(): boolean;
+  getTokens(): string[];
+}
+```
+
+**Responsabilidad**: Encapsula patrones de nombres de archivo con placeholders para fechas, permitiendo generación dinámica de nombres basados en timestamps.
+
+#### RotationPolicy
+
+```typescript
+class RotationPolicy {
+  constructor(by: FsRotationBy, maxSizeMB?: number, maxFiles?: number);
+  get by(): FsRotationBy;
+  get maxSizeMB(): number | undefined;
+  get maxFiles(): number | undefined;
+  shouldRotateBySize(currentSize: FileSize): boolean;
+}
+```
+
+**Responsabilidad**: Define las reglas de rotación de archivos, encapsulando la lógica de cuándo y cómo rotar archivos según diferentes estrategias.
+
+### Tipos del Sistema
+
+#### FsRotationBy
+
+```typescript
+type FsRotationBy = "none" | "day" | "size";
+```
+
+**Responsabilidad**: Define las estrategias de rotación disponibles en el sistema.
+
+### Adaptadores de Infraestructura
+
+#### FsWriterAdapter
+
+```typescript
+class FsWriterAdapter implements IStreamWriterPort {
+  async write(data: string): Promise<boolean>;
+  async open(path: FilePath): Promise<void>;
+  async close(): Promise<void>;
+  async flush(): Promise<void>;
+  isOpen(): boolean;
+  getCurrentPath(): FilePath | null;
+}
+```
+
+**Responsabilidad**: Maneja la escritura física en archivos usando Node.js WriteStream, con gestión de estado y control de flujo.
+
+#### FileRotatorAdapter
+
+```typescript
+class FileRotatorAdapter implements IFileRotatorPort {
+  getCurrentPath(): FilePath | null;
+  getExpectedPathForDate(date: Date): FilePath;
+  async getFileSize(filePath: FilePath): Promise<FileSize>;
+  async shouldRotate(
+    policy: RotationPolicy,
+    currentDate: Date
+  ): Promise<boolean>;
+}
+```
+
+**Responsabilidad**: Implementa la lógica de rotación de archivos, generación de paths basados en fechas y evaluación de políticas de rotación.
+
+#### FsProviderAdapter
+
+```typescript
+class FsProviderAdapter implements IFsProviderPort
+```
+
+**Responsabilidad**: Abstrae operaciones del filesystem (stat, readdir, mkdir) proporcionando una interfaz uniforme para el dominio.
+
+#### NodeClockAdapter
+
+```typescript
+class NodeClockAdapter implements IClockPort
+```
+
+**Responsabilidad**: Proporciona acceso al tiempo del sistema de forma abstraída.
+
+#### NodeFilePathAdapter
+
+```typescript
+class NodeFilePathAdapter implements IFilePathAdapterPort
+```
+
+**Responsabilidad**: Maneja operaciones de manipulación de paths usando el módulo `path` de Node.js.
+
+### Services de Aplicación
+
+#### FsDatasourceService
+
+```typescript
+class FsDatasourceService implements ILogDatasource {
+  async save(log: ILogProps): Promise<void>;
+  async flush(): Promise<void>;
+  async dispose(): Promise<void>;
+}
+```
+
+**Responsabilidad**: Implementa la interfaz `ILogDatasource` del logger principal, actuando como punto de entrada del plugin y delegando a los casos de uso correspondientes.
+
+### Factory Principal
+
+#### createFsDatasource
+
+```typescript
+function createFsDatasource(
+  options: IFilesystemDatasourceOptions
+): ILogDatasource;
+```
+
+**Responsabilidad**: Factory function que ensambla todos los componentes del plugin, creando e inyectando dependencias según la configuración proporcionada.
+
+## Política de Rotación
+
+### Estrategias Implementadas
+
+#### Rotación por Día (`"day"`)
+
+La rotación se basa en cambios de fecha. El sistema evalúa si el archivo actual corresponde a la fecha presente:
+
+1. **Evaluación**: Compara el path actual con el path esperado para la fecha actual
+2. **Decisión**: Si difieren, se requiere rotación
+3. **Proceso**: Cierra el stream actual y abre uno nuevo con el path actualizado
+
+#### Rotación por Tamaño (`"size"`)
+
+La rotación se activa cuando el archivo supera el límite configurado:
+
+1. **Evaluación**: Compara el tamaño actual del archivo con `maxSizeMB` usando `FileSize.isGreaterThan()`
+2. **Decisión**: Se rota cuando el tamaño es mayor o igual al límite
+3. **Proceso**: Se crea un nuevo archivo y el anterior se mantiene según `maxFiles`
+
+#### Sin Rotación (`"none"`)
+
+El archivo crece indefinidamente sin intervención del sistema de rotación.
+
+### Generación de Nombres de Archivos
+
+El sistema utiliza `FileNamePattern` para generar nombres dinámicamente:
+
+**Placeholders soportados**:
+
+- `{yyyy}` - Año de 4 dígitos
+- `{MM}` - Mes con padding (01-12)
+- `{dd}` - Día con padding (01-31)
+- `{HH}` - Hora con padding (00-23)
+- `{mm}` - Minutos con padding (00-59)
+- `{ss}` - Segundos con padding (00-59)
+
+**Proceso**:
+
+1. `FileRotatorAdapter.buildPathForDate()` toma la fecha actual
+2. Reemplaza cada placeholder con el valor correspondiente de la fecha
+3. Combina con `basePath` usando `NodeFilePathAdapter`
+4. Retorna un `FilePath` completo
+
+## Flujo Interno del Datasource
+
+### Pipeline de Escritura de Logs
+
+```
+ILogProps → ISaveLogDto → PersistLogUseCase → Filesystem
+     ↓            ↓              ↓               ↓
+  [Logger]   [Application]   [Domain]    [Infrastructure]
+```
+
+### Secuencia Detallada
+
+1. **Recepción**: `FsDatasourceService.save()` recibe `ILogProps` desde el logger principal
+
+2. **Transformación**: Se encapsula en `ISaveLogDto` para el caso de uso
+
+3. **Orquestación**: `PersistLogUseCase.execute()` coordina el proceso:
+
+   - Asegura que el directorio existe (`EnsureDirectoryUseCase`)
+   - Evalúa necesidad de rotación (`RotateIfNeededUseCase`)
+   - Verifica estado del stream de escritura
+   - Delega escritura (`AppendLogUseCase`)
+
+4. **Evaluación de Rotación**: `RotateIfNeededUseCase`:
+
+   - Consulta `FileRotatorAdapter.shouldRotate()`
+   - Si requiere rotación, cierra stream actual y abre uno nuevo
+   - Ejecuta callback `onRotate` si está configurado
+
+5. **Escritura**: `AppendLogUseCase`:
+
+   - Serializa el log usando `IFsSerializer`
+   - Escribe en el stream actual via `FsWriterAdapter`
+
+6. **Gestión de Stream**: `FsWriterAdapter`:
+   - Maneja WriteStream de Node.js
+   - Controla backpressure y drenaje
+   - Gestiona apertura/cierre de archivos
+
+## Dependencias entre Capas
+
+```
+┌─────────────────────────────────────────────────────┐
+│                Infrastructure                       │
+│  ┌─────────────────┐    ┌─────────────────────────┐ │
+│  │    Adapters     │    │      Filesystem         │ │
+│  │  - FsWriter     │    │  - RotationPolicy       │ │
+│  │  - FileRotator  │    │  - FileNamePattern      │ │
+│  │  - FsProvider   │    │  - Types & Ports        │ │
+│  │  - NodeClock    │    │                         │ │
+│  │  - NodeFilePath │    │                         │ │
+│  └─────────────────┘    └─────────────────────────┘ │
+└─────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌─────────────────────────────────────────────────────┐
+│                  Application                        │
+│  ┌─────────────────┐    ┌─────────────────────────┐ │
+│  │   Use Cases     │    │    Factory & Service    │ │
+│  │  - PersistLog   │    │  - createFsDatasource   │ │
+│  │  - AppendLog    │    │  - FsDatasourceService  │ │
+│  │  - RotateIfNeed │    │                         │ │
+│  │  - EnsureDir    │    │                         │ │
+│  └─────────────────┘    └─────────────────────────┘ │
+└─────────────────────────────────────────────────────┘
+                            │
+                            ▼
+┌─────────────────────────────────────────────────────┐
+│                    Domain                           │
+│  ┌─────────────────┐    ┌─────────────────────────┐ │
+│  │  Value Objects  │    │        Ports            │ │
+│  │  - FilePath     │    │  - IStreamWriterPort    │ │
+│  │  - FileSize     │    │  - IFileRotatorPort     │ │
+│  │                 │    │  - IFsProviderPort      │ │
+│  │                 │    │  - IClockPort           │ │
+│  └─────────────────┘    └─────────────────────────┘ │
+└─────────────────────────────────────────────────────┘
+```
+
+## Patrones Técnicos Implementados
+
+### Adapter Pattern
+
+Los adaptadores (`FsWriterAdapter`, `FileRotatorAdapter`, etc.) implementan interfaces del dominio, adaptando APIs externas (Node.js filesystem) a las necesidades del plugin.
+
+### Strategy Pattern
+
+`RotationPolicy` encapsula diferentes estrategias de rotación (`"day"`, `"size"`, `"none"`) que pueden intercambiarse dinámicamente.
+
+### Value Object Pattern
+
+`FilePath`, `FileSize`, `FileNamePattern` y `RotationPolicy` implementan el patrón Value Object, proporcionando inmutabilidad y encapsulación de conceptos del dominio.
+
+### Factory Pattern
+
+`createFsDatasource` implementa el patrón Factory, encapsulando la complejidad de creación y configuración de dependencias.
+
+### Port & Adapter Pattern
+
+Las interfaces en `/domain/ports/` definen contratos que las implementaciones en `/infrastructure/adapters/` cumplen, permitiendo inversión de dependencias.
+
+## Interacción con @jmlq/logger
+
+### Integración como Datasource
+
+El plugin se integra implementando `ILogDatasource`:
+
+```typescript
+import { createFsDatasource } from "@jmlq/logger-plugin-fs";
+import { LoggerFactory } from "@jmlq/logger";
+
+const fsDatasource = createFsDatasource({
+  basePath: "./logs",
+  rotation: { by: "day" },
+});
+
+const logger = LoggerFactory.create({
+  datasources: [fsDatasource],
+});
+```
+
+### Flujo de Integración
+
+1. `LoggerFactory` registra el datasource creado por `createFsDatasource`
+2. Cuando se ejecuta `logger.info()`, `logger.error()`, etc., el logger principal invoca `FsDatasourceService.save()`
+3. El plugin procesa el log a través de su arquitectura interna
+4. El resultado se persiste en el filesystem según la configuración
+
+### Lifecycle Management
+
+```typescript
+// Flush de buffers pendientes
+await fsDatasource.flush();
+
+// Cierre limpio de recursos
+await fsDatasource.dispose();
+```
+
+## Consideraciones Técnicas
+
+### Gestión de Concurrencia
+
+El plugin maneja escritura asíncrona usando WriteStream de Node.js con control de backpressure a través de eventos `drain` y gestión de estado interno.
+
+### Manejo de Errores
+
+La arquitectura proporciona tres niveles de error:
+
+- `FsPluginError`: Errores generales del plugin
+- `FileOperationError`: Errores específicos de operaciones de archivo
+- `RotationError`: Errores relacionados con rotación de archivos
+
+### Limitaciones Arquitecturales
+
+1. **Dependencia de Node.js**: El plugin está acoplado al runtime de Node.js para operaciones de filesystem
+2. **Rotación Síncrona por Fecha**: La evaluación de rotación por día se basa en comparación de paths, no en metadata de archivos
+3. **Sin Compresión**: No incluye compresión automática de archivos rotados
+4. **Estrategias de Rotación Limitadas**: Solo soporta rotación por día, tamaño o ninguna
+5. **Sin Limpieza Automática**: La limpieza de archivos antiguos debe implementarse externamente usando `maxFiles` como referencia

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