querysub 0.12.0 → 0.13.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "querysub",
-    "version": "0.12.0",
+    "version": "0.13.0",
     "main": "index.js",
     "license": "MIT",
     "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -15,7 +15,7 @@
         "@types/pako": "^2.0.3",
         "@types/yargs": "^15.0.5",
         "acme-client": "^5.0.0",
-        "cbor-x": "^1.5.6",
+        "cbor-x": "^1.6.0",
         "chalk": "^5.2.0",
         "diskusage": "^1.2.0",
         "fs-ext": "^2.0.0",

package/src/0-path-value-core/PathValueCommitter.ts

@@ -55,6 +55,7 @@ class PathValueCommitter {
     // Returns true if all the writes are accepted by some node (this should almost always be the case)
     public commitValues(values: PathValue[], predictWrites: "predictWrites" | undefined): void {
         if (values.length === 0) return;
+
         ActionsHistory.OnWrite(values);
 
         let now = Date.now();

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -31,6 +31,7 @@ import type { FunctionMetadata } from "../3-path-functions/syncSchema";
 import { DEPTH_TO_DATA, MODULE_INDEX, getCurrentCall, getCurrentCallObj } from "../3-path-functions/PathFunctionRunner";
 import { inlineNestedCalls } from "../3-path-functions/syncSchema";
 import { interceptCalls, runCall } from "../3-path-functions/PathFunctionHelpers";
+import { deepCloneCborx } from "../misc/cloneHelpers";
 
 // TODO: Break this into two parts:
 //  1) Run and get accesses
@@ -596,6 +597,15 @@ export class PathValueProxyWatcher {
             throw new Error(`Tried to write a non-local path in a "noLocks" watcher, ${watcher.debugName}, path ${pathStr}`);
         }
 
+        if (!pathStr.startsWith(LOCAL_DOMAIN_PATH)) {
+            // Copy the value, to ensure any proxy values aren't attempted to be written
+            //      to the database. A bit slower, but... it should be fine. We COULD do this
+            //      later on, but this makes it easier to attribute lag and errors to the original source.
+            //  - If we had a proxy, we WOULD copy it eventually, but we would copy it later,
+            //      which would cause an error, because the reader wouldn't be trackable.
+            value = deepCloneCborx(value);
+        }
+
         if (watcher.permissionsChecker) {
             if (!watcher.permissionsChecker.checkPermissions(pathStr).allowed) {
                 if (value !== specialObjectWriteValue) {

package/src/3-path-functions/PathFunctionHelpers.ts

@@ -13,6 +13,7 @@ import { isDefined } from "../misc";
 import { blue, green, red } from "socket-function/src/formatting/logColors";
 import { getPathStr2 } from "../path";
 import { sort } from "socket-function/src/misc";
+import { decodeCborx, encodeCborx } from "../misc/cloneHelpers";
 const cborxInstance = lazy(() => new cborx.Encoder({ structuredClone: true }));
 
 
@@ -174,15 +175,9 @@ export function writeFunctionCall(config: {
 }
 
 export function parseArgs(call: CallSpec) {
-    return cborxInstance().decode(Buffer.from(call.argsEncoded, "base64"));
+    return decodeCborx(Buffer.from(call.argsEncoded, "base64"));
 }
 
 export function encodeArgs(args: unknown[]) {
-    // NOTE: This will throw if we try to encode a function. This is probably okay.
-    //  - We use this to prevent accidentally encoding VirtualDOM to the database / objects
-    //      with functions.
-    //  - If this becomes an issue, we might catch the error, and strip functions if we
-    //      have found them.
-    //      - Or... is there are a way to tell cborx to strip the functions?
-    return cborxInstance().encode(args).toString("base64");
+    return encodeCborx(args).toString("base64");
 }

package/src/misc/cloneHelpers.ts

@@ -0,0 +1,16 @@
+import cborx from "cbor-x";
+import { lazy } from "socket-function/src/caching";
+const cborxInstance = lazy(() => new cborx.Encoder({ structuredClone: true }));
+export function deepCloneCborx<T>(value: T): T {
+    return decodeCborx(encodeCborx(value));
+}
+
+
+export function encodeCborx<T>(value: T): Buffer {
+    // We need to iterate on it, expanding keys, etc
+    return cborxInstance().encode(value);
+}
+
+export function decodeCborx<T>(value: Buffer): T {
+    return cborxInstance().decode(value);
+}