querysub 0.430.0 → 0.432.0

package/src/0-path-value-core/pathValueArchives.ts

@@ -128,7 +128,13 @@ export class PathValueArchives {
             values = await this.filterForDiskStorage(values);
         }
 
-        let buffers = await pathValueSerializer.serialize(values, { noLocks: true, compress: getCompressNetwork(), singleBuffer: true });
+        let buffers = await pathValueSerializer.serialize(values, {
+            noLocks: true,
+            compress: getCompressNetwork(),
+            singleBuffer: true,
+            // NOTE: The system natively handles the concept of knowing not to do a commit if it doesn't have any value. The only reason transactions are required is we might have a value, but it might not be the latest value. However, if we're writing to the disk, we're not going to have an even older value. Anything we write to the disk is going to be the oldest value that we'll receive.
+            noTransactionPaths: true
+        });
         let data = buffers[0];
 
         let minTime = values[0].time.time;

package/src/0-path-value-core/pathValueCore.ts

@@ -14,7 +14,7 @@ import { pathValueSerializer } from "../-h-path-value-serialize/PathValueSeriali
 import { AuthoritySpec, PathRouter } from "./PathRouter";
 import { formatTime } from "socket-function/src/formatting/format";
 import { isOwnNodeId } from "../-f-node-discovery/NodeDiscovery";
-import { PromiseRace } from "../../src/misc/PromiseRace";
+import { PromiseRace } from "socket-function/src/PromiseRace";
 
 import yargs from "yargs";
 import { PromiseObj } from "../promise";

package/src/2-proxy/PathValueProxyWatcher.ts

