querysub 0.339.0 → 0.341.0

package/src/functional/runCommand.ts

@@ -1,71 +1,10 @@
 import child_process from "child_process";
 import path from "path";
 import { blue, red } from "socket-function/src/formatting/logColors";
+import { runPromise } from "socket-function/src/runPromise";
 
 export const runAsync = runPromise;
-export async function runPromise(command: string, config?: {
-    cwd?: string;
-    quiet?: boolean;
-    // Never throw, just return the full output
-    nothrow?: boolean;
-    detach?: boolean;
-}) {
-    return new Promise<string>((resolve, reject) => {
-        console.log(">" + blue(command));
-        const childProc = child_process.spawn(command, {
-            shell: true,
-            cwd: config?.cwd,
-            stdio: ["inherit", "pipe", "pipe"],
-            detached: config?.detach,
-        });
-
-        let fullOutput = "";
-        let stderr = "";
-
-        // Always collect output
-        childProc.stdout?.on("data", (data) => {
-            const chunk = data.toString();
-            fullOutput += chunk;
-
-            // Stream to console unless quiet mode
-            if (!config?.quiet) {
-                process.stdout.write(chunk);
-            }
-        });
-
-        childProc.stderr?.on("data", (data) => {
-            const chunk = data.toString();
-            stderr += chunk;
-            fullOutput += chunk;
-
-            // Stream to console unless quiet mode
-            if (!config?.quiet) {
-                process.stderr.write(red(chunk));
-            }
-        });
-
-        childProc.on("error", (err) => {
-            if (config?.nothrow) {
-                resolve(fullOutput);
-            } else {
-                reject(err);
-            }
-        });
-
-        childProc.on("close", (code) => {
-            if (code === 0 || config?.nothrow) {
-                resolve(fullOutput);
-            } else {
-                let errorMessage = `Process exited with code ${code} for command: ${command}`;
-                if (stderr) {
-                    errorMessage += `\n${stderr}`;
-                }
-                const error = new Error(errorMessage);
-                reject(error);
-            }
-        });
-    });
-}
+export { runPromise };
 
 /** @deprecated, use runPromise */
 export async function runCommand(config: {

package/src/library-components/SyncedController.ts

@@ -5,7 +5,7 @@ import { FullCallType, SocketRegistered } from "socket-function/SocketFunctionTy
 import { onHotReload } from "socket-function/hot/HotReloadController";
 import { cache } from "socket-function/src/caching";
 import { formatTime } from "socket-function/src/formatting/format";
-import { nextId } from "socket-function/src/misc";
+import { nextId, PromiseObj } from "socket-function/src/misc";
 import { getCallObj } from "socket-function/src/nodeProxy";
 import { MaybePromise } from "socket-function/src/types";
 import { isNode } from "typesafecss";
@@ -37,20 +37,24 @@ onHotReload(() => {
 });
 */
 
-export function syncedIsAnyLoading() {
-    return Querysub.fastRead(() => {
+export function syncedIsAnyLoading(): Map<string, number> | undefined {
+    let result = new Map<string, number>();
+    Querysub.fastRead(() => {
         for (let controllerId in syncedData()) {
             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 `${fncName} (on ${nodeId})`;
+                            let text = `${fncName} (on ${nodeId})`;
+                            result.set(text, (result.get(text) || 0) + 1);
                         }
                     }
                 }
             }
         }
     });
+    if (result.size === 0) return undefined;
+    return result;
 }
 
 let syncedData = Querysub.createLocalSchema<{
@@ -58,7 +62,7 @@ let syncedData = Querysub.createLocalSchema<{
         [nodeId: string]: {
             [fnc: string]: {
                 [argsHash: string]: {
-                    promise: Promise<unknown> | undefined;
+                    promise: { promise: Promise<unknown> } | undefined;
                     result?: { result: unknown } | { error: Error };
                     invalidated?: boolean;
                 }
@@ -87,9 +91,16 @@ const writeWatchers = new Map<string, {
     fncName: string;
 }[]>();
 
-export function getSyncedController<T extends SocketRegistered>(
+export function getSyncedController<T extends {
+    nodes: {
+        [key: string]: {
+            [key: string]: ((...args: any[]) => Promise<any>) | string;
+        };
+    };
+}>(
     controller: T,
     config?: {
+        cachePromiseCalls?: boolean;
         /** When a controller call for a write finishes, we refresh all readers.
          *      - Invalidation is global, across all controllers.
          */
@@ -124,7 +135,7 @@ export function getSyncedController<T extends SocketRegistered>(
                         notAllowedOnServer();
                     }
                     call.promise = (...args: any[]) => {
-                        return controller.nodes[nodeId][fncName](...args);
+                        return (controller.nodes[nodeId][fncName] as any)(...args);
                     };
                     call.reset = (...args: any[]) => {
                         notAllowedOnServer();
@@ -179,19 +190,21 @@ export function getSyncedController<T extends SocketRegistered>(
     }
 
     let result = cache((nodeId: string) => {
-        SocketFunction.onNextDisconnect(nodeId, () => {
-            Querysub.commitLocal(() => {
-                let nodeObj = syncedData()[id][nodeId];
-                for (let fnc in nodeObj) {
-                    for (let argsHash in nodeObj[fnc]) {
-                        delete nodeObj[fnc][argsHash].promise;
-                        delete nodeObj[fnc][argsHash].result;
+        if (nodeId) {
+            SocketFunction.onNextDisconnect(nodeId, () => {
+                Querysub.commitLocal(() => {
+                    let nodeObj = syncedData()[id][nodeId];
+                    for (let fnc in nodeObj) {
+                        for (let argsHash in nodeObj[fnc]) {
+                            delete nodeObj[fnc][argsHash].promise;
+                            delete nodeObj[fnc][argsHash].result;
+                        }
+                        delete nodeObj[fnc];
                     }
-                    delete nodeObj[fnc];
-                }
-                delete syncedData()[id][nodeId];
+                    delete syncedData()[id][nodeId];
+                });
             });
-        });
+        }
         return new Proxy({}, {
             get: (target, fncNameUntyped) => {
                 if (typeof fncNameUntyped !== "string") return undefined;
@@ -235,41 +248,41 @@ export function getSyncedController<T extends SocketRegistered>(
                 }
                 let fncName = fncNameUntyped;
                 function call(...args: any[]) {
-                    return Querysub.commitLocal(() => {
-                        let argsHash = JSON.stringify(args);
-                        let obj = syncedData()[id][nodeId][fncName][argsHash];
+                    let argsHash = JSON.stringify(args);
+                    let obj = syncedData()[id][nodeId][fncName][argsHash];
 
-                        let result = atomic(obj.result);
-                        let promise = atomic(obj.promise);
+                    let result = atomic(obj.result);
+                    let promise = atomic(obj.promise);
 
-                        // NOTE: If we are invalidated when the promise is running, nothing happens (as we don't watch invalidated if we are running with a promise). BUT, if the promise isn't running, we will run again, and start running again. In this way we don't queue up a lot if we invalidate a lot, but we do always run again after the invalidation to get the latest result!
-                        if (!promise && (!result || atomic(obj.invalidated))) {
-                            obj.invalidated = false;
-                            let timeStart = Date.now();
-                            function logFinished() {
-                                let duration = Date.now() - timeStart;
-                                if (duration > 500) {
-                                    console.warn(`Slow call ${fncName} took ${formatTime(duration)}`);
-                                }
+                    // NOTE: If we are invalidated when the promise is running, nothing happens (as we don't watch invalidated if we are running with a promise). BUT, if the promise isn't running, we will run again, and start running again. In this way we don't queue up a lot if we invalidate a lot, but we do always run again after the invalidation to get the latest result!
+                    if (!promise && (!result || atomic(obj.invalidated))) {
+                        obj.invalidated = false;
+                        let timeStart = Date.now();
+                        function logFinished() {
+                            let duration = Date.now() - timeStart;
+                            if (duration > 500) {
+                                console.warn(`Slow call ${fncName} took ${formatTime(duration)}`);
                             }
-                            let promise = controller.nodes[nodeId][fncName](...args) as Promise<unknown>;
-                            doAtomicWrites(() => {
-                                obj.promise = promise;
-                            });
-                            function invalidateReaders() {
-                                let root = syncedData();
-                                for (let writesTo of config?.writes?.[fncName] || []) {
-                                    for (let watcher of writeWatchers.get(writesTo) || []) {
-                                        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;
-                                                }
-                                            }
-                                        }
-                                    }
-                                }
+                        }
+                        let promiseObjBase = new PromiseObj<unknown>();
+                        let promiseObj: { promise: Promise<unknown> } = {
+                            promise: promiseObjBase.promise,
+                        };
+                        doAtomicWrites(() => {
+                            obj.promise = promiseObj;
+                        });
+                        // 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;
+                        Querysub.onCommitFinished(() => {
+                            if (Querysub.isAllSynced()) {
+                                void Promise.resolve().then(() => {
+                                    doPromiseCall();
+                                });
                             }
+                        });
+                        function doPromiseCall() {
+                            let promise = fnc(...args) as Promise<unknown>;
+                            promiseObjBase.resolve(promise);
                             promise.then(
                                 result => {
                                     logFinished();
@@ -289,42 +302,81 @@ export function getSyncedController<T extends SocketRegistered>(
                                 }
                             );
                         }
+                        function invalidateReaders() {
+                            let root = syncedData();
+                            for (let writesTo of config?.writes?.[fncName] || []) {
+                                for (let watcher of writeWatchers.get(writesTo) || []) {
+                                    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;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
 
 
-                        if (result) {
-                            if ("error" in result) {
-                                throw result.error;
-                            } else {
-                                return result.result;
-                            }
+                    if (result) {
+                        if ("error" in result) {
+                            throw result.error;
+                        } else {
+                            return result.result;
                         }
-                        return undefined;
-                    });
+                    }
+                    return undefined;
                 }
                 call.promise = (...args: any[]) => {
                     return Querysub.fastRead(() => {
                         let argsHash = JSON.stringify(args);
                         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;
+                        if (!config?.cachePromiseCalls) {
+                            // 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;
+                        } else {
+                            let result = atomic(obj.result);
+                            if (result) {
+                                if ("error" in result) {
+                                    throw result.error;
+                                } else {
+                                    return result.result;
+                                }
+                            }
+                        }
                         call(...args);
                         // Assign to itself, to preset the type assumptions typescript makes (otherwise we get an error below)
                         obj = obj as any;
+                        if (config?.cachePromiseCalls) {
+                            let result = atomic(obj.result);
+                            if (result) {
+                                if ("error" in result) {
+                                    throw result.error;
+                                } else {
+                                    return result.result;
+                                }
+                            }
+                        }
                         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(() => {
-                            Querysub.fastRead(() => {
-                                if (obj.promise === promise) {
-                                    obj.promise = undefined;
-                                }
+                        if (!config?.cachePromiseCalls) {
+                            Querysub.onCommitFinished(() => {
+                                // Don't cache promise calls
+                                void promise?.promise.finally(() => {
+                                    Querysub.fastRead(() => {
+                                        if (obj.promise === promise) {
+                                            obj.promise = undefined;
+                                        }
+                                    });
+                                });
                             });
-                        });
-                        return promise;
+                        }
+                        return promise.promise;
                     });
                 };
                 call.reset = (...args: any[]) => {

package/src/library-components/SyncedControllerLoadingIndicator.tsx

@@ -34,7 +34,7 @@ export class SyncedControllerLoadingIndicator extends qreact.Component {
                     .borderRadius("50%")
                 + " " + spinAnimationClass
             }></div>
-            <span title={loadingPath}>Syncing data...</span>
+            <span title={Array.from(loadingPath.entries()).map(([key, value]) => `${key} (${value})`).join(" | ")}>Syncing data...</span>
             <style>
                 {`
                     @keyframes ${spinAnimationClass} {