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

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

@@ -0,0 +1,19 @@
+import { IClockPort, IStreamWriterPort } from "../../domain/ports";
+import { ISaveLogDto } from "../dto";
+import { IAppendLogUseCase, IEnsureDirectoryUseCase, IRotateIfNeededUseCase } from ".";
+import { IFileRotatorPort, RotationPolicy } from "../../infrastructure/filesystem";
+export interface IPersistLogUseCase {
+    execute(dto: ISaveLogDto): Promise<void>;
+}
+export declare class PersistLogUseCase implements IPersistLogUseCase {
+    private readonly clockPort;
+    private readonly fileRotatorPort;
+    private readonly streamWriterPort;
+    private readonly rotationPolicy;
+    private readonly rotateIfNeededUseCase;
+    private readonly appendLogUseCase;
+    private readonly ensureDirectoryUseCase;
+    private readonly onError?;
+    constructor(clockPort: IClockPort, fileRotatorPort: IFileRotatorPort, streamWriterPort: IStreamWriterPort, rotationPolicy: RotationPolicy, rotateIfNeededUseCase: IRotateIfNeededUseCase, appendLogUseCase: IAppendLogUseCase, ensureDirectoryUseCase: IEnsureDirectoryUseCase, onError?: ((error: Error) => void | Promise<void>) | undefined);
+    execute(dto: ISaveLogDto): Promise<void>;
+}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistLogUseCase = void 0;
+class PersistLogUseCase {
+    constructor(clockPort, fileRotatorPort, streamWriterPort, rotationPolicy, rotateIfNeededUseCase, appendLogUseCase, ensureDirectoryUseCase, onError) {
+        this.clockPort = clockPort;
+        this.fileRotatorPort = fileRotatorPort;
+        this.streamWriterPort = streamWriterPort;
+        this.rotationPolicy = rotationPolicy;
+        this.rotateIfNeededUseCase = rotateIfNeededUseCase;
+        this.appendLogUseCase = appendLogUseCase;
+        this.ensureDirectoryUseCase = ensureDirectoryUseCase;
+        this.onError = onError;
+    }
+    async execute(dto) {
+        try {
+            // Asegurar que el directorio existe
+            await this.ensureDirectoryUseCase.execute();
+            const currentDate = this.clockPort.now();
+            // Verificar si necesitamos rotar
+            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() ||
+                !currentPath ||
+                !currentPath.equals(expectedPath)) {
+                if (this.streamWriterPort.isOpen()) {
+                    await this.streamWriterPort.close();
+                }
+                await this.streamWriterPort.open(expectedPath);
+            }
+            // Escribir el log
+            await this.appendLogUseCase.execute(dto);
+        }
+        catch (error) {
+            if (this.onError) {
+                await this.onError(error);
+            }
+            throw error;
+        }
+    }
+}
+exports.PersistLogUseCase = PersistLogUseCase;

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

@@ -0,0 +1,17 @@
+import { IFileRotatorPort, RotationPolicy } from "../../infrastructure/filesystem";
+import { IStreamWriterPort } from "../../domain/ports";
+import { FilePath } from "../../domain/value-objects";
+export interface IRotateIfNeededDto {
+    currentDate: Date;
+    rotationPolicy: RotationPolicy;
+}
+export interface IRotateIfNeededUseCase {
+    execute(dto: IRotateIfNeededDto): Promise<FilePath | null>;
+}
+export declare class RotateIfNeededUseCase implements IRotateIfNeededUseCase {
+    private readonly fileRotatorPort;
+    private readonly streamWriterPort;
+    private readonly onRotate?;
+    constructor(fileRotatorPort: IFileRotatorPort, streamWriterPort: IStreamWriterPort, onRotate?: ((oldPath: FilePath, newPath: FilePath) => void | Promise<void>) | undefined);
+    execute(dto: IRotateIfNeededDto): Promise<FilePath | null>;
+}

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotateIfNeededUseCase = void 0;
+class RotateIfNeededUseCase {
+    constructor(fileRotatorPort, streamWriterPort, onRotate) {
+        this.fileRotatorPort = fileRotatorPort;
+        this.streamWriterPort = streamWriterPort;
+        this.onRotate = onRotate;
+    }
+    async execute(dto) {
+        const { currentDate, rotationPolicy } = dto;
+        const shouldRotate = await this.fileRotatorPort.shouldRotate(rotationPolicy, currentDate);
+        if (!shouldRotate) {
+            return null;
+        }
+        const oldPath = this.fileRotatorPort.getCurrentPath();
+        const newPath = this.fileRotatorPort.getExpectedPathForDate(currentDate);
+        if (oldPath && !oldPath.equals(newPath)) {
+            await this.streamWriterPort.close();
+            await this.streamWriterPort.open(newPath);
+            if (this.onRotate) {
+                await this.onRotate(oldPath, newPath);
+            }
+        }
+        return newPath;
+    }
+}
+exports.RotateIfNeededUseCase = RotateIfNeededUseCase;