@@ -554,6 +554,7 @@ export class PathValueProxyWatcher {
     public getCallbackPathValue = (pathStr: string, syncParentKeys?: "parentKeys"): PathValue | undefined => {
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
         }
 
@@ -652,6 +653,7 @@ export class PathValueProxyWatcher {
         }
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to get path "${pathStr}" outside of a watcher function.`);
         }
 
@@ -762,6 +764,7 @@ export class PathValueProxyWatcher {
             if (lastPart.startsWith("__") || lastPart === "type") {
                 return;
             }
+            debugger;
             throw new Error(`Tried to set path "${pathStr}" outside of a watcher function.`);
         }
         if (!watcher.options.canWrite) {
@@ -899,6 +902,7 @@ export class PathValueProxyWatcher {
 
         const watcher = this.runningWatcher;
         if (!watcher) {
+            debugger;
             throw new Error(`Tried to getKeys on path "${pathStr}" outside of a watcher function.`);
         }
 

package/src/2-proxy/schema2.ts

@@ -22,7 +22,7 @@ function example() {
     };
 }
 
-type TypeDefType<T = never, Optional = false> = {
+export type TypeDefType<T = never, Optional = false> = {
 
     /** A passthrough to strip the type wrapper for qreact.state,
      *      or for piecing together schemas.

package/src/4-querysub/Querysub.ts

@@ -4,8 +4,8 @@
 import "../inject";
 
 // Shim Promise.race, as no one wants their promises to leak...
-import { promiseRace } from "socket-function/src/promiseRace";
-Promise.race = promiseRace;
+import { PromiseRace } from "socket-function/src/promiseRace";
+Promise.race = PromiseRace;
 
 import { shimDateNow } from "socket-function/time/trueTimeShim";
 shimDateNow();
@@ -378,6 +378,7 @@ export class Querysub {
     public static fastReadAsync<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
         return Querysub.serviceWrite(fnc, { ...options, allowProxyResults: true, noWaitForCommit: true });
     }
+    public static readLocal = Querysub.localRead;
     public static localRead<T>(fnc: () => T, options?: Partial<WatcherOptions<T>>) {
         return proxyWatcher.runOnce({
             watchFunction: fnc,

package/test.ts

@@ -7,7 +7,7 @@ import { getControllerNodeIdList } from "./src/-g-core-values/NodeCapabilities";
 import { delay } from "socket-function/src/batching";
 import { green, yellow } from "socket-function/src/formatting/logColors";
 import { Querysub, t } from "./src/4-querysub/Querysub";
-import { pathValueArchives } from "./src/0-path-value-core/pathValueArchives";
+import { archives, pathValueArchives } from "./src/0-path-value-core/pathValueArchives";
 import { getAllAuthoritySpec } from "./src/0-path-value-core/PathRouterServerAuthoritySpec";
 import { deploySchema } from "./src/4-deploy/deploySchema";
 import { getDomain } from "./src/config";
@@ -17,6 +17,8 @@ import { RemoteWatcher } from "./src/1-path-client/RemoteWatcher";
 import { PathRouter } from "./src/0-path-value-core/PathRouter";
 import { shutdown } from "./src/diagnostics/periodic";
 import { getShardPrefixes } from "./src/0-path-value-core/ShardPrefixes";
+import { PathValue, epochTime } from "./src/0-path-value-core/pathValueCore";
+import { pathValueSerializer } from "./src/-h-path-value-serialize/PathValueSerializer";
 
 let tempTestSchema = Querysub.createSchema({
     value: t.number,
@@ -28,13 +30,14 @@ let tempTestSchema = Querysub.createSchema({
 });
 
 async function main() {
-
-    let prefixes = await getShardPrefixes();
-    for (let prefix of prefixes) {
-        console.log(prefix);
-    }
     // await Querysub.hostService("test");
 
+    // let testValues: PathValue[] = [];
+    // let buffers = await pathValueSerializer.serialize(testValues);
+    // let values = await pathValueSerializer.deserialize(buffers);
+
+    let values = await pathValueArchives.loadValues(await getAllAuthoritySpec());
+
     // let path = getProxyPath(() => tempTestSchema.data().value);
     // console.log({ path });
     // let authorities = PathRouter.getAllAuthorities(path);

package/src/misc/PromiseRace.ts

@@ -1,101 +0,0 @@
-/** Fixed Promise.race, which doesn't leak promises values. Promises still leak, but a Promise is < 100 bytes,
- *      where as the promise value might be huge.
- */
-export function PromiseRace<T extends any[]>(promises: { [K in keyof T]: Promise<T[K]> }): Promise<T[number]> {
-    return new PromiseLessLeaky((resolve: any, reject: any) => {
-        function onFinally() {
-            for (let promise of promises) {
-                if (promise && typeof promise === "object" && promise instanceof Promise) {
-                    let callbackObj = promiseCallbacks.get(promise);
-                    if (!callbackObj) continue;
-                    remove(callbackObj.onResolve, resolve);
-                    remove(callbackObj.onReject, reject);
-                    remove(callbackObj.onFinally, onFinally);
-                }
-            }
-        }
-        for (let promise of promises) {
-            // NOTE: This "if" statement greatly reduce leaks, although it might
-            //  reduce speed as well?
-            if (promise && typeof promise === "object" && promise instanceof Promise) {
-                let callbackObj = promiseCallbacks.get(promise);
-                if (!callbackObj) {
-                    callbackObj = {
-                        onResolve: [],
-                        onReject: [],
-                        onFinally: [],
-                    };
-                    promiseCallbacks.set(promise, callbackObj);
-                    connectPromiseToCallbackObj(promise, callbackObj);
-                }
-                callbackObj.onResolve.push(resolve);
-                callbackObj.onReject.push(reject);
-                callbackObj.onFinally.push(onFinally);
-                continue;
-            }
-
-            Promise.resolve(promise).then(resolve, reject);
-        }
-    }) as any;
-}
-
-// Less leaky promise.
-//  See https://github.com/nodejs/node/issues/17469
-//  See https://bugs.chromium.org/p/v8/issues/detail?id=9858#c9
-// Basically, make resolve/reject weakly reference the Promise, so that
-//  resolved promises aren't kept alive. The `resolve` function is still leaked
-//  itself, but at least it doesn't leak the underlying data.
-// IMPORTANT! This still leaks! So... maybe don't even use Promise.race?
-class PromiseLessLeaky extends Promise<any> {
-    constructor(executor: any) {
-        super((resolve, reject) => {
-            executor(
-                function PromiseLessLeakyResolved(value: any) {
-                    let callback = resolve;
-                    resolve = undefined as any;
-                    reject = undefined as any;
-                    if (callback) {
-                        callback(value);
-                    }
-                },
-                function PromiseLessLeakyRejected(value: any) {
-                    let callback = reject;
-                    resolve = undefined as any;
-                    reject = undefined as any;
-                    if (callback) {
-                        callback(value);
-                    }
-                }
-            );
-            executor = undefined;
-        });
-    }
-}
-function remove(list: any, value: any) {
-    let index = list.indexOf(value);
-    if (index >= 0) {
-        list.splice(index, 1);
-    }
-}
-const promiseCallbacks = new WeakMap();
-
-function connectPromiseToCallbackObj(promise: any, callbackObj: any) {
-    // NOTE: If the promise stays alive forever... this will leak callbackObj. BUT,
-    //  it is only called once per promise, ever, so... the leak isn't so bad!
-    promise.then(
-        (value: any) => {
-            for (let fnc of callbackObj.onResolve) {
-                try { fnc(value); } finally { }
-            }
-        },
-        (value: any) => {
-            for (let fnc of callbackObj.onReject) {
-                try { fnc(value); } finally { }
-            }
-        }
-    ).finally(() => {
-        for (let fnc of callbackObj.onFinally) {
-            try { fnc(); } finally { }
-        }
-    });
-}