querysub 0.470.0 → 0.472.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.470.0",
+  "version": "0.472.0",
   "main": "index.js",
   "license": "MIT",
   "note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -66,7 +66,7 @@
     "node-forge": "https://github.com/sliftist/forge#e618181b469b07bdc70b968b0391beb8ef5fecd6",
     "pako": "^2.1.0",
     "peggy": "^5.0.6",
-    "socket-function": "^1.1.34",
+    "socket-function": "^1.1.35",
     "terser": "^5.31.0",
     "typesafecss": "^0.29.0",
     "yaml": "^2.5.0",

package/src/-c-identity/IdentityController.ts

@@ -54,7 +54,12 @@ export function IdentityController_getReconnectNodeIdAssert(callerContext: Calle
         return callerContext.nodeId;
     }
     let reconnectId = IdentityController_getReconnectNodeId(callerContext);
-    if (!reconnectId) throw new Error(`Caller did not mount before connecting. This call requires the caller to be listening.`);
+    if (!reconnectId) {
+        console.error(`Caller did not mount before connecting. This call requires the caller to be listening.`, {
+            callerNodeId: callerContext.nodeId,
+        });
+        throw new Error(`Caller did not mount before connecting. This call requires the caller to be listening.`);
+    }
     return reconnectId;
 }
 export function IdentityController_getSecureIP(callerContext: CallerContext): string {

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -1664,7 +1664,7 @@ export class PathValueProxyWatcher {
 
                 let maxLocks = watcher.options.maxLocksOverride || DEFAULT_MAX_LOCKS;
                 if (locks.length > maxLocks) {
-                    throw new Error(`Too many locks for ${watcher.debugName} (${locks.length} > ${maxLocks}). Use Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. You can override max locks with maxLocksOverride (in options / functionMetadata). Some locks are ${JSON.stringify(locks.slice(0, 3).map(x => ({ path: x.path, startTime: x.startTime, endTime: x.endTime })))}.`);
+                    throw new Error(`Too many locks for ${watcher.debugName} (${locks.length} > ${maxLocks}). Use Querysub.noLocks(() => ...) around code that is accessing too many values, assuming you don't want to lock them. You can override max locks with maxLocksOverride (in options / functionMetadata). Some locks are ${JSON.stringify(locks.slice(-10).map(x => ({ path: x.path, startTime: x.startTime, endTime: x.endTime })))}.`);
                 }
 
 

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

@@ -144,6 +144,10 @@ export function writeFunctionCall(config: {
 }) {
     let { domainName, moduleId, functionId, args, metadata } = config;
 
+    if (isNode() && !curInterceptor) {
+        throw new Error(`Naked function writes are not allowed serverside. Wrap your code in a Querysub.commitAsync!`);
+    }
+
     // NOTE: Having this be an always-increasing time means that at least if it's the same client making the call ID, the numbers will always be increasing. So we can go from the call ID to determine the order of the calls, which is extremely useful. 
     let now = getTimeUnique();
     // IMPORTANT! CallId MUST be secure, otherwise other users can guess it, and read our calls

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

@@ -58,7 +58,7 @@ export type FunctionMetadata<Schema = unknown, F = unknown> = {
     // NOTE: Eventually we might want to support dynamic paths per call, so we can supported nested lookups.
     //  - We also need to support specifying on the lookup that the key is in the nested lookup, which means hashing has to support wildcards, etc. All-in-all the whole change is very complicated, and only needed for hypothetical cases (data().worlds[region][id]...), which could probably be flattened anyways to just a single lookup (data().worlds[region + "-" + id]...)
     /** This should identify the most common lookup accessed, and then give the path to that lookup and the key that we're using to access it. */
-    keyOverride?: {
+    keyOverride: {
         getPrefix: (data: () => Schema) => unknown;
         getKey: (...args: Args<F>) => string;
     };
@@ -275,7 +275,7 @@ type SyncSchemaResult<Schema> = {
         moduleId: string;
         module: NodeJS.Module;
         functions: Functions;
-        functionMetadata?: { [name in keyof Functions]?: FunctionMetadata<Schema, Functions[name]> };
+        functionMetadata: { [name in keyof Functions]: FunctionMetadata<Schema, Functions[name]> };
         /** Provide access to [Querysub.CALL_PERMISSIONS_KEY] to allow function calls (or provide access at the root). */
         permissions?: SchemaToPermissions<Schema> & {
             [CALL_PERMISSIONS_KEY]?: {

package/src/4-dom/qreactTest.tsx

@@ -326,7 +326,14 @@ let { data, functions } = Querysub.createSchema<{
     },
     module,
     moduleId: "qreactTest",
-    functionMetadata: {},
+    functionMetadata: {
+        setValue: {
+            keyOverride: {
+                getPrefix: data => data().values,
+                getKey: (key: string) => key,
+            },
+        },
+    },
     permissions: {
         PERMISSIONS: isSuperUserPERMISSIONS
     }

package/src/diagnostics/logs/IndexedLogs/LogViewer3.tsx

@@ -95,9 +95,13 @@ export class LogViewer3 extends qreact.Component {
     getPaths(): TimeFilePathWithSize[] {
         let paths: TimeFilePathWithSize[] = [];
         if (savedPathsURL.value) {
-            const compressed = Buffer.from(savedPathsURL.value, "base64");
-            const decompressed = Zip.gunzipSync(compressed);
-            paths = JSON.parse(decompressed.toString("utf8"));
+            try {
+                const compressed = Buffer.from(savedPathsURL.value, "base64");
+                const decompressed = Zip.gunzipSync(compressed);
+                paths = JSON.parse(decompressed.toString("utf8"));
+            } catch (e: any) {
+                console.warn(`Error parsing saved paths: ${e.stack}`);
+            }
         } else {
             paths = this.state.paths;
         }

package/src/diagnostics/logs/diskLogGlobalContext.ts

@@ -7,8 +7,14 @@ import { logErrors } from "../../errors";
 import { addGlobalContext } from "./diskLogger";
 import child_process from "child_process";
 import { getNodeIdLocation } from "socket-function/src/nodeCache";
+import { getGitRefLive } from "../../4-deploy/git";
 
 export function addBuiltInContext() {
+    let __gitHash = "";
+    setImmediate(async () => {
+        __gitHash = await getGitRefLive();
+    });
+
     addGlobalContext(() => {
         let nodeId = getOwnNodeId();
         let nodeParts = getNodeIdLocation(nodeId);
@@ -25,6 +31,7 @@ export function addBuiltInContext() {
             __os: process.platform,
             __pid: process.pid,
             __call: SocketFunction.TOTAL_CALLS,
+            __gitHash: __gitHash,
         };
     });
     const getHostname = lazy(() => child_process.execSync("hostname").toString().trim());

package/src/library-components/InputAutocomplete.tsx

@@ -0,0 +1,100 @@
+import { css } from "typesafecss";
+import { InputProps } from "./Input";
+import { qreact } from "../4-dom/qreact";
+
+export class InputAutocomplete extends qreact.Component<InputProps & {
+    value: string | { value: string };
+    label?: string;
+    options: string[];
+    onChangeValue: (value: string) => void;
+    focusOnMount?: boolean;
+}> {
+    handleInput = (e: Event) => {
+        const input = e.currentTarget as HTMLInputElement;
+        const inputEvent = e as InputEvent;
+
+        // Only autocomplete on text insertion, not deletion
+        if (!inputEvent.inputType || !inputEvent.inputType.startsWith("insert")) {
+            return;
+        }
+
+        const selectionStart = input.selectionStart || 0;
+        const userTyped = input.value.slice(0, selectionStart);
+
+        if (!userTyped) {
+            return;
+        }
+
+        // Find matching character names
+        const options = this.props.options;
+        const lowerUserTyped = userTyped.toLowerCase();
+        const match = options.find(name =>
+            name.toLowerCase().startsWith(lowerUserTyped)
+        );
+
+        if (match) {
+            // Replace with the matched name's casing
+            input.value = match;
+            input.setSelectionRange(userTyped.length, match.length);
+        }
+    };
+
+    handleKeyDown = (e: KeyboardEvent) => {
+        const input = e.currentTarget as HTMLInputElement;
+
+        if (e.key === "Tab" || e.key === "Enter") {
+            e.preventDefault();
+            this.props.onChangeValue(input.value);
+            input.blur();
+        } else if (e.key === "Escape") {
+            input.value = this.getValue();
+            input.blur();
+        }
+    };
+
+    handleBlur = (e: FocusEvent) => {
+        const input = e.currentTarget as HTMLInputElement;
+        this.props.onChangeValue(input.value);
+    };
+    getValue() {
+        if (typeof this.props.value === "string") {
+            return this.props.value;
+        }
+        return this.props.value.value;
+    }
+
+    render() {
+        let { value, options, onChangeValue, focusOnMount, ...nativeProps } = this.props;
+        const styleClass = (
+            css.border("1px solid hsl(0, 0%, 50%)", "soft")
+                .background("hsl(0, 0%, 7%)", "soft")
+                .color("hsl(0, 0%, 95%)", "soft")
+                .display("flex", "soft")
+                .outline("3px solid hsl(204, 100%, 50%)", "focus", "soft")
+            + " " + css.width("100%", "soft")
+            + " " + (nativeProps.className || "")
+        );
+        return (
+            <input
+                {...nativeProps as any}
+                ref={elem => {
+                    if (elem) {
+                        elem.value = this.getValue();
+                        if (focusOnMount) {
+                            setTimeout(() => {
+                                elem.focus();
+                                elem.select();
+                            }, 0);
+                        }
+                    }
+                }}
+                type="text"
+                onFocus={e => (e.currentTarget as HTMLInputElement).select()}
+                onInput={this.handleInput}
+                onKeyDown={this.handleKeyDown}
+                onBlur={this.handleBlur}
+                className={styleClass}
+            />
+        );
+    }
+}

package/src/library-components/URLParam.ts

@@ -183,6 +183,7 @@ const { data } = syncSchema<{
     functions: {},
     module,
     moduleId: "urlSync",
+    functionMetadata: {},
     permissions: {},
 });
 

package/src/library-components/uncaughtToast.tsx

@@ -12,9 +12,9 @@ function onUncaught(...args: unknown[]) {
     }
     // Ignore ResizeObserver errors, they are spurious
     //  - https://github.com/vercel/next.js/discussions/51551
-    if (error.message.startsWith("ResizeObserver loop")) return;
+    if (error.message?.startsWith("ResizeObserver loop")) return;
     // We should really do this better. Basically, if we're disposing or canceling, it's not actually an error, just ignore it. 
-    if (error.message.startsWith("Dispose")) return;
+    if (error.message?.startsWith("Dispose")) return;
 
     onMessage({
         type: "error",

package/src/user-implementation/userData.ts

@@ -285,11 +285,125 @@ const { data, functions } = Querysub.syncSchema<{
     functionMetadata: {
         // There's no point to predict sending emails, or inviting users, or registering the page load time or sending discord messages, As the main function of these can only be done server-side. 
         // verifyMachineId is used when logging in with the login token. We could predict it, but there's no real reason to because if we do, all of our reads are gonna fail until it runs, Which will actually be really confusing to the user and look like a bug. 
-        sendLoginEmail: { nopredict: true },
-        verifyMachineId: { nopredict: true },
-        inviteUser: { nopredict: true },
-        registerPageLoadTime: { nopredict: true },
-        testSendDiscordMessage: { nopredict: true },
+        sendLoginEmail: {
+            nopredict: true,
+            keyOverride: {
+                getPrefix: data => data().secure.emailToUserId,
+                getKey: config => config.email,
+            },
+        },
+        verifyMachineId: {
+            nopredict: true,
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.loginToken.split("_")[1],
+            },
+        },
+        inviteUser: {
+            nopredict: true,
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUserAssert(),
+            },
+        },
+        registerPageLoadTime: {
+            nopredict: true,
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUser() ?? Querysub.getCallerMachineId(),
+            },
+        },
+        testSendDiscordMessage: {
+            nopredict: true,
+            keyOverride: {
+                getPrefix: data => data().secure,
+                getKey: () => "notifyDiscordWebhookURL",
+            },
+        },
+        updateSettings: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUserAssert(),
+            },
+        },
+        logoutCurrent: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUser() ?? Querysub.getCallerMachineId(),
+            },
+        },
+        logoutSpecific: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUserAssert(),
+            },
+        },
+        removeLoginToken: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: () => getCurrentUserAssert(),
+            },
+        },
+        specialResetLogins: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.userId,
+            },
+        },
+        specialBlockIP: {
+            keyOverride: {
+                getPrefix: data => data().secure.blockedIPs,
+                getKey: config => config.ip,
+            },
+        },
+        specialUnblockIP: {
+            keyOverride: {
+                getPrefix: data => data().secure.blockedIPs,
+                getKey: config => config.ip,
+            },
+        },
+        specialSetInviteCount: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.userId,
+            },
+        },
+        setPostmarkAPIKey: {
+            keyOverride: {
+                getPrefix: data => data().secure,
+                getKey: () => "postmarkAPIKey",
+            },
+        },
+        setNotifyDiscordWebhookURL: {
+            keyOverride: {
+                getPrefix: data => data().secure,
+                getKey: () => "notifyDiscordWebhookURL",
+            },
+        },
+        setOpenRouterAPIKey: {
+            keyOverride: {
+                getPrefix: data => data().secure,
+                getKey: () => "openRouterAPIKey",
+            },
+        },
+        specialSetUserType: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.userId,
+            },
+        },
+        banUser: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.userId,
+            },
+        },
+        unbanUser: {
+            keyOverride: {
+                getPrefix: data => data().users,
+                getKey: config => config.userId,
+            },
+        },
     },
 });