package/dist/domain/ports/clock.port.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Representa una abstracción del reloj del sistema dentro de la capa domain.
+ * 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 {
+    now(): Date;
+}

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

@@ -0,0 +1,33 @@
+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/fs-provider.port.d.ts

@@ -0,0 +1,61 @@
+/**
+ * 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 {
+    /**
+     * Permite saber si un archivo o carpeta existe
+     * @param path Ruta del archivo o directorio
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * Permite crear directorios
+     * @param path Ruta del directorio
+     * @param options Opciones de creación. Actualmente solo soporta 'recursive' (Indica si se deben crear directorios padres si no existen)
+     */
+    mkdir(path: string, options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    /**
+     * Se usa para leer registros existentes
+     * @param path Ruta del archivo
+     */
+    readFile(path: string): Promise<Buffer>;
+    /**
+     * Se usa para escribir registros nuevos
+     * @param path Ruta del archivo
+     * @param data Datos a escribir
+     */
+    writeFile(path: string, data: string | Buffer): Promise<void>;
+    /**
+     * Se usa para agregar registros nuevos al final del archivo
+     * @param path Ruta del archivo
+     * @param data Datos a agregar
+     */
+    appendFile(path: string, data: string | Buffer): Promise<void>;
+    /**
+     * Permite obtener metadata del archivo o directorio
+     * - Ver tamaño actual → política de RotationPolicy.
+     * - Ver fecha de modificación → rotación diaria/semanal.
+     * @param path Ruta del archivo o directorio
+     */
+    stat(path: string): Promise<{
+        size: number;
+        mtime: Date;
+    }>;
+    /**
+     * Necesario para rotación por índice y descubrimiento de archivos app.log.1, app.log.2, etc.
+     * @param path Ruta del directorio
+     */
+    readdir(path: string): Promise<string[]>;
+    /**
+     * Eliminar archivos antiguos.
+     * @param path Ruta del archivo
+     */
+    unlink(path: string): Promise<void>;
+    /**
+     * Clave para renombrar archivos cuando rotan.
+     * @param oldPath Ruta actual del archivo o directorio
+     * @param newPath Nueva ruta del archivo o directorio
+     */
+    rename(oldPath: string, newPath: string): Promise<void>;
+}

package/dist/domain/ports/fs-provider.port.js

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

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

@@ -0,0 +1,4 @@
+export * from "./clock.port";
+export * from "./fs-provider.port";
+export * from "./stream-writer.port";
+export * from "./file-path-adapter.port";

package/dist/domain/{contracts → ports}/index.js

@@ -14,7 +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("./clock.contract"), exports);
-__exportStar(require("./serializer.contract"), exports);
-__exportStar(require("./file-rotator.contract"), exports);
+__exportStar(require("./clock.port"), exports);
+__exportStar(require("./fs-provider.port"), exports);
 __exportStar(require("./stream-writer.port"), exports);
+__exportStar(require("./file-path-adapter.port"), exports);

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

@@ -0,0 +1,42 @@
+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/domain/ports/stream-writer.port.js

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

package/dist/domain/value-objects/file-path.vo.d.ts

@@ -0,0 +1,27 @@
+export interface IFilePathProps {
+    absolutePath: string;
+    directory: string;
+    filename: string;
+    extension: string;
+    basename: string;
+}
+/**
+ * Value Object que representa una ruta de archivo ya normalizada.
+ * No depende de Node ni del módulo `path`. Solo encapsula datos inmutables.
+ */
+export declare class FilePath {
+    private readonly _absolutePath;
+    private readonly _directory;
+    private readonly _filename;
+    private readonly _extension;
+    private readonly _basename;
+    constructor(props: IFilePathProps);
+    get value(): string;
+    get absolutePath(): string;
+    get directory(): string;
+    get filename(): string;
+    get extension(): string;
+    get basename(): string;
+    equals(other: FilePath): boolean;
+    toString(): string;
+}

