@synet/fs/dist/observable.js

Robust, battle-tested filesystem abstraction for Node.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ObservableFileSystem = exports.FilesystemEventTypes = void 0;
const unit_1 = require("@synet/unit");
var FilesystemEventTypes;
(function (FilesystemEventTypes) {
    FilesystemEventTypes["EXISTS"] = "file.exists";
    FilesystemEventTypes["READ"] = "file.read";
    FilesystemEventTypes["WRITE"] = "file.write";
    FilesystemEventTypes["DELETE"] = "file.delete";
    FilesystemEventTypes["CHMOD"] = "file.chmod";
    FilesystemEventTypes["ENSURE_DIR"] = "file.ensureDir";
    FilesystemEventTypes["DELETE_DIR"] = "file.deleteDir";
    FilesystemEventTypes["READ_DIR"] = "file.readDir";
    FilesystemEventTypes["STAT"] = "file.stat";
})(FilesystemEventTypes || (exports.FilesystemEventTypes = FilesystemEventTypes = {}));
class ObservableFileSystem {
    constructor(baseFilesystem, events) {
        this.baseFilesystem = baseFilesystem;
        this.events = events;
        this.eventEmitter = new unit_1.EventEmitter();
    }
    getEventEmitter() {
        return this.eventEmitter;
    }
    shouldEmit(eventType) {
        return !this.events || this.events.includes(eventType);
    }
    existsSync(filename) {
        try {
            const result = this.baseFilesystem.existsSync(filename);
            if (this.shouldEmit(FilesystemEventTypes.EXISTS)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.EXISTS,
                    data: {
                        filePath: filename,
                        result,
                    },
                    timestamp: new Date(),
                });
            }
            return result;
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.EXISTS)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.EXISTS,
                    data: {
                        filePath: filename,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    readFileSync(filename) {
        try {
            const content = this.baseFilesystem.readFileSync(filename);
            if (this.shouldEmit(FilesystemEventTypes.READ)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.READ,
                    data: {
                        filePath: filename,
                        result: content.length,
                    },
                    timestamp: new Date(),
                });
            }
            return content;
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.READ)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.READ,
                    data: {
                        filePath: filename,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    writeFileSync(filename, data) {
        try {
            this.baseFilesystem.writeFileSync(filename, data);
            if (this.shouldEmit(FilesystemEventTypes.WRITE)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.WRITE,
                    data: {
                        filePath: filename,
                        result: data.length,
                    },
                    timestamp: new Date(),
                });
            }
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.WRITE)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.WRITE,
                    data: {
                        filePath: filename,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    deleteFileSync(filename) {
        try {
            this.baseFilesystem.deleteFileSync(filename);
            if (this.shouldEmit(FilesystemEventTypes.DELETE)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.DELETE,
                    data: {
                        filePath: filename,
                    },
                    timestamp: new Date(),
                });
            }
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.DELETE)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.DELETE,
                    data: {
                        filePath: filename,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    deleteDirSync(dirPath) {
        try {
            this.baseFilesystem.deleteDirSync(dirPath);
            if (this.shouldEmit(FilesystemEventTypes.DELETE_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.DELETE_DIR,
                    data: {
                        filePath: dirPath,
                    },
                    timestamp: new Date(),
                });
            }
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.DELETE_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.DELETE_DIR,
                    data: {
                        filePath: dirPath,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    ensureDirSync(dirPath) {
        try {
            this.baseFilesystem.ensureDirSync(dirPath);
            if (this.shouldEmit(FilesystemEventTypes.ENSURE_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.ENSURE_DIR,
                    data: {
                        filePath: dirPath,
                    },
                    timestamp: new Date(),
                });
            }
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.ENSURE_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.ENSURE_DIR,
                    data: {
                        filePath: dirPath,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    readDirSync(dirPath) {
        try {
            const result = this.baseFilesystem.readDirSync(dirPath);
            if (this.shouldEmit(FilesystemEventTypes.READ_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.READ_DIR,
                    data: {
                        filePath: dirPath,
                        result: result.length,
                    },
                    timestamp: new Date(),
                });
            }
            return result;
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.READ_DIR)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.READ_DIR,
                    data: {
                        filePath: dirPath,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    chmodSync(path, mode) {
        try {
            this.baseFilesystem.chmodSync(path, mode);
            if (this.shouldEmit(FilesystemEventTypes.CHMOD)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.CHMOD,
                    data: {
                        filePath: path,
                        result: mode,
                    },
                    timestamp: new Date(),
                });
            }
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.CHMOD)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.CHMOD,
                    data: {
                        filePath: path,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
    statSync(path) {
        if (!this.baseFilesystem.statSync) {
            throw new Error("Base filesystem does not support statSync operation");
        }
        try {
            const result = this.baseFilesystem.statSync(path);
            if (this.shouldEmit(FilesystemEventTypes.STAT)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.STAT,
                    data: {
                        filePath: path,
                        result: result.size,
                    },
                    timestamp: new Date(),
                });
            }
            return result;
        }
        catch (error) {
            if (this.shouldEmit(FilesystemEventTypes.STAT)) {
                this.eventEmitter.emit({
                    type: FilesystemEventTypes.STAT,
                    data: {
                        filePath: path,
                    },
                    error: {
                        message: error instanceof Error ? error.message : String(error),
                    },
                    timestamp: new Date(),
                });
            }
            throw error;
        }
    }
}
exports.ObservableFileSystem = ObservableFileSystem;