querysub 0.599.0 → 0.601.0

package/package.json

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

package/src/4-deploy/edgeNodes.ts

@@ -25,6 +25,7 @@ import { getGitRefLive, getGitURLLive } from "./git";
 import { DeployProgress } from "./deployFunctions";
 import { PromiseObj } from "../promise";
 import type { FunctionRunnerIndex } from "../4-querysub/FunctionRunnerTracking";
+import { unique } from "../misc";
 
 const UPDATE_POLL_INTERVAL = timeInMinute * 15;
 const DEAD_NODE_COUNT_THRESHOLD = 15;
@@ -314,7 +315,7 @@ async function updateEdgeNodesFile() {
     }
 
     let edgeNodeFiles = await edgeNodeStorage.find("node", { type: "files" });
-    let edgeNodeNodeIds = edgeNodeFiles.map(getNodeIdFromPath);
+    let edgeNodeNodeIds = unique(edgeNodeFiles.map(getNodeIdFromPath));
 
     let liveHash = "";
     if (!noSyncing()) {

package/src/library-components/SyncedController.ts

@@ -296,11 +296,11 @@ export function getSyncedController<T extends {
                         // We have to wait until we actually commit before making the call. Otherwise, if this commit is rejected because we need to do synchronized values, we'll call the function twice.
                         let fnc = controller.nodes[nodeId][fncName] as any;
                         // NOTE: We can't do on commit finish because we later have a trigger on promise finish for our own promise. And if we don't start the promise call until we finish the commit, And we can't finish the commit until we start the promise call, it'll never finish. So... The best we can do is just check for if everything's synced at this current point. 
-                        if (Querysub.isAllSynced()) {
+                        Querysub.onCommitFinished(() => {
                             void Promise.resolve().then(() => {
                                 doPromiseCall();
                             });
-                        }
+                        });
                         function doPromiseCall() {
                             let promise = fnc(...args) as Promise<unknown>;
                             promiseObjBase.resolve(promise);
@@ -349,11 +349,13 @@ export function getSyncedController<T extends {
                         }
                     }
                     currentPromise = currentPromise || promise?.promise;
-                    if (currentPromise) {
-                        Querysub.triggerOnPromiseFinish(currentPromise, {
-                            waitReason: `Waiting for ${fncName} to finish`,
-                        });
-                    }
+                    // NOTE: We do somewhat want this if it's a function that's called inside of a render function. However, a lot of the time this is called just as a promise function, in which case we don't want to rerun the event handler. 
+                    //  ALSO, We really want to only call the promise on commit finished. Before I thought we could do it if isAll synced, but that doesn't mean we're not going to run again, and we don't want to call the promise function multiple times ever. And if we block here, Then commit finish is blocked so... We can't block committing for synced controller functions. 
+                    // if (currentPromise) {
+                    //     Querysub.triggerOnPromiseFinish(currentPromise, {
+                    //         waitReason: `Waiting for ${fncName} to finish`,
+                    //     });
+                    // }
                     return undefined;
                 }
                 call.promise = (...args: any[]) => {