@jmlq/logger-plugin-fs 0.1.0-alpha.6 → 0.1.0-alpha.8

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

@@ -1 +1,3 @@
+export * from "./rotation-check.dto";
 export * from "./save-log.dto";
+export * from "./write-operation.dto";

package/dist/application/dto/index.js

@@ -14,4 +14,6 @@ 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("./rotation-check.dto"), exports);
 __exportStar(require("./save-log.dto"), exports);
+__exportStar(require("./write-operation.dto"), exports);

package/dist/application/dto/rotation-check.dto.d.ts

@@ -0,0 +1,5 @@
+export interface IRotationCheckDto {
+    currentPath: string;
+    currentDate: Date;
+    currentSizeBytes: number;
+}

package/dist/application/dto/save-log.dto.d.ts

@@ -1,4 +1,4 @@
-import type { ILog } from "@jmlq/logger";
-export interface SaveLogDTO {
-    log: ILog;
+import { ILogProps } from "@jmlq/logger";
+export interface ISaveLogDto {
+    log: ILogProps;
 }

package/dist/application/dto/write-operation.dto.d.ts

@@ -0,0 +1,5 @@
+export interface IWriteOperationDto {
+    data: string;
+    targetPath: string;
+    append?: boolean;
+}

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

@@ -0,0 +1,3 @@
+import { ILogDatasource } from "@jmlq/logger";
+import { IFilesystemDatasourceOptions } from "../../infrastructure/filesystem";
+export declare function createFsDatasource(options: IFilesystemDatasourceOptions): ILogDatasource;

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFsDatasource = createFsDatasource;
+const adapters_1 = require("../../infrastructure/adapters");
+const use_cases_1 = require("../use-cases");
+const services_1 = require("../services");
+const filesystem_1 = require("../../infrastructure/filesystem");
+function createFsDatasource(options) {
+    // Crear Value Objects
+    const fileNamePattern = new filesystem_1.FileNamePattern(options.fileNamePattern || "app-{yyyy}{MM}{dd}.log");
+    const rotationPolicy = new filesystem_1.RotationPolicy(options.rotation?.by || "day", options.rotation?.maxSizeMB, options.rotation?.maxFiles);
+    // Crear adaptadores
+    const clockAdapter = new adapters_1.NodeClockAdapter();
+    const filePathAdapter = new adapters_1.NodeFilePathAdapter();
+    const fsProviderAdapter = new adapters_1.FsProviderAdapter();
+    const streamWriterAdapter = new adapters_1.FsWriterAdapter();
+    const fileRotatorAdapter = new adapters_1.FileRotatorAdapter(fsProviderAdapter, filePathAdapter, fileNamePattern, options.basePath);
+    // Crear casos de uso
+    const ensureDirectoryUseCase = new use_cases_1.EnsureDirectoryUseCase(fsProviderAdapter, options.basePath, options.mkdir);
+    const appendLogUseCase = new use_cases_1.AppendLogUseCase(streamWriterAdapter, options.serializer);
+    const rotateIfNeededUseCase = new use_cases_1.RotateIfNeededUseCase(fileRotatorAdapter, streamWriterAdapter, options.onRotate);
+    const persistLogUseCase = new use_cases_1.PersistLogUseCase(clockAdapter, fileRotatorAdapter, streamWriterAdapter, rotationPolicy, rotateIfNeededUseCase, appendLogUseCase, ensureDirectoryUseCase, options.onError);
+    // Inicializar directorio
+    ensureDirectoryUseCase.execute();
+    return new services_1.FsDatasourceService(persistLogUseCase, streamWriterAdapter);
+}

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

@@ -0,0 +1 @@
+export * from "./create-fs-datasource.factory";

package/dist/{presentation → application}/factory/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("./create-fs-datasource"), exports);
+__exportStar(require("./create-fs-datasource.factory"), exports);

package/dist/application/services/fs-datasource.service.d.ts

@@ -1,9 +1,11 @@
-import type { ILogDatasource, ILog } from "@jmlq/logger";
-import { PersistLogUseCase } from "../use-cases";
+import { ILogProps, ILogDatasource } from "@jmlq/logger";
+import { IPersistLogUseCase } from "../use-cases";
+import { IStreamWriterPort } from "../../domain/ports";
 export declare class FsDatasourceService implements ILogDatasource {
-    private readonly persistUC;
-    constructor(persistUC: PersistLogUseCase);
-    save(log: ILog): Promise<void>;
+    private readonly persistLogUseCase;
+    private readonly streamWriterPort;
+    constructor(persistLogUseCase: IPersistLogUseCase, streamWriterPort: IStreamWriterPort);
+    save(log: ILogProps): Promise<void>;
     flush(): Promise<void>;
     dispose(): Promise<void>;
 }

