querysub 0.15.0 → 0.16.0

package/package.json

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

package/src/1-path-client/pathValueClientWatcher.ts

@@ -318,7 +318,10 @@ export class ClientWatcher {
                     void Promise.resolve().finally(() => { throw e; });
                 }
                 this.activeWatchSpec = undefined;
-                if (Date.now() - time > ClientWatcher.MAX_TRIGGER_TIME) {
+                if (
+                    Date.now() - time > ClientWatcher.MAX_TRIGGER_TIME
+                    && !isDevDebugbreak()
+                ) {
                     stoppedEarly = true;
                     break;
                 }

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -12,7 +12,7 @@ import { getThreadKeyCert } from "../-a-auth/certs";
 import { ActionsHistory } from "../diagnostics/ActionsHistory";
 import { registerResource } from "../diagnostics/trackResources";
 import { ClientWatcher, WatchSpecData, clientWatcher } from "../1-path-client/pathValueClientWatcher";
-import { createPathValueProxy, getProxyPath, isValueProxy, isValueProxy2 } from "./pathValueProxy";
+import { createPathValueProxy, getPathFromProxy, getProxyPath, isValueProxy, isValueProxy2 } from "./pathValueProxy";
 import { authorityStorage, compareTime, ReadLock, epochTime, getNextTime, MAX_ACCEPTED_CHANGE_AGE, PathValue, Time, getCreatorId } from "../0-path-value-core/pathValueCore";
 import { runCodeWithDatabase, rawSchema } from "./pathDatabaseProxyBase";
 import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
@@ -364,6 +364,25 @@ export type PermissionsChecker = {
 
 class SyncWatcherTag { }
 
+function isRecursiveMatch(paths: Set<string>, path: string): boolean {
+    if (paths.size === 0) return false;
+    if (paths.has(path)) return true;
+    for (let otherPath of paths) {
+        if (path.includes(otherPath) || otherPath.includes(path)) {
+            return true;
+        }
+    }
+    return false;
+}
+function removeMatches(paths: Set<string>, path: string): void {
+    paths.delete(path);
+    for (let otherPath of paths) {
+        if (path.includes(otherPath) || otherPath.includes(path)) {
+            paths.delete(otherPath);
+        }
+    }
+}
+
 export class PathValueProxyWatcher {
     public static BREAK_ON_READS = new Set<string>();
     public static BREAK_ON_WRITES = new Set<string>();
@@ -474,7 +493,8 @@ export class PathValueProxyWatcher {
     };
     public getCallback = (pathStr: string, syncParentKeys?: "parentKeys", readTransparent?: "readTransparent"): { value: unknown } | undefined => {
         if (PathValueProxyWatcher.BREAK_ON_READS.size > 0 && proxyWatcher.isAllSynced()) {
-            if (PathValueProxyWatcher.BREAK_ON_READS.has(pathStr)) {
+            if (isRecursiveMatch(PathValueProxyWatcher.BREAK_ON_READS, pathStr)) {
+                const unwatch = () => PathValueProxyWatcher.BREAK_ON_READS.delete(pathStr); unwatch;
                 debugger;
             }
         }
@@ -548,13 +568,15 @@ export class PathValueProxyWatcher {
 
     private setCallback = (pathStr: string, value: unknown, inRecursion = false, allowSpecial = false): void => {
         if (PathValueProxyWatcher.BREAK_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
-            if (PathValueProxyWatcher.BREAK_ON_WRITES.has(pathStr)) {
+            if (isRecursiveMatch(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr)) {
+                let unwatch = () => PathValueProxyWatcher.BREAK_ON_WRITES.delete(pathStr); unwatch;
                 debugger;
             }
         }
 
         if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
-            if (PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.has(pathStr)) {
+            if (isRecursiveMatch(PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES, pathStr)) {
+                let unwatch = () => PathValueProxyWatcher.SET_FUNCTION_WATCH_ON_WRITES.delete(pathStr); unwatch;
                 PathValueProxyWatcher.BREAK_ON_CALL.add(
                     getPathStr2(getCurrentCall().ModuleId, getCurrentCall().FunctionId)
                 );
@@ -562,10 +584,9 @@ export class PathValueProxyWatcher {
         }
 
         if (PathValueProxyWatcher.LOG_WRITES_INCLUDES.size > 0 && proxyWatcher.isAllSynced()) {
-            for (let log of PathValueProxyWatcher.LOG_WRITES_INCLUDES) {
-                if (pathStr.includes(log)) {
-                    console.log(`Write path "${pathStr}" = ${value}`);
-                }
+            if (isRecursiveMatch(PathValueProxyWatcher.LOG_WRITES_INCLUDES, pathStr)) {
+                let unwatch = () => PathValueProxyWatcher.LOG_WRITES_INCLUDES.delete(pathStr); unwatch;
+                console.log(`Write path "${pathStr}" = ${value}`);
             }
         }
         if (value === specialObjectWriteSymbol) {
@@ -1704,6 +1725,23 @@ export class PathValueProxyWatcher {
             watcher.pendingUnsyncedParentAccesses.delete(path);
         }
     }
+
+    public debug_breakOnWrite(proxy: unknown | (() => unknown)) {
+        let path = typeof proxy === "function" ? getProxyPath(proxy as any) : getPathFromProxy(proxy);
+        if (!path) {
+            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
+            return;
+        }
+        PathValueProxyWatcher.BREAK_ON_WRITES.add(path);
+    }
+    public debug_logOnWrite(proxy: unknown | (() => unknown)) {
+        let path = typeof proxy === "function" ? getProxyPath(proxy as any) : getPathFromProxy(proxy);
+        if (!path) {
+            console.error(`Value is not a proxy, and so cannot get path. Either pass a proxy, or a getter for a value.`);
+            return;
+        }
+        PathValueProxyWatcher.LOG_WRITES_INCLUDES.add(path);
+    }
 }
 
 // gitHash => domainName => moduleId => schema
@@ -1729,13 +1767,17 @@ function getBaseMatchingSchema(pathStr: string): {
     schema: Schema2;
     nestedPath: string[];
 } | undefined {
-    let gitHash = getCurrentCallObj()?.fnc.gitRef || "ambient";
+    let schemaForHash = (
+        schemas.get(getCurrentCallObj()?.fnc.gitRef || "ambient")
+        // Default to the ambient schema for clientside calls.
+        || schemas.get("ambient")
+    );
 
     if (_noAtomicSchema) return undefined;
     if (getPathIndex(pathStr, 3) !== "Data") return undefined;
     let domain = getPathIndex(pathStr, 0)!;
     let moduleId = getPathIndex(pathStr, 2)!;
-    let schema = schemas.get(gitHash)?.get(domain)?.get(moduleId);
+    let schema = schemaForHash?.get(domain)?.get(moduleId);
     if (!schema) return undefined;
     let nestedPathStr = getPathSuffix(pathStr, 4);
     let nestedPath = getPathFromStr(nestedPathStr);

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

@@ -174,7 +174,7 @@ export function writeFunctionCall(config: {
     return callSpec;
 }
 
-export function parseArgs(call: CallSpec) {
+export function parseArgs(call: CallSpec): unknown[] {
     return decodeCborx(Buffer.from(call.argsEncoded, "base64"));
 }
 

package/src/4-querysub/Querysub.ts

@@ -177,6 +177,10 @@ export class Querysub {
     public static unwatchCurrentFnc = () => PathValueProxyWatcher.BREAK_ON_CALL.delete(
         getPathStr2(getCurrentCall().ModuleId, getCurrentCall().FunctionId)
     );
+    public static watchWrites = (value: unknown) => proxyWatcher.debug_breakOnWrite(value);
+    public static debugWrites = (value: unknown) => proxyWatcher.debug_breakOnWrite(value);
+    public static breakOnWrite = (value: unknown) => proxyWatcher.debug_breakOnWrite(value);
+    public static logWrites = (value: unknown) => proxyWatcher.debug_logOnWrite(value);
 
     public static watchUnsyncedComponents = () => qreact.watchUnsyncedComponents();
     public static watchAnyUnsyncedComponents = () => qreact.watchUnsyncedComponents().size > 0;
@@ -317,12 +321,6 @@ export class Querysub {
         return isSynced(value);
     }
 
-    public static watchWrites(get: () => unknown) {
-        let path = getProxyPath(get);
-        if (!path) throw new Error(`Failed to get path`);
-        PathValueProxyWatcher.LOG_WRITES_INCLUDES.add(path);
-    }
-
     public static assertDomainAllowed(path: string) {
         let domain = getPathIndexAssert(path, 0);
         if (!Querysub.trustedDomains.has(domain)) {
@@ -875,4 +873,4 @@ setImmediate(() => {
 registerGetCompressNetwork(() => Querysub.COMPRESS_NETWORK);
 registerGetCompressDisk(() => Querysub.COMPRESS_DISK);
 
-(global as any).Querysub = Querysub;
+(globalThis as any).Querysub = Querysub;

package/src/4-querysub/querysubPrediction.ts

@@ -486,7 +486,7 @@ export async function getCallWrites(config: {
             //     throw new Error(`Module not found ${call.DomainName}.${call.ModuleId}`);
             // }
             let moduleObject = domainObject.PathFunctionRunner[call.ModuleId];
-            if (!(call.FunctionId in moduleObject.Sources)) {
+            if (!(call.FunctionId in moduleObject.Sources) && Querysub.isAllSynced()) {
                 throw new Error(`Function not found ${call.DomainName}.${call.ModuleId}.${call.FunctionId}`);
             }
             let functionSpec = atomicObjectRead(moduleObject.Sources[call.FunctionId]);

package/src/config.ts

@@ -39,9 +39,14 @@ export function devDebugbreak() {
     debugbreak(2);
     debugger;
 }
+let debuggedEnabled = false;
 export function isDevDebugbreak() {
-    return yargObj.debugbreak;
+    return yargObj.debugbreak || !isNode() && location.hostname.startsWith("noproxy.") || debuggedEnabled;
 }
+export function enableDebugging() {
+    debuggedEnabled = true;
+}
+(globalThis as any).enableDebugging = enableDebugging;
 
 
 export function authorityRaw() {