@jmlq/logger-plugin-fs 0.1.0-alpha.3 → 0.1.0-alpha.4

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

@@ -0,0 +1,74 @@
+"use strict";
+// Orquesta: (1) rotar si hace falta, (2) escribir línea, (3) hooks de rotación/errores.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PersistLogUseCase = void 0;
+class PersistLogUseCase {
+    constructor(rotateUC, // caso de uso de rotación
+    appendUC, // caso de uso de escritura
+    rotator, // puerto para actualizar activePath
+    openWriter, // factory: abre stream
+    onRotate, onError) {
+        this.rotateUC = rotateUC;
+        this.appendUC = appendUC;
+        this.rotator = rotator;
+        this.openWriter = openWriter;
+        this.onRotate = onRotate;
+        this.onError = onError;
+        this.writer = null; // writer activo
+        this.path = null; // path activo
+    }
+    // Inicializa el writer si no existe (idempotente)
+    ensureWriter(currentPath) {
+        if (!this.writer) {
+            this.writer = this.openWriter(currentPath);
+            this.path = currentPath;
+        }
+    }
+    // Cierra writer activo de forma segura
+    async disposeWriter() {
+        if (!this.writer)
+            return;
+        await new Promise((resolve) => this.writer.end(resolve));
+        this.writer = null;
+    }
+    // Persistir un log con rotación condicional
+    async execute(input) {
+        try {
+            // 1) Asegurar writer inicial para el path actual del rotator
+            const currentPath = this.rotator.getActiveFilePath();
+            this.ensureWriter(currentPath);
+            // 2) Consultar si debemos rotar → abrir nuevo writer si hace falta
+            const nextPath = await this.rotateUC.execute();
+            if (nextPath) {
+                const old = this.path;
+                await this.disposeWriter();
+                this.rotator.setActivePath(nextPath);
+                this.writer = this.openWriter(nextPath);
+                this.path = nextPath;
+                // Notificar rotación (no bloqueante)
+                Promise.resolve(this.onRotate?.(old, nextPath)).catch((e) => this.onError?.(e));
+            }
+            // 3) Escribir línea manejando backpressure
+            await this.appendUC.execute(input, this.writer);
+        }
+        catch (err) {
+            // Notificar error sin tumbar el proceso (política del plugin)
+            await Promise.resolve(this.onError?.(err));
+            // Si quieres propagar al core, descomenta:
+            // throw err;
+        }
+    }
+    // Esperar drenaje del buffer
+    async flush() {
+        if (!this.writer)
+            return;
+        if (this.writer.writableNeedDrain) {
+            await new Promise((resolve) => this.writer.once("drain", resolve));
+        }
+    }
+    // Cerrar el writer activo
+    async dispose() {
+        await this.disposeWriter();
+    }
+}
+exports.PersistLogUseCase = PersistLogUseCase;

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

@@ -0,0 +1,10 @@
+import { IClock, IFileRotatorPort } from "../../domain/contracts";
+import { RotationPolicy } from "../../domain/value-objects";
+export declare class RotateIfNeededUseCase {
+    private readonly policy;
+    private readonly rotator;
+    private readonly clock;
+    private readonly maxSizeBytes?;
+    constructor(policy: RotationPolicy, rotator: IFileRotatorPort, clock: IClock, maxSizeBytes?: number | undefined);
+    execute(): Promise<string | null>;
+}

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

@@ -0,0 +1,39 @@
+"use strict";
+// Caso de uso: evaluar si corresponde rotar el archivo y, si corresponde, devolver el nuevo path.
+// NO toca node:fs directamente; delega a servicios de infraestructura (rotator).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotateIfNeededUseCase = void 0;
+class RotateIfNeededUseCase {
+    // Dependencias: política (VO), puerto de rotación y reloj.
+    constructor(policy, rotator, clock, maxSizeBytes // cache de bytes (derivado de policy.maxSizeMB)
+    ) {
+        this.policy = policy;
+        this.rotator = rotator;
+        this.clock = clock;
+        this.maxSizeBytes = maxSizeBytes;
+    }
+    // Devuelve null si no se requiere rotar; o el "nextPath" a usar si hay rotación.
+    async execute() {
+        // Selecciona estrategia según la política
+        if (this.policy.by === "none")
+            return null;
+        if (this.policy.by === "day") {
+            // Compara path actual vs path esperado para "hoy"
+            const now = this.clock.now();
+            const expected = this.rotator.expectedPathForToday(now);
+            return expected !== this.rotator.getActiveFilePath() ? expected : null;
+        }
+        if (this.policy.by === "size") {
+            // Si el archivo supera el umbral, pedimos un nuevo path indexado
+            const current = this.rotator.getActiveFilePath();
+            const size = await this.rotator.sizeOf(current);
+            const limit = this.maxSizeBytes ?? this.policy.maxSizeMB * 1024 * 1024;
+            if ((size ?? 0) >= limit) {
+                return await this.rotator.nextIndexedPath();
+            }
+            return null;
+        }
+        return null;
+    }
+}
+exports.RotateIfNeededUseCase = RotateIfNeededUseCase;

