@spinajs/fs 2.0.180 → 2.0.181

package/lib/cjs/local-provider.js

@@ -1,279 +1,322 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fsNative = void 0;
-/* eslint-disable security/detect-non-literal-fs-filename */
-const exceptions_1 = require("@spinajs/exceptions");
-const fs_1 = require("fs");
-const promises_1 = require("node:fs/promises");
-const luxon_1 = require("luxon");
-const di_1 = require("@spinajs/di");
-const interfaces_js_1 = require("./interfaces.js");
-const path_1 = require("path");
-const log_common_1 = require("@spinajs/log-common");
-const archiver_1 = __importDefault(require("archiver"));
-const unzipper_1 = __importDefault(require("unzipper"));
-/**
- * Abstract layer for file operations.
- * Basic implementation is just wrapper for native node fs functions
- *
- * It allows to wrap other libs eg. aws s3, ftp
- * and inject it into code without changing logic that use them.
- *
- * TODO: map errors to some kind of common errors shared with other implementations
- */
-let fsNative = class fsNative extends interfaces_js_1.fs {
-    /**
-     * Name of provider. We can have multiple providers of the same type but with different options.
-     * Also used in InjectService decorator for mapping
-     */
-    get Name() {
-        return this.Options.name;
-    }
-    constructor(Options) {
-        super();
-        this.Options = Options;
-    }
-    async resolve() {
-        // yup, exceptions as conditional execution path is bad :)
-        try {
-            await (0, promises_1.access)(this.Options.basePath, fs_1.constants.F_OK);
-        }
-        catch {
-            this.Logger.warn(`Base path ${this.Options.basePath} for file provider ${this.Options.name} not exists, trying to create base folder`);
-            await (0, promises_1.mkdir)(this.Options.basePath, { recursive: true });
-            this.Logger.success(`Base path ${this.Options.basePath} created`);
-        }
-    }
-    /**
-     *
-     * Tries to download file to local filesystem, then returns local filesystem path.
-     * Native implementation simply returns local path and does nothing.
-     *
-     * @param path - file to download
-     */
-    async download(path) {
-        const p = this.resolvePath(path);
-        const exists = await this.exists(path);
-        if (!exists) {
-            throw new exceptions_1.IOFail(`file ${p} does not exists`);
-        }
-        return p;
-    }
-    async upload(srcPath, destPath) {
-        if (!(0, fs_1.existsSync)(srcPath)) {
-            throw new exceptions_1.IOFail(`file ${srcPath} does not exists`);
-        }
-        const dPath = this.resolvePath(destPath ?? (0, path_1.basename)(srcPath));
-        (0, fs_1.copyFileSync)(srcPath, dPath);
-    }
-    /**
-     * read all content of file
-     */
-    async read(path, encoding) {
-        return new Promise((resolve, reject) => {
-            (0, fs_1.readFile)(this.resolvePath(path), { encoding: encoding ?? 'binary' }, (err, data) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(data);
-                }
-            });
-        });
-    }
-    readStream(path, encoding) {
-        return Promise.resolve((0, fs_1.createReadStream)(this.resolvePath(path), { encoding: encoding ?? 'binary' }));
-    }
-    /**
-     * Write to file string or buffer
-     */
-    async write(path, data, encoding) {
-        const fDesc = await (0, promises_1.open)(this.resolvePath(path), 'w');
-        return await fDesc.writeFile(data, { encoding });
-    }
-    async append(path, data, encoding) {
-        await (0, promises_1.appendFile)(path, data, encoding);
-    }
-    writeStream(path, rStream, encoding) {
-        return Promise.resolve((0, fs_1.createWriteStream)(this.resolvePath(path), {
-            encoding: (typeof rStream === 'string' ? rStream : encoding) ?? 'binary',
-        }));
-    }
-    /**
-     * Checks if file existst
-     * @param path - path to check
-     */
-    async exists(path) {
-        try {
-            await (0, promises_1.access)(this.resolvePath(path), fs_1.constants.F_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async dirExists(path) {
-        return this.exists(this.resolvePath(path));
-    }
-    /**
-     * Copy file to another location
-     * @param path - src path
-     * @param dest - dest path
-     */
-    async copy(path, dest) {
-        await (0, promises_1.copyFile)(this.resolvePath(path), this.resolvePath(dest));
-    }
-    /**
-     * Copy file to another location and deletes src file
-     */
-    async move(oldPath, newPath) {
-        const oPath = this.resolvePath(oldPath);
-        const nPath = this.resolvePath(newPath);
-        try {
-            await (0, promises_1.rename)(oPath, nPath);
-        }
-        catch (err) {
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-            if (err.code === 'EXDEV') {
-                await (0, promises_1.copyFile)(oPath, nPath);
-                await (0, promises_1.unlink)(oPath);
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    /**
-     * Change name of a file
-     */
-    async rename(oldPath, newPath) {
-        await (0, promises_1.rename)(this.resolvePath(oldPath), this.resolvePath(newPath));
-    }
-    /**
-     * Deletes file permanently
-     *
-     * @param path - path to file that will be deleted
-     * @param onlyTemp - remote filesystems need to download file before, if so, calling unlink with this flag removes only local temp file after we finished processing
-     */
-    async unlink(path, onlyTemp) {
-        // local fs returns only local path to file, we dont want to delete it
-        if (onlyTemp) {
-            return;
-        }
-        await (0, promises_1.unlink)(this.resolvePath(path));
-    }
-    /**
-     *
-     * Deletes dir recursively & all contents inside
-     *
-     * @param path - dir to remove
-     */
-    async rm(path) {
-        await (0, promises_1.rm)(this.resolvePath(path), { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 });
-    }
-    /**
-     *
-     * Creates directory, recursively
-     *
-     * @param path - directory to create
-     */
-    async mkdir(path) {
-        await (0, promises_1.mkdir)(this.resolvePath(path), { recursive: true });
-    }
-    /**
-     * Returns file statistics, not all fields may be accesible
-     */
-    async stat(path) {
-        const result = await (0, promises_1.stat)(this.resolvePath(path));
-        return {
-            IsDirectory: result.isDirectory(),
-            IsFile: result.isFile(),
-            CreationTime: luxon_1.DateTime.fromJSDate(result.ctime),
-            ModifiedTime: luxon_1.DateTime.fromJSDate(result.mtime),
-            AccessTime: luxon_1.DateTime.fromJSDate(result.atime),
-            Size: result.size,
-        };
-    }
-    tmppath() {
-        return (0, path_1.join)(this.Options.basePath, super.tmpname());
-    }
-    /**
-     * List content of directory
-     *
-     * @param path - path to directory
-     */
-    async list(path) {
-        return await (0, promises_1.readdir)(this.resolvePath(path));
-    }
-    async unzip(path, destPath) {
-        return new Promise((resolve, reject) => {
-            (0, fs_1.createReadStream)(this.resolvePath(path)).pipe(unzipper_1.default
-                .Extract({
-                path: this.resolvePath(destPath),
-            })
-                .on('close', resolve)
-                .on('error', reject));
-        });
-    }
-    async zip(path, zName) {
-        const fs = await di_1.DI.resolve('__file_provider__', ['fs-temp']);
-        const outFile = fs.resolvePath(fs.tmpname() + '.zip');
-        const output = (0, fs_1.createWriteStream)(outFile);
-        const pStat = await this.stat(path);
-        const fPath = this.resolvePath(path);
-        const archive = (0, archiver_1.default)('zip', {
-            zlib: { level: 9 }, // Sets the compression level.
-        });
-        // pipe archive data to the file
-        archive.pipe(output);
-        if (pStat.IsDirectory) {
-            archive.directory(fPath, false);
-        }
-        else {
-            archive.file(fPath, { name: zName ?? (0, path_1.basename)(fPath) });
-        }
-        await archive.finalize();
-        return {
-            asFilePath: () => {
-                return outFile;
-            },
-            asStream: (encoding) => {
-                return (0, fs_1.createReadStream)(outFile, {
-                    encoding: encoding ?? 'binary',
-                });
-            },
-            asBase64: () => {
-                return (0, fs_1.readFileSync)(outFile, { encoding: 'base64' });
-            },
-        };
-    }
-    resolvePath(path) {
-        if (path.startsWith(this.Options.basePath)) {
-            return path;
-        }
-        return (0, path_1.join)(this.Options.basePath, path);
-    }
-};
-__decorate([
-    (0, log_common_1.Logger)('fs'),
-    __metadata("design:type", log_common_1.Log)
-], fsNative.prototype, "Logger", void 0);
-fsNative = __decorate([
-    (0, di_1.Injectable)('fs'),
-    (0, di_1.PerInstanceCheck)(),
-    __metadata("design:paramtypes", [Object])
-], fsNative);
-exports.fsNative = fsNative;
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fsNative = void 0;
+/* eslint-disable security/detect-non-literal-fs-filename */
+const exceptions_1 = require("@spinajs/exceptions");
+const fs_1 = require("fs");
+const promises_1 = require("node:fs/promises");
+const luxon_1 = require("luxon");
+const di_1 = require("@spinajs/di");
+const interfaces_js_1 = require("./interfaces.js");
+const path_1 = require("path");
+const log_common_1 = require("@spinajs/log-common");
+const archiver_1 = __importDefault(require("archiver"));
+const unzipper_1 = __importDefault(require("unzipper"));
+const promises_2 = require("fs/promises");
+const util_1 = require("@spinajs/util");
+/**
+ * Abstract layer for file operations.
+ * Basic implementation is just wrapper for native node fs functions
+ *
+ * It allows to wrap other libs eg. aws s3, ftp
+ * and inject it into code without changing logic that use them.
+ *
+ * TODO: map errors to some kind of common errors shared with other implementations
+ */
+let fsNative = class fsNative extends interfaces_js_1.fs {
+    /**
+     * Name of provider. We can have multiple providers of the same type but with different options.
+     * Also used in InjectService decorator for mapping
+     */
+    get Name() {
+        return this.Options.name;
+    }
+    constructor(Options) {
+        super();
+        this.Options = Options;
+    }
+    async resolve() {
+        if (!this.Options.basePath) {
+            throw new exceptions_1.IOFail(`Base path for file provider ${this.Options.name} not set`);
+        }
+        if ((await this.exists(this.Options.basePath)) === false) {
+            this.Logger.warn(`Base path ${this.Options.basePath} for file provider ${this.Options.name} not exists, trying to create base folder`);
+            await (0, promises_1.mkdir)(this.Options.basePath, { recursive: true });
+            this.Logger.success(`Base path ${this.Options.basePath} created`);
+        }
+    }
+    /**
+     *
+     * Tries to download file to local filesystem, then returns local filesystem path.
+     * Native implementation simply returns local path and does nothing.
+     *
+     * @param path - file to download
+     */
+    async download(path) {
+        const p = this.resolvePath(path);
+        const exists = await this.exists(path);
+        if (!exists) {
+            throw new exceptions_1.IOFail(`file ${p} does not exists`);
+        }
+        return p;
+    }
+    async upload(srcPath, destPath) {
+        if (!(0, fs_1.existsSync)(srcPath)) {
+            throw new exceptions_1.IOFail(`file ${srcPath} does not exists`);
+        }
+        const dPath = this.resolvePath(destPath ?? (0, path_1.basename)(srcPath));
+        await (0, promises_2.cp)(srcPath, dPath, { force: true, recursive: true });
+    }
+    /**
+     * read all content of file
+     */
+    async read(path, encoding) {
+        return new Promise((resolve, reject) => {
+            (0, fs_1.readFile)(this.resolvePath(path), { encoding: encoding ?? 'binary' }, (err, data) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    readStream(path, encoding) {
+        return Promise.resolve((0, fs_1.createReadStream)(this.resolvePath(path), { encoding: encoding ?? 'binary' }));
+    }
+    /**
+     * Write to file string or buffer
+     */
+    async write(path, data, encoding) {
+        let fHandle = null;
+        try {
+            fHandle = await (0, promises_1.open)(this.resolvePath(path), 'w');
+            await fHandle.writeFile(data, { encoding });
+        }
+        catch (err) {
+            throw new exceptions_1.IOFail(`Cannot write to file ${path}`, err);
+        }
+        finally {
+            if (fHandle) {
+                await fHandle.sync();
+                await fHandle.close();
+            }
+        }
+    }
+    async append(path, data, encoding) {
+        await (0, promises_1.appendFile)(path, data, encoding);
+    }
+    writeStream(path, rStream, encoding) {
+        const stream = (0, fs_1.createWriteStream)(this.resolvePath(path), {
+            encoding: (typeof rStream === 'string' ? rStream : encoding) ?? 'binary',
+        });
+        if (rStream instanceof fs_1.ReadStream) {
+            rStream.pipe(stream);
+        }
+        return Promise.resolve(stream);
+    }
+    /**
+     * Checks if file existst
+     * @param path - path to check
+     */
+    async exists(path) {
+        try {
+            await (0, promises_1.access)(this.resolvePath(path), fs_1.constants.F_OK);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async dirExists(path) {
+        return this.exists(this.resolvePath(path));
+    }
+    /**
+     * Copy file or dir to another location
+     * @param path - src path
+     * @param dest - dest path
+     */
+    async copy(path, dest, dstFs) {
+        const sPath = this.resolvePath(path);
+        const exists = await this.exists(path);
+        if (!exists) {
+            throw new exceptions_1.IOFail(`File ${path} not exists`);
+        }
+        if (dstFs) {
+            await dstFs.upload(sPath, dest);
+        }
+        else {
+            const dPath = this.resolvePath(dest);
+            await (0, promises_2.cp)(sPath, dPath, {
+                recursive: true,
+                force: true,
+            });
+        }
+    }
+    /**
+     * Copy file to another location and deletes src file
+     */
+    async move(oldPath, newPath, dstFs) {
+        const oPath = this.resolvePath(oldPath);
+        if (dstFs) {
+            await dstFs.upload(oPath, newPath);
+            await this.rm(oldPath);
+        }
+        else {
+            const nPath = this.resolvePath(newPath);
+            await (0, promises_1.rename)(oPath, nPath);
+        }
+    }
+    /**
+     * Change name of a file
+     */
+    async rename(oldPath, newPath) {
+        await (0, promises_1.rename)(this.resolvePath(oldPath), this.resolvePath(newPath));
+    }
+    /**
+     *
+     * Deletes file OR
+     * Deletes dir recursively & all contents inside
+     *
+     * @param path - dir to remove
+     */
+    async rm(path) {
+        await (0, promises_1.rm)(this.resolvePath(path), { recursive: true, force: true, maxRetries: 3, retryDelay: 1000 });
+    }
+    /**
+     *
+     * Creates directory, recursively
+     *
+     * @param path - directory to create
+     */
+    async mkdir(path) {
+        await (0, promises_1.mkdir)(this.resolvePath(path), { recursive: true });
+    }
+    /**
+     * Returns file statistics, not all fields may be accesible
+     */
+    async stat(path) {
+        const result = await (0, promises_1.stat)(this.resolvePath(path));
+        return {
+            IsDirectory: result.isDirectory(),
+            IsFile: result.isFile(),
+            CreationTime: luxon_1.DateTime.fromJSDate(result.ctime),
+            ModifiedTime: luxon_1.DateTime.fromJSDate(result.mtime),
+            AccessTime: luxon_1.DateTime.fromJSDate(result.atime),
+            Size: result.size,
+        };
+    }
+    tmppath() {
+        return (0, path_1.join)(this.Options.basePath, super.tmpname());
+    }
+    /**
+     * List content of directory
+     *
+     * @param path - path to directory
+     */
+    async list(path) {
+        return await (0, promises_1.readdir)(this.resolvePath(path));
+    }
+    async unzip(path, destPath, dstFs) {
+        const dFs = dstFs ?? this;
+        const dst = dFs.resolvePath(destPath ?? dFs.tmpname());
+        return new Promise((resolve, reject) => {
+            (0, fs_1.createReadStream)(this.resolvePath(path)).pipe(unzipper_1.default
+                .Extract({
+                path: dst,
+            })
+                .on('close', resolve)
+                .on('error', reject));
+        });
+    }
+    async isDir(path) {
+        try {
+            const pStat = await this.stat(path);
+            return pStat.IsDirectory;
+        }
+        catch {
+            return false;
+        }
+    }
+    async zip(path, dstFs, dstFile) {
+        const paths = (0, util_1.toArray)(path);
+        const fs = dstFs ?? (await di_1.DI.resolve('__file_provider__', ['fs-temp']));
+        const outFile = dstFile ?? `${fs.tmpname()}.zip`;
+        const wStream = await fs.writeStream(outFile);
+        const archive = (0, archiver_1.default)('zip');
+        // pipe archive data to the file
+        archive.pipe(wStream);
+        for (const p of paths.map((p) => this.resolvePath(p))) {
+            if (await this.isDir(p)) {
+                archive.directory(p, false);
+                continue;
+            }
+            archive.file(p, { name: (0, path_1.basename)(p) });
+        }
+        return new Promise((resolve, reject) => {
+            archive.on('warning', (err) => {
+                if (err.code === 'ENOENT') {
+                    this.Logger.error(err, `File not found ( archiving file ), reason: ${err.message})`);
+                    return;
+                }
+                reject(new exceptions_1.IOFail('Archiving error', err));
+            });
+            archive.on('error', (err) => {
+                reject(new exceptions_1.IOFail('Archiving error', err));
+            });
+            archive.on('entry', (entry) => {
+                this.Logger.trace(`Archiving file ${entry.name}, size: ${entry.stats?.size} into ${outFile}, fs: ${fs.Name}`);
+            });
+            wStream.on('close', () => {
+                const result = {
+                    fs,
+                    asFilePath: () => {
+                        return outFile;
+                    },
+                    asStream: (encoding) => {
+                        return (0, fs_1.createReadStream)(outFile, {
+                            encoding: encoding ?? 'binary',
+                        });
+                    },
+                    asBase64: () => {
+                        return (0, fs_1.readFileSync)(outFile, { encoding: 'base64' });
+                    },
+                    unlink: async () => {
+                        return await fs.rm(outFile);
+                    },
+                };
+                resolve(result);
+            });
+            archive.finalize();
+        });
+    }
+    resolvePath(path) {
+        if (!this.Options.basePath || path.startsWith(this.Options.basePath))
+            return path;
+        return (0, path_1.join)(this.Options.basePath, path);
+    }
+};
+exports.fsNative = fsNative;
+__decorate([
+    (0, log_common_1.Logger)('fs'),
+    __metadata("design:type", log_common_1.Log)
+], fsNative.prototype, "Logger", void 0);
+exports.fsNative = fsNative = __decorate([
+    (0, di_1.Injectable)('fs'),
+    (0, di_1.PerInstanceCheck)(),
+    __metadata("design:paramtypes", [Object])
+], fsNative);
 //# sourceMappingURL=local-provider.js.map