querysub 0.426.0 → 0.427.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.426.0",
+  "version": "0.427.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/PathRouter.ts

@@ -651,7 +651,7 @@ export class PathRouter {
             // TODO: We could maybe match a partial match. However, even that is suspect. The site being partially broken is almost worse than it being completely broken. We should just get ALL the shards running again...
 
             // NOTE: We *could* actually synchronize it even if it doesn't have a prefix shard as we can fall back to just the full path sharding. However, it becomes very complicated if we want a specific range, and then it becomes complicated if it then switches to prefix hashing (With the nodes that were using the full path hashing slowly going away). AND... key synchronization IS slow, so it's good to discourage it in general. 
-            console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). Path: ${JSON.stringify(path)}`, { path, allSources });
+            console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 2) Don't access the .keys() 3) call addRoutingPrefixForDeploy to add a route/parent route explicitly (as is done in PathFunctionRunner.ts). Path: ${JSON.stringify(path)}`, { path, allSources: allSources.map(x => x.authoritySpec) });
         }
         return { nodes: [] };
     }

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

@@ -369,8 +369,10 @@ class PathWatcher {
 
         // initialTriggers.parentPaths => triggerPaths
         for (let parentPath of initialTriggers.parentPaths) {
-            let valuePaths = authorityStorage.getPathsFromParent(parentPath);
+            // NOTE: We have to trigger all of the values without the hacked path restriction. This should be safe, if a little bit inefficient, because we're still not going to send the values to watchers who aren't watching them. But we need to trigger all of it because it might be the case that we had synchronized 99% of the path and someone was watching 100% of the path and we just finished synchronizing the last 1%. So the parent path trigger that we received only has 1%, but we need to send everything. And it's too complicated to determine exactly what we need to send as in the intersection of all the watchers. So it's easier to just trigger all the value paths and what they're watching will naturally be sent. 
+            let valuePaths = authorityStorage.getPathsFromParent(hack_stripPackedPath(parentPath));
             for (let valuePath of valuePaths || []) {
+                if (!authorityStorage.isSynced(valuePath)) continue;
                 // IMPORTANT! Add all the values to the initial triggers so then later we not only trigger them but know their initial trigger so we can make sure that the is initial trigger logic for each value runs as well. 
                 initialTriggers.values.add(valuePath);
                 triggerPaths.add(valuePath);
@@ -378,7 +380,9 @@ class PathWatcher {
 
             let latestParentWatches = this.parentWatchers.get(hack_stripPackedPath(parentPath));
             if (!latestParentWatches) continue;
-            for (let { watchers } of latestParentWatches.values()) {
+            for (let [packedPath, { watchers }] of latestParentWatches) {
+                // ONLY trigger, if packedPath is fully synchronized
+                if (!authorityStorage.isParentSynced(packedPath)) continue;
                 for (let watcher of watchers) {
                     if (onlyTriggerNodeId && watcher !== onlyTriggerNodeId) continue;
                     let changes = changedPerCallbacks.get(watcher);
@@ -386,7 +390,7 @@ class PathWatcher {
                         changes = { values: new Set(), initialTriggers: { values: new Set(), parentPaths: new Set() } };
                         changedPerCallbacks.set(watcher, changes);
                     }
-                    changes.initialTriggers.parentPaths.add(parentPath);
+                    changes.initialTriggers.parentPaths.add(packedPath);
                 }
             }
         }