querysub 0.167.0 → 0.168.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.167.0",
+  "version": "0.168.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,68 +1088,63 @@ export class PathValueProxyWatcher {
             try {
                 let rawResult: Result;
                 const handling = watcher.options.nestedCalls;
+                let curFunction = baseFunction;
                 if (handling === "inline") {
-                    rawResult = inlineNestedCalls(() => {
-                        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.`);
+                    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 (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",
-                                        });
-                                    }
+                        }
+                        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 {
-                                let unhandled: never = handling;
-                                throw new Error(`Invalid handling type ${handling}`);
                             }
-                        },
-                        code() {
-                            return authorityStorage.temporaryOverride(options.overrides, () =>
-                                runCodeWithDatabase(proxy, baseFunction)
-                            );
-                        },
-                    }) as Result;
-                }
 
-                // 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);
+                            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)
+                        );
+                    },
+                }) as Result;
+
+                // NOTE: Always deep clone. 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).
+                rawResult = deepCloneCborx(rawResult);
 
                 result = { result: rawResult };
                 watcher.consecutiveErrors = 0;