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

package/dist/infrastructure/adapters/system-file-path.adapter.js

@@ -0,0 +1,141 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemFilePathAdapter = void 0;
+const path = __importStar(require("path"));
+const value_objects_1 = require("../../domain/value-objects");
+/**
+ * SystemFilePathAdapter
+ * --------------------
+ * Adapter de infraestructura que implementa IFilePathPort usando el módulo `path`
+ * del entorno de ejecución (típicamente Node.js).
+ *
+ * Responsabilidad:
+ * - Aceptar rutas crudas (relativas o absolutas).
+ * - Normalizar y resolver siempre a una ruta absoluta.
+ * - Construir y transformar el Value Object FilePath de forma consistente.
+ *
+ * Nota de diseño:
+ * - Este adapter centraliza TODA la lógica "dependiente del sistema" (path/OS).
+ * - El dominio no debería usar `path.*` directamente.
+ */
+class SystemFilePathAdapter {
+    // ---------------------------------------------------------------------------
+    // Creación: desde input crudo
+    // ---------------------------------------------------------------------------
+    /**
+     * Crea un FilePath desde una ruta cruda (relativa o absoluta).
+     * La implementación:
+     * - valida input
+     * - normaliza
+     * - resuelve a absoluta (path.resolve)
+     */
+    fromRaw(inputPath) {
+        // Validación de entrada: evita valores nulos, no-string o vacíos.
+        if (typeof inputPath !== "string") {
+            throw new Error("SystemFilePathAdapter.fromRaw: inputPath must be a string");
+        }
+        const trimmed = inputPath.trim();
+        if (!trimmed) {
+            throw new Error("SystemFilePathAdapter.fromRaw: inputPath cannot be empty or whitespace");
+        }
+        // Importante: NO resolvemos aquí y también en buildFromAnyPath.
+        // Reducimos redundancia: delegamos la normalización/resolución en un único helper.
+        return this.buildFromAnyPath(trimmed);
+    }
+    // ---------------------------------------------------------------------------
+    // Transformaciones: derivar nuevas rutas desde un FilePath existente
+    // ---------------------------------------------------------------------------
+    /**
+     * Une segmentos a la ruta base.
+     *
+     * Nota importante:
+     * - Aquí es clave definir semántica. Para evitar el caso raro:
+     *     "/logs/app.log" + "x" -> "/logs/app.log/x"
+     *   unimos los segmentos al DIRECTORIO del FilePath.
+     *
+     * Si tu intención era tratar FilePath como "basePath" que puede ser directorio,
+     * entonces tu VO debería representar directorios explícitamente.
+     */
+    join(filePath, ...segments) {
+        // Unimos respecto al directorio del archivo (semántica segura).
+        const fullPath = path.join(filePath.directory, ...segments);
+        return this.buildFromAnyPath(fullPath);
+    }
+    // ---------------------------------------------------------------------------
+    // Helper privado: construcción consistente de IFilePathProps
+    // ---------------------------------------------------------------------------
+    /**
+     * Construye un FilePath resolviendo y normalizando en UN SOLO lugar.
+     *
+     * Redundancia corregida:
+     * - Antes se hacía path.resolve() en métodos públicos y también en el builder.
+     * - Ahora todos pasan por este helper y aquí se aplica resolve/normalize.
+     */
+    buildFromAnyPath(anyPath) {
+        const raw = anyPath.trim();
+        const isDirHint = /[\\\/]$/.test(raw);
+        // Resolver a absoluto y normalizar (maneja ., .., separadores OS, etc.)
+        const normalized = path.resolve(anyPath);
+        if (isDirHint) {
+            // Representa directorio
+            return new value_objects_1.FilePath({
+                kind: "dir",
+                absolutePath: normalized,
+                directory: normalized, // para dirs, directory = sí mismo
+                filename: null,
+                extension: null,
+                basename: null,
+            });
+        }
+        // Derivar partes a partir de la ruta normalizada.
+        const directory = path.dirname(normalized);
+        const filename = path.basename(normalized);
+        const extension = path.extname(normalized);
+        const basename = path.basename(normalized, extension);
+        // Props canónicas del VO.
+        const props = {
+            kind: "file",
+            absolutePath: normalized,
+            directory,
+            filename,
+            extension,
+            basename,
+        };
+        // Crear VO: aquí el dominio puede validar invariantes adicionales si lo deseas.
+        return new value_objects_1.FilePath(props);
+    }
+}
+exports.SystemFilePathAdapter = SystemFilePathAdapter;

