querysub 0.41.0 → 0.42.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "querysub",
-    "version": "0.41.0",
+    "version": "0.42.0",
     "main": "index.js",
     "license": "MIT",
     "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/diagnostics/logs/BrowserLargeFileCache.ts

@@ -0,0 +1,64 @@
+import { SocketFunctionClientHook } from "socket-function/SocketFunctionTypes";
+import { cache, lazy } from "socket-function/src/caching";
+import { decodeCborx, encodeCborx } from "../../misc/cloneHelpers";
+import { sha256 } from "js-sha256";
+import { errorToUndefined } from "../../errors";
+import { isNode } from "typesafecss";
+
+let getRootDirectory = lazy(async () => {
+    await navigator.storage.persist();
+    return navigator.storage.getDirectory();
+});
+
+export const getBrowserLargeFileCache = cache((name: string) => new BrowserLargeFileCache(name));
+
+export class BrowserLargeFileCache {
+    constructor(private name: string) { }
+
+    private getDir = lazy(async () => {
+        let root = await getRootDirectory();
+        return await root.getDirectoryHandle(this.name, { create: true });
+    });
+
+    public async set(key: string, value: Buffer) {
+        let dir = await this.getDir();
+        let file = await dir.getFileHandle(key, { create: true });
+        let writable = await file.createWritable();
+        await writable.write(value);
+        await writable.close();
+    }
+    public async get(key: string): Promise<Buffer | undefined> {
+        let dir = await this.getDir();
+        try {
+            let file = await dir.getFileHandle(key, { create: false });
+            let readable = await file.getFile();
+            return Buffer.from(await readable.arrayBuffer());
+        } catch {
+            return undefined;
+        }
+    }
+}
+
+/** Cache key = [args, functionName, classGuid]
+ *      - Not nodeId, as that change so frequently, so caching based on server is not usually useful.
+ *          - If you want to cache based on nodeId, pass it as an unused arg.
+ * 
+ *  Uses a file per key, and never cleans them up. So... basically, this sucks, but, it should
+ *      work for a few specific functions with large and consistent values.
+ */
+export const cacheCalls: SocketFunctionClientHook = async config => {
+    if (isNode()) return;
+
+    let { args, functionName, classGuid } = config.call;
+    let bucket = sha256(JSON.stringify({ functionName, classGuid }));
+    let cache = getBrowserLargeFileCache(bucket);
+    let key = sha256(encodeCborx(args));
+    let cachedValue = await cache.get(key);
+    if (cachedValue) {
+        config.overrideResult = decodeCborx(cachedValue);
+        return;
+    }
+    config.onResult.push(async (result) => {
+        await errorToUndefined(cache.set(key, encodeCborx(result)));
+    });
+};

package/src/diagnostics/logs/DiskLoggerPage.tsx

@@ -10,7 +10,7 @@ import { getSyncedController } from "../../library-components/SyncedController";
 import { getBrowserUrlNode } from "../../-f-node-discovery/NodeDiscovery";
 import { formatDateTime, formatNiceDateTime, formatNumber, formatTime } from "socket-function/src/formatting/format";
 import { Anchor } from "../../library-components/ATag";
-import { cache, cacheLimited, cacheShallowConfigArgEqual } from "socket-function/src/caching";
+import { cache, cacheLimited, cacheShallowConfigArgEqual, lazy } from "socket-function/src/caching";
 import { InputLabel, InputLabelURL } from "../../library-components/InputLabel";
 import { DropdownSelector } from "../../library-components/DropdownSelector";
 import { Table, TableType } from "../../5-diagnostics/Table";
@@ -30,6 +30,7 @@ import { getNodeIdLocation } from "socket-function/src/nodeCache";
 import { decodeNodeId, encodeNodeId, getMachineId } from "../../-a-auth/certs";
 import { Button } from "../../library-components/Button";
 import { TimeRangeSelector } from "../../library-components/TimeRangeSelector";
+import { BrowserLargeFileCache, cacheCalls } from "./BrowserLargeFileCache";
 
 // TODO: Realtime log mode, by reading from the previous length forward, to add buffers
 //  to what we already read.
@@ -550,10 +551,15 @@ export const DiskLoggerController = SocketFunction.register(
     new DiskLoggerControllerBase(),
     () => ({
         getRemoteLogFiles: {},
-        getRemoteLogBuffer: {},
+        getRemoteLogBuffer: {
+            compress: true,
+            clientHooks: [cacheCalls]
+        },
 
         getLogFiles: {},
-        getLogBuffer: {},
+        getLogBuffer: {
+            compress: true,
+        },
     }),
     () => ({
         hooks: [assertIsManagementUser],