package/dist/domain/value-objects/file-path.vo.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FilePath = void 0;
+/**
+ * Value Object que representa una ruta de archivo ya normalizada.
+ * No depende de Node ni del módulo `path`. Solo encapsula datos inmutables.
+ */
+class FilePath {
+    constructor(props) {
+        const { absolutePath, directory, filename, extension, basename } = props;
+        if (!absolutePath ||
+            typeof absolutePath !== "string" ||
+            !absolutePath.trim()) {
+            throw new Error("FilePath: absolutePath must be a non-empty string");
+        }
+        if (!directory || typeof directory !== "string" || !directory.trim()) {
+            throw new Error("FilePath: directory must be a non-empty string");
+        }
+        if (!filename || typeof filename !== "string" || !filename.trim()) {
+            throw new Error("FilePath: filename must be a non-empty string");
+        }
+        if (typeof extension !== "string") {
+            throw new Error("FilePath: extension must be a string");
+        }
+        if (!basename || typeof basename !== "string" || !basename.trim()) {
+            throw new Error("FilePath: basename must be a non-empty string");
+        }
+        this._absolutePath = absolutePath;
+        this._directory = directory;
+        this._filename = filename;
+        this._extension = extension;
+        this._basename = basename;
+    }
+    get value() {
+        return this._absolutePath;
+    }
+    get absolutePath() {
+        return this._absolutePath;
+    }
+    get directory() {
+        return this._directory;
+    }
+    get filename() {
+        return this._filename;
+    }
+    get extension() {
+        return this._extension;
+    }
+    get basename() {
+        return this._basename;
+    }
+    equals(other) {
+        return this._absolutePath === other._absolutePath;
+    }
+    toString() {
+        return this._absolutePath;
+    }
+}
+exports.FilePath = FilePath;

package/dist/domain/value-objects/file-size.vo.d.ts

@@ -0,0 +1,14 @@
+export declare class FileSize {
+    private readonly _bytes;
+    constructor(bytes: number);
+    get bytes(): number;
+    get kilobytes(): number;
+    get megabytes(): number;
+    get gigabytes(): number;
+    static fromMegabytes(mb: number): FileSize;
+    static fromKilobytes(kb: number): FileSize;
+    isGreaterThan(other: FileSize): boolean;
+    isLessThan(other: FileSize): boolean;
+    equals(other: FileSize): boolean;
+    toString(): string;
+}