package/dist/infrastructure/errors/file-operation.error.d.ts

@@ -0,0 +1,28 @@
+import { FileOperation, FileOperationErrorOptions, FsErrorScope } from "./types";
+/**
+ * Error especializado para fallos de operaciones de filesystem.
+ *
+ * Encapsula errores de I/O (read, write, delete, mkdir, move) agregando
+ * contexto técnico relevante:
+ *   - operation: operación de filesystem que falló.
+ *   - filePath: ruta afectada (si aplica).
+ *   - cause: error original que provocó el fallo.
+ *   - scope: origen del error (por ejemplo, "fs-plugin").
+ *
+ * Su propósito es:
+ *   - Normalizar errores de filesystem dentro del plugin FS.
+ *   - Evitar el uso de Error genérico sin contexto.
+ *   - Facilitar logging, debugging y traducción a errores de capas superiores.
+ *
+ * No representa errores de dominio ni de configuración; solo fallos de I/O.
+ */
+export declare class FileOperationError extends Error {
+    readonly name = "FileOperationError";
+    readonly scope?: FsErrorScope;
+    readonly operation: FileOperation;
+    readonly filePath?: string;
+    readonly cause?: unknown;
+    constructor(opts: FileOperationErrorOptions);
+    static create(operation: FileOperation, filePath?: string, cause?: unknown): FileOperationError;
+    static fs(operation: FileOperation, filePath?: string, cause?: unknown): FileOperationError;
+}

package/dist/infrastructure/errors/file-operation.error.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileOperationError = void 0;
+/**
+ * Error especializado para fallos de operaciones de filesystem.
+ *
+ * Encapsula errores de I/O (read, write, delete, mkdir, move) agregando
+ * contexto técnico relevante:
+ *   - operation: operación de filesystem que falló.
+ *   - filePath: ruta afectada (si aplica).
+ *   - cause: error original que provocó el fallo.
+ *   - scope: origen del error (por ejemplo, "fs-plugin").
+ *
+ * Su propósito es:
+ *   - Normalizar errores de filesystem dentro del plugin FS.
+ *   - Evitar el uso de Error genérico sin contexto.
+ *   - Facilitar logging, debugging y traducción a errores de capas superiores.
+ *
+ * No representa errores de dominio ni de configuración; solo fallos de I/O.
+ */
+class FileOperationError extends Error {
+    constructor(opts) {
+        const message = opts.message ??
+            buildDefaultMessage({
+                operation: opts.operation,
+                filePath: opts.filePath,
+            });
+        super(message);
+        this.name = "FileOperationError";
+        this.scope = opts.scope;
+        this.operation = opts.operation;
+        this.filePath = opts.filePath;
+        this.cause = opts.cause;
+    }
+    // ---------------------------------------------------------------------------
+    // Factories: I/O
+    // ---------------------------------------------------------------------------
+    static create(operation, filePath, cause) {
+        return new FileOperationError({ operation, filePath, cause });
+    }
+    static fs(operation, filePath, cause) {
+        return new FileOperationError({
+            scope: "fs-plugin",
+            operation,
+            filePath,
+            cause,
+        });
+    }
+}
+exports.FileOperationError = FileOperationError;
+function buildDefaultMessage(opts) {
+    // I/O normal
+    return `Failed to ${opts.operation} file: ${opts.filePath ?? "(unknown)"}`;
+}

package/dist/infrastructure/errors/index.d.ts

@@ -0,0 +1 @@
+export * from "./file-operation.error";

package/dist/{shared → infrastructure}/errors/index.js

@@ -15,5 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./file-operation.error"), exports);
-__exportStar(require("./fs-plugin.error"), exports);
-__exportStar(require("./rotation.error"), exports);

package/dist/infrastructure/errors/types/file-operation-error-options.type.d.ts

