@jmlq/logger-plugin-fs 0.1.0-alpha.1 → 0.1.0-alpha.11

package/dist/infrastructure/adapters/index.js

@@ -0,0 +1,24 @@
+"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-rotator.adapter"), exports);
+__exportStar(require("./fileSystem-datasource.adapter"), exports);
+__exportStar(require("./filesystem-log-file-enumerator.adapter"), exports);
+__exportStar(require("./filesystem-log-file-line-reader.adapter"), exports);
+__exportStar(require("./filesystem-provider.adapter"), exports);
+__exportStar(require("./log-stream-writer.adapter"), exports);
+__exportStar(require("./system-clock.adapter"), exports);
+__exportStar(require("./system-file-path.adapter"), exports);

package/dist/infrastructure/adapters/log-stream-writer.adapter.d.ts

@@ -0,0 +1,80 @@
+import { ILogStreamWriterPort } from "../../domain/ports";
+import { FilePath } from "../../domain/value-objects";
+/**
+ * Adapter de infraestructura que implementa IStreamWriterPort
+ * usando streams de escritura de Node.js.
+ *
+ * Responsabilidad:
+ * - Gestionar el ciclo de vida de un WriteStream (open → write → flush → close).
+ * - Manejar backpressure correctamente usando el evento "drain".
+ * - Encapsular errores de I/O en FileOperationError.
+ *
+ * Este adapter NO:
+ * - Decide cuándo rotar.
+ * - Decide qué escribir.
+ * - Conoce reglas de negocio.
+ *
+ * Solo escribe datos de forma eficiente.
+ */
+export declare class LogStreamWriterAdapter implements ILogStreamWriterPort {
+    /**
+     * Stream activo de escritura.
+     * Es null cuando no hay archivo abierto.
+     */
+    private stream;
+    /**
+     * Ruta del archivo actualmente abierto.
+     * Se mantiene para:
+     * - diagnóstico
+     * - errores más informativos
+     */
+    private currentPath;
+    /**
+     * Escribe datos en el stream actual.
+     *
+     * Maneja backpressure:
+     * - Si write() devuelve false, espera al evento "drain".
+     *
+     * @param data Cadena a escribir (ya serializada).
+     * @returns true cuando la escritura fue aceptada por el stream.
+     */
+    write(data: string): Promise<boolean>;
+    /**
+     * Abre un archivo para escritura en modo append.
+     *
+     * Si ya existe un stream abierto:
+     * - Se cierra primero de forma segura.
+     *
+     * @param path FilePath del archivo a abrir.
+     */
+    open(path: FilePath): Promise<void>;
+    /**
+     * Cierra el stream actual de forma ordenada.
+     *
+     * - Llama a stream.end().
+     * - Limpia el estado interno.
+     *
+     * Es seguro llamar varias veces.
+     */
+    close(): Promise<void>;
+    /**
+     * Alias semántico de close().
+     * Útil cuando el writer se usa como “sink” final.
+     */
+    end(): Promise<void>;
+    /**
+     * Espera a que el buffer interno del stream se vacíe.
+     *
+     * No fuerza fsync; solo asegura que el buffer JS esté drenado.
+     */
+    flush(): Promise<void>;
+    /**
+     * Indica si hay un stream abierto actualmente.
+     */
+    isOpen(): boolean;
+    /**
+     * Devuelve la ruta del archivo actualmente abierto.
+     * Puede ser null si no hay stream activo.
+     */
+    getCurrentPath(): FilePath | null;
+}