package/dist/domain/contracts/clock.contract.d.ts

@@ -0,0 +1,3 @@
+export interface IClock {
+    now(): Date;
+}

package/dist/domain/contracts/clock.contract.js

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

package/dist/domain/contracts/file-rotator.contract.d.ts

@@ -0,0 +1,7 @@
+export interface IFileRotatorPort {
+    getActiveFilePath(): string;
+    expectedPathForToday(now: Date): string;
+    sizeOf(path: string): Promise<number | null>;
+    nextIndexedPath(): Promise<string>;
+    setActivePath(next: string): void;
+}

package/dist/domain/contracts/file-rotator.contract.js

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

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

@@ -0,0 +1,4 @@
+export * from "./clock.contract";
+export * from "./serializer.contract";
+export * from "./file-rotator.contract";
+export * from "./stream-writer.port";

package/dist/domain/contracts/index.js

@@ -0,0 +1,20 @@
+"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("./clock.contract"), exports);
+__exportStar(require("./serializer.contract"), exports);
+__exportStar(require("./file-rotator.contract"), exports);
+__exportStar(require("./stream-writer.port"), exports);

package/dist/domain/contracts/serializer.contract.d.ts

@@ -0,0 +1,3 @@
+export interface IFsSerializer {
+    serialize(entry: unknown): string;
+}

package/dist/domain/contracts/serializer.contract.js

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

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

@@ -0,0 +1,6 @@
+export interface IStreamWriterPort {
+    write(line: string): boolean;
+    once(event: "drain" | "error", cb: (...a: any[]) => void): void;
+    end(cb: () => void): void;
+    readonly writableNeedDrain?: boolean;
+}

package/dist/domain/contracts/stream-writer.port.js

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

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

@@ -0,0 +1 @@
+export * from "./options.type";

package/dist/domain/types/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("./options.type"), exports);

package/dist/domain/types/options.type.d.ts

@@ -0,0 +1,11 @@
+import { IFsSerializer } from "../contracts";
+import { FileNamePattern, RotationPolicy } from "../value-objects";
+export interface FsDatasourceOptions {
+    basePath: string;
+    mkdir?: boolean;
+    pattern?: FileNamePattern;
+    rotation?: RotationPolicy;
+    serializer?: IFsSerializer;
+    onRotate?: (oldPath: string, newPath: string) => void | Promise<void>;
+    onError?: (err: unknown) => void | Promise<void>;
+}

package/dist/domain/types/options.type.js

@@ -0,0 +1,5 @@
+"use strict";
+// Tipo de opciones de alto nivel del plugin, expuesto a la "presentación" (factory).
+// Reúne los contratos/VOs de dominio, pero sin detalles de node:fs.
+// Esto mantiene la API pública limpia y testeable.
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,4 @@
+export declare class FileNamePattern {
+    readonly pattern: string;
+    constructor(pattern: string);
+}

package/dist/domain/value-objects/file-name-pattern.vo.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileNamePattern = void 0;
+// Value Object para el patrón de nombre del archivo.
+// Soporta tokens {yyyy}, {MM}, {dd}; el formateo real ocurre en infraestructura.
+class FileNamePattern {
+    constructor(pattern) {
+        this.pattern = pattern;
+        if (!pattern || typeof pattern !== "string") {
+            throw new Error("[FileNamePattern] pattern inválido");
+        }
+    }
+}
+exports.FileNamePattern = FileNamePattern;

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

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

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

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

