datafolder 1.0.7 → 1.0.9

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);
@@ -210,11 +216,11 @@ class t extends r {
             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 {
@@ -227,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
     }
 };
 

package/src/QyDir.d.ts

@@ -0,0 +1,48 @@
+import { QyItem } from "./QyItem.ts";
+import { QyFile } from "./QyFile.ts";
+import type { QyCache } from "./QyCache.ts";
+export declare class QyDir extends QyItem {
+    _subdirCount: number;
+    _fileCount: number;
+    subdirMapChangeCount: number;
+    fileMapChangeCount: number;
+    dChangeId: number;
+    fChangeId: number;
+    cache: {};
+    constructor(name: string | number, created?: boolean, parentDir?: QyDir | undefined, qyCache?: QyCache | undefined);
+    get created(): boolean;
+    set created(val: boolean);
+    get fileCount(): number;
+    get subdirCount(): number;
+    get isDir(): boolean;
+    get isEmpty(): boolean;
+    get isHiddenFolder(): boolean;
+    get subdirMapKey(): string;
+    get fileMapKey(): string;
+    get subdirMap(): {};
+    get fileMap(): {};
+    getSubdir(name: string): QyDir | undefined;
+    getFile(fileName: string): QyFile | undefined;
+    getOrCreateSubdir(name: string, created?: boolean): QyDir;
+    getOrCreateFile(fileName: string, created?: boolean): QyFile;
+    searchSubdir(namePath: string[], endIdx?: number): QyDir | undefined;
+    searchOrCreateSubdir(namePath: string[], created?: boolean, endIdx?: number): QyDir;
+    searchFile(namePath: string[]): QyFile | undefined;
+    searchOrCreateFile(namePath: string[], created?: boolean): QyFile;
+    get subdirList(): QyDir[];
+    get subdirNameList(): string[];
+    get sortedSubdirList(): QyDir[];
+    get sortedSubdirNameList(): string[];
+    get fileList(): QyFile[];
+    get fileNameList(): string[];
+    get sortedFileList(): QyFile[];
+    get sortedFileNameList(): string[];
+    allSubdirs(): any;
+    allLeafSubdirs(): Generator<any, void, unknown>;
+    allFiles(): Generator<any, void, unknown>;
+    allLoadedSubdirs(): any;
+    setChildTriggerNodes(child: QyDir): void;
+    filterSubdirNames(filterFun: any): Generator<QyDir, void, unknown>;
+    compareSubdirRangeL2H(cmpFun: any): Generator<QyDir, void, unknown>;
+    compareSubdirRangeH2L(cmpFun: any): Generator<QyDir | undefined, void, unknown>;
+}