datafolder 1.0.2 → 1.0.3

package/src/QyBinWriter.js

@@ -1,16 +1,28 @@
-let open = require("node:fs/promises").open, QyOpRunner = require("./QyOpRunner.js").QyOpRunner, {
-    ensureParentDir,
-    getSize,
-    getSizeStr,
-    sleep,
-    setPromise,
-    toBuffer
-} = require("./QyUtils.js"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions;
+import {
+    open as s
+} from "node:fs/promises";
 
-class QyBinWriter extends QyOpRunner {
+import {
+    QyOpRunner as e
+} from "./QyOpRunner.js";
+
+import {
+    ensureParentDir as r,
+    getSize as n,
+    getSizeStr as d,
+    sleep as _,
+    setPromise as o,
+    toBuffer as v
+} from "./QyUtils.js";
+
+import {
+    getDefaultOptions as a
+} from "./QyDefaultOptions.js";
+
+class t extends e {
     constructor(e, t) {
         super({
-            ...getDefaultOptions("QyBinWriter"),
+            ...a("QyBinWriter"),
             ...e
         }, [ "start", "stop" ]), this.filePath = t, this._resetParams();
     }
@@ -20,14 +32,14 @@ class QyBinWriter extends QyOpRunner {
     getTotalSavedSize() {
         return this.totalSavedSize;
     }
-    save(e, t, i) {
+    save(e, t, a) {
         null == t && (t = e, e = 0);
-        var a, r = this.lastOp;
-        return "_op_save" === r?.opFunName ? (a = r.args, a[0] = e, a[1].push(t), 
-        i && setPromise(r), r.promise) : (a = {
+        var i, s = this.lastOp;
+        return "_op_save" === s?.opFunName ? (i = s.args, i[0] = e, i[1].push(t), 
+        a && o(s), s.promise) : (i = {
             opFunName: "_op_save",
             args: [ e, [ t ] ]
-        }, i ? this.pushAndRunWithPromise(a) : this.pushAndRun(a));
+        }, a ? this.pushAndRunWithPromise(i) : this.pushAndRun(i));
     }
     truncate() {
         var e = this.lastOp;
@@ -51,28 +63,28 @@ class QyBinWriter extends QyOpRunner {
     }
     async _saveBinData(e, t) {
         var {
-            fileHandle: i,
-            totalSavedSize: a,
-            filePath: r,
-            options: s
+            fileHandle: a,
+            totalSavedSize: i,
+            filePath: s,
+            options: r
         } = this, {
             emitSaveEvent: n,
             maxFileSize: o,
             maxRetryInterval: l,
             retryIntervalFactor: h
-        } = s, u = toBuffer(t), p = u.length, f = `size ${getSizeStr(p)} (MaxId:${e}) to ` + r;
-        let c;
+        } = r, p = v(t), u = p.length, f = `size ${d(u)} (MaxId:${e}) to ` + s;
+        let m;
         for (;"_op_truncate" !== this.firstOp?.opFunName; ) try {
-            await i.appendFile(u, {
+            await a.appendFile(p, {
                 flush: !0
             });
-            var d = this.totalSavedSize = a + p;
-            return n && this.emit("save", e), void (o && o < d && !this.maxFileSizeEmitted && (this.supressMaxFileSizeEvent(), 
-            this.emit("maxFileSize", d)));
+            var c = this.totalSavedSize = i + u;
+            return n && this.emit("save", e), void (o && o < c && !this.maxFileSizeEmitted && (this.supressMaxFileSizeEvent(), 
+            this.emit("maxFileSize", c)));
         } catch (e) {
-            logger.error(`Saving ${f} failed:`, e, "Truncated back to " + a), await i.truncate(a), 
-            c = c ? Math.min(l, c * h) : 1, logger.log(`Retry in ${c} seconds`), 
-            await sleep(c);
+            logger.error(`Saving ${f} failed:`, e, "Truncated back to " + i), await a.truncate(i), 
+            m = m ? Math.min(l, m * h) : 1, logger.log(`Retry in ${m} seconds`), 
+            await _(m);
         }
     }
     async _op_start(e) {
@@ -109,20 +121,20 @@ class QyBinWriter extends QyOpRunner {
     async _op_switch(e) {
         var {
             fileHandle: t,
-            filePath: i
+            filePath: a
         } = this;
-        t && i == e || (await this._openFile(e), logger.info(`Switched from ${i} to ` + e));
+        t && a == e || (await this._openFile(e), logger.info(`Switched from ${a} to ` + e));
     }
     async _openFile(t) {
         var {
             fileHandle: e,
-            options: i
+            options: a
         } = this;
         this._resetParams();
         try {
-            e && (e.close(), this.fileHandle = void 0), await ensureParentDir(t);
-            var a = i.append;
-            this.fileHandle = await open(t, a ? "a" : "w"), this.filePath = t, a && (this.totalSavedSize = await getSize(t));
+            e && (e.close(), this.fileHandle = void 0), await r(t);
+            var i = a.append;
+            this.fileHandle = await s(t, i ? "a" : "w"), this.filePath = t, i && (this.totalSavedSize = await n(t));
         } catch (e) {
             logger.error(`Open ${t} failed:`, e);
         }
@@ -135,6 +147,6 @@ class QyBinWriter extends QyOpRunner {
     }
 }
 
-Object.assign(module.exports, {
-    QyBinWriter: QyBinWriter
-});
+export {
+    t as QyBinWriter
+};

package/src/QyCD.js

@@ -1,27 +1,26 @@
-let {
-    isString,
-    pathSplit
-} = require("./QyUtils.js");
+import {
+    isString as e,
+    pathSplit as s
+} from "./QyUtils.js";
 
-class QyCD {
+class r {
     constructor(r) {
         this.qyCache = r;
     }
     cd(r, i = this.currentDir) {
-        return isString(r) && (r = pathSplit(r)), this.cdP(r, i);
+        return e(r) && (r = s(r)), this.cdP(r, i);
     }
     cdP(r, i = this.currentDir) {
         return this.currentDir = this.qyCache.getOrCreateDir(r, i), this;
     }
     dir(r, i = this.currentDir) {
-        return isString(r) && (r = pathSplit(r)), this.dirP(r, i);
+        return e(r) && (r = s(r)), this.dirP(r, i);
     }
     dirP(r, i = this.currentDir) {
         return this.qyCache.getDir(r, i);
     }
     indexDir(r, i, t = this.currentDir) {
-        return isString(r) && (r = pathSplit(r)), isString(i) && (i = pathSplit(i)), 
-        this.indexDirP(r, i, t);
+        return e(r) && (r = s(r)), e(i) && (i = s(i)), this.indexDirP(r, i, t);
     }
     indexDirP(r, i, t = this.currentDir) {
         var e = this.qyCache, r = e.getDir(r, t);
@@ -31,7 +30,7 @@ class QyCD {
         }
     }
     file(r, i = this.currentDir) {
-        return isString(r) && (r = pathSplit(r)), this.fileP(r, i);
+        return e(r) && (r = s(r)), this.fileP(r, i);
     }
     fileP(r, i = this.currentDir) {
         return this.qyCache.getFile(r, i);
@@ -40,7 +39,7 @@ class QyCD {
         return this.qyCache.getTriggerFile(r);
     }
     view(r, i, t = this.currentDir) {
-        return isString(r) && (r = pathSplit(r)), this.viewP(r, i, t);
+        return e(r) && (r = s(r)), this.viewP(r, i, t);
     }
     viewP(r, i, t = this.currentDir) {
         return this.qyCache.getFile(r, t)?.view(i);
@@ -56,6 +55,6 @@ class QyCD {
     }
 }
 
-Object.assign(module.exports, {
-    QyCD: QyCD
-});
+export {
+    r as QyCD
+};

package/src/QyCache.js

@@ -1,77 +1,151 @@
-let path = require("node:path"), EventEmitter = require("node:events"), QyDir = require("./QyDir.js").QyDir, QyFileLogger = require("./QyFileLogger.js").QyFileLogger, QyKVData = require("./QyKVData.js").QyKVData, {
-    QyTriggerNode,
-    updateTriggerNodes
-} = require("./QyTrigger.js"), {
-    isString,
-    lockExclusiveFilePath,
-    unlockExclusiveFilePath
-} = require("./QyUtils.js"), dumpStructure = require("./QyStructure.js").dumpStructure, {
-    getIndexPropPaths,
-    parseNamePathAndQuery
-} = require("./QyIndex.js"), getDefaultOptions = require("./QyDefaultOptions.js").getDefaultOptions, {
-    ensureDir,
-    SpecialFilePaths
-} = require("./QyUtils.js"), QueryCounter = require("./QyUnionNode.js").QueryCounter, QyKVDataLoader = require("./QyKVDataLoader.js").QyKVDataLoader, requireFromModCode = require("./QyMod.js").requireFromModCode, {
-    IndexDirPath,
-    TriggerDirPath,
-    RpcDirPath
-} = SpecialFilePaths;
-
-class QyCache extends EventEmitter {
-    constructor(e, r, t) {
-        super(), r = {
-            ...getDefaultOptions("QyCache"),
-            ...r
+import {
+    join as v
+} from "node:path";
+
+import r from "node:events";
+
+import {
+    QyDir as o
+} from "./QyDir.js";
+
+import {
+    QyFileLogger as a
+} from "./QyFileLogger.js";
+
+import {
+    QyKVData as s
+} from "./QyKVData.js";
+
+import {
+    QyTriggerNode as f,
+    updateTriggerNodes as g
+} from "./QyTrigger.js";
+
+import {
+    isString as n,
+    lockExclusiveFilePath as C,
+    unlockExclusiveFilePath as i
+} from "./QyUtils.js";
+
+import {
+    dumpStructure as q
+} from "./QyStructure.js";
+
+import {
+    getIndexPropPaths as l,
+    parseNamePathAndQuery as d
+} from "./QyIndex.js";
+
+import {
+    getDefaultOptions as u
+} from "./QyDefaultOptions.js";
+
+import {
+    ensureDir as R,
+    SpecialFilePaths as e
+} from "./QyUtils.js";
+
+import {
+    QueryCounter as p
+} from "./QyUnionNode.js";
+
+import {
+    QyKVDataLoader as Q
+} from "./QyKVDataLoader.js";
+
+import {
+    requireFromModCode as h
+} from "./QyMod.js";
+
+let {
+    IndexDirPath: S,
+    TriggerDirPath: x,
+    RpcDirPath: O
+} = e;
+
+class t extends r {
+    constructor(r, e, t) {
+        super(), e = {
+            ...u("QyCache"),
+            ...e
         };
-        var i = path.join(e, "qykv");
+        var i = v(r, "qykv");
         Object.assign(this, {
             qyDB: t,
-            rootFolder: e,
+            rootFolder: r,
             kvFolder: i,
-            rpcFolder: path.join(e, "rpc"),
-            options: r,
-            rootDir: new QyDir("", !0, void 0, this),
-            exclusiveFilePath: path.join(e, ".opened"),
-            qyKVData: new QyKVData(i, r, this),
-            qyFileLogger: new QyFileLogger(path.join(e, "qylog"), r),
+            rpcFolder: v(r, "rpc"),
+            options: e,
+            rootDir: new o("", !0, void 0, this),
+            exclusiveFilePath: v(r, ".opened"),
+            qyKVData: new s(i, e, this),
+            qyFileLogger: new a(v(r, "qylog"), e),
             rpcFunMap: {}
         });
     }
     async start() {
         var {
-            rootFolder: e,
-            kvFolder: r,
+            rootFolder: r,
+            kvFolder: e,
             options: t,
             qyKVData: i,
-            qyFileLogger: a,
-            exclusiveFilePath: o,
+            qyFileLogger: o,
+            exclusiveFilePath: a,
             rootDir: s
         } = this;
-        logger.log(`Starting at ${e}...`);
+        logger.log(`Starting at ${r}...`);
         try {
-            await ensureDir(r), a.start();
+            await R(e), o.start();
             var [ {
                 maxChangeId: g,
                 loadedMaxAclNum: n,
                 qySnapshots: l,
-                aclKeyValueMap: u
-            } ] = await Promise.all([ this._loadQyKVData(r, t), lockExclusiveFilePath(o) ]);
-            await i.start(g, n, l, u);
-        } catch (e) {
-            throw a.stop(), e;
+                aclKeyValueMap: d
+            } ] = await Promise.all([ ((r, e) => (r = new Q(r, e)).load())(e, t), C(a) ]);
+            await i.start(g, n, l, d);
+        } catch (r) {
+            throw o.stop(), r;
         }
-        return t.preloadFoldersAtStart && this._preloadFolders(s), this.indexRootDir = s.searchOrCreateSubdir(IndexDirPath), 
-        this._initTriggers(), this._initRpcs(), t.dumpStructureAtStart && await dumpStructure(path.join(e, "qystruct"), s), 
-        logger.log("Started."), this;
+        t.preloadFoldersAtStart && !function r(e) {
+            let {
+                subdirList: t,
+                fileMap: i
+            } = e;
+            for (var o of t) r(o);
+        }(s), this.indexRootDir = s.searchOrCreateSubdir(S);
+        var u = this, e = u.rootDir;
+        e.triggerNodes = [ new f() ], u.triggerRootDir = e.searchOrCreateSubdir(x);
+        for (p of u.triggerRootDir.fileList) {
+            var {
+                name: p,
+                fileContent: h
+            } = p, {
+                fileNamePath: h,
+                propNamePathList: c,
+                modCode: D
+            } = h;
+            u.insertTriggerToTree(p, h, c, D);
+        }
+        var y = this;
+        y.rpcRootDir = y.rootDir.searchOrCreateSubdir(O);
+        for (m of y.rpcRootDir.fileList) {
+            var {
+                name: m,
+                fileContent: F
+            } = m;
+            F && (F = F.modCode, F) && y.insertRpc(m, F);
+        }
+        return t.dumpStructureAtStart && await q(v(r, "qystruct"), s), logger.log("Started."), 
+        this;
     }
     async stop() {
         logger.log("Stopping...");
         var {
-            qyKVData: e,
-            qyFileLogger: r,
+            qyKVData: r,
+            qyFileLogger: e,
             exclusiveFilePath: t
         } = this;
-        return await e.stop(), await r.stop(), unlockExclusiveFilePath(t), Object.assign(this, {
+        return await r.stop(), await e.stop(), i(t), Object.assign(this, {
             rootDir: void 0,
             indexRootDir: void 0,
             qyKVData: void 0,
@@ -88,125 +162,88 @@ class QyCache extends EventEmitter {
     decreaseChangeId() {
         this.qyKVData.decreaseChangeId();
     }
-    save(e, r, t, i, a) {
+    save(r, e, t, i, o) {
         var {
-            qyKVData: o,
+            qyKVData: a,
             qyFileLogger: s
         } = this;
-        return t && s.save(e, t), o.save(e, r, i, a);
+        return t && s.save(r, t), a.save(r, e, i, o);
     }
-    getFile(e, r = this.rootDir) {
-        return e.isFile ? e : isString(e) ? r.getFile(e) : r.searchFile(e);
+    getFile(r, e = this.rootDir) {
+        return r.isFile ? r : n(r) ? e.getFile(r) : e.searchFile(r);
     }
-    getDir(e, r = this.rootDir) {
-        return e.isDir ? e : isString(e) ? r.getSubdir(e) : r.searchSubdir(e);
+    getDir(r, e = this.rootDir) {
+        return r.isDir ? r : n(r) ? e.getSubdir(r) : e.searchSubdir(r);
     }
-    getOrCreateFile(e, r = this.rootDir) {
-        return e.isFile ? e : isString(e) ? r.getOrCreateFile(e) : r.searchOrCreateFile(e);
+    getOrCreateFile(r, e = this.rootDir) {
+        return r.isFile ? r : n(r) ? e.getOrCreateFile(r) : e.searchOrCreateFile(r);
     }
-    getOrCreateDir(e, r = this.rootDir) {
-        return e.isDir ? e : isString(e) ? r.getOrCreateSubdir(e) : r.searchOrCreateSubdir(e);
+    getOrCreateDir(r, e = this.rootDir) {
+        return r.isDir ? r : n(r) ? e.getOrCreateSubdir(r) : e.searchOrCreateSubdir(r);
     }
-    getIndexDir(e) {
-        return this.indexRootDir.getSubdir(e.fullPathHash);
+    getIndexDir(r) {
+        return this.indexRootDir.getSubdir(r.fullPathHash);
     }
-    getOrCreateIndexDir(e) {
-        return this.indexRootDir.getOrCreateSubdir(e.fullPathHash);
+    getOrCreateIndexDir(r) {
+        return this.indexRootDir.getOrCreateSubdir(r.fullPathHash);
     }
-    getTriggerFile(e) {
-        return this.triggerRootDir.getFile(e);
+    getTriggerFile(r) {
+        return this.triggerRootDir.getFile(r);
     }
-    getOrCreateTriggerFile(e) {
-        return this.triggerRootDir.getOrCreateFile(e);
+    getOrCreateTriggerFile(r) {
+        return this.triggerRootDir.getOrCreateFile(r);
     }
-    getRpcFile(e) {
-        return this.rpcRootDir.getFile(e);
+    getRpcFile(r) {
+        return this.rpcRootDir.getFile(r);
     }
-    getOrCreateRpcFile(e) {
-        return this.rpcRootDir.getOrCreateFile(e);
+    getOrCreateRpcFile(r) {
+        return this.rpcRootDir.getOrCreateFile(r);
     }
-    insertTriggerToTree(e, r, t, i) {
+    insertTriggerToTree(r, e, t, i) {
         var {
-            rootDir: a,
-            qyDB: o
-        } = this, i = requireFromModCode("trigger", e, i, o);
-        a.triggerNodes[0].insertTrigger(e, r, t, i), updateTriggerNodes(a, r);
+            rootDir: o,
+            qyDB: a
+        } = this, i = h("trigger", r, i, a);
+        o.triggerNodes[0].insertTrigger(r, e, t, i), g(o, e);
     }
-    removeTriggerFromTree(e, r) {
+    removeTriggerFromTree(r, e) {
         var t = this.rootDir;
-        t.triggerNodes[0].removeTrigger(e, r) && updateTriggerNodes(t, r);
+        t.triggerNodes[0].removeTrigger(r, e) && g(t, e);
     }
-    insertRpc(e, r) {
+    insertRpc(r, e) {
         var {
             rpcFunMap: t,
             qyDB: i
-        } = this, r = requireFromModCode("rpc", e, r, i);
-        r && (t[e] = r);
+        } = this, e = h("rpc", r, e, i);
+        e && (t[r] = e);
     }
-    removeRpc(e) {
-        delete this.rpcFunMap[e];
+    removeRpc(r) {
+        delete this.rpcFunMap[r];
     }
-    queryFiles(e, r, t, i, a = this.rootDir) {
-        var o = [], t = (isString(r) && null == t && (t = 1), new QueryCounter(t, i));
-        return this._queryFiles(e, r, o, t, a), o;
+    queryFiles(r, e, t, i, o = this.rootDir) {
+        var a = [], t = (n(e) && null == t && (t = 1), new p(t, i)), i = this.options.queryAutoCreateIndex;
+        return c(r, e, a, t, o, i), a;
     }
-    queryFilesMulti(e, r, t, i = this.rootDir) {
-        var a, o, s = [], g = new QueryCounter(r, t);
-        for ([ a, o ] of e) this._queryFiles(a, o, s, g, i);
+    queryFilesMulti(r, e, t, i = this.rootDir) {
+        var o, a, s = [], g = new p(e, t), n = this.options.queryAutoCreateIndex;
+        for ([ o, a ] of r) c(o, a, s, g, i, n);
         return s;
     }
-    _queryFiles(e, r, t, i, a) {
-        var o;
-        r && (o = this.options.queryAutoCreateIndex, o = o ? getIndexPropPaths(r) : void 0, 
-        parseNamePathAndQuery(e, a, o, r, t, i));
-    }
-    async callRpc(r, e, t) {
-        var i, a = this.rpcFunMap[r];
-        if (!a) return i = `RPC ${r} not implemented.`, logger.warn(i), new Error(i);
+    async callRpc(e, r, t) {
+        var i, o = this.rpcFunMap[e];
+        if (!o) return i = `RPC ${e} not implemented.`, logger.warn(i), new Error(i);
         try {
-            return await a(e, t);
-        } catch (e) {
-            return logger.error(`Calling RPC ${r} failed:`, e), e;
-        }
-    }
-    _preloadFolders(e) {
-        var r, t = e.subdirMap;
-        for (r in t) {
-            var i = t[r];
-            i.created && this._preloadFolders(i);
-        }
-        e._ensureFileMapLoaded();
-    }
-    _initTriggers() {
-        var e, r = this.rootDir;
-        r.triggerNodes = [ new QyTriggerNode() ], this.triggerRootDir = r.searchOrCreateSubdir(TriggerDirPath);
-        for (e of this.triggerRootDir.fileList) {
-            var {
-                name: t,
-                fileContent: i
-            } = e, {
-                fileNamePath: i,
-                propNamePathList: a,
-                modCode: o
-            } = i;
-            this.insertTriggerToTree(t, i, a, o);
-        }
-    }
-    _initRpcs() {
-        this.rpcRootDir = this.rootDir.searchOrCreateSubdir(RpcDirPath);
-        for (var e of this.rpcRootDir.fileList) {
-            var {
-                name: e,
-                fileContent: r
-            } = e;
-            r && (r = r.modCode, r) && this.insertRpc(e, r);
+            return await o(r, t);
+        } catch (r) {
+            return logger.error(`Calling RPC ${e} failed:`, r), r;
         }
     }
-    _loadQyKVData(e, r) {
-        return new QyKVDataLoader(e, r).load();
-    }
 }
 
-Object.assign(module.exports, {
-    QyCache: QyCache
-});
+function c(r, e, t, i, o, a) {
+    e && (a = a ? l(e) : void 0, d(r, o, a, e, t, i));
+}
+
+export {
+    t as QyCache
+};