package/dist/domain/value-objects/rotation-policy.vo.d.ts

@@ -0,0 +1,7 @@
+export type RotationBy = "none" | "day" | "size";
+export declare class RotationPolicy {
+    readonly by: RotationBy;
+    readonly maxSizeMB?: number | undefined;
+    readonly maxFiles?: number | undefined;
+    constructor(by: RotationBy, maxSizeMB?: number | undefined, maxFiles?: number | undefined);
+}

package/dist/domain/value-objects/rotation-policy.vo.js

@@ -0,0 +1,20 @@
+"use strict";
+// Value Object que expresa la política de rotación del adaptador FS.
+// Esto es propio del dominio del plugin (infra-policy), no del core.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationPolicy = void 0;
+class RotationPolicy {
+    // by: modo de rotación
+    // maxSizeMB: umbral (sólo aplica cuando by === "size")
+    // maxFiles: retención opcional
+    constructor(by, maxSizeMB, maxFiles) {
+        this.by = by;
+        this.maxSizeMB = maxSizeMB;
+        this.maxFiles = maxFiles;
+        // Validación mínima de invariantes del VO
+        if (by === "size" && (!maxSizeMB || maxSizeMB <= 0)) {
+            throw new Error("[RotationPolicy] maxSizeMB > 0 es requerido cuando by = 'size'");
+        }
+    }
+}
+exports.RotationPolicy = RotationPolicy;

package/dist/index.d.ts

@@ -1,13 +1,3 @@
-import { ILogDatasource, ILog } from "@jmlq/logger";
-type FsOpts = {
-    filePath: string;
-};
-export declare class FileSystemDatasource implements ILogDatasource {
-    private readonly opts;
-    private stream;
-    constructor(opts: FsOpts);
-    save(log: ILog): Promise<void>;
-    flush(): Promise<void>;
-    dispose(): Promise<void>;
-}
-export {};
+export { RotationPolicy, type RotationBy } from "./domain/value-objects";
+export { createFsDatasource } from "./presentation/factory";
+export { FileNamePattern } from "./domain/value-objects";

package/dist/index.js

@@ -1,40 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileSystemDatasource = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-class FileSystemDatasource {
-    constructor(opts) {
-        this.opts = opts;
-        // Abre una vez en modo append
-        this.stream = node_fs_1.default.createWriteStream(this.opts.filePath, { flags: "a" });
-    }
-    async save(log) {
-        if (!this.stream)
-            throw new Error("FS stream closed");
-        const line = JSON.stringify(log) + "\n";
-        if (!this.stream.write(line)) {
-            // backpressure: esperar a 'drain'
-            await new Promise((resolve) => this.stream.once("drain", resolve));
-        }
-    }
-    async flush() {
-        if (!this.stream)
-            return;
-        if (!this.stream.writableNeedDrain)
-            return;
-        await new Promise((resolve) => this.stream.once("drain", resolve));
-    }
-    async dispose() {
-        if (!this.stream)
-            return;
-        await new Promise((resolve, reject) => {
-            this.stream.end(() => resolve()); // end -> cierra el fd
-            this.stream.once("error", reject);
-        });
-        this.stream = null;
-    }
-}
-exports.FileSystemDatasource = FileSystemDatasource;
+exports.FileNamePattern = exports.createFsDatasource = exports.RotationPolicy = void 0;
+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, "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; } });

package/dist/infrastructure/datasources/fs.datasource.d.ts

@@ -0,0 +1,17 @@
+import type { ILog, ILogDatasource } from "@jmlq/logger";
+import type { FsDatasourceOptions } from "../../domain/types";
+export declare class FileSystemDatasource implements ILogDatasource {
+    private readonly opts;
+    private stream;
+    private readonly fs;
+    private readonly clock;
+    private readonly rotator;
+    private readonly rotateUC;
+    private readonly appendUC;
+    private readonly policy;
+    private readonly serializer;
+    constructor(opts: FsDatasourceOptions);
+    save(log: ILog): Promise<void>;
+    flush(): Promise<void>;
+    dispose(): Promise<void>;
+}

package/dist/infrastructure/datasources/fs.datasource.js

