querysub 0.344.0 → 0.346.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.344.0",
+  "version": "0.346.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -51,7 +51,7 @@
     "js-sha512": "^0.9.0",
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
-    "socket-function": "^0.152.0",
+    "socket-function": "^0.153.0",
     "terser": "^5.31.0",
     "typesafecss": "^0.23.0",
     "yaml": "^2.5.0",

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1636,6 +1636,7 @@ export class PathValueProxyWatcher {
                     // The calls have to happen after our local writes. This is because they are likely to
                     //  influence the local writes, and we don't want our local writes to be always invalidated
                     call.runAtTime = getNextTime();
+                    call.fromProxy = watcher.debugName;
                     logErrors(runCall(call, metadata));
                     watcher.options.onCallCommit?.(call, metadata);
                 }

package/src/3-path-functions/PathFunctionHelpers.ts

@@ -121,7 +121,7 @@ export function interceptCallsBase<T>(
 }
 interceptCalls.declare(interceptCallsBase);
 
-
+/** Writes the function call allowing interceptors to capture it (vs runCall which just runs it). */
 export function writeFunctionCall(config: {
     domainName: string;
     moduleId: string;

package/src/3-path-functions/PathFunctionRunner.ts

@@ -91,6 +91,9 @@ export interface CallSpec {
     callerIP: string;
     runAtTime: Time;
 
+    // Not just used for debugging, also used to add special proxy-related warnings. 
+    fromProxy?: string;
+
     filterable?: Filterable;
 }
 export function debugCallSpec(spec: CallSpec): string {

package/src/3-path-functions/syncSchema.ts

@@ -48,6 +48,9 @@ export type FunctionMetadata<F = unknown> = {
      */
     delayCommit?: boolean;
 
+    /** By default, we try to finish calls in the start order when using Querysub.commitAsync, unless the caller explicitly says not to. However, if this is set, then we won't have this call finish or cause other calls to be finished in the start order. This makes locking less safe, but can be useful for long-running functions that shouldn't block other functions and which the order doesn't matter. */
+    noFinishInStartOrder?: boolean;
+
     /** Too many locks can lag the server, and eventually cause crashes. Consider using Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. However, if absolutely required, you can override max locks to allow as many locks to be created as you want until the server crashses... */
     maxLocksOverride?: number;
 };
@@ -363,7 +366,7 @@ export function syncSchema<Schema>(schema?: Schema2): SyncSchemaResult<Schema> {
                     moduleId,
                     functionId: name,
                     args,
-                    metadata,
+                    metadata: metadata
                 });
             }, {
                 debug() {

package/src/4-deploy/edgeClientWatcher.tsx

@@ -18,6 +18,8 @@ import { Button } from "../library-components/Button";
 import { updateRootDiscoveryLocation } from "../-f-node-discovery/NodeDiscovery";
 
 const SWITCH_SERVER_TIMEOUT = timeInSecond * 15;
+const MAX_DISPLAY_INTERVAL = timeInMinute * 5;
+const FINAL_DELAY = timeInSecond * 30;
 
 let lastHashServer = "";
 export function startEdgeNotifier() {
@@ -61,113 +63,105 @@ const notifyClients = throttleFunction(timeInMinute, async function notifyClient
 // Track current notification state
 let currentNotification: { close: () => void } | null = null;
 let curHash = "";
+let lastShownTime = 0;
 function onLiveHashChange(liveHash: string, refreshThresholdTime: number) {
     console.log(blue(`Received client liveHash ${liveHash}, prev hash: ${curHash}`));
     if (liveHash === curHash) return;
     let prevHash = curHash;
     // Don't notify the user right away. Hopefully they refresh naturally, and we never have to notify them at all!
     // Also, refresh BEFORE the server dies, not exactly when it is about to die
-    let notifyIntervals = [0.4, 0.75, 0.95];
+    let delays = [0.4, 0.75, 1].map(x => delay(x * refreshThresholdTime));
+
     console.log(blue(`Client liveHash changed ${liveHash}, prev hash: ${prevHash}`));
-    // If we are replacing an already existing notification, don't show immediately
-    let skipFirst = false;
-    if (currentNotification) {
-        currentNotification.close();
-        currentNotification = null;
-        skipFirst = true;
-    }
-    curHash = liveHash;
 
-    let duration = refreshThresholdTime - Date.now();
+    curHash = liveHash;
 
     // Start notification loop
     void (async () => {
         // Show notifications at intervals
-        for (let i = 0; i < notifyIntervals.length - 1; i++) {
+        for (let delayTime of delays) {
+            await delayTime;
             // Don't show if a newer notification is active
             if (curHash !== liveHash) return;
 
-            let waitDuration = (notifyIntervals[i + 1] - notifyIntervals[i]) * duration;
-            // If the duration is short, and it's not the last one, skip it
-            if (i < notifyIntervals.length - 2 && waitDuration <= 30 * 1000) continue;
-
             // Update the URL override for manual refreshes
             if (!liveHash.startsWith("forced")) {
                 Querysub.localCommit(() => {
                     liveHashOverrideURL.value = { liveHash, time: Date.now() };
                 });
             }
-            if (!skipFirst) {
-                if (currentNotification) {
-                    currentNotification.close();
-                    currentNotification = null;
-                }
-                // Show notification modal
-                let nextNotification = {
-                    close: showModal({
-                        onClose: () => {
-                            if (currentNotification !== nextNotification) return;
-                            currentNotification = null;
-                        },
-                        content: (
-                            <div
-                                title={`Live Hash: ${liveHash}, prev hash: ${prevHash}`}
-                                className={
-                                    css.vbox(10).pad(20)
-                                        .hsla(0, 0, 0, 0.8)
-                                        .position("fixed")
-                                        .bottom(10)
-                                        .right(10)
-                                        .zIndex(1000)
-                                    + " keepModalsOpen"
-                                }
-                            >
-                                <div className={css.vbox(10).maxWidth(250)}>
-                                    <h3 className={css.margin(0)}>Server Update Available</h3>
-                                    <div>The server has been updated. Please refresh the page to ensure you don't experience compatibility issues.</div>
-                                    {i !== notifyIntervals.length - 2 && <div>This notification will be shown again at {formatNiceDateTime(Date.now() + waitDuration)}</div>}
-                                    {i === notifyIntervals.length - 2 && <div>The page will automatically refresh at {formatNiceDateTime(Date.now() + waitDuration)}</div>}
-                                </div>
-                                <div className={css.hbox(10).justifyContent("flex-end")}>
-                                    <button
-                                        className={css.pad(8, 16).hsl(200, 50, 50).color("white").pointer}
-                                        onClick={(e) => {
-                                            if (!liveHash.startsWith("forced")) {
-                                                Querysub.localCommit(() => {
-                                                    liveHashOverrideURL.value = { liveHash, time: Date.now() };
-                                                });
-                                            }
-                                            window.location.reload();
-                                        }}
-                                    >
-                                        Refresh Now
-                                    </button>
-                                    <button
-                                        className={css.pad(8, 16).pointer}
-                                        onClick={(e) => {
-                                            if (currentNotification) {
-                                                currentNotification.close();
-                                                currentNotification = null;
-                                            }
-                                        }}
-                                    >
-                                        Dismiss
-                                    </button>
-                                </div>
-                            </div>
-                        )
-                    }).close
-                };
-                currentNotification = nextNotification;
-            }
-            skipFirst = false;
 
-            console.log(red(`Notify again in ${formatTime(waitDuration)}`));
-            await delay(waitDuration);
+            let timeSinceLastShown = Date.now() - lastShownTime;
+            let isLastDelay = delayTime === delays.at(-1);
+            if (timeSinceLastShown < MAX_DISPLAY_INTERVAL && !isLastDelay) continue;
+
+            lastShownTime = Date.now();
+
+            if (currentNotification) {
+                currentNotification.close();
+                currentNotification = null;
+            }
+            // Show notification modal
+            let nextNotification = {
+                close: showModal({
+                    onClose: () => {
+                        if (currentNotification !== nextNotification) return;
+                        currentNotification = null;
+                    },
+                    content: (
+                        <div
+                            title={`Live Hash: ${liveHash}, prev hash: ${prevHash}`}
+                            className={
+                                css.vbox(10).pad(20)
+                                    .hsla(0, 0, 0, 0.8)
+                                    .position("fixed")
+                                    .bottom(10)
+                                    .right(10)
+                                    .zIndex(1000)
+                                + " keepModalsOpen"
+                            }
+                        >
+                            <div className={css.vbox(10).maxWidth(250)}>
+                                <h3 className={css.margin(0)}>Server Update Available</h3>
+                                <div>The server has been updated. Please refresh the page to ensure you don't experience compatibility issues.</div>
+                                {isLastDelay && <div>The page will automatically refresh shortly</div>}
+                            </div>
+                            <div className={css.hbox(10).justifyContent("flex-end")}>
+                                <button
+                                    className={css.pad(8, 16).hsl(200, 50, 50).color("white").pointer}
+                                    onClick={(e) => {
+                                        if (!liveHash.startsWith("forced")) {
+                                            Querysub.localCommit(() => {
+                                                liveHashOverrideURL.value = { liveHash, time: Date.now() };
+                                            });
+                                        }
+                                        window.location.reload();
+                                    }}
+                                >
+                                    Refresh Now
+                                </button>
+                                <button
+                                    className={css.pad(8, 16).pointer}
+                                    onClick={(e) => {
+                                        if (currentNotification) {
+                                            currentNotification.close();
+                                            currentNotification = null;
+                                        }
+                                    }}
+                                >
+                                    Dismiss
+                                </button>
+                            </div>
+                        </div>
+                    )
+                }).close
+            };
+            currentNotification = nextNotification;
         }
 
         // Only force refresh if this is still the current notification
-        if (curHash === liveHash) {
+        if (curHash === liveHash && currentNotification) {
+            await delay(FINAL_DELAY);
             window.location.reload();
         }
     })();

package/src/4-querysub/querysubPrediction.ts

@@ -418,7 +418,7 @@ export function getCallWrites(config: {
 
     let finishInStartOrder: number | boolean | undefined;
 
-    if (config.useFinishReordering) {
+    if (config.useFinishReordering && !config.metadata?.noFinishInStartOrder && call.fromProxy) {
         let triggerCaller = getCurrentCallCreationProxy();
         if (!triggerCaller) {
             require("debugbreak")(2);