filefive 2.0.2 → 3.0.0

package/dist/log.js

@@ -29,7 +29,7 @@ class LogFS extends FileSystem_1.FileSystem {
         }
         catch (e) {
             let msg = `Could not connect to ${this.id}`;
-            if ('message' in e) {
+            if (e && typeof e == 'object' && 'message' in e) {
                 msg += ': ' + e.message;
             }
             logger.error(await (0, exports.err)(msg));
@@ -129,7 +129,10 @@ class LogFS extends FileSystem_1.FileSystem {
             return await this.fs.cp(from, to, recursive);
         }
         catch (e) {
-            logger.error(await (0, exports.err)(e.message));
+            const message = String((e && typeof e === 'object' && 'message' in e)
+                ? e.message
+                : e);
+            logger.error(await (0, exports.err)(message));
             throw e;
         }
     }

package/dist/plugins/mirror/commands.js

@@ -0,0 +1,185 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileType = void 0;
+exports.mirror = mirror;
+exports.unmirror = unmirror;
+const posix_1 = require("node:path/posix");
+const node_fs_1 = require("node:fs");
+const types_1 = require("../../types");
+const Local_1 = require("../../Local");
+const URI_1 = require("../../utils/URI");
+const watchers_1 = __importDefault(require("./watchers"));
+const Upload_1 = __importDefault(require("../../queues/Upload"));
+const Remove_1 = __importDefault(require("../../queues/Remove"));
+const mkdir_1 = __importDefault(require("../../commands/mkdir"));
+const sessions_1 = __importDefault(require("./sessions"));
+const filter_1 = require("../../utils/filter");
+const git_1 = require("../../transformers/git");
+var FileType;
+(function (FileType) {
+    FileType[FileType["File"] = 0] = "File";
+    FileType[FileType["Directory"] = 1] = "Directory";
+    FileType[FileType["NonExistent"] = 2] = "NonExistent";
+    FileType[FileType["Unsupported"] = 3] = "Unsupported";
+})(FileType || (exports.FileType = FileType = {}));
+const operations = new Map();
+const pending = new Set();
+const touched = new Map();
+const repos = new Map();
+let counter = 0;
+function mirror(localRoot, remote, sid, recursive, del, filter, watcher, onChange) {
+    const { id: connectionID, path: destPath } = (0, URI_1.parseURI)(remote);
+    const id = "" + ++counter;
+    touched.set(id, new Set());
+    onChange({
+        type: types_1.MirrorEventType.Create,
+        id,
+        sid,
+        setting: { local: localRoot, remote, recursive, del, filter }
+    });
+    const matchesName = filter ? (0, filter_1.buildFilterPredicate)(filter) : () => true;
+    watchers_1.default.set(id, (0, Local_1.watch)(localRoot, (event, file) => {
+        if (!file) {
+            return;
+        }
+        file = (0, Local_1.unosify)(file);
+        if (isInsideGitDir(file)) {
+            return;
+        }
+        const localPath = (0, posix_1.join)(localRoot, file);
+        if (filter && !matchesName((0, posix_1.basename)(file))) {
+            return;
+        }
+        const operationId = localPath + ':' + remote;
+        if (touch(id, operationId)) {
+            onChange({ type: types_1.MirrorEventType.Syncing, id });
+        }
+        const timeout = operations.get(operationId);
+        if (timeout === true) { // operation is in process
+            pending.add(operationId);
+        }
+        else {
+            clearTimeout(timeout);
+            operations.set(operationId, setTimeout(async () => {
+                operations.set(operationId, true);
+                do {
+                    pending.delete(operationId);
+                    await process(localRoot, localPath, file, connectionID, destPath, recursive, del, filter, watcher);
+                } while (pending.has(operationId));
+                operations.delete(operationId);
+                untouch(operationId, onChange);
+            }, 1000));
+        }
+    }, e => {
+        console.log('Sync error', e);
+    }, { recursive }));
+    sessions_1.default.set(sid, [...sessions_1.default.get(sid) ?? [], id]);
+    return id;
+}
+function unmirror(id) {
+    watchers_1.default.get(id)?.();
+    watchers_1.default.delete(id);
+}
+async function process(root, src, relativePath, connId, dest, recursive, del, filter, watcher) {
+    const type = fileType(src);
+    if (type == FileType.Unsupported) {
+        return;
+    }
+    if (filter?.ignored === true &&
+        await isInRepo(root) &&
+        await isIgnored(src)) {
+        return;
+    }
+    if (filter?.uncommited === true &&
+        await isInRepo(root) &&
+        !await isUncommited(root, src)) {
+        return;
+    }
+    if (type == FileType.File) {
+        return new Promise((resolve, reject) => {
+            const q = new Upload_1.default(connId, [src], dest, undefined, root, () => { }, () => q.resolve({ type: types_1.QueueActionType.Replace }, true), reject, () => resolve(), watcher);
+            q.create();
+        });
+    }
+    else if (type == FileType.Directory) {
+        if (recursive) {
+            if (!filter || filter?.folders === true) {
+                return (0, mkdir_1.default)(relativePath, (0, URI_1.createURI)(connId, dest));
+            }
+        }
+    }
+    else if (type == FileType.NonExistent) {
+        if (del) {
+            return new Promise((resolve, reject) => {
+                (new Remove_1.default(connId, [(0, posix_1.join)(dest, relativePath)], () => { }, reject, () => resolve(), watcher)).create();
+            });
+        }
+    }
+}
+function fileType(path) {
+    try {
+        const stat = (0, node_fs_1.statSync)((0, Local_1.osify)(path));
+        if (stat.isFile()) {
+            return FileType.File;
+        }
+        if (stat.isDirectory()) {
+            return FileType.Directory;
+        }
+    }
+    catch (err) {
+        return FileType.NonExistent;
+    }
+    return FileType.Unsupported;
+}
+function touch(mirrorId, operationId) {
+    const m = touched.get(mirrorId);
+    if (m) {
+        m.add(operationId);
+        return m.size == 1;
+    }
+    return false;
+}
+function untouch(operationId, onChange) {
+    for (const [id, items] of touched.entries()) {
+        if (items.delete(operationId) && !items.size) {
+            onChange({ type: types_1.MirrorEventType.Complete, id });
+        }
+    }
+}
+function isInsideGitDir(path) {
+    return path
+        .split('/')
+        .includes('.git');
+}
+async function isInRepo(path) {
+    const repoRoot = repos.get(path);
+    if (repoRoot !== undefined) {
+        return repoRoot != false;
+    }
+    try {
+        const root = await (0, git_1.getRoot)(path);
+        repos.set(path, root);
+        return true;
+    }
+    catch (e) { }
+    repos.set(path, false);
+    return false;
+}
+async function isUncommited(root, file) {
+    const repoRoot = repos.get(root);
+    if (!repoRoot) {
+        return false;
+    }
+    const statuses = await (0, git_1.getStatuses)((0, posix_1.dirname)(file), repoRoot);
+    return statuses.find(([path, status]) => path == file && status.match('[MAD]')) != undefined;
+}
+async function isIgnored(path) {
+    const ignored = await (0, git_1.getIgnoredList)((0, posix_1.dirname)(path));
+    if (!ignored) {
+        return true;
+    }
+    return ignored.includes(path);
+}

package/dist/plugins/mirror/sessions.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const events_1 = require("../../events");
+const commands_1 = require("./commands");
+const index_1 = require("../../index");
+const sessions = new Map();
+exports.default = sessions;
+events_1.event$.subscribe(e => {
+    if (e.type == events_1.SystemEventType.Disconnect) {
+        (sessions.get(e.sid) ?? []).forEach(id => (0, commands_1.unmirror)(id));
+        sessions.delete(e.sid);
+    }
+    else if (e.type == events_1.SystemEventType.Connect) {
+        if (e.settings && Array.isArray(e.settings.mirrors)) {
+            setTimeout(() => {
+                e.settings.mirrors.forEach(mirror => {
+                    fetch(`http://localhost:${index_1.inputOptions.port}/api/mirror`, {
+                        method: 'POST',
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ ...mirror, sid: e.sid })
+                    });
+                });
+            }, 1000);
+        }
+    }
+});

package/dist/plugins/mirror/watchers.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const watchers = new Map();
+exports.default = watchers;