querysub 0.2.0

package/src/3-path-functions/syncSchema.ts

@@ -0,0 +1,475 @@
+import fs from "fs";
+import { cache } from "socket-function/src/caching";
+import { getStringKeys, sort } from "socket-function/src/misc";
+import { Args } from "socket-function/src/types";
+import { appendToPathStr, getPathFromStr, getPathStr, rootPathStr } from "../path";
+import { writeFunctionCall } from "./PathFunctionHelpers";
+import { CallSpec, functionSchema } from "./PathFunctionRunner";
+import { getDomain } from "../config";
+import { isHotReloading } from "socket-function/hot/HotReloadController";
+import { Schema2, Schema2Fncs, Schema2T, SchemaPath } from "../2-proxy/schema2";
+import { PathValueProxyWatcher, atomic, proxyWatcher, registerSchema } from "../2-proxy/PathValueProxyWatcher";
+import { registerAliveChecker } from "../2-proxy/garbageCollection";
+import { rawSchema } from "../2-proxy/pathDatabaseProxyBase";
+import { ARCHIVE_FLUSH_LIMIT } from "../0-path-value-core/pathValueCore";
+import debugbreak from "debugbreak";
+import { getPathFromProxy, getProxyPath } from "../2-proxy/pathValueProxy";
+import { CALL_PERMISSIONS_KEY } from "../4-querysub/permissionsShared";
+import { LOCAL_DOMAIN } from "../0-path-value-core/PathController";
+import path from "path";
+
+// This is the the function id which should be used when creating the FunctionSpec (in order to load the module),
+//  to access the permissions in the schema.
+export const PERMISSIONS_FUNCTION_ID = "PERMISSIONS_FUNCTION_ID";
+
+const SCHEMA_EXPORT_KEY = "schema-00c87ab5-10bb-4795-8f6b-e187a7e45841";
+export function getSchemaObject(module: NodeJS.Module): SchemaObject | undefined {
+    return module.exports[SCHEMA_EXPORT_KEY];
+}
+
+export function getExportPath(functionId: string): string {
+    return getPathStr([SCHEMA_EXPORT_KEY, "rawFunctions", functionId]);
+}
+
+export type FunctionMetadata<F = unknown> = {
+    nopredict?: boolean;
+    /** Delay functions commits by Querysub.DELAY_COMMIT_DELAY
+     *      - We collapse redundant delayed calls, by looking at reads/writes.
+     *      - IMPORTANT! If you delay a function which writes to A, then write to B, which triggers
+     *          a remote server to read A, the server will read the old value of A, which breaks things.
+     *          If this is happening, either stop delaying writes to A, OR, call flushDelayedFunctions
+     *          before writing to B.
+     */
+    delayCommit?: boolean;
+};
+
+export interface SchemaObject<Schema = any, Functions = any> {
+    data: () => Schema;
+    moduleId: string;
+    functions: {
+        [key in keyof Functions]: (
+            //Functions[key] &
+            // NOTE: Functions don't have results, if you want a result write to the database
+            //  and then watch it for the result.
+            //  - The promise resolves once the function has started the commit process, NOT when
+            //      it has finished. Once it resolves you can terminate your process and the function
+            //      will run (but it might still error out due to taking too long to reach the server,
+            //      or too long to run, or insufficient privileges, etc, etc).
+            ((...args: Args<Functions[key]>) => CallSpec) & {
+                // Add a "debugger;" when the holding function is called, to make it easy to debug the function
+                debug(): void;
+            }
+        )
+    };
+    functionMetadata: {
+        [key in keyof Functions]?: FunctionMetadata<Functions[key]> | undefined;
+    };
+    rawFunctions: Functions;
+    permissions: SchemaToPermissions<Schema> | undefined;
+    permissionsNonWildcards: Map<string, PermissionsCallback>;
+    // Sorted by most nested first
+    permissionsWildcards: {
+        pathParts: string[];
+        callback: PermissionsCallback;
+    }[];
+}
+
+let existsCached = cache((path: string) => {
+    return fs.existsSync(path);
+});
+
+
+export function getModuleRelativePath(module: NodeJS.Module): string {
+    let root = path.resolve(".").replaceAll("\\", "/");
+    if (!existsCached(root + "/package.json")) {
+        throw new Error(`Expected to find package.json at ${root}. The current directory must be the root of the project when deploying, so we can resolve relative file references.`);
+    }
+    // Get the relative path
+    let relativePath = path.relative(root, module.filename).replaceAll("\\", "/");
+    if (relativePath.startsWith("../")) {
+        let otherFolder = relativePath.split("/")[1];
+        if (existsCached("node_modules/" + otherFolder)) {
+            relativePath = "node_modules/" + otherFolder + "/" + relativePath.split("/").slice(2).join("/");
+        }
+    }
+    return "/" + relativePath;
+}
+
+export type PermissionsParameters = {
+    // Each part of the path that matched with a wildcard ("*") is added to this array (in order).
+    pathWildcards: string[];
+    /**
+     *  The path the permissions check matched.
+     *      NOTE: The full path matched is not provided for optimization purposes. Otherwise for large
+     *          writes the permissions check would be needlessly run. IF further depth is required,
+     *          use "*" wildcards. If the depth is dynamic... your structure is probably too complex,
+     *          or something similar to a tree. Destructure it to a list, and all of your
+     *          code will run significantly faster.
+     * 
+     *          TODO: If we ABSOLUTELY need it, we COULD conditionally expose fullPath, and just disable
+     *              optimizations when we do. We could even have a parameter which replaces matchedPath with
+     *              fullPath. But, ideally we don't, as it is just very inefficient...
+     *      NOTE: Usually pathWildcards should be used instead. This is only useful if you want to create
+     *          a very generic permission check which can be used in many hierarchies, and depends on the
+     *          hierarchy (ex, if it checks path.slice(0, 3).users for the users table).
+     **/
+    matchedPath: string;
+    /** The callerMachineId will be unique to the calling machine (but a machine may have multiple,
+            ex, 1 per browser, another a fresh one if they are in incognito mode).
+            - To tie machineIds to userIds simple create a lookup in your database, for example:
+                    `{ machineToUserId: { [machineId: string]: string | undefined } }`
+                Logging out from a machine is simply:
+                    `machineToUserId[machineId] = undefined`
+                A reverse index may also be useful, to efficiently log out everywhere (or just
+                    show all machines that a user is logged into)
+                ```
+                    { userIdToMachineIds: { [userId: string]: { [machineId: string]: 1 } } }
+                   funcion logoutEverywhere(userId: string) {
+                        for (let machineId in userIdToMachineIds[userId]) {
+                            userIdToMachineIds[userId][machineId] = undefined;
+                            machineToUserId[machineId] = undefined;
+                        }
+                    }
+                ```
+     * */
+    callerMachineId: string;
+};
+/** A false of false will deny read permissions, resulting in all reads being given value with a value
+ *      of undefined, and a time of 0.
+ *  NOTE: Permissions checks at the root (permissions: { READ_PERMISSIONS(config) { } }) will
+ *      be used to verify calls are allowed as well, even if the call doesn't read or write any data
+ *      that is under a permissions check.
+ */
+export type PermissionsCallback = (config: PermissionsParameters) => PermissionsCheckResult;
+export type PermissionsCheckResult = boolean | { allowed: boolean; skipParentChecks?: boolean; };
+/*
+    NOTE: All ancestor permissions checks are applied as well.
+
+    IMPORTANT! Wildcards are tested via the "" path. This means if the "" key is provided access to a user, they can run
+        Object.keys()/Object.values() on the data. In order to not accidentally provide list access, never allow "" to be
+        a valid path, by never providing access by exclusion. For example:
+            BROKEN: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] !== "admin" || users()[config.callerId].isAdmin; } } }`
+                - This will allow users to access the "admin" data via Object.values(), because the "" !== "admin"
+            BROKEN: `{ admin: { PERMISSIONS(){ return users()[config.callerId].isAdmin; } } }`
+                - Because "" isn't checked
+            CORRECT: `{ ["*"]: { PERMISSIONS(){ return config.pathWildcards?.[0] === config.callerId; } } }`
+            CORRECT: `{ ["*"]: { PERMISSIONS(){ return users()[config.callerId].isAdmin || config.pathWildcards?.[0] === config.callerId; } } }`
+
+    NOTE: Permission checks lag a bit behind data. This means not only will a write that removes checks of itself
+        still be sent (ex, if a user removes their admin access, and only admins can see who is an admin or not,
+        they will be told about their admin change). BUT, a user will receive writes for a bit after that as well!
+        The delay is equal to the network propagation time between two server, which is small (ideally milliseconds),
+        but in the case of excess lag could easily be 10s of seconds (in which case everything on the site would
+        be lagging by 10s of seconds as well).
+
+    For example
+        permissions: {
+            userSecretData: {
+                ["*"]: {
+                    PERMISSIONS(pathWildcards) {
+                        return config.pathWildcards[0] === config.callerMachineId;
+                    }
+                }
+            }
+        }
+*/
+export type SchemaToPermissions<Schema> = {
+    [key in keyof Schema]?: SchemaToPermissions<Schema[key]>;
+} & {
+    PERMISSIONS?: PermissionsCallback;
+} | {
+    PERMISSIONS?: PermissionsCallback;
+};
+
+/** A special key which is prefixed (along with a random value) before special keys used to check child
+ *      permissions. This allows us to explicitly disallow parent syncing (ex Object.keys()) of values.
+ */
+export const CHILD_CHECK_PREFIX = "";
+
+export function hasWildcardMatch(permissionsPath: string[], valuePathParts: string[]): boolean {
+    for (let i = 0; i < permissionsPath.length; i++) {
+        let part = permissionsPath[i];
+        if (part === "*") {
+
+        } else if (part !== valuePathParts[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function getWildcardMatches(permissionsPath: string[], valuePathParts: string[]): string[] | undefined {
+    if (permissionsPath.length > valuePathParts.length) return undefined;
+    let wildcardMatches: string[] | undefined;
+    for (let i = 0; i < permissionsPath.length; i++) {
+        let part = permissionsPath[i];
+        if (part === "*") {
+            if (!wildcardMatches) wildcardMatches = [];
+            wildcardMatches.push(valuePathParts[i]);
+        } else if (part !== valuePathParts[i]) {
+            return undefined;
+        }
+    }
+    return wildcardMatches;
+}
+
+let inliningCalls = false;
+export function inlineNestedCalls<T>(code: () => T) {
+    let prev = inliningCalls;
+    inliningCalls = true;
+    try {
+        return code();
+    } finally {
+        inliningCalls = prev;
+    }
+}
+
+type SyncSchemaResult<Schema> = {
+    // NOTE: The functions are over the network, AND, eventually consistent, so it is not possible
+    //  for them to return a result. If a result is required, pass an id which will instruct them where
+    //  to write their result to, and then watch that location.
+    <Functions extends { [name: string]: ((...args: any) => void) }>(config: {
+        domainName?: string;
+        /** NOTE: moduleId is used to store your data in a unique location, that doesn't change
+         *      if you move this file around. Any unique identifier is allowed, as the deploy command
+         *      will warn you if you accidentally reused a moduleId.
+         */
+        moduleId: string;
+        module: NodeJS.Module;
+        functions: Functions;
+        functionMetadata?: { [name in keyof Functions]?: FunctionMetadata<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]?: {
+                PERMISSIONS: PermissionsCallback;
+            };
+        };
+    }): SchemaObject<Schema, Functions>;
+};
+
+export function syncSchema<Schema>(): SyncSchemaResult<Schema>;
+export function syncSchema<SchemaDef extends Schema2>(schema: SchemaDef): SyncSchemaResult<Schema2T<SchemaDef>>;
+export function syncSchema<Schema>(schema?: Schema2): SyncSchemaResult<Schema> {
+    return function getFunctions(config) {
+        const { moduleId, functions, module, permissions } = config;
+        const domainName = config.domainName ?? getDomain();
+
+        const data = () => functionSchema()[domainName].PathFunctionRunner[moduleId].Data;
+
+        let fncs = { ...functions };
+
+        let undoChecksAdded: {
+            name: string;
+            path: SchemaPath;
+        }[] = [];
+        if (schema) {
+            let dataPrefixPath = getPathFromStr(getProxyPath(data));
+            registerSchema({ domainName, moduleId, schema });
+
+            let gcDefs = Schema2Fncs.getGCObjects(schema);
+            for (let { path, gcDelay } of gcDefs) {
+                createObjectAliveChecker(data, path, gcDelay);
+            }
+
+            let undoChecks = Schema2Fncs.getAllUndoChecks(schema);
+            for (let checkObj of undoChecks) {
+                // Need at least one check
+                if (checkObj.undoChecks.length === 0) continue;
+                function niceSchemaPath(path: SchemaPath) {
+                    return path.map(x => x === Schema2Fncs.WildCard ? "*" : x).join(".");
+                }
+                let name = `__undoer__${niceSchemaPath(checkObj.path)}`;
+                let fullPath = (dataPrefixPath as SchemaPath).concat(checkObj.path);
+                undoChecksAdded.push({
+                    name,
+                    path: fullPath,
+                });
+                (fncs as any)[name] = function undoCallback(path: string[], value: unknown) {
+                    if (!isChildPath(fullPath, path)) {
+                        throw new Error(`Tried to access undo function with path not under undo spec ${niceSchemaPath(fullPath)} . Tried to use path ${path.join(".")}`);
+                    }
+
+                    let permissionsChecker = proxyWatcher.getTriggeredWatcher().permissionsChecker;
+                    if (permissionsChecker) {
+                        let permissionsCheck = permissionsChecker.checkPermissions(getPathStr(path));
+                        if (!permissionsCheck?.allowed) {
+                            throw new Error(`Failed read permission check for undo call at path ${path.join(".")}`);
+                        }
+                    }
+                    for (let check of checkObj.undoChecks) {
+                        let nestedPath = path.slice(0, fullPath.length);
+                        let key = nestedPath[nestedPath.length - 1];
+                        if (!atomic(check(key, nestedPath))) {
+                            throw new Error(`Failed undo permission check at path ${nestedPath.join(".")}, check ${check.name || check.toString().slice(0, 100)}`);
+                        }
+                    }
+                    let parent = rawSchema()() as any;
+                    for (let i = 0; i < path.length - 1; i++) {
+                        parent = parent[path[i]];
+                    }
+                    let key = path[path.length - 1];
+
+                    // NOTE: This isn't an atomic set, because we leave it up proxyWatcher (and schema2)
+                    //  to correctly handle assigning the values atomically.
+                    parent[key] = value;
+                };
+            }
+        }
+
+        let wrappedFunctions: { [name: string]: (...args: any) => CallSpec } = Object.create(null);
+        let functionMetadata = config.functionMetadata;
+        for (let [name, fnc] of Object.entries(fncs)) {
+            let metadata = functionMetadata?.[name] ?? {};
+            let debugging = false;
+            wrappedFunctions[name] = Object.assign((...args: any[]): any => {
+                if (inliningCalls) {
+                    return fnc(...args);
+                }
+                if (debugging) {
+                    debugger;
+                }
+                return writeFunctionCall({
+                    domainName,
+                    moduleId,
+                    functionId: name,
+                    args,
+                    metadata,
+                });
+            }, {
+                debug() {
+                    debugging = true;
+                }
+            });
+        }
+
+        for (let check of undoChecksAdded) {
+            registeredUndoChecks.push({
+                path: check.path,
+                undoSet: wrappedFunctions[check.name] as any,
+            });
+        }
+
+        let permissionsNonWildcards = new Map<string, PermissionsCallback>();
+        let permissionsWildcards: { pathParts: string[]; callback: PermissionsCallback }[] = [];
+        if (permissions) {
+            addPermissions(rootPathStr, permissions);
+        }
+        function addPermissions(path: string, permissions: SchemaToPermissions<Schema> | undefined) {
+            if (!permissions) return;
+            for (let key of getStringKeys(permissions)) {
+                if (key === "PERMISSIONS") {
+                    let value = permissions.PERMISSIONS;
+                    if (value) {
+                        if (path.includes("*")) {
+                            permissionsWildcards.push({
+                                pathParts: getPathFromStr(path),
+                                callback: value,
+                            });
+                        } else {
+                            permissionsNonWildcards.set(path, value);
+                        }
+                    }
+                } else {
+                    addPermissions(appendToPathStr(path, key), permissions[key]);
+                }
+            }
+        }
+        // Sort reversed, so the most specific checks are first
+        permissionsWildcards.sort((b, a) => a.pathParts.length - b.pathParts.length);
+
+        let result: SchemaObject = {
+            data,
+            moduleId,
+            functions: wrappedFunctions as any,
+            functionMetadata: functionMetadata as any,
+            rawFunctions: fncs,
+            permissions,
+            permissionsNonWildcards,
+            permissionsWildcards,
+        };
+        if (!isHotReloading() && module.exports[SCHEMA_EXPORT_KEY]) {
+            throw new Error(`Module ${moduleId} already has a schema. Only 1 schema is allowed per module.`);
+        }
+        // NOTE: We clobber the previous value, as we might just be hotreloading, which
+        //  could mean the exports value has our previous value.
+        module.exports[SCHEMA_EXPORT_KEY] = result;
+        return result;
+    };
+}
+
+function isChildPath(spec: SchemaPath, path: string[]): boolean {
+    if (spec.length > path.length) return false;
+    for (let i = 0; i < spec.length; i++) {
+        if (spec[i] === Schema2Fncs.WildCard) continue;
+        if (spec[i] !== path[i]) return false;
+    }
+    return true;
+}
+
+// pathStr => ...
+let registeredUndoChecks: {
+    path: SchemaPath;
+    undoSet: (nestedPath: string[], value: unknown) => void;
+}[] = [];
+
+export function registerUndoCallback(path: SchemaPath, undoSet: (nestedPath: string[], value: unknown) => void) {
+    registeredUndoChecks.push({ path, undoSet });
+}
+
+/** Throws if there is no undo callback available at this path. */
+export function getUndoCallback(path: string[]): {
+    setValue(path: string[], value: unknown): void;
+} {
+    // Local undos are always allowed
+    if (path[0] === LOCAL_DOMAIN) {
+        return {
+            setValue(path, value) {
+                if (path[0] !== LOCAL_DOMAIN) throw new Error(`Cannot set non-local value with local undo function. Tried to use path ${path.join(".")}`);
+                let parent = rawSchema()() as any;
+                for (let i = 0; i < path.length - 1; i++) {
+                    parent = parent[path[i]];
+                }
+                let key = path[path.length - 1];
+                parent[key] = value;
+            }
+        };
+    }
+    // Any callback should be fine?
+    let undoCallbacks = registeredUndoChecks.filter(x => isChildPath(x.path, path));
+    sort(undoCallbacks, x => -x.path.length);
+    if (undoCallbacks.length === 0) {
+        throw new Error(`No undo callback available at path ${path.join(".")}. There needs to be an undo region at or above this path, via t.undoRegion`);
+    }
+    return { setValue: undoCallbacks[0].undoSet };
+}
+
+function createObjectAliveChecker(data: () => any, path: SchemaPath, delay: number | undefined) {
+    registerAliveChecker({
+        object(wildcard) {
+            let obj = data();
+            for (let part of path) {
+                if (part === Schema2Fncs.WildCard) {
+                    obj = obj[wildcard];
+                } else {
+                    obj = obj[part];
+                }
+            }
+            return obj;
+        },
+        isAlive(value, path) {
+            let parent = rawSchema()() as any;
+            for (let i = 0; i < path.length - 1; i++) {
+                parent = parent[path[i]];
+            }
+            let key = path[path.length - 1];
+            let isAlive = key in parent;
+            return isAlive;
+        },
+        deleteDelayTime: delay,
+        // NOTE: This is actually safe, as we only read a single value, and are really
+        //  just looking to see if ANYTHING has created the value. Without this there is
+        //  a large gap when the value could be deleted, then undeleted, and then
+        //  as we only read old values we might not see the undelete. WITH this the gap
+        //  is much smaller (but still there).
+        unsafeLiveReads: true,
+    });
+}

package/src/3-path-functions/tests/functionsTest.ts

@@ -0,0 +1,135 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { delay } from "socket-function/src/batching";
+import { magenta, red } from "socket-function/src/formatting/logColors";
+import { measureCode } from "socket-function/src/profiling/measure";
+import { getThreadKeyCert } from "../../-a-auth/certs";
+import { logErrors } from "../../errors";
+import { getPathStr1 } from "../../path";
+import { proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
+import { pathValueCommitter } from "../../0-path-value-core/PathValueController";
+import { quietCoreMode } from "../../0-path-value-core/pathValueCore";
+import { PathFunctionRunner } from "../PathFunctionRunner";
+import * as FunctionRunner from "../PathFunctionRunner";
+import * as test from "../../../../shard-app/src/data";
+import { deployFunction } from "../PathFunctionHelpers";
+
+// async function testCallFunctions() {
+//     //ActionsHistory.LOG_ACTION_HISTORY = "caller";
+
+//     quietCoreMode();
+//     // ClientWatcher.DEBUG_READS = true;
+//     // ClientWatcher.DEBUG_WRITES = true;
+//     //PathValueProxyWatcher.DEBUG = true;
+//     //PathFunctionRunner.DEBUG_CALLS = true;
+
+//     await SocketFunction.mount({ port: 0, ...await getThreadKeyCert() });
+
+//     let count = 1000 * 1000;
+//     let writesBetweenDelays = 500;
+//     let delayTime = 1000;
+//     // writesBetweenDelays = 10;
+//     //count = 1;
+//     //count = 0;
+//     // 0 + 30 * 4 = 120
+//     //count = 1000 * 100;
+//     //count = 1000 * 10;
+//     //count = 1000;
+//     //count = 100;
+//     count = 1;
+
+//     await delay(1000);
+
+//     await measureCode(async function testCallFunctions() {
+
+//         const moduleId = "880d9f63-232a-4df7-86b8-eeb711ac3e48";
+//         const functionId = "80d87119-68fc-4440-87d9-fcbab00bec22";
+//         // Deploy the function
+//         await deployFunction({
+//             domainName: "querysub.com",
+//             moduleId,
+//             functionId,
+//             filePath: "/test.ts",
+//             exportPathStr: getPathStr1("testWrite"),
+//             gitRef: "main",
+//             gitURL: "https://github.com/sliftist/shard-app.git",
+//         });
+
+
+//         let lastValue = await proxyWatcher.commitFunction({
+//             debugName: "readValue",
+//             watchFunction() {
+//                 return +test.schema()["querysub.com"].testData.test;
+//             },
+//         });
+//         let endValue = lastValue + count;
+
+//         console.log(magenta(`Start at ${lastValue}`));
+
+//         let triggerReaderCount = 0;
+//         // Watch for updates
+//         proxyWatcher.createWatcher({
+//             watchFunction: function reader() {
+//                 const testData = test.schema()["querysub.com"].testData;
+//                 let value = testData.test;
+//                 lastValue = value as number;
+//                 triggerReaderCount++;
+//             }
+//         });
+
+//         // Write function calls
+//         for (let i = 0; i < count; i++) {
+//             FunctionRunner.writeFunctionCall({
+//                 domainName: "querysub.com",
+//                 moduleId,
+//                 functionId,
+//                 args: ["test"],
+//             });
+//             if (i % (writesBetweenDelays + 1) === 0) {
+//                 // Wait a while, so FunctionRunner has a change to actually run the calls.
+//                 console.log(`Delay to give functions time to run (at ${lastValue})`);
+//                 await delay(delayTime);
+//                 console.log(`(at ${lastValue})`);
+//             }
+//         }
+
+//         await pathValueCommitter.waitForValuesToCommit();
+//         await delay(1000 * 2);
+
+//         while (!(lastValue >= endValue)) {
+//             console.log(`Waiting for ${endValue}, value is ${lastValue} (${endValue - lastValue} to go)`);
+//             await delay(1000);
+//         }
+
+//         console.log(magenta(`Finished at ${endValue}`));
+//     });
+//     console.log(`PathFunctionRunner.RUN_FINISH_COUNT = ${PathFunctionRunner.RUN_FINISH_COUNT}`);
+
+//     /*
+//     // NOTE: Temporary, to ensure we aren't leaking memory
+//     console.log(`Wait for memory to clear`);
+//     await delay(MAX_CHANGE_AGE);
+//     await delay(MAX_CHANGE_AGE);
+//     global.gc?.();
+//     console.log(`Done waiting memory to clear`);
+//     await writeHeapSnapshot(getSubFolder("heapdumps"));
+//     console.log(`Done post heap dump`);
+//     */
+
+//     process.exit();
+// }
+// if (process.argv.includes("--caller")) {
+//     logErrors(testCallFunctions());
+// }
+
+// async function watch() {
+//     await SocketFunction.mount({ port: 0, ...await getThreadKeyCert() });
+//     proxyWatcher.createWatcher({
+//         watchFunction: function reader() {
+//             const testData = test.schema()["querysub.com"].testData;
+//             console.log(red(`testData.test = ${testData.test}`));
+//         }
+//     });
+// }
+// if (process.argv.includes("--watch")) {
+//     logErrors(watch());
+// }

package/src/3-path-functions/tests/rejectTest.ts

@@ -0,0 +1,77 @@
+import { SocketFunction } from "socket-function/SocketFunction";
+import { delay } from "socket-function/src/batching";
+import { getThreadKeyCert } from "../../-a-auth/certs";
+import { ActionsHistory } from "../../diagnostics/ActionsHistory";
+import { errorToUndefined } from "../../errors";
+import { rawSchema } from "../../2-proxy/pathDatabaseProxyBase";
+import { ClientWatcher, clientWatcher } from "../../1-path-client/pathValueClientWatcher";
+import { PathValueProxyWatcher, proxyWatcher } from "../../2-proxy/PathValueProxyWatcher";
+import { pathValueCommitter } from "../../0-path-value-core/PathValueController";
+import { getNextTime } from "../../0-path-value-core/pathValueCore";
+import { PathFunctionRunner } from "../PathFunctionRunner";
+
+export const schema = rawSchema<{
+    ["querysub.com"]: {
+        rejectTest: {
+            value: number;
+        };
+    };
+}>();
+
+async function reader() {
+    await proxyWatcher.createWatcher({
+        debugName: "reader",
+        watchFunction() {
+            console.log(`Reader sees ${JSON.stringify(schema()["querysub.com"].rejectTest.value)}`);
+        },
+    });
+}
+async function badWriter() {
+    let time = getNextTime();
+    console.log(`Saving time`);
+    await delay(10 * 1000);
+    console.log(`Applying write`);
+    await proxyWatcher.commitFunction({
+        debugName: "badWriter",
+        runAtTime: time,
+        canWrite: true,
+        watchFunction() {
+            schema()["querysub.com"].rejectTest.value += 2;
+        }
+    });
+}
+async function writer() {
+    await proxyWatcher.commitFunction({
+        debugName: "badWriter",
+        canWrite: true,
+        watchFunction() {
+            schema()["querysub.com"].rejectTest.value++;
+        }
+    });
+}
+
+async function main() {
+    ClientWatcher.DEBUG_READS = true;
+    ClientWatcher.DEBUG_WRITES = true;
+    PathValueProxyWatcher.TRACE = true;
+    PathFunctionRunner.DEBUG_CALLS = true;
+
+    await SocketFunction.mount({ port: 0, ...await getThreadKeyCert() });
+    if (process.argv.includes("--reader")) {
+        ActionsHistory.LOG_ACTION_HISTORY = "reader";
+        await reader();
+        await new Promise(() => { });
+        return;
+    }
+    if (process.argv.includes("--bad")) {
+        ActionsHistory.LOG_ACTION_HISTORY = "bad";
+        await badWriter();
+        return;
+    }
+    ActionsHistory.LOG_ACTION_HISTORY = "writer";
+    await writer();
+}
+
+errorToUndefined(main())
+    .finally(() => pathValueCommitter.waitForValuesToCommit())
+    .finally(() => process.exit());