querysub 0.147.0 → 0.148.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.147.0",
+  "version": "0.148.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);
                 }
             }
         }