socket-function 0.8.40 → 0.9.0

package/SocketFunction.ts

@@ -249,6 +249,10 @@ export class SocketFunction {
         return getNodeId(location.address, location.port);
     }
 
+    public static locationNode() {
+        return SocketFunction.connect({ address: location.hostname, port: +location.port });
+    }
+
     public static addGlobalHook(hook: SocketFunctionHook<SocketExposedInterface>) {
         registerGlobalHook(hook as SocketFunctionHook);
     }

package/hot/HotReloadController.ts

@@ -5,12 +5,25 @@ module.allowclient = true;
 import { SocketFunction } from "../SocketFunction";
 import { cache, lazy } from "../src/caching";
 import * as fs from "fs";
+import debugbreak from "debugbreak";
+import { isNode } from "../src/misc";
+import { red } from "../src/formatting/logColors";
 
-/** Hot reloads server and client files, just trigger a refresh clientside,
- *      while triggering per file re-evaluation and export updates serverside.
- *      - Requires HotReloadController to be exposed both serverside and clientside.
+/** Enables some hot reload functionality.
+ *      - Triggers a refresh clientside
+ *      - Triggers a reload server, for modules marked with `module.hotreload`
  */
-export function watchFilesAndTriggerHotReloading() {
+export function watchFilesAndTriggerHotReloading(noAutomaticBrowserWatch = false) {
+
+    SocketFunction.expose(HotReloadController);
+    if (!isNode()) {
+        if (!noAutomaticBrowserWatch) {
+            HotReloadController.nodes[SocketFunction.locationNode()]
+                .watchFiles()
+                .catch(e => console.error("watchFiles error", e))
+                ;
+        }
+    }
     setInterval(() => {
         for (let module of Object.values(require.cache)) {
             if (!module) continue;
@@ -19,6 +32,14 @@ export function watchFilesAndTriggerHotReloading() {
     }, 5000);
 }
 
+declare global {
+    namespace NodeJS {
+        interface Module {
+            hotreload?: boolean;
+            noserverhotreload?: boolean;
+        }
+    }
+}
 
 const hotReloadModule = cache((module: NodeJS.Module) => {
     if (!module.updateContents) return;
@@ -26,6 +47,23 @@ const hotReloadModule = cache((module: NodeJS.Module) => {
         if (curr.mtime.getTime() === prev.mtime.getTime()) return;
         console.log(`Hot reloading due to change: ${module.filename}`);
         module.updateContents?.();
+        if (isNode()) {
+            if (
+                module.hotreload
+                // A fairly big hack (as this could just be in a string, or something similar), but... it also VERY useful
+                || module.moduleContents?.includes("\nmodule.hotreload = true;" + "\n")
+                || module.moduleContents?.includes("\r\nmodule.hotreload = true;" + "\r\n")
+            ) {
+                console.log(`Reloading ${module.id}`);
+                try {
+                    module.loaded = false;
+                    module.load(module.id);
+                } catch (e) {
+                    console.error(red(`Error hot reloading ${module.id}`));
+                    console.error(e);
+                }
+            }
+        }
         triggerClientSideReload();
     });
 });
@@ -50,10 +88,7 @@ class HotReloadControllerBase {
     // TODO: Also hot reload when we reconnect to the server, as it is likely setup will need to
     //  be rerun in that case as well (for example, we need to call watchFiles again!)
     async watchFiles() {
-        let callerId = HotReloadController.context.caller?.nodeId;
-        if (!callerId) {
-            throw new Error("No nodeId?");
-        }
+        let callerId = SocketFunction.getCaller().nodeId;
         clientWatcherNodes.add(callerId);
     }
     async fileUpdated() {

package/package.json

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

package/require/require.js

@@ -1,4 +1,6 @@
 (function () {
+    //# sourceURL=require.js
+
     // Globals
     Object.assign(window, {
         process: {

package/src/CallFactory.ts

@@ -374,9 +374,15 @@ export async function createCallFactory(
             }
             throw new Error(`Unhandled data type ${typeof message}`);
         } catch (e: any) {
-            debugbreak(2);
-            debugger;
-            console.error(e.stack);
+            // NOTE: I'm looking for all types of errors here (specifically, .send errors), in case
+            //  there are errors I should be handling.
+            if (e.stack.startsWith("Error: Cannot send data to") && e.stack.includes("as the connection has closed")) {
+                // This is fine, just ignore it
+            } else {
+                debugbreak(2);
+                debugger;
+                console.error(e.stack);
+            }
         }
     }
 

package/src/batching.ts

@@ -113,15 +113,18 @@ 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}`);
+    try {
+        return await fnc();
+    } finally {
+        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/callHTTPHandler.ts

@@ -158,7 +158,7 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
 
 
         // NOTE: Our ETag caching is only to reduce data sent on the wire, we evaluate the calls
-        //  every time (so it is strictly a wire cache, not a computation cache)
+        //  every time (so it is strictly a wire cache for HTTP, not a computation cache)
         if (SocketFunction.httpETagCache) {
             response.setHeader("cache-control", "private, max-age=0, must-revalidate");
             let hash = sha256Hash(resultBuffer);

package/src/certStore.ts

@@ -1,5 +1,5 @@
 import * as tls from "tls";
-import { sha256Hash } from "./misc";
+import { isNode, sha256Hash } from "./misc";
 
 let trustedCerts = new Set<string>();
 let watchCallbacks = new Set<(certs: string[]) => void>();
@@ -15,8 +15,12 @@ export function trustCertificate(cert: string | Buffer) {
     }
 }
 export function getTrustedCertificates(): string[] {
-    //console.log(`trustedCerts = ${Array.from(trustedCerts).map(x => sha256Hash(x).slice(0, 10))}`);
-    return tls.rootCertificates.concat(Array.from(trustedCerts));
+    let certs: string[] = [];
+    if (isNode()) {
+        certs.push(...tls.rootCertificates);
+    }
+    certs.push(...Array.from(trustedCerts));
+    return certs;
 }
 
 export function watchTrustedCertificates(callback: (certs: string[]) => void) {

package/src/misc.ts

@@ -148,4 +148,25 @@ if (isNode()) {
     process.on("unhandledRejection", async (reason: any, promise) => {
         console.error(`Uncaught promise rejection: ${String(reason.stack || reason)}`);
     });
+}
+
+export function keyBy<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T> {
+    let map = new Map<K, T>();
+    for (let item of arr) {
+        map.set(getKey(item), item);
+    }
+    return map;
+}
+export function keyByArray<T, K>(arr: T[], getKey: (value: T) => K): Map<K, T[]> {
+    let map = new Map<K, T[]>();
+    for (let item of arr) {
+        let key = getKey(item);
+        let arr = map.get(key);
+        if (!arr) {
+            arr = [];
+            map.set(key, arr);
+        }
+        arr.push(item);
+    }
+    return map;
 }

package/src/webSocketServer.ts

@@ -13,6 +13,9 @@ import { getNodeId } from "./nodeCache";
 import crypto from "crypto";
 import { Watchable } from "./misc";
 import { delay, runInfinitePoll } from "./batching";
+import { magenta } from "./formatting/logColors";
+import { yellow } from "./formatting/logColors";
+import { green } from "./formatting/logColors";
 
 export type SocketServerConfig = (
     https.ServerOptions & {
@@ -28,6 +31,11 @@ export type SocketServerConfig = (
         public?: boolean;
         ip?: string;
 
+        // NOTE: Any same origin accesses are allowed (header.origin === header.host)
+        // For example, to allow "letx.ca" to access the server (when the hosted domain
+        //  may be, "querysub.com", for example), use ["letx.ca"]
+        allowHostnames?: string[];
+
         /** If the SNI matches this domain, we use a different key/cert. */
         SNICerts?: {
             [domain: string]: Watchable<https.ServerOptions>;
@@ -59,6 +67,11 @@ export async function startSocketServer(
         });
         let httpsServer = await httpServerPromise;
 
+        let allowedHostnames = new Set<string>();
+        for (let hostname of config.allowHostnames || []) {
+            allowedHostnames.add(hostname);
+        }
+
         watchTrustedCertificates(() => {
             lastOptions.ca = getTrustedCertificates();
             httpsServer.setSecureContext(lastOptions);
@@ -100,8 +113,8 @@ export async function startSocketServer(
                 try {
                     let host = new URL("ws://" + request.headers["host"]).hostname;
                     let origin = new URL(originHeader).hostname;
-                    if (host !== origin) {
-                        throw new Error(`Invalid cross thread request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)}`);
+                    if (host !== origin && !allowedHostnames.has(origin)) {
+                        throw new Error(`Invalid cross domain request, ${JSON.stringify(host)} !== ${JSON.stringify(origin)} (also not config.allowedHostnames ${JSON.stringify(config.allowHostnames)})`);
                     }
                 } catch (e) {
                     console.error(e);
@@ -214,7 +227,7 @@ export async function startSocketServer(
     }
 
     if (!SocketFunction.silent) {
-        console.log(`Trying to listening on ${host}:${port}`);
+        console.log(yellow(`Trying to listening on ${host}:${port}`));
     }
     realServer.listen(port, host);
 
@@ -223,7 +236,7 @@ export async function startSocketServer(
     port = (realServer.address() as net.AddressInfo).port;
     let nodeId = getNodeId(getCommonName(config.cert), port);
     if (!SocketFunction.silent) {
-        console.log(`Started Listening on ${nodeId}`);
+        console.log(green(`Started Listening on ${nodeId}`));
     }
 
     return nodeId;

package/test/shared.ts

@@ -8,19 +8,13 @@ class TestBase {
     memberVariable = 5;
 
     async add(lhs: number, rhs: number) {
-        let caller = Test.context.caller?.nodeId;
-        if (!caller) {
-            throw new Error("No caller?");
-        }
+        let caller = SocketFunction.getCaller().nodeId;
         console.log(`Caller is ${caller}`);
         return lhs + rhs;
     }
 
     async callMe() {
-        let caller = Test.context.caller?.nodeId;
-        if (!caller) {
-            throw new Error("No caller?");
-        }
+        let caller = SocketFunction.getCaller().nodeId;
         console.log(`Caller is ${caller}`);
         void (async () => {
             let seqNum = 1;