@@ -0,0 +1,84 @@
+"use strict";
+// Datasource que implementa ILogDatasource del core (@jmlq/logger).
+// Orquesta los casos de uso: rotar si hace falta y luego append.
+// Aquí sí interactuamos con node:fs (a través del provider), streams y hooks.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileSystemDatasource = void 0;
+const fs_1 = require("../fs");
+const use_cases_1 = require("../../application/use-cases");
+const value_objects_1 = require("../../domain/value-objects");
+class FileSystemDatasource {
+    constructor(opts) {
+        this.opts = opts;
+        this.stream = null; // Stream activo de escritura
+        this.clock = new fs_1.NodeClock(); // Reloj real (inyectable si se necesita)
+        // 1) Defaults seguros
+        this.fs = (0, fs_1.createFsProvider)();
+        this.policy = opts.rotation ?? new value_objects_1.RotationPolicy("day");
+        const pattern = opts.pattern ?? new value_objects_1.FileNamePattern("app-{yyyy}{MM}{dd}.log");
+        // Si el usuario no pasa serializer, usamos JSON.stringify como línea
+        this.serializer = opts.serializer ?? {
+            serialize: (x) => JSON.stringify(x),
+        };
+        // 2) Inicializar rotator (asegura carpeta si opts.mkdir === true)
+        this.rotator = new fs_1.FileRotator(this.fs, opts.basePath, this.clock, pattern, 
+        // Para "size" podemos desear un nombre base fijo; si no, que use el daily pattern.
+        /* defaultSeedName */ undefined, 
+        /* ensureDir */ !!opts.mkdir);
+        // 3) Preparar casos de uso (rotación + append)
+        this.rotateUC = new use_cases_1.RotateIfNeededUseCase(this.policy, this.rotator, this.clock);
+        this.appendUC = new use_cases_1.AppendLogUseCase(this.serializer);
+        // 4) Abrir el stream inicial en modo append
+        const initialPath = this.rotator.getActiveFilePath(); // path según patrón/fecha
+        this.stream = this.fs.createWriteStream(initialPath, { flags: "a" });
+    }
+    // Persiste un log. Orquesta:
+    //   - Verificar si se requiere rotación (RotateIfNeededUseCase).
+    //   - Si hay rotación: cierra stream actual, abre uno nuevo y dispara hook.
+    //   - Escribir línea con backpressure (AppendLogUseCase).
+    async save(log) {
+        if (!this.stream)
+            throw new Error("[FileSystemDatasource] stream no inicializado");
+        try {
+            // 1) Rotación condicional
+            const nextPath = await this.rotateUC.execute();
+            if (nextPath) {
+                // Cerrar el stream actual de forma segura
+                await this.dispose();
+                // Actualizar activePath y abrir nuevo stream en append
+                this.rotator.setActivePath(nextPath);
+                this.stream = this.fs.createWriteStream(nextPath, { flags: "a" });
+                // Hook onRotate (no bloqueante)
+                Promise.resolve(this.opts.onRotate?.(/* old */ "", /* new */ nextPath)).catch((e) => this.opts.onError?.(e));
+            }
+            // 2) Append seguro con manejo de backpressure
+            await this.appendUC.execute({ log }, this.stream);
+        }
+        catch (err) {
+            // Notificar error (si hay handler) sin tumbar el proceso
+            await Promise.resolve(this.opts.onError?.(err));
+            // Re-lanzar si prefieres que el core lo capture:
+            // throw err;
+        }
+    }
+    // Espera a que el stream actual drene, si es necesario (útil antes de apagar).
+    async flush() {
+        if (!this.stream)
+            return;
+        const needDrain = this.stream.writableNeedDrain;
+        if (!needDrain)
+            return;
+        await new Promise((resolve) => this.stream.once("drain", resolve));
+    }
+    // Cierra el stream activo. Se usa al rotar y en shutdown.
+    async dispose() {
+        if (!this.stream)
+            return;
+        await new Promise((resolve, reject) => {
+            this.stream.end(() => resolve()); // end() drena y cierra el descriptor
+            this.stream.once("error", reject); // Por si ocurre un error al cerrar
+        });
+        this.stream = null;
+    }
+}
+exports.FileSystemDatasource = FileSystemDatasource;

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

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

package/dist/infrastructure/datasources/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("./fs.datasource"), exports);

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

