querysub 0.437.0 → 0.439.0

package/src/2-proxy/TransactionDelayer.ts

@@ -1,95 +1,95 @@
-import { delay } from "socket-function/src/batching";
-import { PathValue, hashPathForTransaction, compareTime, Time } from "../0-path-value-core/pathValueCore";
-import { proxyWatcher } from "./PathValueProxyWatcher";
-
-const MISSING_TRANSACTION_PART_TIMEOUT = 5000;
-
-export function isMissingTransactionPart(pathValues: PathValue[]): { time: number; path: string; } | undefined {
-    // Create a map of path hash -> time for quick lookups
-    const pathHashToTime = new Map<string, {
-        time: Time;
-        path: string;
-    }>();
-    for (const pv of pathValues) {
-        const hash = hashPathForTransaction(pv.path);
-        const existing = pathHashToTime.get(hash);
-        // Keep the latest time for this path
-        if (!existing || compareTime(pv.time, existing.time) > 0) {
-            pathHashToTime.set(hash, {
-                time: pv.time,
-                path: pv.path,
-            });
-        }
-    }
-
-    // Group PathValues by their transactionPaths array reference
-    const uniqueTransactions = new Map<string[], Time>();
-    for (const pathValue of pathValues) {
-        if (!pathValue.transactionPaths || pathValue.transactionPaths.length === 0) {
-            continue;
-        }
-
-        const existing = uniqueTransactions.get(pathValue.transactionPaths);
-        if (!existing) {
-            uniqueTransactions.set(pathValue.transactionPaths, pathValue.time);
-        }
-    }
-
-    let newestWaitTime: {
-        time: number;
-        path: string;
-    } | undefined = undefined;
-
-    // Check each unique transaction only once
-    for (const [transactionPaths, transactionTime] of uniqueTransactions) {
-        for (const transactionPathHash of transactionPaths) {
-            const pathTime = pathHashToTime.get(transactionPathHash);
-            if (!pathTime) continue;
-
-            // We know that there's a value with this path hash at the transaction time. And so if the value that we've read is before that, then we haven't read the latest value. So we know that we're missing part of the transaction.
-            const timeComparison = compareTime(pathTime.time, transactionTime);
-            if (timeComparison < 0) {
-                if (!newestWaitTime || transactionTime.time > newestWaitTime.time) {
-                    newestWaitTime = {
-                        time: transactionTime.time,
-                        path: pathTime.path,
-                    };
-                }
-            }
-        }
-    }
-    if (!newestWaitTime) return undefined;
-    return newestWaitTime;
-}
-
-export function getAllPendingPathValueReads() {
-    let values: PathValue[] = [];
-    let watcher = proxyWatcher.getTriggeredWatcher();
-    for (let map of watcher.pendingAccesses.values()) {
-        for (let pathValue of map.values()) {
-            values.push(pathValue.pathValue);
-        }
-    }
-    return values;
-}
-
-
-export function waitIfReceivedIncompleteTransaction() {
-    // 1) Keep track of the last proxy watcher we just registered it for. And then if the proxy watcher is the same as that one and that proxy watcher is waiting on a promise, don't register it again. 
-    let watcher = proxyWatcher.getTriggeredWatcher();
-    // We don't want to register a whole bunch of duplicate promises. So if somebody's waiting, there's no need to even do our check. 
-    if (watcher.specialPromiseUnsynced) return;
-
-    let newestTime = isMissingTransactionPart(getAllPendingPathValueReads());
-    if (!newestTime) return;
-
-    let timeout = newestTime.time + MISSING_TRANSACTION_PART_TIMEOUT;
-    let now = Date.now();
-    if (timeout < now) return;
-
-    let promise = delay(timeout - now);
-    // This really nicely both blocks it from finishing because of the waiting for the promise and also triggers it automatically when the delay finishes. HOWEVER, In practice, the promise should never be required to trigger it. It should trigger when we receive the missing parts of the transaction, which we will be, of course, watching as they're in the path values that we're accessing. The timeout is just in case something goes wrong and we incorrectly think we should receive the values, but we won't. That way, eventually, we do commit the value. 
-    // ALSO! Plus the hash I think only stores like 48 bits. So the chance of collision is somewhat high, especially if we're accessing thousands of paths. So sometimes this will trigger even though we're not missing any part just because we had a collision between the path hashes. 
-    proxyWatcher.triggerOnPromiseFinish(promise, { waitReason: "Missing transaction part" });
-    console.error(`(NOT an error, convert this to a warning after we finish testing). Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
+import { delay } from "socket-function/src/batching";
+import { PathValue, hashPathForTransaction, compareTime, Time } from "../0-path-value-core/pathValueCore";
+import { proxyWatcher } from "./PathValueProxyWatcher";
+
+const MISSING_TRANSACTION_PART_TIMEOUT = 5000;
+
+export function isMissingTransactionPart(pathValues: PathValue[]): { time: number; path: string; } | undefined {
+    // Create a map of path hash -> time for quick lookups
+    const pathHashToTime = new Map<string, {
+        time: Time;
+        path: string;
+    }>();
+    for (const pv of pathValues) {
+        const hash = hashPathForTransaction(pv.path);
+        const existing = pathHashToTime.get(hash);
+        // Keep the latest time for this path
+        if (!existing || compareTime(pv.time, existing.time) > 0) {
+            pathHashToTime.set(hash, {
+                time: pv.time,
+                path: pv.path,
+            });
+        }
+    }
+
+    // Group PathValues by their transactionPaths array reference
+    const uniqueTransactions = new Map<string[], Time>();
+    for (const pathValue of pathValues) {
+        if (!pathValue.transactionPaths || pathValue.transactionPaths.length === 0) {
+            continue;
+        }
+
+        const existing = uniqueTransactions.get(pathValue.transactionPaths);
+        if (!existing) {
+            uniqueTransactions.set(pathValue.transactionPaths, pathValue.time);
+        }
+    }
+
+    let newestWaitTime: {
+        time: number;
+        path: string;
+    } | undefined = undefined;
+
+    // Check each unique transaction only once
+    for (const [transactionPaths, transactionTime] of uniqueTransactions) {
+        for (const transactionPathHash of transactionPaths) {
+            const pathTime = pathHashToTime.get(transactionPathHash);
+            if (!pathTime) continue;
+
+            // We know that there's a value with this path hash at the transaction time. And so if the value that we've read is before that, then we haven't read the latest value. So we know that we're missing part of the transaction.
+            const timeComparison = compareTime(pathTime.time, transactionTime);
+            if (timeComparison < 0) {
+                if (!newestWaitTime || transactionTime.time > newestWaitTime.time) {
+                    newestWaitTime = {
+                        time: transactionTime.time,
+                        path: pathTime.path,
+                    };
+                }
+            }
+        }
+    }
+    if (!newestWaitTime) return undefined;
+    return newestWaitTime;
+}
+
+export function getAllPendingPathValueReads() {
+    let values: PathValue[] = [];
+    let watcher = proxyWatcher.getTriggeredWatcher();
+    for (let map of watcher.pendingAccesses.values()) {
+        for (let pathValue of map.values()) {
+            values.push(pathValue.pathValue);
+        }
+    }
+    return values;
+}
+
+
+export function waitIfReceivedIncompleteTransaction() {
+    // 1) Keep track of the last proxy watcher we just registered it for. And then if the proxy watcher is the same as that one and that proxy watcher is waiting on a promise, don't register it again. 
+    let watcher = proxyWatcher.getTriggeredWatcher();
+    // We don't want to register a whole bunch of duplicate promises. So if somebody's waiting, there's no need to even do our check. 
+    if (watcher.specialPromiseUnsynced) return;
+
+    let newestTime = isMissingTransactionPart(getAllPendingPathValueReads());
+    if (!newestTime) return;
+
+    let timeout = newestTime.time + MISSING_TRANSACTION_PART_TIMEOUT;
+    let now = Date.now();
+    if (timeout < now) return;
+
+    let promise = delay(timeout - now);
+    // This really nicely both blocks it from finishing because of the waiting for the promise and also triggers it automatically when the delay finishes. HOWEVER, In practice, the promise should never be required to trigger it. It should trigger when we receive the missing parts of the transaction, which we will be, of course, watching as they're in the path values that we're accessing. The timeout is just in case something goes wrong and we incorrectly think we should receive the values, but we won't. That way, eventually, we do commit the value. 
+    // ALSO! Plus the hash I think only stores like 48 bits. So the chance of collision is somewhat high, especially if we're accessing thousands of paths. So sometimes this will trigger even though we're not missing any part just because we had a collision between the path hashes. 
+    proxyWatcher.triggerOnPromiseFinish(promise, { waitReason: "Missing transaction part" });
+    console.error(`(NOT an error, convert this to a warning after we finish testing). Waiting for missing transaction part ${newestTime.path} which was written at time ${newestTime.time} (now is ${now}). We have parts of this transaction, but we are missing this specific path.`);
 }

package/src/2-proxy/pathDatabaseProxyBase.ts

@@ -1,37 +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;
-    }
+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

@@ -1,160 +1,160 @@
-import { runInfinitePoll } from "socket-function/src/batching";
-import { cache, lazy } from "socket-function/src/caching";
-import { appendToPathStr, rootPathStr } from "../path";
-import { runCodeWithDatabase } from "./pathDatabaseProxyBase";
-import { canHaveChildren } from "socket-function/src/types";
-import { isNode, timeInMinute } from "socket-function/src/misc";
-
-let noopProxy = createPathValueProxy({ getCallback: () => undefined, setCallback: () => { }, getSymbol: () => undefined, getKeys: () => [] });
-let gettingPath: { value: string } | undefined;
-let gettingPathAndWatch: { value: string } | undefined;
-// IMPORTANT! Does NOT add a watch to the proxy path! This means it can be used to check
-//  if a path is being watched.
-//  - HOWEVER, it also runs the get() WITHOUT synced state, so if you want to access any nested synced
-//      objects, you need to get their values outside of the get (which can incur a watch).
-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;
-        }
-    });
-}
-
-export function getProxyPathAndWatch(get: () => unknown): string {
-    // We need to set the database incase it isn't set.
-    return runCodeWithDatabase(noopProxy, () => {
-        if (gettingPathAndWatch) throw new Error(`Can't call getProxyPathAndWatch while already getting a path.`);
-        gettingPathAndWatch = { value: "" };
-        try {
-            get();
-            return gettingPathAndWatch.value;
-        } finally {
-            gettingPathAndWatch = 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(timeInMinute * 5, 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 {
-                        if (gettingPathAndWatch) {
-                            gettingPathAndWatch.value = pathStr;
-                        }
-                        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;
-    }
+import { runInfinitePoll } from "socket-function/src/batching";
+import { cache, lazy } from "socket-function/src/caching";
+import { appendToPathStr, rootPathStr } from "../path";
+import { runCodeWithDatabase } from "./pathDatabaseProxyBase";
+import { canHaveChildren } from "socket-function/src/types";
+import { isNode, timeInMinute } from "socket-function/src/misc";
+
+let noopProxy = createPathValueProxy({ getCallback: () => undefined, setCallback: () => { }, getSymbol: () => undefined, getKeys: () => [] });
+let gettingPath: { value: string } | undefined;
+let gettingPathAndWatch: { value: string } | undefined;
+// IMPORTANT! Does NOT add a watch to the proxy path! This means it can be used to check
+//  if a path is being watched.
+//  - HOWEVER, it also runs the get() WITHOUT synced state, so if you want to access any nested synced
+//      objects, you need to get their values outside of the get (which can incur a watch).
+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;
+        }
+    });
+}
+
+export function getProxyPathAndWatch(get: () => unknown): string {
+    // We need to set the database incase it isn't set.
+    return runCodeWithDatabase(noopProxy, () => {
+        if (gettingPathAndWatch) throw new Error(`Can't call getProxyPathAndWatch while already getting a path.`);
+        gettingPathAndWatch = { value: "" };
+        try {
+            get();
+            return gettingPathAndWatch.value;
+        } finally {
+            gettingPathAndWatch = 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(timeInMinute * 5, 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 {
+                        if (gettingPathAndWatch) {
+                            gettingPathAndWatch.value = pathStr;
+                        }
+                        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;
+    }
 }