querysub 0.2.0

package/src/2-proxy/pathDatabaseProxyBase.ts

@@ -0,0 +1,37 @@
+import debugbreak from "debugbreak";
+
+let currentDatabase!: { value: unknown };
+const CURRENT_DATABASE_GLOBAL_KEY = "pathDatabaseProxy_currentDatabase-7010c456-d83a-40f4-a58a-0ff0251cef16";
+// NOTE: We use the global state, so that required libraries can use a different version
+//  of our library, but still share the same database!
+if ((global as any)[CURRENT_DATABASE_GLOBAL_KEY]) {
+    currentDatabase = (global as any)[CURRENT_DATABASE_GLOBAL_KEY];
+} else {
+    currentDatabase = { value: undefined };
+    (global as any)[CURRENT_DATABASE_GLOBAL_KEY] = currentDatabase;
+}
+
+export function rawSchema<Schema>(): () => Schema {
+    return () => {
+        if (!currentDatabase.value) {
+            debugbreak(2);
+            debugger;
+            throw new Error(`Cannot access synced data outside of tracked code (render functions, event callbacks, QuerySub.serviceWrite, QuerySub.createWatcher callback, etc)`);
+        }
+        return currentDatabase.value as unknown as Schema;
+    };
+}
+
+export function isInProxyDatabase() {
+    return !!currentDatabase.value;
+}
+
+export function runCodeWithDatabase<T>(database: unknown, code: () => T): T {
+    let prevDatabase = currentDatabase.value;
+    currentDatabase.value = database;
+    try {
+        return code();
+    } finally {
+        currentDatabase.value = prevDatabase;
+    }
+}

package/src/2-proxy/pathValueProxy.ts

@@ -0,0 +1,139 @@
+import { runInfinitePoll } from "socket-function/src/batching";
+import { cache, lazy } from "socket-function/src/caching";
+import { appendToPathStr, rootPathStr } from "../path";
+import { MAX_CHANGE_AGE } from "../0-path-value-core/pathValueCore";
+import { runCodeWithDatabase } from "./pathDatabaseProxyBase";
+import { canHaveChildren } from "socket-function/src/types";
+import { isNode } from "socket-function/src/misc";
+
+let noopProxy = createPathValueProxy({ getCallback: () => undefined, setCallback: () => { }, getSymbol: () => undefined, getKeys: () => [] });
+let gettingPath: { value: string } | undefined;
+export function getProxyPath(get: () => unknown): string {
+    // We need to set the database incase it isn't set.
+    return runCodeWithDatabase(noopProxy, () => {
+        if (gettingPath) throw new Error(`Can't call getProxyPath while already getting a path.`);
+        gettingPath = { value: "" };
+        try {
+            get();
+            return gettingPath.value;
+        } finally {
+            gettingPath = undefined;
+        }
+    });
+}
+
+const isProxySymbol = Symbol.for("isProxySymbol");
+export function isValueProxy(value: unknown) {
+    return canHaveChildren(value) && value[isProxySymbol];
+}
+
+const isProxySymbol2 = Symbol.for("isProxySymbol2");
+/** If it is a proxy, returns the proxy path */
+export function isValueProxy2(value: unknown): string | undefined {
+    return canHaveChildren(value) && value[isProxySymbol2] as any || undefined;
+}
+
+export const getPathFromProxy = isValueProxy2;
+(globalThis as any).getPathFromProxy = getPathFromProxy;
+
+export function createPathValueProxy(
+    config: {
+        getCallback: (pathStr: string) => { value: unknown } | undefined;
+        setCallback: (pathStr: string, value: unknown) => void;
+        hasCallback?: (pathStr: string) => boolean;
+        getSymbol: (pathStr: string, symbol: symbol) => { value: unknown } | undefined;
+        getKeys: (pathStr: string) => string[];
+    }
+): unknown {
+    let createdCount = 0;
+    let createProxyCached = cache(createProxy);
+    let proxyClearLoop = lazy(() => {
+        runInfinitePoll(MAX_CHANGE_AGE, function clearProxyCache() {
+            // TODO: Maybe allow proxies to stick around?
+            //if (createdCount > 1000 * 100)
+            {
+                createdCount = 0;
+                createProxyCached = cache(createProxy);
+            }
+        });
+    });
+    let ensureProxyClearLoop = () => {
+        if (createdCount < 1000 * 10) return;
+        proxyClearLoop();
+    };
+    return createProxyCached(rootPathStr);
+    function createProxy(parentPathStr: string) {
+        createdCount++;
+        let proxy: object = new Proxy(
+            // NOTE: This is an object now, because the data won't contain any functions, as that makes things way too
+            //  complicated, and dangerous.
+            Object.create(null),
+            {
+                get(target, property) {
+                    if (property === isProxySymbol) return true;
+                    if (property === isProxySymbol2) return parentPathStr;
+                    ensureProxyClearLoop();
+                    if (typeof property === "symbol") {
+                        let value = config.getSymbol(parentPathStr, property);
+                        if (value) {
+                            return value.value;
+                        }
+                        return createProxyCached(parentPathStr);
+                    }
+                    // if (property === "[object Object]") {
+                    //     console.warn(`Reading from key that looks like an object. Is it possible that you passed a proxy as a parameter which had no value? You might want to check if the key has a value first with if(atomic(value)). In ${parentPathStr}`);
+                    // }
+
+                    let pathStr = appendToPathStr(parentPathStr, property);
+                    if (gettingPath) {
+                        gettingPath.value = pathStr;
+                    } else {
+                        let value = config.getCallback(pathStr);
+                        if (value) {
+                            return value.value;
+                        }
+                    }
+                    return createProxyCached(pathStr);
+                },
+                set(obj, prop, value) {
+                    if (typeof prop === "symbol") {
+                        throw new Error("Can't set symbol properties in the database");
+                    }
+                    let pathStr = appendToPathStr(parentPathStr, prop);
+                    config.setCallback(pathStr, value);
+                    return true;
+                },
+                // Just convert delete to be a set to undefined, so everything works
+                deleteProperty(target, prop) {
+                    if (typeof prop === "symbol") {
+                        throw new Error("Can't set symbol properties in the database");
+                    }
+                    let pathStr = appendToPathStr(parentPathStr, prop);
+                    config.setCallback(pathStr, undefined);
+                    return true;
+                },
+                getOwnPropertyDescriptor(target, property) {
+                    // NOTE: The "value" field shouldn't even be part of the property descriptor, and usually isn't
+                    //  used. Returning it would just be inefficient, So while we should have
+                    //  `value: this[prop]` here, I'm not adding it.
+                    return { configurable: true, enumerable: true, writable: true };
+                },
+                ownKeys(target) {
+                    return config.getKeys(parentPathStr);
+                },
+                has(target, property) {
+                    if (typeof property === "symbol") {
+                        return (proxy as any)[property] !== undefined;
+                    }
+                    if (config.hasCallback) {
+                        let pathStr = appendToPathStr(parentPathStr, property);
+                        return config.hasCallback(pathStr);
+                    }
+                    let keys = config.getKeys(parentPathStr);
+                    return keys.includes(property as string);
+                }
+            }
+        );
+        return proxy;
+    }
+}