socket-function 0.8.35 → 0.8.37

package/SocketFunction.ts

@@ -1,10 +1,14 @@
-import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType } from "./SocketFunctionTypes";
+/// <reference path="./require/RequireController.ts" />
+
+import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
-import { getCreateCallFactoryLocation, getNodeId, getNodeIdLocation } from "./src/nodeCache";
+import { getCallFactory, getCreateCallFactory, getNodeId, getNodeIdLocation } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
-import { Args } from "./src/types";
+import { Args, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
+import debugbreak from "debugbreak";
+import { lazy } from "./src/caching";
 
 module.allowclient = true;
 
@@ -29,27 +33,46 @@ export class SocketFunction {
     };
     public static httpETagCache = false;
 
+    private static onMountCallbacks = new Map<string, (() => MaybePromise<void>)[]>();
+    public static exposedClasses = new Set<string>();
+
+    public static callerContext: CallerContext | undefined;
+    public static getCaller(): CallerContext {
+        const caller = SocketFunction.callerContext;
+        if (!caller) throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);
+        return caller;
+    }
+
+    // NOTE: We use callbacks we don't run into issues with cyclic dependencies
+    //  (ex, using a hook in a controller where the hook also calls the controller).
     public static register<
         ClassInstance extends object,
-        Shape extends SocketExposedShape<SocketExposedInterface, CallContext>,
-        CallContext extends CallContextType
+        Shape extends SocketExposedShape<SocketExposedInterface>,
     >(
         classGuid: string,
         instance: ClassInstance,
-        shape: Shape,
-        defaultHooks?: SocketExposedShape[""]
-    ):
-        (
-            SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext>
-        ) {
-
-        for (let value of Object.values(shape)) {
-            if (!value) continue;
-            value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
-            value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
-            value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
+        shapeFnc: () => Shape,
+        defaultHooksFnc?: () => SocketExposedShape[""] & {
+            onMount?: () => MaybePromise<void>;
         }
-        registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
+    ): SocketRegistered<ExtractShape<ClassInstance, Shape>> {
+        let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
+        const getShape = lazy(() => {
+            let shape = shapeFnc();
+            let defaultHooks = getDefaultHooks?.();
+
+            for (let value of Object.values(shape)) {
+                if (!value) continue;
+                value.clientHooks = [...(defaultHooks?.clientHooks || []), ...(value.clientHooks || [])];
+                value.hooks = [...(defaultHooks?.hooks || []), ...(value.hooks || [])];
+                value.dataImmutable = defaultHooks?.dataImmutable ?? value.dataImmutable;
+            }
+            return shape as any as SocketExposedShape;
+        });
+
+        setImmediate(() => {
+            registerClass(classGuid, instance as SocketExposedInterface, getShape());
+        });
 
         let nodeProxy = getCallProxy(classGuid, async (call) => {
             let nodeId = call.nodeId;
@@ -59,9 +82,9 @@ export class SocketFunction {
                 console.log(`START\t\t\t${classGuid}.${functionName}`);
             }
             try {
-                let callFactory = await getCreateCallFactoryLocation(nodeId, SocketFunction.mountedNodeId);
+                let callFactory = await getCreateCallFactory(nodeId, SocketFunction.mountedNodeId);
 
-                let shapeObj = shape[functionName];
+                let shapeObj = getShape()[functionName];
                 if (!shapeObj) {
                     throw new Error(`Function ${functionName} is not in shape`);
                 }
@@ -72,20 +95,6 @@ export class SocketFunction {
                     return hookResult.overrideResult;
                 }
 
-                if (hookResult.callTimeout !== undefined) {
-                    let timeout = hookResult.callTimeout;
-                    let time = Date.now();
-                    let timeoutPromise = new Promise((resolve, reject) => {
-                        setTimeout(() => {
-                            reject(new Error(`Call timed out after ${Date.now() - time}ms`));
-                        }, timeout);
-                    });
-                    return await Promise.race([
-                        callFactory.performCall(call),
-                        timeoutPromise,
-                    ]);
-                }
-
                 return await callFactory.performCall(call);
             } finally {
                 time = Date.now() - time;
@@ -96,14 +105,59 @@ export class SocketFunction {
         });
 
         let output: SocketRegistered = {
-            context: curSocketContext,
             nodes: nodeProxy,
             _classGuid: classGuid,
         };
 
+        setImmediate(() => {
+            let onMount = getDefaultHooks?.().onMount;
+            if (onMount) {
+                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+                if (!callbacks) {
+                    callbacks = [];
+                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);
+                }
+                callbacks.push(onMount);
+            }
+        });
+
         return output as any;
     }
 
+    public static onNextDisconnect(nodeId: string, callback: () => void) {
+        (async () => {
+            let factory = await getCallFactory(nodeId);
+            if (!factory) {
+                callback();
+                return;
+            }
+
+            factory.onNextDisconnect(callback);
+        })().catch(() => {
+            callback();
+        });
+    }
+    public static getLastDisconnectTime(nodeId: string): number | undefined {
+        let factory = getCallFactory(nodeId);
+        if (!factory) {
+            return undefined;
+        }
+        if (factory instanceof Promise) {
+            return undefined;
+        }
+        return factory.lastClosed;
+    }
+    public static isNodeConnected(nodeId: string): boolean {
+        let factory = getCallFactory(nodeId);
+        if (!factory) {
+            return false;
+        }
+        if (factory instanceof Promise) {
+            return false;
+        }
+        return !!factory.isConnected;
+    }
+
     /** NOTE: Only works if the nodeIs used is from SocketFunction.connect (we can't convert arbitrary nodeIds into urls,
      *      as we have no way of knowing how to contain a nodeId).
      *  */
@@ -125,15 +179,33 @@ export class SocketFunction {
      */
     public static expose(socketRegistered: SocketRegistered) {
         exposeClass(socketRegistered);
+        SocketFunction.exposedClasses.add(socketRegistered._classGuid);
+
+        if (this.hasMounted) {
+            let mountCallbacks = SocketFunction.onMountCallbacks.get(socketRegistered._classGuid);
+            for (let onMount of mountCallbacks || []) {
+                Promise.resolve(onMount()).catch(e => {
+                    console.error("Error in onMount callback exposed after mount", e);
+                });
+            }
+        }
     }
 
     public static mountedNodeId: string = "NOTMOUNTED";
-    public static async mount(config: SocketServerConfig & { nodeId: string }) {
+    private static hasMounted = false;
+    public static async mount(config: SocketServerConfig) {
         if (this.mountedNodeId !== "NOTMOUNTED") {
             throw new Error("SocketFunction already mounted, mounting twice in one thread is not allowed.");
         }
-        this.mountedNodeId = config.nodeId;
-        await startSocketServer(config);
+        this.mountedNodeId = await startSocketServer(config);
+        this.hasMounted = true;
+        for (let classGuid of SocketFunction.exposedClasses) {
+            let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+            if (!callbacks) continue;
+            for (let callback of callbacks) {
+                await callback();
+            }
+        }
         return this.mountedNodeId;
     }
 
@@ -157,41 +229,29 @@ export class SocketFunction {
         return getNodeId(location.address, location.port);
     }
 
-    public static addGlobalHook<CallContext extends CallContextType>(hook: SocketFunctionHook<SocketExposedInterface, CallContext>) {
+    public static addGlobalHook(hook: SocketFunctionHook<SocketExposedInterface>) {
         registerGlobalHook(hook as SocketFunctionHook);
     }
-    public static addGlobalClientHook<CallContext extends CallContextType>(hook: SocketFunctionClientHook<SocketExposedInterface, CallContext>) {
+    public static addGlobalClientHook(hook: SocketFunctionClientHook<SocketExposedInterface>) {
         registerGlobalClientHook(hook as SocketFunctionClientHook);
     }
 }
 
 
-const curSocketContext: SocketRegistered["context"] = {
-    curContext: undefined,
-    caller: undefined,
-    getCaller() {
-        const caller = curSocketContext.caller;
-        if (!caller) throw new Error(`Tried to access caller when not in the synchronous phase of a function call`);
-        return caller;
-    }
-};
 let socketContextSeqNum = 1;
 
 export function _setSocketContext<T>(
-    callContext: CallContextType,
     caller: CallerContext,
     code: () => T,
 ) {
     socketContextSeqNum++;
     let seqNum = socketContextSeqNum;
-    curSocketContext.curContext = callContext;
-    curSocketContext.caller = caller;
+    SocketFunction.callerContext = caller;
     try {
         return code();
     } finally {
         if (seqNum === socketContextSeqNum) {
-            curSocketContext.curContext = undefined;
-            curSocketContext.caller = undefined;
+            SocketFunction.callerContext = undefined;
         }
     }
 }

package/SocketFunctionTypes.ts

@@ -1,5 +1,8 @@
+/// <reference path="./require/RequireController.ts" />
+
 module.allowclient = true;
 
+import { SocketFunction } from "./SocketFunction";
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 
@@ -19,14 +22,14 @@ export type SocketExposedInterfaceClass = {
     new(): unknown;
     prototype: unknown;
 };
-export interface SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
+export interface SocketExposedShape<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
     [functionName: string]: {
         /** Indicates with the same input, we give the same output, forever,
          *      independent of code changes. This only works for data storage.
          */
         dataImmutable?: boolean;
-        hooks?: SocketFunctionHook<ExposedType, CallContext>[];
-        clientHooks?: SocketFunctionClientHook<ExposedType, CallContext>[];
+        hooks?: SocketFunctionHook<ExposedType>[];
+        clientHooks?: SocketFunctionClientHook<ExposedType>[];
     };
 }
 
@@ -34,42 +37,32 @@ export interface CallType {
     classGuid: string;
     functionName: string;
     args: unknown[];
-    // NOTE: When making calls this needs to be set in the client hook.
-    //  To set a timeout on returns, you can set it in the server hook.
-    reconnectTimeout?: number;
 }
 export interface FullCallType extends CallType {
     nodeId: string;
 }
 
-export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
-    (config: HookContext<ExposedType, CallContext>): MaybePromise<void>;
+export interface SocketFunctionHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
+    (config: HookContext<ExposedType>): MaybePromise<void>;
+    /** NOTE: This is useful when we need a clientside hook to set up state specifically for our serverside hook. */
+    clientHook?: SocketFunctionClientHook<ExposedType>;
 }
-export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
+export type HookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
     call: FullCallType;
-    context: SocketRegistered<ExposedType, CallContext>["context"];
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
 
-export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> = {
+export type ClientHookContext<ExposedType extends SocketExposedInterface = SocketExposedInterface> = {
     call: FullCallType;
-    /** If the calls takes longer than this (for ANY reason), we return with an error.
-     *      - Different from reconnectTimeout, which only errors if we lose the connection.
-    */
-    callTimeout?: number;
     // If the result is overriden, we continue evaluating hooks BUT DO NOT perform the final call
     overrideResult?: unknown;
 };
-export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface, CallContext extends CallContextType = CallContextType> {
-    (config: ClientHookContext<ExposedType, CallContext>): MaybePromise<void>;
+export interface SocketFunctionClientHook<ExposedType extends SocketExposedInterface = SocketExposedInterface> {
+    (config: ClientHookContext<ExposedType>): MaybePromise<void>;
 }
 
-export type CallContextType = {
-    [key: string]: unknown;
-};
-
-export interface SocketRegistered<ExposedType = any, DynamicCallContext extends CallContextType = CallContextType> {
+export interface SocketRegistered<ExposedType = any> {
     nodes: {
         // NOTE: Don't pass around nodeId to other nodes, instead pass around NetworkLocation (which they
         //  then turn into a nodeId, which they can then check permissions on themself).
@@ -79,12 +72,6 @@ export interface SocketRegistered<ExposedType = any, DynamicCallContext extends
             }
         };
     };
-    context: {
-        // If undefined we are not synchronously in a call
-        curContext: DynamicCallContext | undefined;
-        caller: CallerContext | undefined;
-        getCaller(): CallerContext;
-    };
     _classGuid: string;
 }
 export type CallerContext = Readonly<CallerContextBase>;

package/hot/HotReloadController.ts

@@ -64,8 +64,8 @@ class HotReloadControllerBase {
 export const HotReloadController = SocketFunction.register(
     "HotReloadController-032b2250-3aac-4187-8c95-75412742b8f5",
     new HotReloadControllerBase(),
-    {
+    () => ({
         watchFiles: {},
         fileUpdated: {}
-    }
+    })
 );

package/package.json

@@ -1,14 +1,10 @@
 {
 	"name": "socket-function",
-	"version": "0.8.35",
+	"version": "0.8.37",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",
 	"dependencies": {
-		"@types/cookie": "^0.5.1",
-		"@types/node": "^18.0.0",
-		"@types/node-forge": "^1.3.1",
-		"@types/ws": "^8.5.3",
 		"cookie": "^0.5.0",
 		"mobx": "^6.6.2",
 		"node-forge": "https://github.com/sliftist/forge#name",
@@ -21,7 +17,10 @@
 		"type": "yarn tsc --noEmit"
 	},
 	"devDependencies": {
+		"@types/cookie": "^0.5.1",
+		"@types/node-forge": "^1.3.1",
+		"@types/ws": "^8.5.3",
 		"debugbreak": "^0.6.5",
-		"typedev": "^0.1.0"
+		"typedev": "^0.1.1"
 	}
 }

package/require/CSSShim.ts

@@ -1,3 +1,4 @@
+/// <reference path=".//RequireController.ts" />
 import debugbreak from "debugbreak";
 import { compileTransformBefore } from "typenode";
 

package/require/RequireController.ts

@@ -1,3 +1,4 @@
+/// <reference path="../../typenode/index.d.ts" />
 import debugbreak from "debugbreak";
 import fs from "fs";
 import { SocketFunction } from "../SocketFunction";
@@ -9,7 +10,7 @@ module.allowclient = true;
 declare global {
     namespace NodeJS {
         interface Module {
-            /** Indiciates the module is allowed clientside. */
+            /** Indicates the module is allowed clientside. */
             allowclient?: boolean;
 
             /** Indicates the module is definitely not allowed clientside */
@@ -237,10 +238,10 @@ export function setRequireBootRequire(path: string) {
 export const RequireController = SocketFunction.register(
     "RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d",
     baseController,
-    {
+    () => ({
         getModules: {},
         requireHTML: {},
         bufferJS: {},
         requireJS: {},
-    }
+    })
 );

package/require/compileFlags.ts

@@ -1,3 +1,4 @@
+/// <reference path="./RequireController.ts" />
 module.allowclient = true;
 
 /**

package/src/CallFactory.ts

@@ -2,13 +2,15 @@ import { CallerContext, CallerContextBase, CallType, FullCallType } from "../Soc
 import * as ws from "ws";
 import { performLocalCall } from "./callManager";
 import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
-import { createWebsocketFactory, getTLSSocket } from "./nodeAuthentication";
+import { createWebsocketFactory, getTLSSocket } from "./websocketFactory";
 import { SocketFunction } from "../SocketFunction";
 import { gzip } from "zlib";
 import * as tls from "tls";
 import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCache";
+import debugbreak from "debugbreak";
+import { lazy } from "./caching";
 
-const retryInterval = 2000;
+const MIN_RETRY_DELAY = 1000;
 
 type InternalCallType = FullCallType & {
     seqNum: number;
@@ -28,10 +30,13 @@ type InternalReturnType = {
 
 export interface CallFactory {
     nodeId: string;
+    lastClosed: number;
+    closedForever?: boolean;
+    isConnected?: boolean;
     // NOTE: May or may not have reconnection or retry logic inside of performCall.
     //  Trigger performLocalCall on the other side of the connection
     performCall(call: CallType): Promise<unknown>;
-    closedForever: boolean;
+    onNextDisconnect(callback: () => void): void;
 }
 
 export interface SenderInterface {
@@ -45,6 +50,8 @@ export interface SenderInterface {
     addEventListener(event: "close", listener: () => void): void;
     addEventListener(event: "error", listener: (err: { message: string }) => void): void;
     addEventListener(event: "message", listener: (data: ws.RawData | ws.MessageEvent | string) => void): void;
+
+    readyState: number;
 }
 
 export async function createCallFactory(
@@ -55,19 +62,15 @@ export async function createCallFactory(
     let niceConnectionName = nodeId;
 
     const createWebsocket = createWebsocketFactory();
+    const registerOnce = lazy(() => registerNodeClient(callFactory));
 
-    let retriesEnabled = !!getNodeIdLocation(nodeId);
+    const canReconnect = !!getNodeIdLocation(nodeId);
 
     let lastReceivedSeqNum = 0;
 
-    let reconnectingPromise: Promise<void> | undefined;
-    let reconnectAttempts = 0;
-
-
     let pendingCalls: Map<number, {
         data: Buffer;
         call: InternalCallType;
-        reconnectTimeout: number | undefined;
         callback: (resultJSON: InternalReturnType) => void;
     }> = new Map();
     // NOTE: It is important to make this as random as possible, to prevent
@@ -75,19 +78,23 @@ export async function createCallFactory(
     //  in return calls.
     let nextSeqNum = Math.random();
 
+    let lastConnectionAttempt = 0;
+
     let callerContext: CallerContextBase = {
         nodeId,
         localNodeId
     };
 
+    let disconnectCallbacks: (() => void)[] = [];
+    function onNextDisconnect(callback: () => void): void {
+        disconnectCallbacks.push(callback);
+    }
+
     let callFactory: CallFactory = {
         nodeId,
-        closedForever: false,
+        lastClosed: 0,
+        onNextDisconnect,
         async performCall(call: CallType) {
-            if (callFactory.closedForever) {
-                throw new Error(`Connection lost to ${niceConnectionName}`);
-            }
-
             let seqNum = nextSeqNum++;
             let fullCall: InternalCallType = {
                 nodeId,
@@ -111,144 +118,105 @@ export async function createCallFactory(
                         resolve(result.result);
                     }
                 };
-                pendingCalls.set(seqNum, { callback, data, call: fullCall, reconnectTimeout: call.reconnectTimeout });
+                pendingCalls.set(seqNum, { callback, data, call: fullCall });
             });
 
-            await sendWithRetry(call.reconnectTimeout, data);
+            await send(data);
 
             return await resultPromise;
         }
     };
 
-    let webSocket!: SenderInterface;
-    if (!webSocketBase) {
-        await tryToReconnect();
-    } else {
-        webSocket = webSocketBase;
-        setupWebsocket(webSocketBase);
+    let webSocketPromise: Promise<SenderInterface> | undefined;
+    if (webSocketBase) {
+        webSocketPromise = Promise.resolve(webSocketBase);
+        await initializeWebsocket(webSocketBase);
     }
 
-    niceConnectionName = `${niceConnectionName} (${callerContext.nodeId})`;
-
-    async function sendWithRetry(reconnectTimeout: number | undefined, data: Buffer) {
-        if (!retriesEnabled) {
-            webSocket.send(data);
-            return;
-        }
+    async function initializeWebsocket(newWebSocket: SenderInterface) {
+        registerOnce();
 
-        while (true) {
-            if (reconnectingPromise) {
-                if (reconnectTimeout) {
-                    await Promise.race([
-                        reconnectingPromise,
-                        new Promise<SenderInterface>(resolve =>
-                            setTimeout(() => {
-                                retriesEnabled = false;
-                                resolve(webSocket);
-                            }, reconnectTimeout)
-                        )
-                    ]);
-                } else {
-                    await reconnectingPromise;
-                }
+        function onClose(error: string) {
+            callFactory.lastClosed = Date.now();
+            webSocketPromise = undefined;
+            if (!canReconnect) {
+                callFactory.closedForever = true;
             }
-
-            if (!retriesEnabled) {
-                webSocket.send(data);
-                break;
+            for (let [key, call] of pendingCalls) {
+                pendingCalls.delete(key);
+                call.callback({
+                    isReturn: true,
+                    result: undefined,
+                    error: error,
+                    seqNum: call.call.seqNum,
+                    resultSize: 0,
+                    compressed: false,
+                });
             }
 
-            try {
-                webSocket.send(data);
-                break;
-            } catch (e) {
-                // Ignore errors, as we will catch them synchronously in the next loop.
-                void (tryToReconnect());
+            let callbacks = disconnectCallbacks;
+            disconnectCallbacks = [];
+            for (let callback of callbacks) {
+                try {
+                    callback();
+                } catch { }
             }
         }
-    }
-    function tryToReconnect(): Promise<void> {
-        if (reconnectingPromise) return reconnectingPromise;
-        return reconnectingPromise = (async () => {
-            while (true) {
-                if (!retriesEnabled) {
-                    callFactory.closedForever = true;
-                    console.log(`Cannot reconnect to ${niceConnectionName}, aborting pendingCalls: ${pendingCalls.size}`);
-                    for (let call of pendingCalls.values()) {
-                        call.callback({
-                            isReturn: true,
-                            result: undefined,
-                            error: `Connection lost to ${niceConnectionName}`,
-                            seqNum: call.call.seqNum,
-                            resultSize: 0,
-                            compressed: false,
-                        });
-                    }
-                    return;
-                }
-
-                let newWebSocket = createWebsocket(nodeId);
-
-                let connectError = await new Promise<string | undefined>(resolve => {
-                    newWebSocket.addEventListener("open", () => {
-                        resolve(undefined);
-                    });
-                    newWebSocket.addEventListener("close", () => {
-                        resolve("Connection closed for non-error reason?");
-                    });
-                    newWebSocket.addEventListener("error", e => {
-                        resolve(String(e.message));
-                    });
-                });
 
-                setupWebsocket(newWebSocket);
+        newWebSocket.addEventListener("error", e => {
+            // NOTE: No more logging, as we throw, so the caller should be logging the
+            //  error (or swallowing it, if that is what it wants to do).
+            //console.log(`Websocket error for ${niceConnectionName}`, e.message);
+            onClose(`Connection error for ${niceConnectionName}: ${e.message}`);
+        });
 
-                if (!connectError) {
-                    console.log(`Reconnected to ${niceConnectionName}`);
+        newWebSocket.addEventListener("close", async () => {
+            //console.log(`Websocket closed ${niceConnectionName}`);
+            onClose(`Connection closed to ${niceConnectionName}`);
+        });
 
-                    // I'm not sure if we should clear reconnectAttempts? Maybe if we eventually have a max reconnectAttempts?
-                    //reconnectAttempts = 0;
-                    reconnectingPromise = undefined;
+        newWebSocket.addEventListener("message", onMessage);
 
-                    webSocket = newWebSocket;
 
-                    for (let call of pendingCalls.values()) {
-                        sendWithRetry(call.reconnectTimeout, call.data).catch(e => {
-                            call.callback({
-                                isReturn: true,
-                                result: undefined,
-                                error: String(e),
-                                seqNum: call.call.seqNum,
-                                resultSize: 0,
-                                compressed: false,
-                            });
-                        });
-                    }
-                    return;
-                }
+        if (newWebSocket.readyState === 0 /* CONNECTING */) {
+            await new Promise<void>(resolve => {
+                newWebSocket.addEventListener("open", () => {
+                    console.log(`Connection established to ${niceConnectionName}`);
+                    callFactory.isConnected = true;
+                    resolve();
+                });
+                newWebSocket.addEventListener("close", () => resolve());
+                newWebSocket.addEventListener("error", () => resolve());
+            });
+        } else if (newWebSocket.readyState !== 1 /* OPEN */) {
+            onClose(`Websocket received in closed state`);
+            callFactory.isConnected = true;
+        }
+    }
 
-                reconnectAttempts++;
-                console.error(`Connection retry to ${niceConnectionName} failed (attempt ${reconnectAttempts}), retrying in ${retryInterval}ms, error: ${JSON.stringify(connectError)}`);
-                await new Promise(resolve => setTimeout(resolve, retryInterval));
+    async function send(data: Buffer) {
+        if (!webSocketPromise) {
+            if (canReconnect) {
+                webSocketPromise = tryToReconnect();
+            } else {
+                throw new Error(`Cannot send data to ${niceConnectionName} as the connection has closed`);
             }
-        })();
+        }
+        let webSocket = await webSocketPromise;
+        webSocket.send(data);
     }
+    async function tryToReconnect(): Promise<SenderInterface> {
+        // Don't try to reconnect too often!
+        let timeSinceLastAttempt = Date.now() - lastConnectionAttempt;
+        if (timeSinceLastAttempt < MIN_RETRY_DELAY) {
+            await new Promise(r => setTimeout(r, MIN_RETRY_DELAY - timeSinceLastAttempt));
+        }
+        lastConnectionAttempt = Date.now();
 
-    function setupWebsocket(webSocket: SenderInterface) {
-        registerNodeClient(callFactory);
-
-        webSocket.addEventListener("error", e => {
-            console.log(`Websocket error for ${niceConnectionName}`, e);
-        });
-
-        webSocket.addEventListener("close", async () => {
-            console.log(`Websocket closed ${niceConnectionName}`);
-            if (retriesEnabled) {
-                await tryToReconnect();
-            }
-        });
+        let newWebSocket = createWebsocket(nodeId);
+        await initializeWebsocket(newWebSocket);
 
-        webSocket.addEventListener("message", onMessage);
+        return newWebSocket;
     }
 
 
@@ -328,7 +296,7 @@ export async function createCallFactory(
                     } else {
                         result = Buffer.from(JSON.stringify(response));
                     }
-                    await sendWithRetry(call.reconnectTimeout, result);
+                    await send(result);
                 }
                 return;
             }

package/src/caching.ts

@@ -33,6 +33,7 @@ export function cacheEmptyArray<T>(array: T[]): T[] {
 
 export function cache<Output, Key>(getValue: (key: Key) => Output): {
     (key: Key): Output;
+    clear(key: Key): void;
 } {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
@@ -51,6 +52,9 @@ export function cache<Output, Key>(getValue: (key: Key) => Output): {
         values.set(key, value);
         return value;
     }
+    cache.clear = (key: Key) => {
+        values.delete(key);
+    };
     return cache;
 }
 

package/src/callManager.ts

@@ -1,5 +1,7 @@
-import { CallContextType, CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
+import { CallerContext, CallType, ClientHookContext, FullCallType, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from "../SocketFunctionTypes";
 import { _setSocketContext } from "../SocketFunction";
+import { isNode } from "./misc";
+import debugbreak from "debugbreak";
 
 let classes: {
     [classGuid: string]: {
@@ -39,14 +41,13 @@ export async function performLocalCall(
         throw new Error(`Function ${call.functionName} does not exist`);
     }
 
-    let curContext: CallContextType = {};
-    let serverContext = await runServerHooks(call, { caller, curContext, getCaller: () => caller }, functionShape);
+    let serverContext = await runServerHooks(call, caller, functionShape);
     if ("overrideResult" in serverContext) {
         return serverContext.overrideResult;
     }
 
     // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously
-    let result = _setSocketContext(curContext, caller, () => {
+    let result = _setSocketContext(caller, () => {
         return controller[call.functionName](...call.args);
     });
 
@@ -96,7 +97,17 @@ export async function runClientHooks(
     hooks: SocketExposedShape[""],
 ): Promise<ClientHookContext> {
     let context: ClientHookContext = { call: callType };
-    for (let hook of globalClientHooks.concat(hooks.clientHooks || [])) {
+
+    let clientHooks = (
+        globalClientHooks
+            .concat(hooks.clientHooks || [])
+    );
+    for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
+        if (otherClientHook) {
+            clientHooks.push(otherClientHook);
+        }
+    }
+    for (let hook of clientHooks) {
         await hook(context);
         if ("overrideResult" in context) {
             break;
@@ -107,12 +118,12 @@ export async function runClientHooks(
 
 async function runServerHooks(
     callType: FullCallType,
-    context: SocketRegistered["context"],
+    caller: CallerContext,
     hooks: SocketExposedShape[""],
 ): Promise<HookContext> {
-    let hookContext: HookContext = { call: callType, context };
+    let hookContext: HookContext = { call: callType };
     for (let hook of globalHooks.concat(hooks.hooks || [])) {
-        await hook(hookContext);
+        await _setSocketContext(caller, () => hook(hookContext));
         if ("overrideResult" in hookContext) {
             break;
         }

package/src/misc.ts

@@ -1,4 +1,7 @@
 import * as crypto from "crypto";
+import { MaybePromise } from "./types";
+
+export type Watchable<T> = (callback: (value: T) => void) => MaybePromise<void>;
 
 export function convertErrorStackToError(error: string): Error {
     let errorObj = new Error();

package/src/nodeCache.ts

@@ -19,11 +19,21 @@ export function getNodeId(domain: string, port: number): string {
 
 /** A nodeId not available for reconnecting. */
 export function getClientNodeId(address: string): string {
-    return `client_${address}:${Date.now()}:${Math.random()}`;
+    return `client:${address}:${Date.now()}:${Math.random()}`;
+}
+/** Will always be available, even if getNodeIdLocation is not (as we don't always have the port,
+ *      but we should always have an address).
+ *  - Rarely used, as for logging you can just log the nodeId. ALSO, it isn't sufficient to reconnect, as the port is also needed!
+ *  */
+export function getNodeIdIP(nodeId: string): string {
+    if (nodeId.startsWith("client:")) {
+        return nodeId.split(":")[1];
+    }
+    return getNodeIdLocation(nodeId)!.address;
 }
 
 export function getNodeIdLocation(nodeId: string): { address: string, port: number; } | undefined {
-    if (nodeId.startsWith("client_")) {
+    if (nodeId.startsWith("client:")) {
         return undefined;
     }
     let [address, port] = nodeId.split(":");
@@ -49,7 +59,7 @@ export function registerNodeClient(callFactory: CallFactory) {
     startCleanupLoop();
 }
 
-export function getCreateCallFactoryLocation(nodeId: string, mountedNodeId: string): MaybePromise<CallFactory> {
+export function getCreateCallFactory(nodeId: string, mountedNodeId: string): MaybePromise<CallFactory> {
     let callFactory = nodeCache.get(nodeId);
     if (callFactory === undefined) {
         callFactory = createCallFactory(undefined, nodeId, mountedNodeId);
@@ -57,6 +67,9 @@ export function getCreateCallFactoryLocation(nodeId: string, mountedNodeId: stri
     }
     return callFactory;
 }
+export function getCallFactory(nodeId: string): MaybePromise<CallFactory | undefined> {
+    return nodeCache.get(nodeId);
+}
 
 const startCleanupLoop = lazy(() => {
     (async () => {

package/src/webSocketServer.ts

@@ -9,15 +9,18 @@ import { getTrustedCertificates, watchTrustedCertificates } from "./certStore";
 import { createCallFactory } from "./CallFactory";
 import { parseSNIExtension, parseTLSHello, SNIType } from "./tlsParsing";
 import debugbreak from "debugbreak";
+import { getNodeId } from "./nodeCache";
+import crypto from "crypto";
+import { Watchable } from "./misc";
 
 export type SocketServerConfig = (
     https.ServerOptions & {
-        nodeId?: string;
-
         key: string | Buffer;
         cert: string | Buffer;
 
         port: number;
+        /** You can also set `port: 0` if you don't care what port you want at all.  */
+        useAvailablePortIfPortInUse?: boolean;
 
         // public sets ip to "0.0.0.0", otherwise it defaults to "127.0.0.1", which
         //  causes the server to only accept local connections.
@@ -26,24 +29,38 @@ export type SocketServerConfig = (
 
         /** If the SNI matches this domain, we use a different key/cert. */
         SNICerts?: {
-            [domain: string]: https.ServerOptions;
+            [domain: string]: Watchable<https.ServerOptions>;
         };
     }
 );
 
 export async function startSocketServer(
     config: SocketServerConfig
-): Promise<void> {
+): Promise<string> {
 
     const webSocketServer = new ws.Server({
         noServer: true,
     });
 
-    function setupHTTPSServer(options: https.ServerOptions) {
-        let httpsServer = https.createServer(options);
+    async function setupHTTPSServer(watchOptions: Watchable<https.ServerOptions>) {
+        let httpsServerLast: https.Server | undefined;
+        let onHttpServer: (server: https.Server) => void;
+        let httpServerPromise = new Promise<https.Server>(r => onHttpServer = r);
+        let lastOptions!: https.ServerOptions;
+        await watchOptions(value => {
+            lastOptions = { ...value, ca: getTrustedCertificates() };
+            if (!httpsServerLast) {
+                httpsServerLast = https.createServer(lastOptions);
+            } else {
+                httpsServerLast.setSecureContext(lastOptions);
+            }
+            onHttpServer(httpsServerLast);
+        });
+        let httpsServer = await httpServerPromise;
+
         watchTrustedCertificates(() => {
-            options.ca = getTrustedCertificates();
-            httpsServer.setSecureContext(options);
+            lastOptions.ca = getTrustedCertificates();
+            httpsServer.setSecureContext(lastOptions);
         });
 
         httpsServer.on("connection", socket => {
@@ -97,11 +114,17 @@ export async function startSocketServer(
     let options: https.ServerOptions = {
         ...config,
     };
+    if (!config.cert) {
+        throw new Error("No cert specified");
+    }
+    if (!config.key) {
+        throw new Error("No key specified");
+    }
 
-    const mainHTTPSServer = setupHTTPSServer(options);
+    const mainHTTPSServer = await setupHTTPSServer(callback => callback(options));
     let sniServers = new Map<string, https.Server>();
     for (let [domain, obj] of Object.entries(config.SNICerts || {})) {
-        sniServers.set(domain, setupHTTPSServer(obj));
+        sniServers.set(domain, await setupHTTPSServer(obj));
     }
 
     let httpServer = http.createServer({}, async function (req, res) {
@@ -130,6 +153,7 @@ export async function startSocketServer(
             } else {
                 let data = parseTLSHello(buffer);
                 let sni = data.extensions.filter(x => x.type === SNIType).flatMap(x => parseSNIExtension(x.data))[0];
+                console.log(`Received TCP connection with SNI ${JSON.stringify(sni)}`);
                 server = sniServers.get(sni) || mainHTTPSServer;
             }
 
@@ -158,12 +182,43 @@ export async function startSocketServer(
         host = "0.0.0.0";
     }
 
-    console.log(`Trying to listening on ${host}:${config.port}`);
-    realServer.listen(config.port, host);
+    let port = config.port;
+    if (config.useAvailablePortIfPortInUse && port) {
+        async function isPortInUse(port: number): Promise<boolean> {
+            return new Promise<boolean>((resolve, reject) => {
+                let server = net.createServer();
+                server.listen(port, host)
+                    .on("listening", function () {
+                        server.close();
+                        resolve(false);
+                    }).on("close", function () {
+                        resolve(true);
+                    }).on("error", function (e) {
+                        resolve(true);
+                    });
+            });
+        }
+        if (await isPortInUse(port)) {
+            port = 0;
+        }
+    }
+
+    console.log(`Trying to listening on ${host}:${port}`);
+    realServer.listen(port, host);
 
     await listenPromise;
 
-    let port = (realServer.address() as net.AddressInfo).port;
+    port = (realServer.address() as net.AddressInfo).port;
+    let nodeId = getNodeId(getCommonName(config.cert), port);
+    console.log(`Started Listening on ${nodeId}`);
+
+    return nodeId;
+}
 
-    console.log(`Started Listening on ${config.nodeId || host}:${port}`);
+function getCommonName(cert: Buffer | string) {
+    let subject = new crypto.X509Certificate(cert).subject;
+    let subjectKVPs = new Map(subject.split(",").map(x => x.trim().split("=")).map(x => [x[0], x.slice(1).join("=")]));
+    let commonName = subjectKVPs.get("CN");
+    if (!commonName) throw new Error(`No common name in subject: ${subject}`);
+    return commonName;
 }

package/src/{nodeAuthentication.ts → websocketFactory.ts}

@@ -4,6 +4,7 @@ import { isNode } from "./misc";
 import { SenderInterface } from "./CallFactory";
 import { getTrustedCertificates } from "./certStore";
 import { getNodeIdLocation } from "./nodeCache";
+import debugbreak from "debugbreak";
 
 
 export function getTLSSocket(webSocket: ws.WebSocket) {

package/test/client.ts

@@ -1,3 +1,5 @@
+/// <reference path="../require/RequireController.ts" />
+
 // https://letx.ca:2542/?classGuid=RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d&functionName=requireHTML&args=[%22./test/test%22]
 
 //import typescript from "typescript";
@@ -24,8 +26,6 @@ void main();
 async function main() {
     if (isNode()) return;
 
-    SocketFunction.rejectUnauthorized = false;
-
     SocketFunction.expose(Test);
 
     console.log("cool");

package/test/shared.ts

@@ -41,7 +41,7 @@ class TestBase {
 export const Test = SocketFunction.register(
     "80d9f328-72df-4baa-8be8-019c1003d4a2",
     new TestBase(),
-    {
+    () => ({
         add: {
             // hooks: [
             //     async (config) => {
@@ -49,17 +49,11 @@ export const Test = SocketFunction.register(
             //     }
             // ]
         },
-        callMe: {
-            clientHooks: [
-                async (config) => {
-                    config.call.reconnectTimeout = 2000;
-                }
-            ]
-        },
+        callMe: {},
         callBack: {
 
         },
         //fncNotAsync: {},
         //notAFnc: {},
-    }
+    })
 );