@@ -0,0 +1,22 @@
+import type { IFsProvider } from ".";
+import type { IClock, IFileRotatorPort } from "../../domain/contracts";
+import { FileNamePattern } from "../../domain/value-objects";
+export declare class FileRotatorAdapter implements IFileRotatorPort {
+    private readonly fs;
+    private readonly basePath;
+    private readonly clock;
+    private readonly pattern;
+    private readonly seedName?;
+    private activePath;
+    constructor(fs: IFsProvider, // Acceso a fs
+    basePath: string, // Carpeta base de logs
+    clock: IClock, // Reloj (testable)
+    pattern: FileNamePattern, // Patrón de nombre
+    ensureDir: boolean, // Crear carpeta si no existe
+    seedName?: string | undefined);
+    getActiveFilePath(): string;
+    setActivePath(next: string): void;
+    expectedPathForToday(now: Date): string;
+    sizeOf(path: string): Promise<number | null>;
+    nextIndexedPath(): Promise<string>;
+}

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRotatorAdapter = void 0;
+const _1 = require(".");
+class FileRotatorAdapter {
+    constructor(fs, // Acceso a fs
+    basePath, // Carpeta base de logs
+    clock, // Reloj (testable)
+    pattern, // Patrón de nombre
+    ensureDir, // Crear carpeta si no existe
+    seedName // Nombre semilla para modo "size" (opcional)
+    ) {
+        this.fs = fs;
+        this.basePath = basePath;
+        this.clock = clock;
+        this.pattern = pattern;
+        this.seedName = seedName;
+        if (ensureDir)
+            this.fs.mkdirSync(this.basePath, { recursive: true });
+        // Arrancamos con el path esperado para "hoy"
+        this.activePath = this.expectedPathForToday(this.clock.now());
+    }
+    getActiveFilePath() {
+        return this.activePath;
+    }
+    setActivePath(next) {
+        this.activePath = next;
+    }
+    expectedPathForToday(now) {
+        const fname = (0, _1.formatPattern)(this.pattern.pattern, now);
+        return (0, _1.joinBase)(this.basePath, fname);
+    }
+    async sizeOf(path) {
+        const stat = await this.fs.statSafe(path);
+        return stat ? stat.size : null;
+    }
+    async nextIndexedPath() {
+        // Si hay seedName (ej. "app.log") úsalo; si no, usa pattern de hoy
+        const seed = this.seedName ?? (0, _1.formatPattern)(this.pattern.pattern, this.clock.now());
+        const { base, ext } = (0, _1.splitBaseExt)(seed);
+        let i = 1;
+        while (true) {
+            const candidate = (0, _1.joinBase)(this.basePath, `${base}.${i}${ext}`);
+            const exists = await this.fs.exists(candidate);
+            if (!exists)
+                return candidate;
+            i++;
+        }
+    }
+}
+exports.FileRotatorAdapter = FileRotatorAdapter;

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

@@ -0,0 +1,15 @@
+import * as fs from "fs";
+type CreateWriteStreamOpts = Parameters<typeof fs.createWriteStream>[1];
+type WriteStreamType = ReturnType<typeof fs.createWriteStream>;
+export interface IFsProvider {
+    createWriteStream(path: string, opts: CreateWriteStreamOpts): WriteStreamType;
+    mkdirSync(path: string, opts?: fs.MakeDirectoryOptions & {
+        recursive?: boolean;
+    }): void;
+    exists(path: string): Promise<boolean>;
+    statSafe(path: string): Promise<{
+        size: number;
+    } | null>;
+}
+export declare function createFsProvider(): IFsProvider;
+export {};

package/dist/infrastructure/fs/fs-provider.js

@@ -0,0 +1,55 @@
+"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.createFsProvider = createFsProvider;
+// Provider de fs compatible (tipos derivados para evitar errores por versión).
+const fs = __importStar(require("fs"));
+const fsp = __importStar(require("fs/promises"));
+function createFsProvider() {
+    return {
+        createWriteStream: (p, opts) => fs.createWriteStream(p, opts),
+        mkdirSync: (p, opts) => fs.mkdirSync(p, { recursive: true, ...(opts ?? {}) }),
+        exists: async (p) => await new Promise((r) => fs.access(p, (e) => r(!e))),
+        statSafe: async (p) => {
+            try {
+                const s = await fsp.stat(p);
+                return { size: s.size };
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}