querysub 0.469.0 → 0.471.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "querysub",
-  "version": "0.469.0",
+  "version": "0.471.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).`);
+                    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 })))}.`);
                 }
 
 

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/URLParam.ts

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

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,
+            },
+        },
     },
 });