querysub 0.252.0 → 0.253.0

package/src/deployManager/urlParams.ts

@@ -2,7 +2,6 @@ import { URLParam } from "../library-components/URLParam";
 
 export type ViewType = "services" | "machines" | "service-detail" | "machine-detail";
 
-// URL Parameters for navigation state
 export const currentViewParam = new URLParam<ViewType>("machineview", "machines");
 export const selectedServiceIdParam = new URLParam("serviceId", "");
 export const selectedMachineIdParam = new URLParam("machineId", ""); 

package/src/diagnostics/errorLogs/ErrorLogController.ts

@@ -140,6 +140,7 @@ let ensureBlocksFlushing = lazy(() => {
 let pendingLogs: { log: LogRaw; type: LogType }[] = [];
 let logClassifier: ((log: LogRaw, typeHint: LogType) => LogClass) | undefined;
 let initLogClassifier = lazy(async () => {
+    if (!isNode()) return null as never;
     let logClasses = await new ErrorLogControllerBase().getClasses();
     logClassifier = getLogClassCategorizer(logClasses);
     if (pendingLogs.length > 0) {

package/src/diagnostics/errorLogs/LogClassifiers.tsx

@@ -284,6 +284,12 @@ export class SuppressUntil extends qreact.Component<{
                         </>
                     )}
                 </div>
+                {type !== "info" && <Button
+                    onClick={() => updateClass({ suppressUntil: changeTime })}
+                    class={css.hsl(infoColor.h, infoColor.s, infoColor.l)}
+                >
+                    Fixed
+                </Button>}
                 {type !== "info" && <Button
                     onClick={() => updateClass({ type: "info" })}
                     class={css.hsl(infoColor.h, infoColor.s, infoColor.l)}

package/src/library-components/SyncedController.ts

@@ -8,12 +8,16 @@ import { formatTime } from "socket-function/src/formatting/format";
 import { nextId } from "socket-function/src/misc";
 import { getCallObj } from "socket-function/src/nodeProxy";
 import { MaybePromise } from "socket-function/src/types";
+import { isNode } from "typesafecss";
 
 // IMPORTANT! See cacheAsyncSynced if you just want to run promise functions
 
 let controllerIds = new Set<string>();
 
 module.hotreload = false;
+// NOTE: Most SyncedController are defined in files we don't hotreload anyways, so the page will refresh on changes. And if they aren't... they should be.
+//  - And if we reload all the calls on hot reload, it makes iterating on the UI extremely annoying. So... we don't anymore.
+/*
 onHotReload(() => {
     Querysub.commitLocal(() => {
         let root = syncedData();
@@ -31,14 +35,15 @@ onHotReload(() => {
         }
     });
 });
+*/
 
 export function syncedIsAnyLoading() {
     return Querysub.fastRead(() => {
         for (let controllerId in syncedData()) {
-            for (let nodeId in syncedData()[controllerId]) {
-                for (let fnc in syncedData()[controllerId][nodeId]) {
-                    for (let argsHash in syncedData()[controllerId][nodeId][fnc]) {
-                        if (atomic(syncedData()[controllerId][nodeId][fnc][argsHash].promise)) {
+            for (let fncs of Object.values(syncedData()[controllerId])) {
+                for (let fnc of Object.values(fncs)) {
+                    for (let obj of Object.values(fnc)) {
+                        if (atomic(obj.promise)) {
                             return true;
                         }
                     }
@@ -103,6 +108,58 @@ export function getSyncedController<T extends SocketRegistered>(
     refreshAll(): void;
     isAnyLoading(): boolean;
 } {
+    if (isNode()) {
+        let result = cache((nodeId: string) => {
+            let proxy = new Proxy({}, {
+                get: (target, fncNameUntyped) => {
+                    if (typeof fncNameUntyped !== "string") return undefined;
+                    if (fncNameUntyped === "resetAll" || fncNameUntyped === "refreshAll" || fncNameUntyped === "isAnyLoading") {
+                        return notAllowedOnServer;
+                    }
+                    let fncName = fncNameUntyped;
+                    function call(...args: any[]) {
+                        notAllowedOnServer();
+                    }
+                    call.promise = (...args: any[]) => {
+                        return controller.nodes[nodeId][fncName](...args);
+                    };
+                    call.reset = (...args: any[]) => {
+                        notAllowedOnServer();
+                    };
+                    call.resetAll = () => {
+                        notAllowedOnServer();
+                    };
+                    call.refresh = (...args: any[]) => {
+                        notAllowedOnServer();
+                    };
+                    call.refreshAll = () => {
+                        notAllowedOnServer();
+                    };
+                    call.isAnyLoading = () => {
+                        notAllowedOnServer();
+                    };
+                    call.setCache = (config: { args: any[], result: any }) => {
+                        notAllowedOnServer();
+                    };
+                    return call;
+                }
+            }) as any;
+            return proxy;
+        }) as any;
+        function notAllowedOnServer() {
+            throw new Error(`Syncing with getSyncedController is not allowed on the server. If we absolutely need this we can support it, but... you should just be using raw synced state anyways.`);
+        }
+        result.resetAll = () => {
+            notAllowedOnServer();
+        };
+        result.refreshAll = () => {
+            notAllowedOnServer();
+        };
+        result.isAnyLoading = () => {
+            notAllowedOnServer();
+        };
+        return result;
+    }
     let id = nextId();
     controllerIds.add(id);
 
@@ -151,9 +208,9 @@ export function getSyncedController<T extends SocketRegistered>(
                 if (fncNameUntyped === "refreshAll") {
                     return () => {
                         return Querysub.commitLocal(() => {
-                            for (let fnc in syncedData()[id][nodeId]) {
-                                for (let argsHash in syncedData()[id][nodeId][fnc]) {
-                                    syncedData()[id][nodeId][fnc][argsHash].invalidated = true;
+                            for (let fnc of Object.values(syncedData()[id][nodeId])) {
+                                for (let obj of Object.values(fnc)) {
+                                    obj.invalidated = true;
                                 }
                             }
                         });
@@ -162,9 +219,9 @@ export function getSyncedController<T extends SocketRegistered>(
                 if (fncNameUntyped === "isAnyLoading") {
                     return () => {
                         return Querysub.commitLocal(() => {
-                            for (let fnc in syncedData()[id][nodeId]) {
-                                for (let argsHash in syncedData()[id][nodeId][fnc]) {
-                                    if (atomic(syncedData()[id][nodeId][fnc][argsHash].promise)) {
+                            for (let fnc of Object.values(syncedData()[id][nodeId])) {
+                                for (let obj of Object.values(fnc)) {
+                                    if (atomic(obj.promise)) {
                                         return true;
                                     }
                                 }
@@ -195,14 +252,13 @@ export function getSyncedController<T extends SocketRegistered>(
                             doAtomicWrites(() => {
                                 obj.promise = promise;
                             });
-                            function invalidateAll() {
+                            function invalidateReaders() {
                                 let root = syncedData();
                                 for (let writesTo of config?.writes?.[fncName] || []) {
                                     for (let watcher of writeWatchers.get(writesTo) || []) {
-                                        for (let nodeId in root[watcher.controllerId]) {
-                                            for (let fnc in root[watcher.controllerId][nodeId]) {
-                                                for (let argsHash in root[watcher.controllerId][nodeId][fnc]) {
-                                                    let obj = root[watcher.controllerId][nodeId][fnc][argsHash];
+                                        for (let fncs of Object.values(root[watcher.controllerId])) {
+                                            for (let fnc of Object.values(fncs)) {
+                                                for (let obj of Object.values(fnc)) {
                                                     obj.invalidated = true;
                                                 }
                                             }
@@ -216,7 +272,7 @@ export function getSyncedController<T extends SocketRegistered>(
                                     Querysub.commitLocal(() => {
                                         obj.result = atomicObjectWriteNoFreeze({ result });
                                         obj.promise = undefined;
-                                        invalidateAll();
+                                        invalidateReaders();
                                     });
                                 },
                                 error => {
@@ -224,7 +280,7 @@ export function getSyncedController<T extends SocketRegistered>(
                                     Querysub.commitLocal(() => {
                                         obj.result = atomicObjectWriteNoFreeze({ error });
                                         obj.promise = undefined;
-                                        invalidateAll();
+                                        invalidateReaders();
                                     });
                                 }
                             );
@@ -243,9 +299,13 @@ export function getSyncedController<T extends SocketRegistered>(
                 }
                 call.promise = (...args: any[]) => {
                     return Querysub.fastRead(() => {
-                        call(...args);
                         let argsHash = JSON.stringify(args);
-                        let promise = atomic(syncedData()[id][nodeId][fncName][argsHash].promise);
+                        let obj = syncedData()[id][nodeId][fncName][argsHash];
+                        // Reset promise, to force it to not use the cache, as promise functions should never be cached. This might result in the results being set out of order, but... generally functions called with promise and accessed inside a watcher, so this should be fine.
+                        obj.promise = undefined;
+                        obj.invalidated = true;
+                        call(...args);
+                        let promise = atomic(obj.promise);
                         if (!promise) {
                             debugger;
                             throw new Error(`Impossible, called function, but promise is not found for ${fncName}`);
@@ -279,15 +339,15 @@ export function getSyncedController<T extends SocketRegistered>(
                 };
                 call.refreshAll = () => {
                     return Querysub.commitLocal(() => {
-                        for (let argsHash in syncedData()[id][nodeId][fncName]) {
-                            syncedData()[id][nodeId][fncName][argsHash].invalidated = true;
+                        for (let obj of Object.values(syncedData()[id][nodeId][fncName])) {
+                            obj.invalidated = true;
                         }
                     });
                 };
                 call.isAnyLoading = () => {
                     return Querysub.commitLocal(() => {
-                        for (let argsHash in syncedData()[id][nodeId][fncName]) {
-                            if (atomic(syncedData()[id][nodeId][fncName][argsHash].promise)) {
+                        for (let obj of Object.values(syncedData()[id][nodeId][fncName])) {
+                            if (atomic(obj.promise)) {
                                 return true;
                             }
                         }
@@ -320,10 +380,10 @@ export function getSyncedController<T extends SocketRegistered>(
     };
     result.refreshAll = () => {
         return Querysub.commitLocal(() => {
-            for (let nodeId in syncedData()[id]) {
-                for (let fnc in syncedData()[id][nodeId]) {
-                    for (let argsHash in syncedData()[id][nodeId][fnc]) {
-                        syncedData()[id][nodeId][fnc][argsHash].invalidated = true;
+            for (let fncs of Object.values(syncedData()[id])) {
+                for (let fnc of Object.values(fncs)) {
+                    for (let obj of Object.values(fnc)) {
+                        obj.invalidated = true;
                     }
                 }
             }
@@ -331,10 +391,10 @@ export function getSyncedController<T extends SocketRegistered>(
     };
     result.isAnyLoading = () => {
         return Querysub.commitLocal(() => {
-            for (let nodeId in syncedData()[id]) {
-                for (let fnc in syncedData()[id][nodeId]) {
-                    for (let argsHash in syncedData()[id][nodeId][fnc]) {
-                        if (atomic(syncedData()[id][nodeId][fnc][argsHash].promise)) {
+            for (let fncs of Object.values(syncedData()[id])) {
+                for (let fnc of Object.values(fncs)) {
+                    for (let obj of Object.values(fnc)) {
+                        if (atomic(obj.promise)) {
                             return true;
                         }
                     }

package/src/misc/formatJSX.tsx

@@ -0,0 +1,6 @@
+import { qreact } from "../4-dom/qreact";
+import { formatTime, formatVeryNiceDateTime } from "socket-function/src/formatting/format";
+
+export function formatTimeJSX(time: number) {
+    return <span title={formatVeryNiceDateTime(time)}>({formatTime(Date.now() - time)})</span>;
+}