package/dist/domain/value-objects/file-size.vo.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSize = void 0;
+class FileSize {
+    constructor(bytes) {
+        if (bytes < 0 || !Number.isInteger(bytes)) {
+            throw new Error("FileSize: bytes must be a non-negative integer");
+        }
+        this._bytes = bytes;
+    }
+    get bytes() {
+        return this._bytes;
+    }
+    get kilobytes() {
+        return this._bytes / 1024;
+    }
+    get megabytes() {
+        return this._bytes / (1024 * 1024);
+    }
+    get gigabytes() {
+        return this._bytes / (1024 * 1024 * 1024);
+    }
+    static fromMegabytes(mb) {
+        if (mb < 0) {
+            throw new Error("FileSize: megabytes must be non-negative");
+        }
+        return new FileSize(Math.floor(mb * 1024 * 1024));
+    }
+    static fromKilobytes(kb) {
+        if (kb < 0) {
+            throw new Error("FileSize: kilobytes must be non-negative");
+        }
+        return new FileSize(Math.floor(kb * 1024));
+    }
+    isGreaterThan(other) {
+        return this._bytes > other._bytes;
+    }
+    isLessThan(other) {
+        return this._bytes < other._bytes;
+    }
+    equals(other) {
+        return this._bytes === other._bytes;
+    }
+    toString() {
+        if (this._bytes >= 1024 * 1024 * 1024) {
+            return `${(this._bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+        }
+        if (this._bytes >= 1024 * 1024) {
+            return `${(this._bytes / (1024 * 1024)).toFixed(2)} MB`;
+        }
+        if (this._bytes >= 1024) {
+            return `${(this._bytes / 1024).toFixed(2)} KB`;
+        }
+        return `${this._bytes} bytes`;
+    }
+}
+exports.FileSize = FileSize;

package/dist/domain/value-objects/index.d.ts

@@ -1,2 +1,2 @@
-export * from "./file-name-pattern.vo";
-export * from "./rotation-policy.vo";
+export * from "./file-path.vo";
+export * from "./file-size.vo";

package/dist/domain/value-objects/index.js

@@ -14,5 +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-name-pattern.vo"), exports);
-__exportStar(require("./rotation-policy.vo"), exports);
+__exportStar(require("./file-path.vo"), exports);
+__exportStar(require("./file-size.vo"), exports);

package/dist/index.d.ts

@@ -1,3 +1,4 @@
-export { RotationPolicy, type RotationBy } from "./domain/value-objects";
-export { createFsDatasource } from "./presentation/factory";
-export { FileNamePattern } from "./domain/value-objects";
+export { FilePath, FileSize } from "./domain/value-objects";
+export { createFsDatasource } from "./application/factory";
+export { FsPluginError, FileOperationError, RotationError, } from "./shared/errors";
+export { IFilesystemDatasourceOptions, FsRotationBy, IFileRotationConfig, IFsSerializer, FileNamePattern, RotationPolicy, } from "./infrastructure/filesystem";

package/dist/index.js

@@ -1,9 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileNamePattern = exports.createFsDatasource = exports.RotationPolicy = void 0;
+exports.RotationPolicy = exports.FileNamePattern = exports.RotationError = exports.FileOperationError = exports.FsPluginError = exports.createFsDatasource = exports.FileSize = exports.FilePath = void 0;
+// Value Objects
 var value_objects_1 = require("./domain/value-objects");
-Object.defineProperty(exports, "RotationPolicy", { enumerable: true, get: function () { return value_objects_1.RotationPolicy; } });
-var factory_1 = require("./presentation/factory");
+Object.defineProperty(exports, "FilePath", { enumerable: true, get: function () { return value_objects_1.FilePath; } });
+Object.defineProperty(exports, "FileSize", { enumerable: true, get: function () { return value_objects_1.FileSize; } });
+// Factory
+var factory_1 = require("./application/factory");
 Object.defineProperty(exports, "createFsDatasource", { enumerable: true, get: function () { return factory_1.createFsDatasource; } });
-var value_objects_2 = require("./domain/value-objects");
-Object.defineProperty(exports, "FileNamePattern", { enumerable: true, get: function () { return value_objects_2.FileNamePattern; } });
+// Errors
+var errors_1 = require("./shared/errors");
+Object.defineProperty(exports, "FsPluginError", { enumerable: true, get: function () { return errors_1.FsPluginError; } });
+Object.defineProperty(exports, "FileOperationError", { enumerable: true, get: function () { return errors_1.FileOperationError; } });
+Object.defineProperty(exports, "RotationError", { enumerable: true, get: function () { return errors_1.RotationError; } });
+var filesystem_1 = require("./infrastructure/filesystem");
+Object.defineProperty(exports, "FileNamePattern", { enumerable: true, get: function () { return filesystem_1.FileNamePattern; } });
+Object.defineProperty(exports, "RotationPolicy", { enumerable: true, get: function () { return filesystem_1.RotationPolicy; } });

package/dist/infrastructure/adapters/file-rotator.adapter.d.ts

@@ -0,0 +1,20 @@
+import { IFsProviderPort, IFilePathAdapterPort } from "../../domain/ports";
+import { FileSize, FilePath } from "../../domain/value-objects";
+import { FileNamePattern, IFileRotatorPort, RotationPolicy } from "../filesystem";
+export declare class FileRotatorAdapter implements IFileRotatorPort {
+    private readonly fsProvider;
+    private readonly filePathAdapter;
+    private readonly fileNamePattern;
+    private readonly basePath;
+    private currentFilePath;
+    constructor(fsProvider: IFsProviderPort, filePathAdapter: IFilePathAdapterPort, fileNamePattern: FileNamePattern, basePath: string);
+    getCurrentPath(): FilePath | null;
+    getExpectedPathForDate(date: Date): FilePath;
+    private buildPathForDate;
+    getFileSize(filePath: FilePath): Promise<FileSize>;
+    getFileSizeBytes(path: string): Promise<number>;
+    getNextRotationIndex(baseFilePath: FilePath): Promise<number>;
+    shouldRotate(policy: RotationPolicy, currentDate: Date): Promise<boolean>;
+    private shouldRotateByDay;
+    private shouldRotateBySize;
+}

package/dist/infrastructure/adapters/file-rotator.adapter.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRotatorAdapter = void 0;
+const value_objects_1 = require("../../domain/value-objects");
+class FileRotatorAdapter {
+    constructor(fsProvider, filePathAdapter, fileNamePattern, basePath) {
+        this.fsProvider = fsProvider;
+        this.filePathAdapter = filePathAdapter;
+        this.fileNamePattern = fileNamePattern;
+        this.basePath = basePath;
+        this.currentFilePath = null;
+    }
+    getCurrentPath() {
+        return this.currentFilePath;
+    }
+    getExpectedPathForDate(date) {
+        const fullFilePath = this.buildPathForDate(date);
+        this.currentFilePath = fullFilePath;
+        return fullFilePath;
+    }
+    buildPathForDate(date) {
+        const pattern = this.fileNamePattern.pattern;
+        const replacements = {
+            "{yyyy}": date.getFullYear().toString(),
+            "{MM}": (date.getMonth() + 1).toString().padStart(2, "0"),
+            "{dd}": date.getDate().toString().padStart(2, "0"),
+            "{HH}": date.getHours().toString().padStart(2, "0"),
+            "{mm}": date.getMinutes().toString().padStart(2, "0"),
+            "{ss}": date.getSeconds().toString().padStart(2, "0"),
+        };
+        let fileName = pattern;
+        for (const [token, value] of Object.entries(replacements)) {
+            fileName = fileName.replace(new RegExp(token.replace(/[{}]/g, "\\$&"), "g"), value);
+        }
+        return this.filePathAdapter.join(this.filePathAdapter.fromRaw(this.basePath), fileName);
+    }
+    async getFileSize(filePath) {
+        try {
+            const stats = await this.fsProvider.stat(filePath.absolutePath);
+            return new value_objects_1.FileSize(stats.size);
+        }
+        catch {
+            return new value_objects_1.FileSize(0);
+        }
+    }
+    // Método de compatibilidad - deprecado, usar getFileSize
+    async getFileSizeBytes(path) {
+        const filePath = this.filePathAdapter.fromRaw(path);
+        const fileSize = await this.getFileSize(filePath);
+        return fileSize.bytes;
+    }
+    async getNextRotationIndex(baseFilePath) {
+        try {
+            const files = await this.fsProvider.readdir(baseFilePath.directory);
+            const pattern = new RegExp(`^${baseFilePath.basename}\\.(\\d+)${baseFilePath.extension.replace(".", "\\.")}$`);
+            let maxIndex = 0;
+            for (const file of files) {
+                const match = file.match(pattern);
+                if (match) {
+                    const index = parseInt(match[1], 10);
+                    if (index > maxIndex) {
+                        maxIndex = index;
+                    }
+                }
+            }
+            return maxIndex + 1;
+        }
+        catch {
+            return 1;
+        }
+    }
+    async shouldRotate(policy, currentDate) {
+        if (policy.by === "none") {
+            return false;
+        }
+        if (policy.by === "day") {
+            return this.shouldRotateByDay(currentDate);
+        }
+        if (policy.by === "size") {
+            return this.shouldRotateBySize(policy);
+        }
+        return false;
+    }
+    shouldRotateByDay(currentDate) {
+        if (!this.currentFilePath) {
+            return true; // No hay archivo actual, necesitamos crear uno
+        }
+        // Ahora solo calculamos, NO mutamos currentFilePath
+        const expectedPath = this.buildPathForDate(currentDate);
+        return !this.currentFilePath.equals(expectedPath);
+    }
+    async shouldRotateBySize(policy) {
+        if (!this.currentFilePath || !policy.maxSize) {
+            return false;
+        }
+        try {
+            const currentFileSize = await this.getFileSize(this.currentFilePath);
+            return policy.shouldRotateBySize(currentFileSize);
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.FileRotatorAdapter = FileRotatorAdapter;

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

@@ -0,0 +1,17 @@
+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>;
+}