@sync-in/server 1.3.0

package/server/applications/files/services/files-manager.service.js

@@ -0,0 +1,565 @@
+/*
+ * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
+ * This file is part of Sync-in | The open source file sync and share solution
+ * See the LICENSE file for licensing details
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "FilesManager", {
+    enumerable: true,
+    get: function() {
+        return FilesManager;
+    }
+});
+const _axios = require("@nestjs/axios");
+const _common = require("@nestjs/common");
+const _archiver = /*#__PURE__*/ _interop_require_default(require("archiver"));
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _promises = require("node:stream/promises");
+const _tar = require("tar");
+const _image = require("../../../common/image");
+const _applicationsconstants = require("../../applications.constants");
+const _spaces = require("../../spaces/constants/spaces");
+const _paths = require("../../spaces/utils/paths");
+const _permissions = require("../../spaces/utils/permissions");
+const _webdav = require("../../webdav/constants/webdav");
+const _compress = require("../constants/compress");
+const _files = require("../constants/files");
+const _operations = require("../constants/operations");
+const _samples = require("../constants/samples");
+const _filetaskevent = require("../events/file-task-event");
+const _fileerror = require("../models/file-error");
+const _filelockerror = require("../models/file-lock-error");
+const _files1 = require("../utils/files");
+const _sendfile = require("../utils/send-file");
+const _unzipfile = require("../utils/unzip-file");
+const _urlfile = require("../utils/url-file");
+const _fileslockmanagerservice = require("./files-lock-manager.service");
+const _filesqueriesservice = require("./files-queries.service");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _ts_decorate(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;
+}
+function _ts_metadata(k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+let FilesManager = class FilesManager {
+    sendFileFromSpace(space, asAttachment = false, downloadName = '') {
+        return new _sendfile.SendFile(space.realPath, asAttachment, downloadName);
+    }
+    async saveStream(user, space, req, options) {
+        // if tmpPath is used, we lock the final destination during the transfer
+        // space.realPath is replaced by tmpPath (if allowed), if the move operation failed we remove the tmp file
+        const fExists = await (0, _files1.isPathExists)(space.realPath);
+        const fTmpExists = options?.tmpPath ? await (0, _files1.isPathExists)(options.tmpPath) : false;
+        if (fExists && req.method === _applicationsconstants.HTTP_METHOD.POST) {
+            throw new _fileerror.FileError(_common.HttpStatus.METHOD_NOT_ALLOWED, 'Resource already exists');
+        }
+        if (fExists && await (0, _files1.isPathIsDir)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.METHOD_NOT_ALLOWED, 'The location is a directory');
+        }
+        if (options?.tmpPath) {
+            // ensure tmpPath parent dir exists
+            await (0, _files1.makeDir)((0, _files1.dirName)(options.tmpPath), true);
+        } else if (!await (0, _files1.isPathExists)((0, _files1.dirName)(space.realPath))) {
+            throw new _fileerror.FileError(_common.HttpStatus.CONFLICT, 'Parent must exists');
+        }
+        /* File Lock */ let fileLock;
+        if (options?.dav) {
+            // check locks
+            await this.filesLockManager.checkConflicts(space.dbFile, options?.dav?.depth || _webdav.DEPTH.RESOURCE, {
+                userId: user.id,
+                lockTokens: options.dav?.lockTokens
+            });
+        } else {
+            // create lock if there is no webdav context
+            const [ok, lock] = await this.filesLockManager.create(user, space.dbFile, _webdav.DEPTH.RESOURCE);
+            if (!ok) {
+                throw new _filelockerror.LockConflict(lock, 'Conflicting lock');
+            }
+            fileLock = lock;
+        }
+        try {
+            // check range
+            let startRange = 0;
+            if ((fExists || fTmpExists) && req.headers['content-range']) {
+                // with PUT method, some webdav clients use the `content-range` header,
+                // which is normally reserved for a response to a request containing the `range` header.
+                // However, for more compatibility let's accept it
+                const match = /\d+/.exec(req.headers['content-range']);
+                if (!match.length) {
+                    throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Content-range : header is malformed');
+                }
+                startRange = parseInt(match[0], 10);
+                const size = await (0, _files1.fileSize)(options?.tmpPath || space.realPath);
+                if (startRange !== size) {
+                    throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Content-range : start offset does not match the current file size');
+                }
+            }
+            // todo: check file in db to update
+            // todo : versioning here
+            let checksum;
+            if (options?.checksumAlg) {
+                checksum = await (0, _files1.writeFromStreamAndChecksum)(options?.tmpPath || space.realPath, req.raw, startRange, options.checksumAlg);
+            } else {
+                await (0, _files1.writeFromStream)(options?.tmpPath || space.realPath, req.raw, startRange);
+            }
+            if (options?.tmpPath) {
+                try {
+                    // ensure parent path exists
+                    await (0, _files1.makeDir)(_nodepath.default.dirname(space.realPath), true);
+                    // move the uploaded file to destination
+                    await (0, _files1.moveFiles)(options.tmpPath, space.realPath, true);
+                } catch (e) {
+                    // cleanup tmp file
+                    await (0, _files1.removeFiles)(options.tmpPath);
+                    this.logger.error(`${this.saveStream.name} - unable to move ${options.tmpPath} -> ${space.realPath} : ${e}`);
+                    throw new _fileerror.FileError(_common.HttpStatus.INTERNAL_SERVER_ERROR, 'Unable to move tmp file to dst file');
+                }
+            }
+            if (options?.checksumAlg) {
+                return checksum;
+            }
+            return fExists;
+        } finally{
+            if (fileLock) {
+                try {
+                    await this.filesLockManager.removeLock(fileLock.key);
+                } catch (e) {
+                    this.logger.warn(`Failed to remove lock ${fileLock.key}: ${e}`);
+                }
+            }
+        }
+    }
+    async saveMultipart(user, space, req) {
+        /* Accepted methods:
+        POST: create new resource
+        PUT: create or update new resource (even if parent path does not exist)
+    */ const realParentPath = (0, _files1.dirName)(space.realPath);
+        if (req.method === _applicationsconstants.HTTP_METHOD.POST) {
+            if (await (0, _files1.isPathExists)(space.realPath)) {
+                throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Resource already exists');
+            }
+            if (!await (0, _files1.isPathExists)(realParentPath)) {
+                throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Parent must exists');
+            }
+            if (!await (0, _files1.isPathIsDir)(realParentPath)) {
+                throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Parent must be a directory');
+            }
+        }
+        const basePath = realParentPath + _nodepath.default.sep;
+        for await (const part of req.files()){
+            // part.filename may contain a path like foo/bar.txt.
+            const dstFile = _nodepath.default.resolve(basePath, part.filename);
+            // prevent path traversal
+            if (!dstFile.startsWith(basePath)) {
+                throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'Location is not allowed');
+            }
+            // make dir in space
+            const dstDir = (0, _files1.dirName)(dstFile);
+            if (!await (0, _files1.isPathExists)(dstDir)) {
+                await (0, _files1.makeDir)(dstDir, true);
+            }
+            // create lock
+            const dbFile = {
+                ...space.dbFile,
+                path: _nodepath.default.join((0, _files1.dirName)(space.dbFile.path), part.filename)
+            };
+            const [ok, fileLock] = await this.filesLockManager.create(user, dbFile, _webdav.DEPTH.RESOURCE);
+            if (!ok) throw new _filelockerror.LockConflict(fileLock, 'Conflicting lock');
+            // do
+            try {
+                await (0, _promises.pipeline)(part.file, _nodefs.default.createWriteStream(dstFile, {
+                    highWaterMark: _files.DEFAULT_HIGH_WATER_MARK
+                }));
+            } finally{
+                await this.filesLockManager.removeLock(fileLock.key);
+            }
+        }
+    }
+    async touch(user, space, mtime, checkLocks = true) {
+        if (!await (0, _files1.isPathExists)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.NOT_FOUND, 'Location not found');
+        }
+        if (checkLocks) {
+            await this.filesLockManager.checkConflicts(space.dbFile, _webdav.DEPTH.RESOURCE, {
+                userId: user.id
+            });
+        }
+        // todo: update mtime in last files ( & in db file ?)
+        await (0, _files1.touchFile)(space.realPath, mtime);
+    }
+    async mkFile(user, space, overwrite = false, checkLocks = true, checkDocument = false) {
+        (0, _files1.checkFileName)(space.realPath);
+        if (!overwrite && await (0, _files1.isPathExists)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Resource already exists');
+        }
+        if (checkLocks) {
+            await this.filesLockManager.checkConflicts(space.dbFile, _webdav.DEPTH.RESOURCE, {
+                userId: user.id
+            });
+        }
+        // use sample documents when possible
+        const fileExtension = _nodepath.default.extname(space.realPath);
+        if (checkDocument && fileExtension !== '.txt' && Object.values(_samples.DOCUMENT_TYPE).indexOf(fileExtension) > -1) {
+            const srcSample = _nodepath.default.join(__dirname, `${_samples.SAMPLE_PATH_WITHOUT_EXT}${fileExtension}`);
+            await (0, _files1.copyFiles)(srcSample, space.realPath);
+            return (0, _files1.touchFile)(space.realPath);
+        } else {
+            return (0, _files1.createEmptyFile)(space.realPath);
+        }
+    }
+    async mkDir(user, space, recursive = false, dav) {
+        (0, _files1.checkFileName)(space.realPath);
+        if (!recursive) {
+            if (await (0, _files1.isPathExists)(space.realPath)) {
+                throw new _fileerror.FileError(_common.HttpStatus.METHOD_NOT_ALLOWED, 'Resource already exists');
+            } else if (!await (0, _files1.isPathExists)((0, _files1.dirName)(space.realPath))) {
+                throw new _fileerror.FileError(_common.HttpStatus.CONFLICT, 'Parent must exists');
+            }
+        }
+        await this.filesLockManager.checkConflicts(space.dbFile, dav?.depth || _webdav.DEPTH.RESOURCE, {
+            userId: user.id,
+            lockTokens: dav?.lockTokens
+        });
+        await (0, _files1.makeDir)(space.realPath, recursive);
+    }
+    async copyMove(user, srcSpace, dstSpace, isMove, overwrite = false, dav) {
+        // checks
+        if (!(0, _permissions.canAccessToSpace)(user, dstSpace)) {
+            this.logger.warn(`${this.copyMove.name} - is not allowed to access to this space repository : ${dstSpace.repository}`);
+            throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'You are not allowed to access to this repository');
+        }
+        if (!(0, _permissions.haveSpaceEnvPermissions)(dstSpace, _spaces.SPACE_OPERATION.ADD)) {
+            this.logger.warn(`${this.copyMove.name} - is not allowed to copy/move on this space : *${dstSpace.alias}* (${dstSpace.id}) : ${dstSpace.url}`);
+            throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'You are not allowed to copy/move on the destination');
+        }
+        if (dstSpace.quotaIsExceeded) {
+            this.logger.warn(`${this.copyMove.name} - quota is exceeded for *${dstSpace.alias}* (${dstSpace.id})`);
+            throw new _fileerror.FileError(_common.HttpStatus.INSUFFICIENT_STORAGE, 'Quota is exceeded');
+        }
+        if (!await (0, _files1.isPathExists)(srcSpace.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.NOT_FOUND, 'Location not found');
+        }
+        if (!await (0, _files1.isPathExists)((0, _files1.dirName)(dstSpace.realPath))) {
+            throw new _fileerror.FileError(_common.HttpStatus.CONFLICT, 'Parent must exists');
+        }
+        if (srcSpace.realPath === dstSpace.realPath) {
+            throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'Cannot copy/move source onto itself');
+        }
+        if (`${dstSpace.realPath}/`.startsWith(`${srcSpace.realPath}/`)) {
+            throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'Cannot copy/move source below itself');
+        }
+        if ((0, _files1.dirName)(srcSpace.url) === (0, _files1.dirName)(dstSpace.url) && (0, _files1.dirName)(srcSpace.realPath) !== (0, _files1.dirName)(dstSpace.realPath)) {
+            /* Handle renaming a space file with the same name as a space root :
+        srcSpace.url = '/space/sync-in/code2.ts' (a space file)
+        srcSpace.realPath = '/home/sync-in/spaces/sync-in/code2.ts
+        dstSpace.url = '/space/sync-in/code.ts' (a space root)
+        dstSpace.realPath = '/home/sync-in/users/jo/files/code2.ts !!
+       */ throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'An anchored file already has this name');
+        }
+        if (!overwrite && await (0, _files1.isPathExists)(dstSpace.realPath)) {
+            /* Handle case-sensitive (in renaming context):
+        srcSpace.url = '/space/sync-in/code.ts'
+        dstSpace.url = '/space/sync-in/code.TS'
+       The destination exists because it's the same file, bypass this
+     */ if (!(isMove && srcSpace.realPath.toLowerCase() === dstSpace.realPath.toLowerCase())) {
+                throw new _fileerror.FileError(dav ? _common.HttpStatus.PRECONDITION_FAILED : _common.HttpStatus.BAD_REQUEST, 'The destination already exists');
+            }
+        }
+        const isDir = await (0, _files1.isPathIsDir)(srcSpace.realPath);
+        if (dstSpace.storageQuota) {
+            /* Skip validation when moving to the same space; for copy operations, run all checks. */ if (!isMove || isMove && srcSpace.id !== dstSpace.id) {
+                const size = isDir ? (await (0, _files1.dirSize)(srcSpace.realPath))[0] : await (0, _files1.fileSize)(srcSpace.realPath);
+                if (dstSpace.willExceedQuota(size)) {
+                    this.logger.warn(`${this.copyMove.name} - quota will be exceeded for *${dstSpace.alias}* (${dstSpace.id})`);
+                    throw new _fileerror.FileError(_common.HttpStatus.INSUFFICIENT_STORAGE, 'Quota will be exceeded');
+                }
+            }
+        }
+        // check lock conflicts on source & destination
+        let recursive;
+        let depth;
+        if (dav?.depth) {
+            recursive = dav.depth === _webdav.DEPTH.INFINITY;
+            depth = dav.depth;
+        } else {
+            recursive = isDir;
+            depth = recursive ? _webdav.DEPTH.INFINITY : _webdav.DEPTH.RESOURCE;
+        }
+        if (isMove) {
+            // check source
+            await this.filesLockManager.checkConflicts(srcSpace.dbFile, depth, {
+                userId: user.id,
+                lockTokens: dav?.lockTokens
+            });
+        }
+        // check destination
+        await this.filesLockManager.checkConflicts(dstSpace.dbFile, depth, {
+            userId: user.id,
+            lockTokens: dav?.lockTokens
+        });
+        // overwrite
+        if (overwrite && await (0, _files1.isPathExists)(dstSpace.realPath)) {
+            // todo : versioning here
+            await this.delete(user, dstSpace);
+        }
+        // send to task watcher
+        if (srcSpace.task?.cacheKey) {
+            if (!isDir) srcSpace.task.props.totalSize = await (0, _files1.fileSize)(srcSpace.realPath);
+            _filetaskevent.FileTaskEvent.emit('startWatch', srcSpace, isMove ? _operations.FILE_OPERATION.MOVE : _operations.FILE_OPERATION.COPY, dstSpace.realPath);
+        }
+        // do
+        if (isMove) {
+            await (0, _files1.moveFiles)(srcSpace.realPath, dstSpace.realPath, overwrite);
+            return this.filesQueries.moveFiles(srcSpace.dbFile, dstSpace.dbFile, isDir);
+        }
+        return (0, _files1.copyFiles)(srcSpace.realPath, dstSpace.realPath, overwrite, recursive);
+    }
+    async delete(user, space, dav) {
+        if (!await (0, _files1.isPathExists)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.NOT_FOUND, 'Location not found');
+        }
+        // check lock conflicts
+        const isDir = await (0, _files1.isPathIsDir)(space.realPath);
+        await this.filesLockManager.checkConflicts(space.dbFile, isDir ? _webdav.DEPTH.INFINITY : _webdav.DEPTH.RESOURCE, {
+            userId: user.id,
+            lockTokens: dav?.lockTokens
+        });
+        // file system deletion
+        let forceDeleteInDB = false;
+        if (space.inTrashRepository) {
+            await (0, _files1.removeFiles)(space.realPath);
+        } else {
+            const baseTrashPath = (0, _paths.realTrashPathFromSpace)(user, space);
+            if (baseTrashPath) {
+                const name = (0, _files1.fileName)(space.realPath);
+                const trashDir = _nodepath.default.join(baseTrashPath, (0, _files1.dirName)(space.dbFile.path));
+                const trashFile = _nodepath.default.join(trashDir, name);
+                if (!await (0, _files1.isPathExists)(trashDir)) {
+                    await (0, _files1.makeDir)(trashDir, true);
+                }
+                if (await (0, _files1.isPathExists)(trashFile)) {
+                    // if a resource already exists in the trash, rename it with the date
+                    const dstTrash = await (0, _files1.uniqueDatedFilePath)(trashFile);
+                    // move the resource on fs
+                    await (0, _files1.moveFiles)(trashFile, dstTrash.path);
+                    // move the resource in db
+                    const trashFileDB = {
+                        ...space.dbFile,
+                        inTrash: true
+                    };
+                    const dstTrashFileDB = {
+                        ...trashFileDB,
+                        path: _nodepath.default.join((0, _files1.dirName)(trashFileDB.path), (0, _files1.fileName)(dstTrash.path))
+                    };
+                    this.filesQueries.moveFiles(trashFileDB, dstTrashFileDB, dstTrash.isDir).catch((e)=>this.logger.error(`${this.delete.name} - ${e}`));
+                }
+                await (0, _files1.moveFiles)(space.realPath, trashFile, true);
+            } else {
+                this.logger.log(`Unable to find trash path for space - *${space.alias}* (${space.id}) : delete permanently : ${space.realPath}`);
+                // todo: define a default trash for external paths
+                forceDeleteInDB = true;
+                await (0, _files1.removeFiles)(space.realPath);
+            }
+        }
+        // remove locks, these locks have already been checked in the `checkConflicts` function
+        if (isDir) {
+            this.filesLockManager.removeChildLocks(user, space.dbFile).catch((e)=>this.logger.error(`${this.delete.name} - ${e}`));
+        }
+        for (const lock of (await this.filesLockManager.getLocksByPath(space.dbFile))){
+            this.filesLockManager.removeLock(lock.key).catch((e)=>this.logger.error(`${this.delete.name} - ${e}`));
+        }
+        // delete or move to trash the files in db
+        return this.filesQueries.deleteFiles(space.dbFile, isDir, forceDeleteInDB);
+    }
+    async downloadFromUrl(user, space, url) {
+        this.logger.log(`${this.downloadFromUrl.name} : ${url}`);
+        // create lock
+        const rPath = await (0, _files1.uniqueFilePathFromDir)(space.realPath);
+        const dbFile = space.dbFile;
+        dbFile.path = _nodepath.default.join((0, _files1.dirName)(dbFile.path), (0, _files1.fileName)(space.realPath));
+        const [ok, fileLock] = await this.filesLockManager.create(user, dbFile, _webdav.DEPTH.RESOURCE);
+        if (!ok) {
+            throw new _filelockerror.LockConflict(fileLock, 'Conflicting lock');
+        }
+        // tasking
+        if (space.task.cacheKey) {
+            let headRes;
+            try {
+                headRes = await this.http.axiosRef({
+                    method: _applicationsconstants.HTTP_METHOD.HEAD,
+                    url: url,
+                    maxRedirects: 1
+                });
+            } catch (e) {
+                // release lock
+                await this.filesLockManager.removeLock(fileLock.key);
+                this.logger.error(`${this.downloadFromUrl.name} - ${url} : ${e}`);
+                throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'Unable to download file');
+            }
+            if (_urlfile.regExpPrivateIP.test(headRes.request.socket.remoteAddress)) {
+                // release lock
+                await this.filesLockManager.removeLock(fileLock.key);
+                // prevent SSRF attack
+                throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'Access to internal IP addresses is forbidden');
+            }
+            // attempt to retrieve the Content-Length header
+            try {
+                if ('content-length' in headRes.headers) {
+                    space.task.props.totalSize = parseInt(headRes.headers['content-length'], 10) || null;
+                }
+            } catch (e) {
+                this.logger.debug(`${this.downloadFromUrl.name} - content-length : ${e}`);
+            }
+            _filetaskevent.FileTaskEvent.emit('startWatch', space, _operations.FILE_OPERATION.DOWNLOAD, rPath);
+        }
+        // do
+        try {
+            const getRes = await this.http.axiosRef({
+                method: _applicationsconstants.HTTP_METHOD.GET,
+                url: url,
+                responseType: 'stream',
+                maxRedirects: 1
+            });
+            if (_urlfile.regExpPrivateIP.test(getRes.request.socket.remoteAddress)) {
+                // Prevent SSRF attacks and perform a DNS-rebinding check if a HEAD request has already been made
+                throw new _fileerror.FileError(_common.HttpStatus.FORBIDDEN, 'Access to internal IP addresses is forbidden');
+            }
+            await (0, _files1.writeFromStream)(rPath, getRes.data);
+        } finally{
+            // release lock
+            await this.filesLockManager.removeLock(fileLock.key);
+        }
+    }
+    async compress(user, space, dto) {
+        // This method is currently used only by files-methods.service, which handles input sanitization.
+        // If it is used in other services in the future, make sure to refactor accordingly to sanitize inputs properly.
+        const srcPath = (0, _files1.dirName)(space.realPath);
+        // todo: a guest link tasksPath should be in specific directory (guest link has no home)
+        const archiveExt = dto.name.endsWith(dto.extension) ? '' : `.${dto.extension}`;
+        const dstPath = await (0, _files1.uniqueFilePathFromDir)(_nodepath.default.join(dto.compressInDirectory ? srcPath : user.tasksPath, `${dto.name}${archiveExt}`));
+        const archive = (0, _archiver.default)('tar', {
+            gzip: dto.extension === _compress.tarGzExtension,
+            gzipOptions: {
+                level: 9
+            }
+        });
+        // create lock
+        let fileLock;
+        if (dto.compressInDirectory) {
+            const dbFile = space.dbFile;
+            dbFile.path = _nodepath.default.join((0, _files1.dirName)(dbFile.path), (0, _files1.fileName)(dstPath));
+            const [ok, lock] = await this.filesLockManager.create(user, dbFile, _webdav.DEPTH.RESOURCE);
+            if (!ok) {
+                throw new _filelockerror.LockConflict(lock, 'Conflicting lock');
+            }
+            fileLock = lock;
+        }
+        if (space.task?.cacheKey) {
+            space.task.props.compressInDirectory = dto.compressInDirectory;
+            _filetaskevent.FileTaskEvent.emit('startWatch', space, _operations.FILE_OPERATION.COMPRESS, dstPath);
+        }
+        // do
+        try {
+            archive.on('error', (error)=>{
+                throw error;
+            });
+            const dstStream = _nodefs.default.createWriteStream(dstPath, {
+                highWaterMark: _files.DEFAULT_HIGH_WATER_MARK
+            });
+            archive.pipe(dstStream);
+            for (const f of dto.files){
+                if (await (0, _files1.isPathIsDir)(f.path)) {
+                    archive.directory(f.path, dto.files.length > 1 ? (0, _files1.fileName)(f.path) : false);
+                } else {
+                    archive.file(f.path, {
+                        name: f.rootAlias ? f.name : (0, _files1.fileName)(f.path)
+                    });
+                }
+            }
+            await archive.finalize();
+        } finally{
+            if (fileLock) {
+                await this.filesLockManager.removeLock(fileLock.key);
+            }
+        }
+    }
+    async decompress(user, space) {
+        // checks
+        if (!await (0, _files1.isPathExists)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.NOT_FOUND, 'Location not found');
+        }
+        const extension = _nodepath.default.extname(space.realPath);
+        if (!_files.COMPRESSION_EXTENSION.has(extension)) {
+            throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, `${extension} is not supported`);
+        }
+        // make destination folder
+        const dstPath = await (0, _files1.uniqueFilePathFromDir)(_nodepath.default.join((0, _files1.dirName)(space.realPath), _nodepath.default.basename(space.realPath, extension)));
+        await (0, _files1.makeDir)(dstPath);
+        // create lock
+        const dbFile = space.dbFile;
+        dbFile.path = _nodepath.default.join((0, _files1.dirName)(dbFile.path), (0, _files1.fileName)(dstPath));
+        const [ok, fileLock] = await this.filesLockManager.create(user, dbFile, _webdav.DEPTH.INFINITY);
+        if (!ok) {
+            throw new _filelockerror.LockConflict(fileLock, 'Conflicting lock');
+        }
+        // tasking
+        if (space.task?.cacheKey) _filetaskevent.FileTaskEvent.emit('startWatch', space, _operations.FILE_OPERATION.DECOMPRESS, dstPath);
+        // do
+        try {
+            if (extension === '.zip') {
+                await (0, _unzipfile.extractZip)(space.realPath, dstPath);
+            } else {
+                await (0, _tar.extract)({
+                    file: space.realPath,
+                    cwd: dstPath,
+                    gzip: _files.COMPRESSION_EXTENSION.get(extension) === _compress.tarGzExtension,
+                    preserveOwner: false
+                });
+            }
+        } finally{
+            await this.filesLockManager.removeLock(fileLock.key);
+        }
+    }
+    async generateThumbnail(space, size) {
+        if (!await (0, _files1.isPathExists)(space.realPath)) {
+            throw new _fileerror.FileError(_common.HttpStatus.NOT_FOUND, 'Location not found');
+        }
+        if ((0, _files1.getMimeType)(space.realPath, false).indexOf('image') === -1) {
+            throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'File is not an image');
+        }
+        try {
+            return (0, _image.generateThumbnail)(space.realPath, size);
+        } catch (e) {
+            this.logger.warn(e);
+            throw new _fileerror.FileError(_common.HttpStatus.BAD_REQUEST, 'File is not an image');
+        }
+    }
+    constructor(http, filesQueries, filesLockManager){
+        this.http = http;
+        this.filesQueries = filesQueries;
+        this.filesLockManager = filesLockManager;
+        /* Spaces permissions are checked in the space guard, except for the copy/move destination */ this.logger = new _common.Logger(FilesManager.name);
+    }
+};
+FilesManager = _ts_decorate([
+    (0, _common.Injectable)(),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _axios.HttpService === "undefined" ? Object : _axios.HttpService,
+        typeof _filesqueriesservice.FilesQueries === "undefined" ? Object : _filesqueriesservice.FilesQueries,
+        typeof _fileslockmanagerservice.FilesLockManager === "undefined" ? Object : _fileslockmanagerservice.FilesLockManager
+    ])
+], FilesManager);
+
+//# sourceMappingURL=files-manager.service.js.map