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

package/dist/infrastructure/{fs/fs-provider.js → adapters/fs-provider.adapter.js}

@@ -33,23 +33,45 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 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;
-            }
-        },
-    };
+exports.FsProviderAdapter = void 0;
+const fs = __importStar(require("fs/promises"));
+class FsProviderAdapter {
+    async exists(path) {
+        try {
+            await fs.access(path);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async mkdir(path, options) {
+        await fs.mkdir(path, options);
+    }
+    async readFile(path) {
+        return fs.readFile(path);
+    }
+    async writeFile(path, data) {
+        await fs.writeFile(path, data);
+    }
+    async appendFile(path, data) {
+        await fs.appendFile(path, data);
+    }
+    async stat(path) {
+        const stats = await fs.stat(path);
+        return {
+            size: stats.size,
+            mtime: stats.mtime,
+        };
+    }
+    async readdir(path) {
+        return fs.readdir(path);
+    }
+    async unlink(path) {
+        await fs.unlink(path);
+    }
+    async rename(oldPath, newPath) {
+        await fs.rename(oldPath, newPath);
+    }
 }
+exports.FsProviderAdapter = FsProviderAdapter;

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,71 @@
+"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/{fs → adapters}/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./file-rotator.adapter";
+export * from "./fs-provider.adapter";
 export * from "./fs-writer.adapter";
-export * from "./fs-provider";
-export * from "./path-utils";
 export * from "./node-clock.adapter";
+export * from "./node-file-path.adapter";

package/dist/infrastructure/{fs → adapters}/index.js

@@ -15,7 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./file-rotator.adapter"), exports);
+__exportStar(require("./fs-provider.adapter"), exports);
 __exportStar(require("./fs-writer.adapter"), exports);
-__exportStar(require("./fs-provider"), exports);
-__exportStar(require("./path-utils"), exports);
 __exportStar(require("./node-clock.adapter"), exports);
+__exportStar(require("./node-file-path.adapter"), exports);

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

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

package/dist/infrastructure/{fs → adapters}/node-clock.adapter.js

@@ -1,5 +1,4 @@
 "use strict";
-// Reloj real del sistema.
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeClockAdapter = void 0;
 class NodeClockAdapter {

package/dist/infrastructure/adapters/node-file-path.adapter.d.ts

@@ -0,0 +1,16 @@
+import { FilePath } from "../../domain/value-objects/file-path.vo";
+import { IFilePathAdapterPort } from "../../domain/ports/file-path-adapter.port";
+/**
+ * Adapter concreto basado en Node.js (`path`) que construye y transforma FilePath.
+ * Es infraestructura pura que implementa el port de dominio.
+ */
+export declare class NodeFilePathAdapter implements IFilePathAdapterPort {
+    fromRaw(inputPath: string): FilePath;
+    fromBasename(directory: string, basename: string, extension: string): FilePath;
+    withExtension(filePath: FilePath, newExtension: string): FilePath;
+    withBasename(filePath: FilePath, newBasename: string): FilePath;
+    join(filePath: FilePath, ...segments: string[]): FilePath;
+    resolve(filePath: FilePath, ...segments: string[]): FilePath;
+    relativeTo(basePath: string, filePath: FilePath): string;
+    private buildFromAbsolute;
+}

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

@@ -0,0 +1,117 @@
+"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.NodeFilePathAdapter = void 0;
+const path = __importStar(require("path"));
+const file_path_vo_1 = require("../../domain/value-objects/file-path.vo");
+/**
+ * Adapter concreto basado en Node.js (`path`) que construye y transforma FilePath.
+ * Es infraestructura pura que implementa el port de dominio.
+ */
+class NodeFilePathAdapter {
+    fromRaw(inputPath) {
+        if (!inputPath || typeof inputPath !== "string") {
+            throw new Error("NodeFilePathAdapter.fromRaw: inputPath must be a non-empty string");
+        }
+        const trimmed = inputPath.trim();
+        if (!trimmed) {
+            throw new Error("NodeFilePathAdapter.fromRaw: inputPath cannot be empty or whitespace");
+        }
+        const absolutePath = path.resolve(trimmed);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    fromBasename(directory, basename, extension) {
+        if (!directory || !basename) {
+            throw new Error("NodeFilePathAdapter.fromBasename: directory and basename are required");
+        }
+        const ext = extension
+            ? extension.startsWith(".")
+                ? extension
+                : `.${extension}`
+            : "";
+        const fullPath = path.join(directory, basename + ext);
+        const absolutePath = path.resolve(fullPath);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    withExtension(filePath, newExtension) {
+        const ext = newExtension.startsWith(".")
+            ? newExtension
+            : `.${newExtension}`;
+        const filename = filePath.basename + ext;
+        const absolutePath = path.join(filePath.directory, filename);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    withBasename(filePath, newBasename) {
+        if (!newBasename || !newBasename.trim()) {
+            throw new Error("NodeFilePathAdapter.withBasename: newBasename must be a non-empty string");
+        }
+        const filename = newBasename + filePath.extension;
+        const absolutePath = path.join(filePath.directory, filename);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    join(filePath, ...segments) {
+        const absolutePath = path.join(filePath.absolutePath, ...segments);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    resolve(filePath, ...segments) {
+        const absolutePath = path.resolve(filePath.absolutePath, ...segments);
+        return this.buildFromAbsolute(absolutePath);
+    }
+    relativeTo(basePath, filePath) {
+        if (!basePath || !basePath.trim()) {
+            throw new Error("NodeFilePathAdapter.relativeTo: basePath must be a non-empty string");
+        }
+        return path.relative(path.resolve(basePath.trim()), filePath.absolutePath);
+    }
+    // ────────────────────────────────────────────
+    // Helper privado: construye IFilePathProps
+    // ────────────────────────────────────────────
+    buildFromAbsolute(absolutePath) {
+        const normalized = path.resolve(absolutePath);
+        const directory = path.dirname(normalized);
+        const filename = path.basename(normalized);
+        const extension = path.extname(normalized);
+        const basename = path.basename(normalized, extension);
+        const props = {
+            absolutePath: normalized,
+            directory,
+            filename,
+            extension,
+            basename,
+        };
+        return new file_path_vo_1.FilePath(props);
+    }
+}
+exports.NodeFilePathAdapter = NodeFilePathAdapter;

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

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

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

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

@@ -0,0 +1 @@
+export { RotationPolicy } from "./rotation-policy";

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationPolicy = void 0;
+var rotation_policy_1 = require("./rotation-policy");
+Object.defineProperty(exports, "RotationPolicy", { enumerable: true, get: function () { return rotation_policy_1.RotationPolicy; } });

package/dist/infrastructure/filesystem/polices/rotation-policy.d.ts

@@ -0,0 +1,29 @@
+import { FsRotationBy } from "..";
+import { FileSize } from "../../../domain/value-objects/file-size.vo";
+/**
+ * Es un Value Object de dominio que encapsula la política de rotación de logs
+ * by: cómo se rota → "none" | "day" | "size".
+ * maxSizeMB: umbral de tamaño (solo tiene sentido para "size").
+ * maxFiles: cuántos archivos rotados se mantienen (concepto típico en rotation).
+ */
+export declare class RotationPolicy {
+    private readonly _by;
+    private readonly _maxSize?;
+    private readonly _maxFiles?;
+    constructor(by: FsRotationBy, maxSizeMB?: number, maxFiles?: number);
+    get by(): FsRotationBy;
+    get maxSizeMB(): number | undefined;
+    get maxSize(): FileSize | undefined;
+    get maxFiles(): number | undefined;
+    /**
+     * Lógica de negocio mejorada usando FileSize value object
+     * @param currentSize Tamaño actual del archivo como FileSize
+     * @returns true si debe rotar por tamaño
+     */
+    shouldRotateBySize(currentSize: FileSize): boolean;
+    /**
+     * Método de compatibilidad para tamaños en bytes
+     * Usar shouldRotateBySize(FileSize) en su lugar
+     */
+    shouldRotateBySizeBytes(currentSizeBytes: number): boolean;
+}

package/dist/infrastructure/filesystem/polices/rotation-policy.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RotationPolicy = void 0;
+const file_size_vo_1 = require("../../../domain/value-objects/file-size.vo");
+/**
+ * Es un Value Object de dominio que encapsula la política de rotación de logs
+ * by: cómo se rota → "none" | "day" | "size".
+ * maxSizeMB: umbral de tamaño (solo tiene sentido para "size").
+ * maxFiles: cuántos archivos rotados se mantienen (concepto típico en rotation).
+ */
+class RotationPolicy {
+    constructor(by, maxSizeMB, maxFiles) {
+        if (!["none", "day", "size"].includes(by)) {
+            throw new Error("RotationPolicy: invalid rotation strategy");
+        }
+        if (by === "size" && (maxSizeMB == null || maxSizeMB <= 0)) {
+            throw new Error("RotationPolicy: maxSizeMB must be positive for size rotation");
+        }
+        this._by = by;
+        this._maxSize = maxSizeMB ? file_size_vo_1.FileSize.fromMegabytes(maxSizeMB) : undefined;
+        this._maxFiles = maxFiles;
+    }
+    get by() {
+        return this._by;
+    }
+    get maxSizeMB() {
+        return this._maxSize?.megabytes;
+    }
+    get maxSize() {
+        return this._maxSize;
+    }
+    get maxFiles() {
+        return this._maxFiles;
+    }
+    /**
+     * Lógica de negocio mejorada usando FileSize value object
+     * @param currentSize Tamaño actual del archivo como FileSize
+     * @returns true si debe rotar por tamaño
+     */
+    shouldRotateBySize(currentSize) {
+        if (this._by !== "size" || !this._maxSize) {
+            return false;
+        }
+        return (currentSize.isGreaterThan(this._maxSize) ||
+            currentSize.equals(this._maxSize));
+    }
+    /**
+     * Método de compatibilidad para tamaños en bytes
+     * Usar shouldRotateBySize(FileSize) en su lugar
+     */
+    shouldRotateBySizeBytes(currentSizeBytes) {
+        return this.shouldRotateBySize(new file_size_vo_1.FileSize(currentSizeBytes));
+    }
+}
+exports.RotationPolicy = RotationPolicy;

package/dist/infrastructure/filesystem/ports/file-rotator.port.d.ts

@@ -0,0 +1,32 @@
+import { FileSize, FilePath } from "../../../domain/value-objects";
+import { RotationPolicy } from "../polices";
+/**
+ * "Puente" entre dominio y filesystem
+ */
+export interface IFileRotatorPort {
+    /**
+     * Saber qué archivo de log está activo ahora
+     */
+    getCurrentPath(): FilePath | null;
+    /**
+     * Calcular cómo se va a llamar el archivo según una fecha
+     * @param date Fecha para la que se quiere el path
+     */
+    getExpectedPathForDate(date: Date): FilePath;
+    /**
+     * Consultar metadata del archivo usando FileSize value object
+     * @param filePath Ruta del archivo como FilePath
+     */
+    getFileSize(filePath: FilePath): Promise<FileSize>;
+    /**
+     * Saber qué índice usar para el siguiente archivo rotado
+     * @param baseFilePath Ruta base del archivo como FilePath
+     */
+    getNextRotationIndex(baseFilePath: FilePath): Promise<number>;
+    /**
+     * Decidir si corresponde rotar de acuerdo a una RotationPolicy y la fecha actual
+     * @param policy Política de rotación
+     * @param currentDate Fecha actual
+     */
+    shouldRotate(policy: RotationPolicy, currentDate: Date): Promise<boolean>;
+}

package/dist/infrastructure/filesystem/ports/file-rotator.port.js

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

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

@@ -0,0 +1 @@
+export * from "./file-rotator.port";

package/dist/{domain/types → infrastructure/filesystem/ports}/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("./options.type"), exports);
+__exportStar(require("./file-rotator.port"), exports);

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

@@ -0,0 +1,49 @@
+import { IFileRotationConfig, IFsSerializer } from "..";
+import { FilePath } from "../../../domain/value-objects";
+/**
+ * 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
+ */
+export interface IFilesystemDatasourceOptions {
+    /**
+     * Directorio base donde se van a crear/leer los archivos de log.
+     */
+    basePath: string;
+    /**
+     * Indica si se deben crear los directorios padres si no existen
+     * Si es true, la implementación puede crear el basePath (con fs.mkdir({ recursive: true })) si no existe.
+     * Si es false o undefined, o no lo crea o depende de tu implementación.
+     */
+    mkdir?: boolean;
+    /**
+     * Patrón de nombre del archivo de log
+     */
+    fileNamePattern?: string;
+    /**
+     * 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;
+    /**
+     * Hook que se dispara cuando se rota un archivo de log. Útil para:
+     * - Notificar a otro sistema.
+     * - Enviar el archivo rotado a S3.
+     * - Hacer limpieza adicional.
+     * @param oldPath Ruta del archivo de log antes de la rotación
+     * @param newPath Ruta del archivo de log después de la rotación
+     * @returns
+     */
+    onRotate?: (oldPath: FilePath, newPath: FilePath) => void | Promise<void>;
+    /**
+     * Hook centralizado para manejar errores del datasource:
+     * - Loggear en otro canal.
+     * - Enviar métricas / alertas.
+     * - Evitar que el logger “reviente” la app.
+     * @param error Error ocurrido en el datasource
+     * @returns
+     */
+    onError?: (error: Error) => void | Promise<void>;
+}

package/dist/infrastructure/filesystem/types/filesystem-datasource-options.type.js

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

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

@@ -0,0 +1,19 @@
+/**
+ * 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";
+/**
+ * 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 {
+    by: FsRotationBy;
+    maxSizeMB?: number;
+    maxFiles?: number;
+}

package/dist/infrastructure/filesystem/types/filesystem-rotation.type.js

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

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

@@ -0,0 +1,10 @@
+/**
+ * Es una estrategia de serialización usada por el datasource de filesystem para convertir cualquier entrada (entry: unknown) en una cadena (string) antes de escribirla en el archivo.
+ */
+export interface IFsSerializer {
+    /**
+     * Serializa una entrada genérica a string
+     * @param entry Entrada a serializar
+     */
+    serialize(entry: unknown): string;
+}

package/dist/infrastructure/filesystem/types/filesystem-serializer.type.js

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

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

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

package/dist/infrastructure/filesystem/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("./filesystem-datasource-options.type"), exports);
+__exportStar(require("./filesystem-rotation.type"), exports);
+__exportStar(require("./filesystem-serializer.type"), exports);

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

@@ -0,0 +1,22 @@
+/**
+ * representa el patrón de nombrado de archivos de log
+ */
+export declare class FileNamePattern {
+    private readonly _pattern;
+    constructor(pattern: string);
+    /**
+     * Retorna el valor inmutable
+     */
+    get pattern(): string;
+    /**
+     * Indica si el patrón contiene tokens de fecha
+     * Útil para detectar si el nombre del archivo depende de fecha
+     * @returns true si el patrón contiene tokens de fecha, false en caso contrario
+     */
+    hasDateTokens(): boolean;
+    /**
+     * Devuelve todos los tokens encerrados en llaves presentes en el patrón
+     * @returns Array de tokens encontrados en el patrón
+     */
+    getTokens(): string[];
+}