querysub 0.147.0 → 0.149.0

package/package.json

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

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

@@ -580,8 +580,10 @@ class AuthorityPathValueStorage {
         childPaths.add(path);
     }
 
-    /** Called by PathWatcher / ourself when paths are unwatched / destroyed */
-    public markPathAsUnwatched(path: string) {
+    /** Called by PathWatcher / ourself when paths are unwatched / destroyed, to free memory.
+     *      NOOPS if we are the authority of the path.
+     */
+    public destroyPath(path: string) {
         // If we are the authority we:
         //  1) Need to maintain the values for other nodes
         //  2) Don't need to worry about the values getting out of date,
@@ -1096,7 +1098,7 @@ class AuthorityPathValueStorage {
 
             if (pathsToClear.size > 0) {
                 for (let path of pathsToClear) {
-                    this.markPathAsUnwatched(path);
+                    this.destroyPath(path);
                     // I'm not sure if removing it as a parent is needed, or... maybe it is needed,
                     //  and this isn't enough of a check?
                     this.markParentPathAsUnwatched(path);
@@ -1322,27 +1324,6 @@ class PathWatcher {
 
         let pathsWatched = this.watchersToPaths.get(callback);
 
-        for (let path of config.paths) {
-            if (pathsWatched) {
-                pathsWatched.paths.delete(path);
-            }
-
-            let watchers = this.watchers.get(path);
-            if (!watchers) continue;
-            watchers.watchers.delete(callback);
-            if (watchers.watchers.size === 0) {
-                this.watchers.delete(path);
-
-                let parentPath = getParentPathStr(path);
-                let parentWatchers = this.watcherParentToPath.get(parentPath);
-                if (parentWatchers) {
-                    parentWatchers.delete(path);
-                }
-
-                fullyUnwatched.paths.push(path);
-                authorityStorage.markPathAsUnwatched(path);
-            }
-        }
         for (let path of config.parentPaths) {
             if (pathsWatched) {
                 pathsWatched.parents.delete(path);
@@ -1364,6 +1345,46 @@ class PathWatcher {
 
                 if (watchersObj.size === 0) {
                     this.parentWatchers.delete(unpackedPath);
+
+                    let childPaths = authorityStorage.getPathsFromParent(unpackedPath);
+                    // Destroy values that now have no watchers (no value watchers, and now no parent watcher
+                    if (childPaths) {
+                        for (let childPath of childPaths) {
+                            if (!this.watchers.has(childPath)) {
+                                authorityStorage.destroyPath(childPath);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        // NOTE: Unwatch parents, then values, as parent paths might keep alive value path watches.
+        for (let path of config.paths) {
+            if (pathsWatched) {
+                pathsWatched.paths.delete(path);
+            }
+
+            let watchers = this.watchers.get(path);
+            if (!watchers) continue;
+            watchers.watchers.delete(callback);
+            if (watchers.watchers.size === 0) {
+                this.watchers.delete(path);
+
+                let parentPath = getParentPathStr(path);
+                let parentWatchers = this.watcherParentToPath.get(parentPath);
+                if (parentWatchers) {
+                    parentWatchers.delete(path);
+                }
+
+                fullyUnwatched.paths.push(path);
+                // NOTE: If the parent is being watched, don't destroy the value.
+                //  - The fact that we only do the check here does mean that if the path is unwatched
+                //      first and then later the parent path is unwatched we will fail to properly destroy
+                //      the path. However, in practice, either both are unwatched at the same time, or more
+                //      likely, the value watch only goes away because it's made redundant by the parent watch.
+                if (!this.parentWatchers.has(parentPath)) {
+                    authorityStorage.destroyPath(path);
                 }
             }
         }

package/src/4-deploy/edgeBootstrap.ts

@@ -209,6 +209,8 @@ async function edgeNodeFunction(config: {
         };
     }
 
+    await new Promise(resolve => setTimeout(resolve, 1000 * 10));
+
     let cachedConfig = config.cachedConfig;
 
     let liveHashOverride = "";
@@ -267,8 +269,8 @@ async function edgeNodeFunction(config: {
     async function isNodeAlive(node: EdgeNodeConfig): Promise<boolean> {
         try {
             let abortController = new AbortController();
-            let url = `https://${node.host}?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=[[]]`;
-            let response = await fetch(url, { signal: abortController.signal });
+            let url = `https://${node.host}?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=getModules&args=[[]]&cachebuster=${Date.now()}`;
+            let response = await fetch(url, { signal: abortController.signal, cache: "no-store" });
             // Cancel, so we don't use up all of our sockets (we are limited to 6 per domain in chrome)
             //  on non-responsive servers.
             setTimeout(() => {
@@ -410,11 +412,7 @@ async function edgeNodeFunction(config: {
         let host = edgeNodeConfig.host;
         if (!host.endsWith("/")) host += "/";
         for (let entryPath of edgeNodeConfig.entryPaths) {
-            try {
-                await require("https://" + host + entryPath);
-            } catch (e) {
-                console.error(e);
-            }
+            await require("https://" + host + entryPath);
         }
     }
 }