package/dist/application/services/fs-datasource.service.js

@@ -2,21 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FsDatasourceService = void 0;
 class FsDatasourceService {
-    constructor(persistUC) {
-        this.persistUC = persistUC;
+    constructor(persistLogUseCase, streamWriterPort) {
+        this.persistLogUseCase = persistLogUseCase;
+        this.streamWriterPort = streamWriterPort;
     }
-    // Guarda un log (core llama esto). Orquesta vía PersistLogUseCase.
     async save(log) {
-        const dto = { log };
-        await this.persistUC.execute(dto);
+        await this.persistLogUseCase.execute({ log });
     }
-    // Espera drenaje del buffer (útil para shutdown)
     async flush() {
-        await this.persistUC.flush();
+        await this.streamWriterPort.flush();
     }
-    // Cierra recursos (stream)
     async dispose() {
-        await this.persistUC.dispose();
+        await this.streamWriterPort.close();
     }
 }
 exports.FsDatasourceService = FsDatasourceService;

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

@@ -0,0 +1,12 @@
+import { ISaveLogDto } from "../dto/save-log.dto";
+import { IStreamWriterPort } from "../../domain/ports/stream-writer.port";
+import { IFsSerializer } from "../../infrastructure/filesystem";
+export interface IAppendLogUseCase {
+    execute(dto: ISaveLogDto): Promise<void>;
+}
+export declare class AppendLogUseCase implements IAppendLogUseCase {
+    private readonly streamWriterPort;
+    private readonly serializer?;
+    constructor(streamWriterPort: IStreamWriterPort, serializer?: IFsSerializer | undefined);
+    execute(dto: ISaveLogDto): Promise<void>;
+}

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppendLogUseCase = void 0;
+class AppendLogUseCase {
+    constructor(streamWriterPort, serializer) {
+        this.streamWriterPort = streamWriterPort;
+        this.serializer = serializer;
+    }
+    async execute(dto) {
+        const { log } = dto;
+        let serializedData;
+        if (this.serializer) {
+            serializedData = this.serializer.serialize(log);
+        }
+        else {
+            // Serialización por defecto
+            serializedData = JSON.stringify(log);
+        }
+        // Agregar salto de línea si no lo tiene
+        if (!serializedData.endsWith("\n")) {
+            serializedData += "\n";
+        }
+        await this.streamWriterPort.write(serializedData);
+    }
+}
+exports.AppendLogUseCase = AppendLogUseCase;

package/dist/application/use-cases/ensure-directory.use-case.d.ts

@@ -0,0 +1,11 @@
+import { IFsProviderPort } from "../../domain/ports";
+export interface IEnsureDirectoryUseCase {
+    execute(): Promise<void>;
+}
+export declare class EnsureDirectoryUseCase implements IEnsureDirectoryUseCase {
+    private readonly fsProvider;
+    private readonly basePath;
+    private readonly createIfNotExists;
+    constructor(fsProvider: IFsProviderPort, basePath: string, createIfNotExists?: boolean);
+    execute(): Promise<void>;
+}

package/dist/application/use-cases/ensure-directory.use-case.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnsureDirectoryUseCase = void 0;
+const errors_1 = require("../../shared/errors");
+class EnsureDirectoryUseCase {
+    constructor(fsProvider, basePath, createIfNotExists = true) {
+        this.fsProvider = fsProvider;
+        this.basePath = basePath;
+        this.createIfNotExists = createIfNotExists;
+    }
+    async execute() {
+        if (!this.createIfNotExists) {
+            return;
+        }
+        try {
+            // El basePath ES el directorio que queremos crear
+            const exists = await this.fsProvider.exists(this.basePath);
+            if (!exists) {
+                await this.fsProvider.mkdir(this.basePath, { recursive: true });
+            }
+        }
+        catch (error) {
+            throw errors_1.FileOperationError.createForMkdir(this.basePath, error);
+        }
+    }
+}
+exports.EnsureDirectoryUseCase = EnsureDirectoryUseCase;

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

@@ -1,3 +1,4 @@
-export * from "./rotate-if-needed.usecase";
-export * from "./append-log.usecase";
-export * from "./persist-log.usecase";
+export * from "./append-log.use-case";
+export * from "./ensure-directory.use-case";
+export * from "./persist-log.use-case";
+export * from "./rotate-if-needed.use-case";

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

@@ -14,6 +14,7 @@ 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.usecase"), exports);
-__exportStar(require("./append-log.usecase"), exports);
-__exportStar(require("./persist-log.usecase"), exports);
+__exportStar(require("./append-log.use-case"), exports);
+__exportStar(require("./ensure-directory.use-case"), exports);
+__exportStar(require("./persist-log.use-case"), exports);
+__exportStar(require("./rotate-if-needed.use-case"), exports);