querysub 0.437.0 → 0.439.0

package/src/errors.ts

@@ -1,134 +1,134 @@
-import debugbreak from "debugbreak";
-import { delay } from "socket-function/src/batching";
-import { blue, red } from "socket-function/src/formatting/logColors";
-import { canHaveChildren } from "socket-function/src/types";
-
-let callstackTracking = false;
-/** WARNING: This can be VERY slow. The only way to record the callstack of some errors is to record it
- *      on promise initialization, which results in gathering callstacks even for successful promises.
- */
-export function enableCallbackTracking() {
-    callstackTracking = true;
-}
-
-function logError(e: Error, callstack: unknown) {
-    console.error(`${blue("Error from promise")}: ${red(e.stack || e.message)}`);
-    if (callstackTracking) {
-        console.log(callstack);
-    }
-}
-export function logErrors(promiseorError: Promise<unknown> | unknown | undefined) {
-    let callstack = callstackTracking && new Error().stack;
-    if (!promiseorError) return;
-    if (!canHaveChildren(promiseorError)) return;
-    if (promiseorError instanceof Promise) {
-        promiseorError.catch(e => {
-            logError(e, callstack);
-        });
-    } else {
-        if (promiseorError instanceof Error) {
-            logError(promiseorError, callstack);
-        }
-    }
-}
-export function ignoreErrors(promise: Promise<unknown>) {
-    if (!promise) return;
-    if (!promise?.catch) return;
-    promise.catch(e => { });
-}
-
-/** Logs the error as well. */
-export function errorToUndefined<T>(p: Promise<T>): Promise<T | undefined> {
-    if (!p?.catch) return p;
-    return p.catch((e) => {
-        console.error(`${blue("Error to undefined error")}: ${red(e.stack)}`);
-        return undefined;
-    });
-}
-export function errorToUndefinedSilent<T>(p: Promise<T>): Promise<T | undefined> {
-    if (!p?.catch) return Promise.resolve(undefined);
-    return p.catch((e) => {
-        return undefined;
-    });
-}
-
-export function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {
-    return new Promise<T>((resolve, reject) => {
-        let timeout = setTimeout(() => reject(err()), time);
-        p.then(resolve, reject).finally(() => clearTimeout(timeout));
-    });
-}
-
-// NOTE: Both errors and timeouts are converted to undefined
-export function timeoutToUndefined<T>(time: number, p: Promise<T>) {
-    return new Promise<T | undefined>((resolve, reject) => {
-        let timeout = setTimeout(() => {
-            console.error(blue(`timeoutToUndefined timed out after ${time}`));
-            resolve(undefined);
-        }, time);
-        p.then(resolve,
-            (err) => {
-                console.error(`${blue("timeoutToUndefined error")}: ${red(err.stack)}`);
-                resolve(undefined);
-            }
-        ).finally(() => clearTimeout(timeout));
-    });
-}
-export function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {
-    return new Promise<T | undefined>((resolve, reject) => {
-        let timeout = setTimeout(() => {
-            resolve(undefined);
-        }, time);
-        p.then(
-            resolve,
-            (err) => {
-                resolve(undefined);
-            }
-        ).finally(() => clearTimeout(timeout));
-    });
-}
-
-/** Used when accessing paid resources, so we don't rack up charges due to an error,
- *      but also so that it doesn't take forever for the initial call to run.
- */
-export async function backoffRetryLoop<T>(code: () => Promise<T>, waitTime = 5 * 1000) {
-    while (true) {
-        try {
-            return await code();
-        } catch (e: any) {
-            console.error(`Error retrying in ${waitTime}ms\n${e.stack}`);
-            await delay(waitTime);
-            waitTime *= 1.01;
-        }
-    }
-}
-
-export function errorify(error: any, messageOverride?: string) {
-    if (error instanceof Error) {
-        return error;
-    }
-    let errorObj = new Error();
-    if (typeof error === "string" && error.includes("\n")) {
-        errorObj.stack = error;
-        errorObj.message = error.split("\n")[0];
-    } else {
-        errorObj.message = error;
-        errorObj.stack = error + "\n" + errorObj.stack;
-    }
-    if (messageOverride) {
-        errorObj.message = messageOverride;
-    }
-    return errorObj;
-}
-
-export function assertValue<T>(value: T | undefined | null, message?: string): T {
-    if (value === undefined || value === null) {
-        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
-    }
-    return value;
-}
-export function assert<T>(value: T | undefined | null, message?: string): asserts value is T {
-    if (value === undefined || value === null) {
-        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
-    }
+import debugbreak from "debugbreak";
+import { delay } from "socket-function/src/batching";
+import { blue, red } from "socket-function/src/formatting/logColors";
+import { canHaveChildren } from "socket-function/src/types";
+
+let callstackTracking = false;
+/** WARNING: This can be VERY slow. The only way to record the callstack of some errors is to record it
+ *      on promise initialization, which results in gathering callstacks even for successful promises.
+ */
+export function enableCallbackTracking() {
+    callstackTracking = true;
+}
+
+function logError(e: Error, callstack: unknown) {
+    console.error(`${blue("Error from promise")}: ${red(e.stack || e.message)}`);
+    if (callstackTracking) {
+        console.log(callstack);
+    }
+}
+export function logErrors(promiseorError: Promise<unknown> | unknown | undefined) {
+    let callstack = callstackTracking && new Error().stack;
+    if (!promiseorError) return;
+    if (!canHaveChildren(promiseorError)) return;
+    if (promiseorError instanceof Promise) {
+        promiseorError.catch(e => {
+            logError(e, callstack);
+        });
+    } else {
+        if (promiseorError instanceof Error) {
+            logError(promiseorError, callstack);
+        }
+    }
+}
+export function ignoreErrors(promise: Promise<unknown>) {
+    if (!promise) return;
+    if (!promise?.catch) return;
+    promise.catch(e => { });
+}
+
+/** Logs the error as well. */
+export function errorToUndefined<T>(p: Promise<T>): Promise<T | undefined> {
+    if (!p?.catch) return p;
+    return p.catch((e) => {
+        console.error(`${blue("Error to undefined error")}: ${red(e.stack)}`);
+        return undefined;
+    });
+}
+export function errorToUndefinedSilent<T>(p: Promise<T>): Promise<T | undefined> {
+    if (!p?.catch) return Promise.resolve(undefined);
+    return p.catch((e) => {
+        return undefined;
+    });
+}
+
+export function timeoutToError<T>(time: number, p: Promise<T>, err: () => Error) {
+    return new Promise<T>((resolve, reject) => {
+        let timeout = setTimeout(() => reject(err()), time);
+        p.then(resolve, reject).finally(() => clearTimeout(timeout));
+    });
+}
+
+// NOTE: Both errors and timeouts are converted to undefined
+export function timeoutToUndefined<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            console.error(blue(`timeoutToUndefined timed out after ${time}`));
+            resolve(undefined);
+        }, time);
+        p.then(resolve,
+            (err) => {
+                console.error(`${blue("timeoutToUndefined error")}: ${red(err.stack)}`);
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}
+export function timeoutToUndefinedSilent<T>(time: number, p: Promise<T>) {
+    return new Promise<T | undefined>((resolve, reject) => {
+        let timeout = setTimeout(() => {
+            resolve(undefined);
+        }, time);
+        p.then(
+            resolve,
+            (err) => {
+                resolve(undefined);
+            }
+        ).finally(() => clearTimeout(timeout));
+    });
+}
+
+/** Used when accessing paid resources, so we don't rack up charges due to an error,
+ *      but also so that it doesn't take forever for the initial call to run.
+ */
+export async function backoffRetryLoop<T>(code: () => Promise<T>, waitTime = 5 * 1000) {
+    while (true) {
+        try {
+            return await code();
+        } catch (e: any) {
+            console.error(`Error retrying in ${waitTime}ms\n${e.stack}`);
+            await delay(waitTime);
+            waitTime *= 1.01;
+        }
+    }
+}
+
+export function errorify(error: any, messageOverride?: string) {
+    if (error instanceof Error) {
+        return error;
+    }
+    let errorObj = new Error();
+    if (typeof error === "string" && error.includes("\n")) {
+        errorObj.stack = error;
+        errorObj.message = error.split("\n")[0];
+    } else {
+        errorObj.message = error;
+        errorObj.stack = error + "\n" + errorObj.stack;
+    }
+    if (messageOverride) {
+        errorObj.message = messageOverride;
+    }
+    return errorObj;
+}
+
+export function assertValue<T>(value: T | undefined | null, message?: string): T {
+    if (value === undefined || value === null) {
+        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
+    }
+    return value;
+}
+export function assert<T>(value: T | undefined | null, message?: string): asserts value is T {
+    if (value === undefined || value === null) {
+        throw new Error(`Value is ${value === undefined ? "undefined" : "null"}, ${message}`);
+    }
 }

package/src/forceProduction.ts

@@ -1,3 +1,3 @@
-if (typeof process === "object") {
-    process.env["NODE_ENV"] = "production";
+if (typeof process === "object") {
+    process.env["NODE_ENV"] = "production";
 }

package/src/fs.ts

@@ -1,81 +1,81 @@
-import { cache, lazy } from "socket-function/src/caching";
-import os from "os";
-import fs from "fs";
-import debugbreak from "debugbreak";
-import { isNode } from "socket-function/src/misc";
-import path from "path";
-import { magenta } from "socket-function/src/formatting/logColors";
-
-let rootDir = "";
-if (isNode()) {
-    let base = path.resolve(".");
-    // Search upwards until we find a package.json
-    while (base.length > 3 && !fs.existsSync(base + "/package.json")) {
-        base = path.resolve(base + "/..");
-    }
-    rootDir = pathToLongPath(base.replaceAll("\\", "/") + "/database-storage/");
-}
-
-export function setRootDirKey(key: string) {
-    rootDir = pathToLongPath(os.homedir() + "/" + key + "/");
-}
-export function setRootDir(newRootDir: string) {
-    rootDir = newRootDir;
-    rootDir = pathToLongPath(rootDir);
-}
-function pathToLongPath(fullPath: string): string {
-    // I guess we don't need the special prefix?
-    // if (isNode() && process.platform === "win32") {
-    //     fullPath = path.resolve(fullPath);
-    //     if (!fullPath.startsWith("\\\\?\\")) {
-    //         fullPath = "\\\\?\\" + fullPath;
-    //     }
-    // }
-    if (isNode()) {
-        fullPath = path.resolve(fullPath).replaceAll("\\", "/") + "/";
-    }
-    return fullPath;
-}
-
-export const getStorageDir = lazy(() => {
-    let dir = rootDir;
-    if (isNode() && !fs.existsSync(dir)) {
-        fs.mkdirSync(dir);
-    }
-    return dir;
-});
-
-export const getSubFolder = cache((path: string) => {
-    let dir = getStorageDir() + path;
-    if (!dir.endsWith("/")) {
-        dir += "/";
-    }
-    if (isNode() && !fs.existsSync(dir)) {
-        fs.mkdirSync(dir);
-    }
-    return dir;
-});
-export const getStorageFolder = getSubFolder;
-
-export async function* readDirRecursive(dir: string): AsyncGenerator<string> {
-    try {
-        for (let file of await fs.promises.readdir(dir)) {
-            let fullPath = dir + file;
-            try {
-                let stat = await fs.promises.stat(fullPath);
-                if (stat.isDirectory()) {
-                    yield* readDirRecursive(fullPath + "/");
-                }
-            } catch { }
-        }
-    } catch { }
-}
-
-export async function fsExistsAsync(path: string) {
-    try {
-        await fs.promises.stat(path);
-        return true;
-    } catch {
-        return false;
-    }
+import { cache, lazy } from "socket-function/src/caching";
+import os from "os";
+import fs from "fs";
+import debugbreak from "debugbreak";
+import { isNode } from "socket-function/src/misc";
+import path from "path";
+import { magenta } from "socket-function/src/formatting/logColors";
+
+let rootDir = "";
+if (isNode()) {
+    let base = path.resolve(".");
+    // Search upwards until we find a package.json
+    while (base.length > 3 && !fs.existsSync(base + "/package.json")) {
+        base = path.resolve(base + "/..");
+    }
+    rootDir = pathToLongPath(base.replaceAll("\\", "/") + "/database-storage/");
+}
+
+export function setRootDirKey(key: string) {
+    rootDir = pathToLongPath(os.homedir() + "/" + key + "/");
+}
+export function setRootDir(newRootDir: string) {
+    rootDir = newRootDir;
+    rootDir = pathToLongPath(rootDir);
+}
+function pathToLongPath(fullPath: string): string {
+    // I guess we don't need the special prefix?
+    // if (isNode() && process.platform === "win32") {
+    //     fullPath = path.resolve(fullPath);
+    //     if (!fullPath.startsWith("\\\\?\\")) {
+    //         fullPath = "\\\\?\\" + fullPath;
+    //     }
+    // }
+    if (isNode()) {
+        fullPath = path.resolve(fullPath).replaceAll("\\", "/") + "/";
+    }
+    return fullPath;
+}
+
+export const getStorageDir = lazy(() => {
+    let dir = rootDir;
+    if (isNode() && !fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+    return dir;
+});
+
+export const getSubFolder = cache((path: string) => {
+    let dir = getStorageDir() + path;
+    if (!dir.endsWith("/")) {
+        dir += "/";
+    }
+    if (isNode() && !fs.existsSync(dir)) {
+        fs.mkdirSync(dir);
+    }
+    return dir;
+});
+export const getStorageFolder = getSubFolder;
+
+export async function* readDirRecursive(dir: string): AsyncGenerator<string> {
+    try {
+        for (let file of await fs.promises.readdir(dir)) {
+            let fullPath = dir + file;
+            try {
+                let stat = await fs.promises.stat(fullPath);
+                if (stat.isDirectory()) {
+                    yield* readDirRecursive(fullPath + "/");
+                }
+            } catch { }
+        }
+    } catch { }
+}
+
+export async function fsExistsAsync(path: string) {
+    try {
+        await fs.promises.stat(path);
+        return true;
+    } catch {
+        return false;
+    }
 }