querysub 0.324.0 → 0.326.0

package/src/functional/SocketChannel.ts

@@ -4,6 +4,8 @@ import { getAllNodeIds, watchNodeIds } from "../-f-node-discovery/NodeDiscovery"
 import { requiresNetworkTrustHook } from "../-d-trust/NetworkTrust2";
 import { errorToUndefinedSilent } from "../errors";
 import { assertIsManagementUser } from "../diagnostics/managementPages";
+import { IdentityController_getCurrentReconnectNodeId, IdentityController_getMachineId } from "../-c-identity/IdentityController";
+import { blue } from "socket-function/src/formatting/logColors";
 
 export class SocketChannel<T> {
     constructor(private globalUniqueChannelName: string) { }
@@ -34,7 +36,9 @@ export class SocketChannel<T> {
     private remoteWatchers = new Set<string>();
     public async _internal_watchMessages() {
         let caller = SocketFunction.getCaller();
+        let callerNodeId = IdentityController_getCurrentReconnectNodeId();
         this.remoteWatchers.add(caller.nodeId);
+        console.info(blue(`New watcher for channel ${this.globalUniqueChannelName} from ${caller.nodeId} (${callerNodeId})`));
         SocketFunction.onNextDisconnect(caller.nodeId, () => {
             this.remoteWatchers.delete(caller.nodeId);
         });
@@ -44,7 +48,7 @@ export class SocketChannel<T> {
         void Array.from(this.remoteWatchers).map(async (nodeId) => {
             try {
                 await this.controller.nodes[nodeId]._internal_onMessage(message);
-            } catch {
+            } catch (e) {
                 this.remoteWatchers.delete(nodeId);
             }
         });

package/src/library-components/ATag.tsx

@@ -2,6 +2,7 @@ import preact from "preact";
 import { css, isNode } from "typesafecss";
 import { URLParam, parseSearchString, encodeSearchString } from "./URLParam";
 import { qreact } from "../4-dom/qreact";
+import { niceStringify } from "../niceStringify";
 
 export type URLOverride<T = unknown> = {
     param: URLParam<T>;

package/src/library-components/SyncedController.ts

@@ -40,11 +40,11 @@ onHotReload(() => {
 export function syncedIsAnyLoading() {
     return Querysub.fastRead(() => {
         for (let controllerId in syncedData()) {
-            for (let fncs of Object.values(syncedData()[controllerId])) {
-                for (let fnc of Object.values(fncs)) {
+            for (let [nodeId, fncs] of Object.entries(syncedData()[controllerId])) {
+                for (let [fncName, fnc] of Object.entries(fncs)) {
                     for (let obj of Object.values(fnc)) {
                         if (atomic(obj.promise)) {
-                            return true;
+                            return `${fncName} (on ${nodeId})`;
                         }
                     }
                 }
@@ -109,6 +109,7 @@ export function getSyncedController<T extends SocketRegistered>(
     resetAll(): void;
     refreshAll(): void;
     isAnyLoading(): boolean;
+    base: T;
 } {
     if (isNode()) {
         let result = cache((nodeId: string) => {
@@ -160,6 +161,7 @@ export function getSyncedController<T extends SocketRegistered>(
         result.isAnyLoading = () => {
             notAllowedOnServer();
         };
+        result.base = controller;
         return result;
     }
     let id = nextId();
@@ -307,11 +309,19 @@ export function getSyncedController<T extends SocketRegistered>(
                         obj.promise = undefined;
                         obj.invalidated = true;
                         call(...args);
+                        // Assign to itself, to preset the type assumptions typescript makes (otherwise we get an error below)
+                        obj = obj as any;
                         let promise = atomic(obj.promise);
                         if (!promise) {
                             debugger;
                             throw new Error(`Impossible, called function, but promise is not found for ${fncName}`);
                         }
+                        // Don't cache promise calls
+                        void promise.finally(() => {
+                            if (obj.promise === promise) {
+                                obj.promise = undefined;
+                            }
+                        });
                         return promise;
                     });
                 };
@@ -404,5 +414,6 @@ export function getSyncedController<T extends SocketRegistered>(
             }
         });
     };
+    result.base = controller;
     return result;
 }

package/src/library-components/SyncedControllerLoadingIndicator.tsx

@@ -7,7 +7,8 @@ export class SyncedControllerLoadingIndicator extends qreact.Component {
     timeLastLoaded = Date.now();
     lastWasLoaded = false;
     render() {
-        if (!syncedIsAnyLoading()) {
+        let loadingPath = syncedIsAnyLoading();
+        if (!loadingPath) {
             if (!this.lastWasLoaded) {
                 console.log(`Loaded all SyncedController calls in ${formatTime(Date.now() - this.timeLastLoaded)}`);
             }
@@ -33,7 +34,7 @@ export class SyncedControllerLoadingIndicator extends qreact.Component {
                     .borderRadius("50%")
                 + " " + spinAnimationClass
             }></div>
-            <span>Syncing data...</span>
+            <span title={loadingPath}>Syncing data...</span>
             <style>
                 {`
                     @keyframes ${spinAnimationClass} {

package/src/library-components/URLParam.ts

@@ -34,16 +34,37 @@ if (!isNode()) {
     loadSearchCache = parseSearchString(location.search);
 }
 
+declare global {
+    var urlResetLinks: Map<string, Set<string>>;
+}
+// changed => reset
+let resetLinks: Map<string, Set<string>> = globalThis.urlResetLinks || (globalThis.urlResetLinks = new Map());
+
 
 export class URLParam<T = unknown> {
-    constructor(urlKey: string, defaultValue: T) {
-        return createURLSync(urlKey, defaultValue);
+    constructor(urlKey: string, defaultValue: T, config?: URLParamConfig) {
+        return createURLSync(urlKey, defaultValue, config);
     }
 }
-/** const myVariable = createURLSync("myvar", 0) */
-export function createURLSync<T>(urlKey: string, defaultValue: T, config?: {
+export type URLParamConfig = {
     storage?: "url" | "localStorage";
-}): URLParam<T> {
+    // Reset when any of these urlKeys change
+    reset?: { (): { urlKey: string }[] }[];
+};
+/** const myVariable = createURLSync("myvar", 0) */
+export function createURLSync<T>(urlKey: string, defaultValue: T, config?: URLParamConfig): URLParam<T> {
+    setImmediate(() => {
+        for (let reset of config?.reset || []) {
+            for (let resetSource of reset()) {
+                let lookup = resetLinks.get(resetSource.urlKey);
+                if (!lookup) {
+                    lookup = new Set();
+                    resetLinks.set(resetSource.urlKey, lookup);
+                }
+                lookup.add(urlKey);
+            }
+        }
+    });
 
     let prev = globalURLLookup[urlKey];
     if (prev) {
@@ -104,6 +125,15 @@ export function createURLSync<T>(urlKey: string, defaultValue: T, config?: {
             }
         },
         set value(value: T) {
+            let resetTargets = resetLinks.get(urlKey);
+            if (resetTargets) {
+                for (let resetTarget of resetTargets) {
+                    let param = globalURLLookup[resetTarget];
+                    if (param) {
+                        param.reset();
+                    }
+                }
+            }
             if (!proxyWatcher.inWatcher()) {
                 Querysub.commit(() => {
                     param.value = value;

package/src/library-components/icons.tsx

@@ -9,6 +9,9 @@ import { renderToString } from "./renderToString";
 import { debugTime } from "../../src/0-path-value-core/pathValueCore";
 import { measureBlock } from "socket-function/src/profiling/measure";
 
+// TODO: Create more icons with: https://www.recraft.ai/project/e2a2200f-bed2-4426-b8f1-e5120b9dc990
+//  - This should also make creating animated SVGs a lot easier. If the base is nice, and we add comments, we can probably get the AI to help animate it
+
 // Most icons are from https://www.figma.com/file/eVpKKmt8uOKmSYKW4LyusF/Free-Icon-Pack-1600%2B-icons-(Community)?node-id=1654-9894&t=0bDbK0bA9KGpswRE-0
 
 // TODO: Add a build step that does this (storing the .svgs in a file), so we don't

package/src/library-components/niceStringify.ts

@@ -10,7 +10,7 @@ let specialStringValuesEncode = new Map([...specialStringValuesDecode].map(([key
 export function serializeURLParam(value: unknown): string | undefined {
     if (value === true) return undefined;
     // If it is a string and doesn't look JSON encoded, then just use it raw.
-    if (typeof value === "string" && !lookJSONEncoded(value)) {
+    if (typeof value === "string" && !lookJSONEncoded(value) && value !== "") {
         return value;
     }
     let specialValue = specialStringValuesEncode.get(value);

package/src/library-components/urlResetGroups.ts

@@ -0,0 +1,14 @@
+import { URLParam, URLParamConfig } from "./URLParam";
+
+
+export const pageURL = new URLParam("page", "");
+export const tabURL = new URLParam("tab", "");
+export const managementPageURL = new URLParam("managementpage", "");
+
+export const filterURL = new URLParam("filter", "", { reset: [mainResets] });
+export const startTimeURL = new URLParam("startTime", 0, { reset: [mainResets] });
+export const endTimeURL = new URLParam("endTime", 0, { reset: [mainResets] });
+
+export function mainResets(): URLParam[] {
+    return [pageURL, tabURL, managementPageURL];
+}

package/src/misc/formatJSX.tsx

@@ -1,6 +1,12 @@
 import { qreact } from "../4-dom/qreact";
 import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+import { Querysub } from "../4-querysub/QuerysubController";
 
 export function formatDateJSX(time: number) {
-    return <span title={formatVeryNiceDateTime(time)}>{formatTime(Date.now() - time)}</span>;
+    let diff = time - Querysub.nowDelayed(10 * 1000);
+    let ago = diff < 0;
+    if (ago) {
+        diff = -diff;
+    }
+    return <span title={formatVeryNiceDateTime(time)}>{!ago && "IN "}{formatTime(diff)}{ago && " AGO"}</span>;
 }

package/src/server.ts

@@ -33,7 +33,8 @@ async function main() {
 
     Error.stackTraceLimit = 20;
 
-    //SocketFunction.logMessages = true;
+    // SocketFunction.logMessages = true;
+    // SocketFunction.silent = false;
 
     // ClientWatcher.DEBUG_READS = true;
     // ClientWatcher.DEBUG_WRITES = true;

package/testEntry2.ts

@@ -3,13 +3,23 @@ import { getOwnMachineId } from "./src/-a-auth/certs";
 import { getOwnThreadId } from "./src/-f-node-discovery/NodeDiscovery";
 import { shutdown } from "./src/diagnostics/periodic";
 import { testTCPIsListening } from "socket-function/src/networking";
+import { Querysub } from "./src/4-querysub/QuerysubController";
+import { timeInSecond } from "socket-function/src/misc";
 
 export async function testMain() {
-    let test = await testTCPIsListening("1.1.1.1", 443);
-    console.log(test);
-    // await delay(0);
+    Querysub;
+    //let test = await testTCPIsListening("1.1.1.1", 443);
+    //console.log(test);
+    // Writing heartbeat 2025/09/14 08:37:46 PM for self (5ac8a2fa78fce4ea.971ed8b01743d123.querysubtest.com:13900)
+    await delay(timeInSecond);
+    await Querysub.hostService("test");
+    await delay(timeInSecond * 5);
     // console.log(getOwnThreadId());
-    // console.error(`Test warning for ErrorWarning testing`);
+    // Log an error every 30 seconds forever. 
+    while (true) {
+        console.error(`Test warning for im testing ${Date.now()}`);
+        await delay(timeInSecond * 30);
+    }
     // console.log(getOwnThreadId());
     // await shutdown();
     //await Querysub.hostService("test");
@@ -24,7 +34,8 @@ export async function testMain() {
     //     }
     //     await testLogs.flushNow();
     // }
-    // await shutdown();
+    await delay(timeInSecond * 15);
+    await shutdown();
 }
 async function main() {