@@ -0,0 +1,8 @@
+import { FileOperation, FsErrorScope } from ".";
+export type FileOperationErrorOptions = {
+    scope?: FsErrorScope;
+    operation: FileOperation;
+    filePath?: string;
+    cause?: unknown;
+    message?: string;
+};

package/dist/infrastructure/errors/types/file-operation-error-options.type.js

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

package/dist/infrastructure/errors/types/file-operation.type.d.ts

@@ -0,0 +1 @@
+export type FileOperation = "read" | "write" | "delete" | "mkdir" | "move";

package/dist/infrastructure/errors/types/file-operation.type.js

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

package/dist/infrastructure/errors/types/fs-error-scope.type.d.ts

@@ -0,0 +1 @@
+export type FsErrorScope = "fs-plugin";

package/dist/infrastructure/errors/types/fs-error-scope.type.js

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

package/dist/infrastructure/errors/types/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./file-operation.type";
+export * from "./fs-error-scope.type";
+export * from "./file-operation-error-options.type";

package/dist/infrastructure/errors/types/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./file-operation.type"), exports);
+__exportStar(require("./fs-error-scope.type"), exports);
+__exportStar(require("./file-operation-error-options.type"), exports);

package/dist/infrastructure/filesystem/index.d.ts

@@ -1,4 +1 @@
-export * from "./polices";
 export * from "./types";
-export * from "./value-objects";
-export * from "./ports";

package/dist/infrastructure/filesystem/index.js

