querysub 0.2.0

package/src/errors.ts

@@ -0,0 +1,132 @@
+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;
+    } else {
+        errorObj.message = error;
+    }
+    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

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

package/src/fs.ts

@@ -0,0 +1,72 @@
+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 { }
+}