querysub 0.481.0 → 0.482.0

package/package.json

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

package/src/-a-archives/archivesBackBlaze.ts

@@ -542,8 +542,9 @@ export class ArchivesBackblaze {
                     || err.stack.includes(`"internal_error"`)
                     || err.stack.includes(`ENOBUFS`)
                 ) && Date.now() - this.last503Reset > 60 * 1000) {
-                console.error(`[${context}] 503 error, waiting and resetting: ${err.message}`);
-                this.log(`[${context}] 503 error, waiting and resetting: ${err.message}`);
+                // Backblades is so flaky that we're just going to warn here. 
+                console.warn(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);
+                this.log(`[${context}] Backblaze error, waiting and resetting: ${err.message}`);
                 this.currentReset = this.currentReset || (async () => {
                     await delay(10 * 1000);
                     // We check again in case, and in the very likely case that this is being run in parallel, we only want to reset once.
@@ -579,7 +580,7 @@ export class ArchivesBackblaze {
                 || err.stack.includes(`ECONNREFUSED`)
                 || err.stack.includes(`ENOBUFS`)
             ) {
-                console.error(`[${context}] Retrying in 5s: ${err.message}`);
+                console.warn(`[${context}] Retrying in 5s: ${err.message}`);
                 this.log(`[${context}] ${err.message} retrying in 5s`);
                 await delay(5000);
                 return this.apiRetryLogic(context, fnc, retries - 1);

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

@@ -672,10 +672,9 @@ export class PathRouter {
 
 
         if (!config?.onlyOwnNodes) {
-            // 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: allSources.map(x => x.authoritySpec) });
+            console.error(`Want to sync a prefix which is not under an existing prefix, nor equal to a prefix. 1) The servers are down. 1.5) The servers are in an inconsistent state (one shard range added a parent path, the other didn't). 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/ValidStateComputer.ts

@@ -390,6 +390,20 @@ class ValidStateComputer {
 
             for (let pathValue of valueGroup) {
                 let prevValidState = prevValidStates.get(pathValue);
+                if (valid && prevValidState === false) {
+                    console.info(`Accepting value that was previously rejected`, {
+                        path: pathValue.path,
+                        timeId: pathValue.time.time,
+                        timeIdFull: pathValue.time,
+                    });
+                }
+                if (valid === false && prevValidState === false) {
+                    console.info(`Valid still rejected after re-evaluation`, {
+                        path: pathValue.path,
+                        timeId: pathValue.time.time,
+                        timeIdFull: pathValue.time,
+                    });
+                }
 
                 // IMPORTANT! This means if it didn't previously exist and it's presently rejected, we count that as a change, as it this is going from undefined to false. This is actually very useful, as a lot of places want to know if a write is rejected, so they can display it in the UI for the developer.
                 if (valid === prevValidState) continue;

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -715,12 +715,12 @@ export class PathValueProxyWatcher {
     // We exclude undefined, BUT, we include "null", etc.
     //  - This differs from javascript, but... due to how deletions work, we can't/don't differentiate between
     //      a deleted value and undefined, and a lot of things break if deleting a value doesn't remove it from an "in" check!
-    private hasCallback = (pathStr: string): boolean => {
+    public hasCallback = (pathStr: string): boolean => {
         let value = this.getCallback(pathStr, undefined, "readTransparent");
         return value?.value !== undefined;
     };
 
-    private setCallback = (pathStr: string, value: unknown, inRecursion = false, allowSpecial = false): void => {
+    public setCallback = (pathStr: string, value: unknown, inRecursion = false, allowSpecial = false): void => {
         if (PathValueProxyWatcher.BREAK_ON_WRITES.size > 0 && proxyWatcher.isAllSynced()) {
             if (isRecursiveMatch(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr)) {
                 let unwatch = () => removeMatches(PathValueProxyWatcher.BREAK_ON_WRITES, pathStr);

package/src/2-proxy/garbageCollection.ts

@@ -67,6 +67,7 @@ let aliveCheckers: AliveChecker<any>[] = [];
  *      AND, when nodes haven't auditted the disk, they might be in a different state. So... it should only
  *      be used for values users can't access anymore, and so that won't be noticed when they disappear.
  */
+export const configGarbageCollection = registerAliveChecker;
 export function registerAliveChecker<T>(config: AliveChecker<T>) {
     if (config.lock) {
         config.lockBasedDelete = true;

package/src/4-dom/qreact.tsx

@@ -2673,7 +2673,7 @@ function watchUnsyncedComponents(): Set<ExternalRenderClass> {
     return unsyncedComponents;
 }
 function componentRendered(component: QRenderClass) {
-    if (component.disposed || Querysub.isAllSynced()) {
+    if (component.disposed || Querysub.isAllSynced({ ignoreAlwaysCommitAllRunsFlag: true })) {
         if (unsyncedComponents.has(component)) {
             unsyncedComponents.delete(component);
             triggerUnsyncedNow();

package/src/4-querysub/Querysub.ts

@@ -415,8 +415,8 @@ export class Querysub {
     public static anyUnsynced() {
         return !Querysub.allSynced();
     }
-    public static allSynced() {
-        return proxyWatcher.isAllSynced();
+    public static allSynced(config?: { ignoreAlwaysCommitAllRunsFlag?: boolean }) {
+        return proxyWatcher.isAllSynced(config);
     }
     public static fullySynced = Querysub.allSynced;
     public static isFullySynced = Querysub.allSynced;

package/src/library-components/loadingIndicator.tsx

@@ -32,7 +32,7 @@ export class UnsyncedIndicator extends qreact.Component {
                         css.vbox(10).pad(20)
                             .hsla(0, 0, 0, 0.8)
                             .position("fixed")
-                            .bottom(10)
+                            .left(10)
                             .right(10)
                             .zIndex(1000)
                     }
@@ -58,7 +58,7 @@ export class UnsyncedIndicator extends qreact.Component {
         return <div
             class={
                 css
-                    .position("fixed").bottom(0).right(0)
+                    .position("fixed").bottom(0).left(0)
                     .background("hsl(0, 0%, 10%)").color("hsl(0, 0%, 80%)")
                     .fontSize(12).zIndex(1000)
                     .borderRadius(100)