package/dist/infrastructure/adapters/log-stream-writer.adapter.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogStreamWriterAdapter = void 0;
+const fs_1 = require("fs");
+const errors_1 = require("../errors");
+/**
+ * Adapter de infraestructura que implementa IStreamWriterPort
+ * usando streams de escritura de Node.js.
+ *
+ * Responsabilidad:
+ * - Gestionar el ciclo de vida de un WriteStream (open → write → flush → close).
+ * - Manejar backpressure correctamente usando el evento "drain".
+ * - Encapsular errores de I/O en FileOperationError.
+ *
+ * Este adapter NO:
+ * - Decide cuándo rotar.
+ * - Decide qué escribir.
+ * - Conoce reglas de negocio.
+ *
+ * Solo escribe datos de forma eficiente.
+ */
+class LogStreamWriterAdapter {
+    constructor() {
+        /**
+         * Stream activo de escritura.
+         * Es null cuando no hay archivo abierto.
+         */
+        this.stream = null;
+        /**
+         * Ruta del archivo actualmente abierto.
+         * Se mantiene para:
+         * - diagnóstico
+         * - errores más informativos
+         */
+        this.currentPath = null;
+    }
+    // ---------------------------------------------------------------------------
+    // Escritura
+    // ---------------------------------------------------------------------------
+    /**
+     * Escribe datos en el stream actual.
+     *
+     * Maneja backpressure:
+     * - Si write() devuelve false, espera al evento "drain".
+     *
+     * @param data Cadena a escribir (ya serializada).
+     * @returns true cuando la escritura fue aceptada por el stream.
+     */
+    async write(data) {
+        // Protección: no se puede escribir sin haber abierto un stream
+        if (!this.stream) {
+            throw errors_1.FileOperationError.fs("write", this.currentPath?.absolutePath, "Stream not opened");
+        }
+        return new Promise((resolve, reject) => {
+            // write() devuelve false si el buffer interno está lleno
+            const accepted = this.stream.write(data);
+            if (!accepted) {
+                // Esperar a que el buffer se drene
+                this.stream.once("drain", () => resolve(true));
+                // Error del stream (I/O real)
+                this.stream.once("error", reject);
+            }
+            else {
+                resolve(true);
+            }
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Apertura
+    // ---------------------------------------------------------------------------
+    /**
+     * Abre un archivo para escritura en modo append.
+     *
+     * Si ya existe un stream abierto:
+     * - Se cierra primero de forma segura.
+     *
+     * @param path FilePath del archivo a abrir.
+     */
+    async open(path) {
+        // Si hay un stream previo, cerrarlo primero
+        if (this.stream) {
+            await this.close();
+        }
+        const pathString = path.absolutePath;
+        // Creamos el stream, pero NO lo asignamos todavía
+        const stream = (0, fs_1.createWriteStream)(pathString, { flags: "a" });
+        return new Promise((resolve, reject) => {
+            // El evento "open" garantiza que el archivo está listo
+            stream.once("open", () => {
+                this.stream = stream;
+                this.currentPath = path;
+                resolve();
+            });
+            // Error durante apertura (permisos, path inválido, etc.)
+            stream.once("error", (err) => {
+                reject(errors_1.FileOperationError.fs("write", pathString, err));
+            });
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Cierre
+    // ---------------------------------------------------------------------------
+    /**
+     * Cierra el stream actual de forma ordenada.
+     *
+     * - Llama a stream.end().
+     * - Limpia el estado interno.
+     *
+     * Es seguro llamar varias veces.
+     */
+    async close() {
+        if (!this.stream)
+            return;
+        return new Promise((resolve) => {
+            this.stream.end(() => {
+                this.stream = null;
+                this.currentPath = null;
+                resolve();
+            });
+        });
+    }
+    /**
+     * Alias semántico de close().
+     * Útil cuando el writer se usa como “sink” final.
+     */
+    async end() {
+        return this.close();
+    }
+    /**
+     * Espera a que el buffer interno del stream se vacíe.
+     *
+     * No fuerza fsync; solo asegura que el buffer JS esté drenado.
+     */
+    async flush() {
+        if (!this.stream)
+            return;
+        return new Promise((resolve) => {
+            if (this.stream.writableNeedDrain) {
+                this.stream.once("drain", () => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // Estado
+    // ---------------------------------------------------------------------------
+    /**
+     * Indica si hay un stream abierto actualmente.
+     */
+    isOpen() {
+        return this.stream !== null;
+    }
+    /**
+     * Devuelve la ruta del archivo actualmente abierto.
+     * Puede ser null si no hay stream activo.
+     */
+    getCurrentPath() {
+        return this.currentPath;
+    }
+}
+exports.LogStreamWriterAdapter = LogStreamWriterAdapter;

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

@@ -0,0 +1,25 @@
+import { ISystemClockPort } from "../../domain/ports";
+/**
+ * Adapter de infraestructura que implementa IClockPort
+ * utilizando el reloj real del sistema.
+ *
+ * Responsabilidad:
+ * - Proveer la fecha y hora actual al sistema.
+ *
+ * Propósito arquitectónico:
+ * - Evitar el uso directo de `new Date()` en dominio y aplicación.
+ * - Permitir tests deterministas mediante clocks falsos (FixedClock, MockClock).
+ * - Centralizar la noción de "tiempo actual" del sistema.
+ *
+ * Nota:
+ * - No depende de APIs específicas de Node.js.
+ * - Funciona en cualquier entorno JavaScript.
+ */
+export declare class SystemClockAdapter implements ISystemClockPort {
+    /**
+     * Retorna la fecha y hora actual del sistema.
+     *
+     * @returns Date actual (timestamp UTC con representación local).
+     */
+    now(): Date;
+}

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SystemClockAdapter = void 0;
+/**
+ * Adapter de infraestructura que implementa IClockPort
+ * utilizando el reloj real del sistema.
+ *
+ * Responsabilidad:
+ * - Proveer la fecha y hora actual al sistema.
+ *
+ * Propósito arquitectónico:
+ * - Evitar el uso directo de `new Date()` en dominio y aplicación.
+ * - Permitir tests deterministas mediante clocks falsos (FixedClock, MockClock).
+ * - Centralizar la noción de "tiempo actual" del sistema.
+ *
+ * Nota:
+ * - No depende de APIs específicas de Node.js.
+ * - Funciona en cualquier entorno JavaScript.
+ */
+class SystemClockAdapter {
+    /**
+     * Retorna la fecha y hora actual del sistema.
+     *
+     * @returns Date actual (timestamp UTC con representación local).
+     */
+    now() {
+        return new Date();
+    }
+}
+exports.SystemClockAdapter = SystemClockAdapter;

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

@@ -0,0 +1,47 @@
+import { FilePath } from "../../domain/value-objects";
+import { IFilePathPort } from "../../domain/ports";
+/**
+ * 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.
+ */
+export declare class SystemFilePathAdapter implements IFilePathPort {
+    /**
+     * Crea un FilePath desde una ruta cruda (relativa o absoluta).
+     * La implementación:
+     * - valida input
+     * - normaliza
+     * - resuelve a absoluta (path.resolve)
+     */
+    fromRaw(inputPath: string): FilePath;
+    /**
+     * 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: FilePath, ...segments: string[]): FilePath;
+    /**
+     * 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.
+     */
+    private buildFromAnyPath;
+}

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/infrastructure/errors/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("./file-operation.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

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