querysub 0.167.0 → 0.169.0

package/package.json

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

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1088,69 +1088,71 @@ export class PathValueProxyWatcher {
             try {
                 let rawResult: Result;
                 const handling = watcher.options.nestedCalls;
+                let curFunction = baseFunction;
                 if (handling === "inline") {
-                    rawResult = inlineNestedCalls(() => {
+                    curFunction = () => inlineNestedCalls(baseFunction);
+                }
+                rawResult = interceptCalls({
+                    onCall(call, metadata) {
+                        if (PathValueProxyWatcher.BREAK_ON_CALL.size > 0 && !watcher.hasAnyUnsyncedAccesses()) {
+                            let hash = getPathStr2(call.ModuleId, call.FunctionId);
+                            if (PathValueProxyWatcher.BREAK_ON_CALL.has(hash)) {
+                                const unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_CALL, hash);
+                                debugger;
+                                unwatch;
+                            }
+                        }
+                        if (!watcher.options.canWrite) {
+                            throw new Error(`Cannot call a synced function in a watcher which does not have write permissions. If you want to call a function, you must also have write permissions.`);
+                        }
+                        if (handling === "throw") {
+                            // TODO: Support making inline calls, which is useful as it will check permissions. Although, it can
+                            //  easily be slow, and adds a lot of complexity, so... maybe not... maybe always force the app
+                            //  to do the permissions checks if they want them
+                            throw new Error(`Nested synced function calls are not allowed. Call the function directly, or use Querysub.onCommitFinished to wait for the function to finish.`);
+                        } else if (handling === "after" || handling === undefined) {
+
+                            // We need to wait for predictions to finish, otherwise we run into situations
+                            //  where we call a function which should change a parameter we want to pass
+                            //  to another function, but because the first call didn't predict, the second
+                            //  call gets a different values, causing all kinds of issues.
+                            if (watcher.pendingCalls.length === 0) {
+                                let waitPromise = onAllPredictionsFinished();
+                                if (waitPromise) {
+                                    proxyWatcher.triggerOnPromiseFinish(waitPromise, {
+                                        waitReason: "Waiting for predictions to finish",
+                                    });
+                                }
+                            }
+
+                            watcher.pendingCalls.push({ call, metadata });
+                        } else if (handling === "ignore") {
+                        } else if (handling === "inline") {
+                            throw new Error(`inlineNestedCalls should have prevented this call from being passed to us`);
+                        } else {
+                            let unhandled: never = handling;
+                            throw new Error(`Invalid handling type ${handling}`);
+                        }
+                    },
+                    code() {
                         return authorityStorage.temporaryOverride(options.overrides, () =>
                             runCodeWithDatabase(proxy, baseFunction)
                         );
-                    });
-                } else {
-                    rawResult = interceptCalls({
-                        onCall(call, metadata) {
-                            if (PathValueProxyWatcher.BREAK_ON_CALL.size > 0 && !watcher.hasAnyUnsyncedAccesses()) {
-                                let hash = getPathStr2(call.ModuleId, call.FunctionId);
-                                if (PathValueProxyWatcher.BREAK_ON_CALL.has(hash)) {
-                                    const unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_CALL, hash);
-                                    debugger;
-                                    unwatch;
-                                }
-                            }
-                            if (!watcher.options.canWrite) {
-                                throw new Error(`Cannot call a synced function in a watcher which does not have write permissions. If you want to call a function, you must also have write permissions.`);
-                            }
-                            if (handling === "throw") {
-                                // TODO: Support making inline calls, which is useful as it will check permissions. Although, it can
-                                //  easily be slow, and adds a lot of complexity, so... maybe not... maybe always force the app
-                                //  to do the permissions checks if they want them
-                                throw new Error(`Nested synced function calls are not allowed. Call the function directly, or use Querysub.onCommitFinished to wait for the function to finish.`);
-                            } else if (handling === "after" || handling === undefined) {
-
-                                // We need to wait for predictions to finish, otherwise we run into situations
-                                //  where we call a function which should change a parameter we want to pass
-                                //  to another function, but because the first call didn't predict, the second
-                                //  call gets a different values, causing all kinds of issues.
-                                if (watcher.pendingCalls.length === 0) {
-                                    let waitPromise = onAllPredictionsFinished();
-                                    if (waitPromise) {
-                                        proxyWatcher.triggerOnPromiseFinish(waitPromise, {
-                                            waitReason: "Waiting for predictions to finish",
-                                        });
-                                    }
-                                }
+                    },
+                }) as Result;
 
-                                watcher.pendingCalls.push({ call, metadata });
-                            } else if (handling === "ignore") {
-                            } else {
-                                let unhandled: never = handling;
-                                throw new Error(`Invalid handling type ${handling}`);
-                            }
-                        },
-                        code() {
-                            return authorityStorage.temporaryOverride(options.overrides, () =>
-                                runCodeWithDatabase(proxy, baseFunction)
-                            );
-                        },
-                    }) as Result;
+                // NOTE: Deep clone non-local paths. It's too confusing for a partial object to be returned. Any issues caused by
+                //  this (aka, returning the entire database), would also happen if we manually added deep clones before
+                //  we returned values (and both should be throttled at a framework level so we don't break the database).
+                //  - For local paths there is a risk that there are functions
+                try {
+                    rawResult = deepCloneCborx(rawResult);
+                } catch {
+                    // Unfortunately, cborx throws on functions.
+                    // TODO: Use a recursive clone technique that doesn't throw on functions
+                    rawResult = atomicObjectRead(rawResult);
                 }
 
-                // We use atomic object read, as our callers don't want a proxy.
-                //  If they want to get a full object, they will have to destructure it themselves
-                //  (as for us to destructure it would require further synchronization, which...
-                //  is just annoying, and so we won't implement that unless it becomes very useful).
-                //  (Also, if the result is a proxy is confuses promises into thinking it is another promise,
-                //  which is annoying).
-                rawResult = atomicObjectRead(rawResult);
-
                 result = { result: rawResult };
                 watcher.consecutiveErrors = 0;
             } catch (e: any) {