socket-function 0.8.38 → 0.8.40

package/SocketFunction.ts

@@ -9,6 +9,7 @@ import { Args, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
 import debugbreak from "debugbreak";
 import { lazy } from "./src/caching";
+import { delay } from "./src/batching";
 
 module.allowclient = true;
 
@@ -76,7 +77,7 @@ export class SocketFunction {
             return shape as any as SocketExposedShape;
         });
 
-        setImmediate(() => {
+        void Promise.resolve().then(() => {
             registerClass(classGuid, instance as SocketExposedInterface, getShape());
         });
 
@@ -115,7 +116,7 @@ export class SocketFunction {
             _classGuid: classGuid,
         };
 
-        setImmediate(() => {
+        void Promise.resolve().then(() => {
             let onMount = getDefaultHooks?.().onMount;
             if (onMount) {
                 let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
@@ -200,6 +201,8 @@ export class SocketFunction {
     public static mountedNodeId: string = "";
     public static mountedIP: string = "";
     private static hasMounted = false;
+    private static onMountCallback: () => void = () => { };
+    public static mountPromise: Promise<void> = new Promise(r => this.onMountCallback = r);
     public static async mount(config: SocketServerConfig) {
         if (this.mountedNodeId) {
             throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
@@ -209,6 +212,10 @@ export class SocketFunction {
         if (config.ip) {
             this.mountedIP = config.ip;
         }
+
+        // Wait for any additionals functions to expose themselves
+        await delay("immediate");
+
         this.mountedNodeId = await startSocketServer(config);
         this.hasMounted = true;
         for (let classGuid of SocketFunction.exposedClasses) {
@@ -218,6 +225,7 @@ export class SocketFunction {
                 await callback();
             }
         }
+        this.onMountCallback();
         return this.mountedNodeId;
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.38",
+	"version": "0.8.40",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
@@ -10,7 +10,7 @@
 		"node-forge": "https://github.com/sliftist/forge#name",
 		"preact": "^10.10.6",
 		"rdtsc-now": "^0.3.0",
-		"typenode": "^4.9.4-b",
+		"typenode": "^4.9.4-f",
 		"ws": "^8.8.0"
 	},
 	"scripts": {

package/require/RequireController.ts

@@ -13,6 +13,11 @@ declare global {
             /** Indicates the module is allowed clientside. */
             allowclient?: boolean;
 
+            /** Causes the module to not preload, requiring `await import()` for it to load correctly
+             *      - Shouldn't be set recursively, otherwise nested packages will break.
+             */
+            lazyload?: boolean;
+
             /** Indicates the module is definitely not allowed clientside */
             serveronly?: boolean;
 
@@ -118,7 +123,8 @@ class RequireControllerBase {
         let modules: {
             [resolvedPath: string]: SerializedModule;
         } = Object.create(null);
-        function addModule(module: NodeJS.Module) {
+        function addModule(module: NodeJS.Module, rootImport = false) {
+            if (!rootImport && module.lazyload) return;
             if (!module.requireControllerSeqNum) {
                 module.requireControllerSeqNum = nextModuleSeqNum++;
             }
@@ -223,7 +229,7 @@ class RequireControllerBase {
                 clientModule = createNotFoundModule(`Module ${pathRequest} (resolved to ${resolvedPath}) is not allowed clientside (set module.allowclient in it, or call setFlag when it is imported).`);
             }
 
-            addModule(clientModule);
+            addModule(clientModule, true);
         }
 
         return { requestsResolvedPaths, modules, requireSeqNumProcessId };

package/require/require.js

@@ -242,6 +242,15 @@
             }
 
             let resolvedPath = serializedModule.requests[request];
+            if (resolvedPath !== "NOTALLOWEDCLIENTSIDE" && !serializedModules[resolvedPath]) {
+                if (!asyncIsFine) {
+                    console.warn(`Accessed unexpected module %c${request}%c in %c${module.id}%c\n\tTreating it as an async require.\n\tAll modules require synchronously clientside must be required serverside at a module level.`,
+                        "color: red", "color: unset",
+                        "color: red", "color: unset",
+                    );
+                }
+                return rootRequire(resolvedPath);
+            }
 
             let exportsOverride = undefined;
             if (resolvedPath === "NOTALLOWEDCLIENTSIDE" || !serializedModules[resolvedPath].allowclient) {
@@ -337,6 +346,7 @@
         module.id = resolvedId;
         module.filename = serializedModule?.filename;
         module.exports = {};
+        module.exports.default = module.exports;
         module.children = [];
 
         module.load = load;
@@ -383,19 +393,6 @@
 
             let dirname = module.filename.replace(/\\/g, "/").split("/").slice(0, -1).join("/");
 
-            var __createBinding = (Object.create ? (function (o, m, k, k2) {
-                if (k2 === undefined) k2 = k;
-                Object.defineProperty(o, k2, { enumerable: true, get: function () { return m[k]; } });
-            }) : (function (o, m, k, k2) {
-                if (k2 === undefined) k2 = k;
-                o[k2] = m[k];
-            }));
-            var __setModuleDefault = (Object.create ? (function (o, v) {
-                Object.defineProperty(o, "default", { enumerable: true, value: v });
-            }) : function (o, v) {
-                o["default"] = v;
-            });
-
             let time = Date.now();
             currentModuleEvaluationStack.push(module.filename);
             try {
@@ -405,21 +402,9 @@
                         //  which checks for unloadedModule and returns undefined in that case.
                         __importStar(mod) {
                             if (mod[unloadedModule]) return undefined;
-                            if (mod && mod.__esModule) return mod;
-                            var result = {};
-                            if (mod !== null && mod !== undefined) {
-                                for (var k in mod) {
-                                    if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) {
-                                        __createBinding(result, mod, k);
-                                    }
-                                }
-                            }
-                            __setModuleDefault(result, mod);
-                            return result;
+                            return mod;
                         },
                         __importDefault(mod) {
-                            // If typescript isn't going to complain about importing from a module with no default export,
-                            //  then we'll just change our implementation to work the same way as typescript types...
                             return mod.default ? mod : { default: mod };
                         },
                     },

package/src/CallFactory.ts

@@ -1,7 +1,7 @@
 import { CallerContext, CallerContextBase, CallType, FullCallType } from "../SocketFunctionTypes";
 import * as ws from "ws";
 import { performLocalCall } from "./callManager";
-import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
+import { convertErrorStackToError, formatNumberSuffixed, isNode, list } from "./misc";
 import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
@@ -10,7 +10,9 @@ import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCa
 import debugbreak from "debugbreak";
 import { lazy } from "./caching";
 import { JSONLACKS } from "./JSONLACKS/JSONLACKS";
-import { red } from "./formatting/logColors";
+import { red, yellow } from "./formatting/logColors";
+import { isSplitableArray, markArrayAsSplitable } from "./fixLargeNetworkCalls";
+import { delay } from "./batching";
 
 const MIN_RETRY_DELAY = 1000;
 
@@ -55,6 +57,8 @@ export interface SenderInterface {
     addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
 
     readyState: number;
+
+    ping?(): void;
 }
 
 export async function createCallFactory(
@@ -81,6 +85,18 @@ export async function createCallFactory(
     //  in return calls.
     let nextSeqNum = Date.now() + Math.random();
 
+    // NOTE: I'm not sure if this is needed, I thought it was, but... now I think
+    //  it probably isn't...
+    // if (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //     // Heartbeat loop, otherwise onDisconnect is never called.
+    //     ((async () => {
+    //         while (webSocketBase?.readyState === 1 /* OPEN */ && webSocketBase.ping) {
+    //             await delay(1000 * 60);
+    //             webSocketBase.ping?.();
+    //         }
+    //     }))().catch(() => { });
+    // }
+
     let lastConnectionAttempt = 0;
 
     let callerContext: CallerContextBase = {
@@ -115,6 +131,35 @@ export async function createCallFactory(
             if (time > SocketFunction.WIRE_WARN_TIME) {
                 console.log(red(`Slow serialize, took ${time}ms to serialize ${data.byteLength} bytes. For ${call.classGuid}.${call.functionName}`));
             }
+
+            if (data.byteLength > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
+                let splitArgIndex = call.args.findIndex(isSplitableArray);
+                if (splitArgIndex >= 0) {
+                    console.log(yellow(`Splitting large call due to large args: ${call.classGuid}.${call.functionName}`));
+                    let SPLIT_GROUPS = 10;
+                    let splitArg = call.args[splitArgIndex] as unknown[];
+                    let subCalls = list(SPLIT_GROUPS).map(index => {
+                        let start = Math.floor(index / SPLIT_GROUPS * splitArg.length);
+                        let end = Math.floor((index + 1) / SPLIT_GROUPS * splitArg.length);
+                        return splitArg.slice(start, end);
+                    }).filter(x => x.length > 0);
+
+                    let calls = subCalls.map(async splitList => {
+                        let subCall = { ...call };
+                        subCall.args = subCall.args.slice();
+                        subCall.args[splitArgIndex] = markArrayAsSplitable(splitList);
+                        await callFactory.performCall(subCall);
+                    });
+                    await Promise.allSettled(calls);
+                    await Promise.all(calls);
+                    // Eh... we COULD return the array of results, but... then the result would sometimes be an array,
+                    //  some times not, so, it is better to return a string which will make it more clear why it sometimes varies.
+                    return "CALLS_SPLIT_DUE_TO_LARGE_ARGS";
+                }
+
+                throw new Error(`Call too large to send (${call.classGuid}.${call.functionName}, size: ${data.byteLength} > ${SocketFunction.MAX_MESSAGE_SIZE}). If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or consider fragmenting data at an application level, because sending large data will cause large lag spikes for other clients using this server. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`);
+            }
+
             let resultPromise = new Promise((resolve, reject) => {
                 let callback = (result: InternalReturnType) => {
                     if (SocketFunction.logMessages) {
@@ -130,10 +175,6 @@ export async function createCallFactory(
                 pendingCalls.set(seqNum, { callback, data, call: fullCall });
             });
 
-            if (data.byteLength > SocketFunction.MAX_MESSAGE_SIZE * 1.5) {
-                throw new Error(`Call too large to send (${call.classGuid}.${call.functionName}, size: ${data.byteLength} > ${SocketFunction.MAX_MESSAGE_SIZE}). If you need to handle very large static data use some external service, such as Backblaze B2 or AWS S3. Or consider fragmenting data at an application level, because sending large data will cause large lag spikes for other clients using this server. Or, if absolutely required, set SocketFunction.MAX_MESSAGE_SIZE to a higher value.`);
-            }
-
             await send(data);
 
             return await resultPromise;
@@ -333,7 +374,7 @@ export async function createCallFactory(
             }
             throw new Error(`Unhandled data type ${typeof message}`);
         } catch (e: any) {
-            debugbreak(1);
+            debugbreak(2);
             debugger;
             console.error(e.stack);
         }

package/src/batching.ts

@@ -91,4 +91,37 @@ export function runInSerial<T extends (...args: any[]) => Promise<any>>(fnc: T):
             updateQueue[0]?.();
         }
     }) as T;
+}
+
+export function runInfinitePoll(
+    delayTime: number,
+    fnc: () => Promise<void> | void
+) {
+    void (async () => {
+        while (true) {
+            await delay(delayTime);
+            try {
+                await fnc();
+            } catch (e: any) {
+                console.error(`Error in infinite poll ${fnc.name || fnc.toString().slice(0, 100).split("\n").slice(0, 2).join("\n")} (continuing poll loop)\n${e.stack}`);
+            }
+        }
+    })();
+}
+
+export async function runInfinitePollCallAtStart(
+    delayTime: number,
+    fnc: () => Promise<void> | void
+) {
+    void (async () => {
+        while (true) {
+            await delay(delayTime);
+            try {
+                await fnc();
+            } catch (e: any) {
+                console.error(`Error in infinite poll ${fnc.name} (continuing poll loop)\n${e.stack}`);
+            }
+        }
+    })();
+    return await fnc();
 }

package/src/caching.ts

@@ -3,7 +3,6 @@ import { AnyFunction, Args, canHaveChildren } from "./types";
 
 export function lazy<T>(factory: () => T): () => T {
     let value: { value: T } | undefined = undefined;
-
     return () => {
         if (!value) {
             value = { value: factory() };
@@ -33,8 +32,10 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
 
 export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
+    // NOTE: If you want to clear all, just make a new cache!
     clear(key: Key): void;
     forceSet(key: Key, value: Output): void;
+    getAllKeys(): Key[];
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -61,6 +62,9 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
         values.set(key, value);
         startingCalculating.add(key);
     };
+    cache.getAllKeys = () => {
+        return [...values.keys()];
+    };
     return cache;
 }
 

package/src/fixLargeNetworkCalls.ts

@@ -0,0 +1,9 @@
+const arrayIsSplitable = Symbol.for("arrayIsSplitable");
+export function markArrayAsSplitable<T>(data: T[]): T[] {
+    (data as any)[arrayIsSplitable] = true;
+    return data;
+}
+export function isSplitableArray<T>(data: T): data is T & (unknown[]) {
+    if (!Array.isArray(data)) return false;
+    return !!(data as any)[arrayIsSplitable];
+}

package/src/misc.ts

@@ -139,6 +139,9 @@ export function getKeys(obj: unknown) {
     }
     return keyArray;
 }
+export function getStringKeys<T extends {}>(obj: T): ((keyof T) & string)[] {
+    return Object.keys(obj) as any;
+}
 
 if (isNode()) {
     // TODO: Find a better place for this...

package/src/profiling/measure.ts

@@ -1,6 +1,6 @@
 import debugbreak from "debugbreak";
 import { formatTime, formatNumber } from "../formatting/format";
-import { red, yellow, blue } from "../formatting/logColors";
+import { red, yellow, blue, magenta } from "../formatting/logColors";
 
 import { getOwnTime, getPendingOwnTimeInstances, getPendingOwnTimeObjs, OwnTimeObj } from "./getOwnTime";
 import { addToStats, addToStatsValue, createStatsValue, getStatsTop, StatsValue } from "./stats";
@@ -12,6 +12,10 @@ export function enableMeasurements() {
     }
     measurementsEnabled = true;
 }
+/** NOTE: Must be called BEFORE anything else is imported! */
+export function disableMeasurements() {
+    measurementsEnabled = false;
+}
 
 let functionsSkipped = 0;
 
@@ -104,9 +108,9 @@ export function logMeasureTable(
     let totalTime = entries.map(x => getTime(x).sum).reduce((a, b) => a + b, 0);
 
     console.log();
-    let title = yellow(`Profiled ${formatTime(totalTime)}`);
+    let title = yellow(`Profiled ${formatTime(totalTime)} (logged at ${new Date().toISOString()})`);
     if (name) {
-        title += ` ${blue(name)}`;
+        title = `(${blue(name)}) ${title}`;
     }
     console.log(title);
     function percent(value: number) {
@@ -138,7 +142,7 @@ export function logMeasureTable(
 
         let ownTimeTop = getStatsTop(getTime(entry));
         if (ownTimeTop.topHeavy) {
-            output += red(`    TOP ${percent(ownTimeTop.valueFraction)} of the time is owned by ${percent(ownTimeTop.countFraction)} of the calls`);
+            output += red(`    TOP ${percent(ownTimeTop.valueFraction)} of the time is owned by ${percent(ownTimeTop.countFraction)} of the calls (${formatTime(ownTimeTop.value / ownTimeTop.count)} per * ${formatNumber(ownTimeTop.count)} = ${formatTime(ownTimeTop.value)})`);
         }
 
         if (entry.stillOpenCount > 0) {
@@ -209,7 +213,7 @@ interface ProfileEntry {
     stillOpenCount: number;
 }
 
-let measurementsEnabled = false;
+let measurementsEnabled = true;
 
 let outstandingProfiles: MeasureProfile[] = [];
 function recordOwnTime(ownTimeObj: OwnTimeObj) {

package/src/webSocketServer.ts

@@ -12,6 +12,7 @@ import debugbreak from "debugbreak";
 import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
 import { Watchable } from "./misc";
+import { delay, runInfinitePoll } from "./batching";
 
 export type SocketServerConfig = (
     https.ServerOptions & {

package/src/websocketFactory.ts

@@ -38,7 +38,7 @@ export function createWebsocketFactory(): (nodeId: string) => SenderInterface {
                 console.log(`Connecting to ${address}:${port}`);
             }
             let webSocket = new ws.WebSocket(`wss://${address}:${port}`, {
-                ca: tls.rootCertificates.concat(getTrustedCertificates()),
+                ca: getTrustedCertificates()
             });
             let result = Object.assign(webSocket, { socket: undefined as tls.TLSSocket | undefined });
             webSocket.once("upgrade", e => {