datafolder 1.0.6 → 1.0.8

package/src/QyCD.js

@@ -4,6 +4,8 @@ import {
 } from "./QyUtils.js";
 
 class r {
+    qyCache;
+    currentDir = void 0;
     constructor(r) {
         this.qyCache = r;
     }
@@ -11,33 +13,42 @@ class r {
         return i(r) && (r = s(r)), this.cdP(r, e);
     }
     cdP(r, e = this.currentDir) {
-        return this.currentDir = this.qyCache.getOrCreateDir(r, e), this;
+        return this.currentDir = this.qyCache?.getOrCreateDir(r, e), this;
     }
     dir(r, e = this.currentDir) {
         return i(r) && (r = s(r)), this.dirP(r, e);
     }
     dirP(r, e = this.currentDir) {
-        return this.qyCache.getDir(r, e);
+        return this.qyCache?.getDir(r, e);
     }
     indexDir(r, e, t = this.currentDir) {
         return i(r) && (r = s(r)), i(e) && (e = s(e)), this.indexDirP(r, e, t);
     }
     indexDirP(r, e, t = this.currentDir) {
-        var i = this.qyCache, r = i.getDir(r, t);
+        var i = this.qyCache, r = i?.getDir(r, t);
         if (r) {
-            t = i.getIndexDir(r);
-            if (t) return e && 0 != e.length ? i.getDir(e, t) : t;
+            t = i?.getIndexDir(r);
+            if (t) return e && 0 != e.length ? i?.getDir(e, t) : t;
         }
     }
     file(r, e = this.currentDir) {
         return i(r) && (r = s(r)), this.fileP(r, e);
     }
     fileP(r, e = this.currentDir) {
-        return this.qyCache.getFile(r, e);
+        return this.qyCache?.getFile(r, e);
     }
     triggerFile(r) {
         return this.qyCache.getTriggerFile(r);
     }
+    get triggerFileList() {
+        return this.qyCache.triggerFileList;
+    }
+    rpcFile(r) {
+        return this.qyCache.getRpcFile(r);
+    }
+    get rpcFileList() {
+        return this.qyCache.rpcFileList;
+    }
     view(r, e, t = this.currentDir) {
         return i(r) && (r = s(r)), this.viewP(r, e, t);
     }
@@ -50,32 +61,32 @@ class r {
     queryFilesMulti(r, e, t, i = this.currentDir) {
         return this.qyCache.queryFilesMulti(r, e, t, i);
     }
-    queryTree(r, e, t, i, s, n = this.currentDir) {
-        return u(this.qyCache.queryFiles(r, e, i, s, n), t);
+    queryTree(r, e, t, i, s, h = this.currentDir) {
+        return n(this.qyCache.queryFiles(r, e, i, s, h), t);
     }
     queryTreeMulti(r, e, t, i, s = this.currentDir) {
-        return u(this.qyCache.queryFilesMulti(r, t, i, s), e);
+        return n(this.qyCache.queryFilesMulti(r, t, i, s), e);
     }
     resetCurrentDir() {
         this.currentDir = void 0;
     }
     fileListToTree(r, e) {
-        return u(r, e);
+        return n(r, e);
     }
 }
 
-function u(r, t) {
+function n(r, t) {
     var i, s = {};
     for (i of r) {
-        var n, u = i.parentList;
+        var h, n = i.parentList;
         let e = s;
-        for (n of u) {
+        for (h of n) {
             var {
-                name: h,
+                name: u,
                 fullPathHash: c
-            } = n;
+            } = h;
             let r = e.subdirMap;
-            r = r || (e.subdirMap = {}), e = (e = r[h]) || (r[h] = {
+            r = r || (e.subdirMap = {}), e = (e = r[u]) || (r[u] = {
                 fullPathHash: c
             });
         }

package/src/QyCache.d.ts

@@ -0,0 +1,44 @@
+import EventEmitter from "node:events";
+import { QyDir } from "./QyDir.ts";
+import { QyFileLogger } from "./QyFileLogger.ts";
+import { QyKVData } from "./QyKVData.ts";
+import type { QyDB } from "./QyDB.ts";
+import type { QyFile } from "./QyFile.ts";
+export declare class QyCache extends EventEmitter {
+    rootFolder: string;
+    options: {};
+    qyDB: QyDB | undefined;
+    kvFolder: string;
+    rpcFolder: string;
+    rootDir: QyDir;
+    indexRootDir: QyDir | undefined;
+    exclusiveFilePath: string;
+    qyKVData: QyKVData;
+    qyFileLogger: QyFileLogger;
+    rpcFunMap: {};
+    constructor(rootFolder: string, options?: {}, qyDB?: QyDB);
+    start(): Promise<this>;
+    stop(): Promise<this>;
+    increaseChangeId(): number;
+    decreaseChangeId(): void;
+    save(changeId: any, cmdArgAsListObj: any, logText: any, syncList: any, needPromise: any): any;
+    getFile(namePath: QyFile | string | string[], parentDir?: QyDir): QyFile | undefined;
+    getDir(namePath: QyDir | string | string[], parentDir?: QyDir): QyDir | undefined;
+    getOrCreateFile(namePath: QyFile | string | string[], parentDir?: QyDir): QyFile;
+    getOrCreateDir(namePath: QyDir | string | string[], parentDir?: QyDir): QyDir;
+    getIndexDir(indexHostDir: QyDir): QyDir | undefined;
+    getOrCreateIndexDir(indexHostDir: any): QyDir | undefined;
+    getTriggerFile(triggerName: any): any;
+    getOrCreateTriggerFile(triggerName: any): any;
+    get triggerFileList(): any;
+    getRpcFile(rpcFunName: any): any;
+    getOrCreateRpcFile(rpcFunName: any): any;
+    get rpcFileList(): any;
+    insertTriggerToTree(triggerName: any, fileNamePath: any, propNamePathList: any, modCode: any): void;
+    removeTriggerFromTree(triggerName: any, fileNamePath: any): void;
+    insertRpc(rpcFunName: any, modCode: any): void;
+    removeRpc(rpcFunName: any): void;
+    queryFiles(indexHostDirNamePath: any, queryObj: any, limit: any, cursor: any, parentDir?: QyDir): never[];
+    queryFilesMulti(indexHostDirNamePathMulti: any, limit: any, cursor: any, parentDir?: QyDir): never[];
+    callRpc(rpcFunName: any, args: any, body: any): Promise<any>;
+}

package/src/QyCache.js

@@ -5,26 +5,26 @@ import {
 import r from "node:events";
 
 import {
-    QyDir as o
+    QyDir as i
 } from "./QyDir.js";
 
 import {
-    QyFileLogger as a
+    QyFileLogger as o
 } from "./QyFileLogger.js";
 
 import {
-    QyKVData as s
+    QyKVData as a
 } from "./QyKVData.js";
 
 import {
     QyTriggerNode as f,
-    updateTriggerNodes as g
+    updateTriggerNodes as s
 } from "./QyTrigger.js";
 
 import {
     isString as C,
     lockExclusiveFilePath as q,
-    unlockExclusiveFilePath as i
+    unlockExclusiveFilePath as g
 } from "./QyUtils.js";
 
 import {
@@ -41,47 +41,53 @@ import {
 } from "./QyDefaultOptions.js";
 
 import {
-    ensureDir as Q,
+    ensureDir as x,
     SpecialFilePaths as e
 } from "./QyUtils.js";
 
 import {
-    QueryCounter as u
+    QueryCounter as h
 } from "./QyUnionNode.js";
 
 import {
-    QyKVDataLoader as S
+    QyKVDataLoader as Q
 } from "./QyKVDataLoader.js";
 
 import {
     requireFromModCode as p
 } from "./QyMod.js";
 
+import {
+    logger as S
+} from "./QyLogger.js";
+
 let {
-    IndexDirPath: x,
-    TriggerDirPath: O,
-    RpcDirPath: P
+    IndexDirPath: P,
+    TriggerDirPath: L,
+    RpcDirPath: O
 } = e;
 
 class t extends r {
+    rootFolder;
+    options;
+    qyDB;
+    kvFolder;
+    rpcFolder;
+    rootDir;
+    indexRootDir = void 0;
+    exclusiveFilePath;
+    qyKVData;
+    qyFileLogger;
+    rpcFunMap = {};
     constructor(r, e, t) {
-        super(), e = {
+        super(), this.options = e = {
             ...d("QyCache"),
             ...e
-        };
-        var i = v(r, "qykv");
-        Object.assign(this, {
-            qyDB: t,
-            rootFolder: r,
-            kvFolder: i,
-            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: {}
-        });
+        }, this.rootFolder = r, this.qyDB = t;
+        t = this.kvFolder = v(r, "qykv");
+        this.rpcFolder = v(r, "rpc"), this.rootDir = new i("", !0, void 0, this), 
+        this.exclusiveFilePath = v(r, ".opened"), this.qyKVData = new a(t, e, this), 
+        this.qyFileLogger = new o(v(r, "qylog"), e);
     }
     async start() {
         var {
@@ -93,16 +99,16 @@ class t extends r {
             exclusiveFilePath: a,
             rootDir: s
         } = this;
-        logger.log(`Starting at ${r}...`);
+        S.log(`Starting at ${r}...`);
         try {
-            await Q(e), o.start();
+            await x(e), o.start();
             var [ {
                 maxChangeId: g,
                 loadedMaxAclNum: n,
                 qySnapshots: l,
                 aclKeyValueMap: d
-            } ] = await Promise.all([ ((r, e) => (r = new S(r, e)).load())(e, t), q(a) ]);
-            await i.start(g, n, l, d);
+            } ] = await Promise.all([ ((r, e) => (r = new Q(r, e)).load())(e, t), q(a) ]);
+            i.start(g, n, l, d);
         } catch (r) {
             throw o.stop(), r;
         }
@@ -112,40 +118,40 @@ class t extends r {
                 fileMap: i
             } = e;
             for (var o of t) r(o);
-        }(s), this.indexRootDir = s.searchOrCreateSubdir(x);
-        var u = this, e = u.rootDir;
-        e.triggerNodes = [ new f() ], u.triggerRootDir = e.searchOrCreateSubdir(O);
-        for (p of u.triggerRootDir.fileList) {
+        }(s), this.indexRootDir = s.searchOrCreateSubdir(P);
+        var h = this, e = h.rootDir;
+        e.triggerNodes = [ new f() ], h.triggerRootDir = e.searchOrCreateSubdir(L);
+        for (p of h.triggerRootDir.fileList) {
             var {
                 name: p,
-                fileContent: h
+                fileContent: u
             } = p, {
-                fileNamePath: h,
+                fileNamePath: u,
                 propNamePathList: c,
                 modCode: D
-            } = h;
-            u.insertTriggerToTree(p, h, c, D);
+            } = u;
+            h.insertTriggerToTree(p, u, c, D);
         }
         var y = this;
-        y.rpcRootDir = y.rootDir.searchOrCreateSubdir(P);
-        for (m of y.rpcRootDir.fileList) {
+        y.rpcRootDir = y.rootDir.searchOrCreateSubdir(O);
+        for (F of y.rpcRootDir.fileList) {
             var {
-                name: m,
-                fileContent: F
-            } = m;
-            C(F) && y.insertRpc(m, F);
+                name: F,
+                fileContent: m
+            } = F;
+            C(m) && y.insertRpc(F, m);
         }
-        return t.dumpStructureAtStart && await R(v(r, "qystruct"), s), logger.log("Started."), 
+        return t.dumpStructureAtStart && await R(v(r, "qystruct"), s), S.log("Started."), 
         this;
     }
     async stop() {
-        logger.log("Stopping...");
+        S.log("Stopping...");
         var {
             qyKVData: r,
             qyFileLogger: e,
             exclusiveFilePath: t
         } = this;
-        return await r.stop(), await e.stop(), i(t), Object.assign(this, {
+        return await r.stop(), await e.stop(), g(t), Object.assign(this, {
             rootDir: void 0,
             indexRootDir: void 0,
             qyKVData: void 0,
@@ -154,7 +160,7 @@ class t extends r {
             qyFileLogger: void 0,
             triggerRootDir: void 0,
             rpcRootDir: void 0
-        }), logger.log("Stopped."), this;
+        }), S.log("Stopped."), this;
     }
     increaseChangeId() {
         return this.qyKVData.increaseChangeId();
@@ -182,10 +188,10 @@ class t extends r {
         return r.isDir ? r : C(r) ? e.getOrCreateSubdir(r) : e.searchOrCreateSubdir(r);
     }
     getIndexDir(r) {
-        return this.indexRootDir.getSubdir(r.fullPathHash);
+        return this.indexRootDir?.getSubdir(r.fullPathHash);
     }
     getOrCreateIndexDir(r) {
-        return this.indexRootDir.getOrCreateSubdir(r.fullPathHash);
+        return this.indexRootDir?.getOrCreateSubdir(r.fullPathHash);
     }
     getTriggerFile(r) {
         return this.triggerRootDir.getFile(r);
@@ -193,22 +199,28 @@ class t extends r {
     getOrCreateTriggerFile(r) {
         return this.triggerRootDir.getOrCreateFile(r);
     }
+    get triggerFileList() {
+        return this.triggerRootDir.fileList;
+    }
     getRpcFile(r) {
         return this.rpcRootDir.getFile(r);
     }
     getOrCreateRpcFile(r) {
         return this.rpcRootDir.getOrCreateFile(r);
     }
+    get rpcFileList() {
+        return this.rpcRootDir.fileList;
+    }
     insertTriggerToTree(r, e, t, i) {
         var {
             rootDir: o,
             qyDB: a
         } = this, i = p("trigger", r, i, a);
-        o.triggerNodes[0].insertTrigger(r, e, t, i), g(o, e);
+        o.triggerNodes[0].insertTrigger(r, e, t, i), s(o, e);
     }
     removeTriggerFromTree(r, e) {
         var t = this.rootDir;
-        t.triggerNodes[0].removeTrigger(r, e) && g(t, e);
+        t.triggerNodes[0].removeTrigger(r, e) && s(t, e);
     }
     insertRpc(r, e) {
         var {
@@ -221,26 +233,26 @@ class t extends r {
         delete this.rpcFunMap[r];
     }
     queryFiles(r, e, t, i, o = this.rootDir) {
-        var a = [], t = (C(e) && !t && (t = 1), new u(t, i)), i = this.options.queryAutoCreateIndex;
-        return h(r, e, a, t, o, i), a;
+        var a = [], t = (C(e) && !t && (t = 1), new h(t, i)), i = this.options.queryAutoCreateIndex;
+        return u(r, e, a, t, o, i), a;
     }
     queryFilesMulti(r, e, t, i = this.rootDir) {
-        var o, a, s = [], g = new u(e, t), n = this.options.queryAutoCreateIndex;
-        for ([ o, a ] of r) h(o, a, s, g, i, n);
+        var o, a, s = [], g = new h(e, t), n = this.options.queryAutoCreateIndex;
+        for ([ o, a ] of r) u(o, a, s, g, i, n);
         return s;
     }
     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);
+        if (!o) return S.warn(i = `RPC ${e} not implemented.`), new Error(i);
         try {
             return await o(r, t);
         } catch (r) {
-            return logger.error(`Calling RPC ${e} failed:`, r), r;
+            return S.error(`Calling RPC ${e} failed:`, r), r;
         }
     }
 }
 
-function h(r, e, t, i, o, a) {
+function u(r, e, t, i, o, a) {
     e && (a = a ? n(e) : void 0, l(r, o, a, e, t, i));
 }
 

package/src/QyCompressor.d.ts

@@ -0,0 +1,9 @@
+export declare const Zip_File_Extension = ".gz";
+export declare function compressFile(srcFilePath: any, destFilePath: any, options: any): any;
+export declare function decompressFile(srcFilePath: any, destFilePath: any, options: any): any;
+export declare function runOperation({ operation, srcFilePath, destFilePath, options }: {
+    operation: any;
+    srcFilePath: any;
+    destFilePath: any;
+    options: any;
+}): Promise<void>;

package/src/QyCompressor.js

@@ -1,5 +1,5 @@
 import {
-    extname as i
+    extname as t
 } from "node:path";
 
 import {
@@ -17,70 +17,70 @@ import {
 
 import {
     createReadStream as n,
-    createWriteStream as p
+    createWriteStream as d
 } from "node:fs";
 
 import m from "node:fs/promises";
 
 import {
-    logger as d
+    logger as p
 } from "./QyLogger.js";
 
 import {
-    isNotNullObj as t,
+    isNotNullObj as i,
     folderOrFileExists as l,
-    ensureParentDir as c
+    ensureParentDir as f
 } from "./QyUtils.js";
 
 import {
-    runOnceWithWorker as f
+    runOnceWithWorker as c
 } from "./QyWorker.js";
 
-let h = r(e), g = ".gz", w = "QyCompressor_Worker.js";
+let g = r(e), o = ".gz", h = "QyCompressor_Worker.ts";
 
-function o(e, r, o) {
-    return t(r) && (o = r, r = void 0), r = r || e + g, o = o || {}, e.endsWith(g) ? (d.log(e + " already ends with .gz."), 
-    !1) : r.endsWith(g) ? f(w, {
+function w(e, r, o) {
+    return i(r) && (o = r, r = void 0), r = r || e + ".gz", o = o || {}, e.endsWith(".gz") ? (p.log(e + " already ends with .gz."), 
+    !1) : r.endsWith(".gz") ? c(h, {
         operation: "compress",
         srcFilePath: e,
         destFilePath: r,
         options: o
-    }).promise : (d.log(r + " doesn't end with .gz."), !1);
+    }).promise : (p.log(r + " doesn't end with .gz."), !1);
 }
 
-function u(e, r, o) {
-    return e.endsWith(g) ? (t(r) && (o = r, r = void 0), r = r || e.replace(new RegExp(g + "$"), ""), 
-    o = o || {}, i(r) == g ? (d.log(r + " already ends with .gz."), !1) : f(w, {
+function z(e, r, o) {
+    return e.endsWith(".gz") ? (i(r) && (o = r, r = void 0), r = r || e.replace(new RegExp(".gz$"), ""), 
+    o = o || {}, ".gz" == t(r) ? (p.log(r + " already ends with .gz."), !1) : c(h, {
         operation: "decompress",
         srcFilePath: e,
         destFilePath: r,
         options: o
-    }).promise) : (d.log(e + " doesn't end with .gz."), !1);
+    }).promise) : (p.log(e + " doesn't end with .gz."), !1);
 }
 
-async function F({
+async function u({
     operation: e,
     srcFilePath: r,
     destFilePath: o,
-    options: i
+    options: t
 }) {
     var {
-        removeSrcAfterSuccess: i,
-        override: t
-    } = i;
+        removeSrcAfterSuccess: t,
+        override: i
+    } = t;
     if (!await l(r)) throw new Error(r + " doesn't exist.");
-    if (!t && await l(o)) throw new Error(o + " already exists.");
-    if (await c(o), await h(n(r), ("compress" == e ? s : a)(), p(o)), d.info(e + `ed ${r} to ${o}.`), 
-    i) try {
-        await m.unlink(r), d.info("Unlinked " + r);
+    if (!i && await l(o)) throw new Error(o + " already exists.");
+    if (await f(o), await g(n(r), ("compress" == e ? s : a)(), d(o)), p.info(e + `ed ${r} to ${o}.`), 
+    t) try {
+        await m.unlink(r), p.info("Unlinked " + r);
     } catch (e) {
-        d.error(`Failed to unlink ${r}:`, e);
+        p.error(`Failed to unlink ${r}:`, e);
     }
 }
 
 export {
-    g as Zip_File_Extension,
-    o as compressFile,
-    u as decompressFile,
-    F as runOperation
+    o as Zip_File_Extension,
+    w as compressFile,
+    z as decompressFile,
+    u as runOperation
 };

package/src/QyCompressor_Worker.d.ts

@@ -0,0 +1 @@
+export {};

package/src/QyDB.d.ts

@@ -0,0 +1,42 @@
+import { QyFetch } from "./QyFetch.ts";
+import { QyBatch } from "./QyBatch.ts";
+import { QyCache } from "./QyCache.ts";
+import { QyCD } from "./QyCD.ts";
+import type { QyDir } from "./QyDir.ts";
+import type { QyFile } from "./QyFile.ts";
+export declare class QyDB extends QyCD {
+    rootFolder: string;
+    options: {};
+    fetch: QyFetch;
+    batch: QyBatch;
+    _immediate: QyBatch;
+    constructor(rootFolder?: string, options?: {});
+    start(options?: {}): Promise<this>;
+    stop(): Promise<void>;
+    createDir(namePath: string | string[]): QyDir;
+    createDirP(namePath: string | string[]): QyDir;
+    createFile(namePath: string | string[]): QyFile;
+    createFileP(namePath: string | string[]): QyFile;
+    createIndex(indexHostDirNamePath: string | string[] | QyDir, indexPropPathList: string[][]): any;
+    createIndexP(indexHostDirNamePath: string | string[] | QyDir, indexPropPathList: string[][]): any;
+    delIndex(indexHostDirNamePath: string | string[] | QyDir, indexPropPath: string | string[]): any;
+    delIndexP(indexHostDirNamePath: any, indexPropPath: any): any;
+    insert(namePath: any, content: any): any;
+    insertP(namePath: any, content: any): any;
+    remove(namePath: any, content: any): any;
+    removeP(namePath: any, content: any): any;
+    replace(namePath: any, content: any): any;
+    replaceP(namePath: any, content: any): any;
+    delDir(namePath: any): any;
+    delDirP(namePath: any): any;
+    delFile(namePath: any): any;
+    delFileP(namePath: any): any;
+    delContent(namePath: any): any;
+    delContentP(namePath: any): any;
+    insertTrigger(triggerName: any, fileNamePath: any, propNamePathList: any, modCode: any): any;
+    removeTrigger(triggerName: any): any;
+    insertRpc(rpcFunName: any, modCode: any): any;
+    removeRpc(rpcFunName: any): any;
+    on(eventName: any, listener: any): QyCache | undefined;
+    callRpc(rpcFunName: any, args: any, body: any): Promise<any> | undefined;
+}

package/src/QyDB.js

@@ -30,14 +30,16 @@ import {
 let d = e(m, "../data/sampleDataFolder");
 
 class h extends t {
+    rootFolder;
+    options;
+    fetch;
+    batch;
+    _immediate;
     constructor(e = d, t) {
-        s(e) && (t = e, e = d), super(), Object.assign(this, {
-            rootFolder: e,
-            options: {
-                ...a("QyDB"),
-                ...t
-            }
-        });
+        s(e) && (t = e, e = d), super(), this.options = {
+            ...a("QyDB"),
+            ...t
+        }, this.rootFolder = e;
     }
     async start(e) {
         var t;
@@ -58,8 +60,8 @@ class h extends t {
             batch: r,
             _immediate: i
         } = this;
-        e && (await e.stop(), t.qyCache = void 0, r.qyCache = void 0, i.qyCache = void 0, 
-        Object.assign(this, {
+        e && (await e.stop(), t && (t.qyCache = void 0), r && (r.qyCache = void 0), 
+        i && (i.qyCache = void 0), Object.assign(this, {
             qyCache: void 0,
             fetch: void 0,
             batch: void 0,
@@ -139,10 +141,10 @@ class h extends t {
         return this._immediate.removeRpc(e).run();
     }
     on(e, t) {
-        return this.qyCache.on(e, t);
+        return this.qyCache?.on(e, t);
     }
     callRpc(e, t, r) {
-        return this.qyCache.callRpc(e, t, r);
+        return this.qyCache?.callRpc(e, t, r);
     }
 }
 

package/src/QyDefaultOptions.d.ts

@@ -0,0 +1 @@
+export declare function getDefaultOptions(className: any): any;

package/src/QyDefaultOptions.js

@@ -51,6 +51,9 @@ let t = {
     },
     QySnapshotSaver_Worker: {
         maxInMemSnapshotCount: 3
+    },
+    QyKVDataSaver_Worker: {
+        noAcl: !1
     }
 };