@@ -14,7 +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("./polices"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./value-objects"), exports);
-__exportStar(require("./ports"), exports);

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

@@ -1,5 +1,5 @@
-import { IFileRotationConfig, IFsSerializer } from "..";
 import { FilePath } from "../../../domain/value-objects";
+import { IFileSystemRotationConfig } from ".";
 /**
  * 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
@@ -22,11 +22,7 @@ export interface IFilesystemDatasourceOptions {
     /**
      * Conecta con la política de rotación: "none" | "day" | "size", tamaño máximo, número de archivos, etc
      */
-    rotation?: IFileRotationConfig;
-    /**
-     * Estrategia para serializar el log a string / buffer antes de escribir: JSON, texto plano, custom, etc
-     */
-    serializer?: IFsSerializer;
+    rotation?: IFileSystemRotationConfig;
     /**
      * Hook que se dispara cuando se rota un archivo de log. Útil para:
      * - Notificar a otro sistema.

package/dist/infrastructure/filesystem/types/filesystem-rotation.type.d.ts

@@ -1,18 +1,11 @@
-/**
- * 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";
+import { FsRotationBy } from "../../../domain/types";
 /**
  * Representa la configuración que el sistema de log debe seguir para decidir cuándo rotar archivos.
  * by: Estrategia principal de rotación: "none", "day", "size".
  * maxSizeMB: Tamaño máximo del archivo antes de rotar (solo aplica si by === "size").
  * maxFiles: Cuántos archivos rotados se mantienen. Ejemplo: si maxFiles = 5, se mantienen:
  */
-export interface IFileRotationConfig {
+export interface IFileSystemRotationConfig {
     by: FsRotationBy;
     maxSizeMB?: number;
     maxFiles?: number;

package/dist/infrastructure/filesystem/types/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./filesystem-datasource-options.type";
 export * from "./filesystem-rotation.type";
-export * from "./filesystem-serializer.type";

package/dist/infrastructure/filesystem/types/index.js

@@ -16,4 +16,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./filesystem-datasource-options.type"), exports);
 __exportStar(require("./filesystem-rotation.type"), exports);
-__exportStar(require("./filesystem-serializer.type"), exports);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jmlq/logger-plugin-fs",
   "description": "Filesystem plugin for JMLQ Logger implementing Clean Architecture principles.",
-  "version": "0.1.0-alpha.8",
+  "version": "0.1.0-alpha.9",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
@@ -14,12 +14,10 @@
     "example:help": "tsx examples/index.example.ts help",
     "example:all": "tsx examples/index.example.ts",
     "example:value-objects": "tsx examples/index.example.ts value-objects",
-    "example:infrastructure-policies": "tsx examples/index.example.ts infrastructure-policies",
     "example:infrastructure-adapters": "tsx examples/index.example.ts infrastructure-adapters",
     "example:application-use-cases": "tsx examples/index.example.ts application-use-cases",
     "example:application-services": "tsx examples/index.example.ts application-services",
-    "example:application-factories": "tsx examples/index.example.ts application-factories",
-    "example:filesize": "tsx examples/filesize.example.ts"
+    "example:application-factories": "tsx examples/index.example.ts application-factories"
   },
   "keywords": [
     "logger",
@@ -47,6 +45,6 @@
     "install.md"
   ],
   "dependencies": {
-    "@jmlq/logger": ">=0.1.0-alpha.12"
+    "@jmlq/logger": "^0.1.0-alpha.18"
   }
 }

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

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

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

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

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

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

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

@@ -1,11 +0,0 @@
-import { ILogProps, ILogDatasource } from "@jmlq/logger";
-import { IPersistLogUseCase } from "../use-cases";
-import { IStreamWriterPort } from "../../domain/ports";
-export declare class FsDatasourceService implements ILogDatasource {
-    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

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FsDatasourceService = void 0;
-class FsDatasourceService {
-    constructor(persistLogUseCase, streamWriterPort) {
-        this.persistLogUseCase = persistLogUseCase;
-        this.streamWriterPort = streamWriterPort;
-    }
-    async save(log) {
-        await this.persistLogUseCase.execute({ log });
-    }
-    async flush() {
-        await this.streamWriterPort.flush();
-    }
-    async dispose() {
-        await this.streamWriterPort.close();
-    }
-}
-exports.FsDatasourceService = FsDatasourceService;

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

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

package/dist/domain/ports/file-path-adapter.port.d.ts

@@ -1,33 +0,0 @@
-import { FilePath } from "../value-objects";
-export interface IFilePathAdapterPort {
-    /**
-     * Crea un FilePath a partir de una ruta cruda (relativa o absoluta).
-     * La implementación se encarga de normalizar y resolver a absoluta.
-     */
-    fromRaw(inputPath: string): FilePath;
-    /**
-     * Crea un FilePath a partir de (directorio, basename, extensión).
-     */
-    fromBasename(directory: string, basename: string, extension: string): FilePath;
-    /**
-     * Devuelve un nuevo FilePath con la misma ruta pero otra extensión.
-     */
-    withExtension(filePath: FilePath, newExtension: string): FilePath;
-    /**
-     * Devuelve un nuevo FilePath con el mismo directorio y extensión,
-     * pero con otro basename.
-     */
-    withBasename(filePath: FilePath, newBasename: string): FilePath;
-    /**
-     * Une segmentos a la ruta actual.
-     */
-    join(filePath: FilePath, ...segments: string[]): FilePath;
-    /**
-     * Resuelve segmentos relativos respecto al FilePath actual.
-     */
-    resolve(filePath: FilePath, ...segments: string[]): FilePath;
-    /**
-     * Obtiene la ruta relativa desde basePath hacia el FilePath.
-     */
-    relativeTo(basePath: string, filePath: FilePath): string;
-}

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

@@ -1,42 +0,0 @@
-import { FilePath } from "../value-objects";
-/**
- * Es una abstracción de un writer basado en stream, típicamente usado para escribir logs de forma eficiente sin reabrir archivos por cada línea.
- * Es un Outbound Port del dominio hacia una implementación de infraestructura
- */
-export interface IStreamWriterPort {
-    /**
-     * Escritura directa de datos al stream
-     * @param data Datos a escribir
-     * @return Retorna true si la escritura fue exitosa, false si el buffer está lleno y se debe esperar a que se vacíe antes de escribir más
-     */
-    write(data: string): Promise<boolean>;
-    /**
-     * Abre un stream para un archivo específico.
-     * @param filePath Ruta del archivo a abrir para escritura como FilePath
-     */
-    open(filePath: FilePath): Promise<void>;
-    /**
-     * Cierra el stream sin finalizar el archivo, dejando posibilidad de reabrirlo o rotarlo
-     * @return Promise que se resuelve cuando el stream ha sido cerrado
-     */
-    close(): Promise<void>;
-    /**
-     * Buffer pendiente (si la implementación usa buffering).
-     * Asegura que todos los datos en el buffer hayan sido escritos al archivo
-     */
-    flush(): Promise<void>;
-    /**
-     * Permite saber si el stream está listo para aceptar escritura
-     * @return true si el stream está abierto y listo, false si está cerrado o no disponible
-     */
-    isOpen(): boolean;
-    /**
-     * Permite al dominio saber qué archivo está actualmente siendo usado para escribir
-     * @return FilePath del archivo actualmente abierto, o null si no hay ninguno abierto
-     */
-    getCurrentPath(): FilePath | null;
-    /**
-     * Finaliza el stream
-     */
-    end(): Promise<void>;
-}

package/dist/infrastructure/adapters/fs-provider.adapter.d.ts

@@ -1,17 +0,0 @@
-import { IFsProviderPort } from "../../domain/ports";
-export declare class FsProviderAdapter implements IFsProviderPort {
-    exists(path: string): Promise<boolean>;
-    mkdir(path: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    readFile(path: string): Promise<Buffer>;
-    writeFile(path: string, data: string | Buffer): Promise<void>;
-    appendFile(path: string, data: string | Buffer): Promise<void>;
-    stat(path: string): Promise<{
-        size: number;
-        mtime: Date;
-    }>;
-    readdir(path: string): Promise<string[]>;
-    unlink(path: string): Promise<void>;
-    rename(oldPath: string, newPath: string): Promise<void>;
-}

package/dist/infrastructure/adapters/fs-writer.adapter.d.ts

@@ -1,13 +0,0 @@
-import { IStreamWriterPort } from "../../domain/ports";
-import { FilePath } from "../../domain/value-objects";
-export declare class FsWriterAdapter implements IStreamWriterPort {
-    private stream;
-    private currentPath;
-    write(data: string): Promise<boolean>;
-    open(path: FilePath): Promise<void>;
-    close(): Promise<void>;
-    end(): Promise<void>;
-    flush(): Promise<void>;
-    isOpen(): boolean;
-    getCurrentPath(): FilePath | null;
-}

package/dist/infrastructure/adapters/fs-writer.adapter.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FsWriterAdapter = void 0;
-const fs_1 = require("fs");
-const errors_1 = require("../../shared/errors");
-class FsWriterAdapter {
-    constructor() {
-        this.stream = null;
-        this.currentPath = null;
-    }
-    async write(data) {
-        if (!this.stream) {
-            throw new errors_1.FsPluginError("Stream not opened");
-        }
-        return new Promise((resolve, reject) => {
-            const success = this.stream.write(data);
-            if (!success) {
-                this.stream.once("drain", () => resolve(true));
-                this.stream.once("error", reject);
-            }
-            else {
-                resolve(true);
-            }
-        });
-    }
-    async open(path) {
-        if (this.stream) {
-            await this.close();
-        }
-        const pathString = path.absolutePath;
-        this.stream = (0, fs_1.createWriteStream)(pathString, { flags: "a" });
-        this.currentPath = path;
-        return new Promise((resolve, reject) => {
-            this.stream.once("open", () => resolve());
-            this.stream.once("error", reject);
-        });
-    }
-    async close() {
-        if (!this.stream)
-            return;
-        return new Promise((resolve) => {
-            this.stream.end(() => {
-                this.stream = null;
-                this.currentPath = null;
-                resolve();
-            });
-        });
-    }
-    async end() {
-        return this.close();
-    }
-    async flush() {
-        if (!this.stream)
-            return;
-        return new Promise((resolve) => {
-            if (this.stream.writableNeedDrain) {
-                this.stream.once("drain", () => resolve());
-            }
-            else {
-                resolve();
-            }
-        });
-    }
-    isOpen() {
-        return this.stream !== null;
-    }
-    getCurrentPath() {
-        return this.currentPath;
-    }
-}
-exports.FsWriterAdapter = FsWriterAdapter;

package/dist/infrastructure/adapters/node-clock.adapter.d.ts

@@ -1,4 +0,0 @@
-import { IClockPort } from "../../domain/ports";
-export declare class NodeClockAdapter implements IClockPort {
-    now(): Date;
-}

package/dist/infrastructure/adapters/node-clock.adapter.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NodeClockAdapter = void 0;
-class NodeClockAdapter {
-    now() {
-        return new Date();
-    }
-}
-exports.NodeClockAdapter = NodeClockAdapter;