socket-function 0.8.36 → 0.8.37

package/SocketFunction.ts

@@ -1,9 +1,9 @@
 /// <reference path="./require/RequireController.ts" />
 
-import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType } from "./SocketFunctionTypes";
+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, MaybePromise } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
@@ -36,12 +36,18 @@ export class SocketFunction {
     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,
@@ -49,7 +55,7 @@ export class SocketFunction {
         defaultHooksFnc?: () => SocketExposedShape[""] & {
             onMount?: () => MaybePromise<void>;
         }
-    ): SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext> {
+    ): SocketRegistered<ExtractShape<ClassInstance, Shape>> {
         let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
         const getShape = lazy(() => {
             let shape = shapeFnc();
@@ -76,7 +82,7 @@ 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 = getShape()[functionName];
                 if (!shapeObj) {
@@ -99,7 +105,6 @@ export class SocketFunction {
         });
 
         let output: SocketRegistered = {
-            context: curSocketContext,
             nodes: nodeProxy,
             _classGuid: classGuid,
         };
@@ -119,6 +124,40 @@ export class SocketFunction {
         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).
      *  */
@@ -190,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

@@ -2,6 +2,7 @@
 
 module.allowclient = true;
 
+import { SocketFunction } from "./SocketFunction";
 import { getCallObj } from "./src/nodeProxy";
 import { Args, MaybePromise } from "./src/types";
 
@@ -21,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>[];
     };
 }
 
@@ -41,32 +42,27 @@ 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, CallContext>;
+    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 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).
@@ -76,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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.36",
+	"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",

package/src/CallFactory.ts

@@ -10,6 +10,8 @@ import { getClientNodeId, getNodeIdLocation, registerNodeClient } from "./nodeCa
 import debugbreak from "debugbreak";
 import { lazy } from "./caching";
 
+const MIN_RETRY_DELAY = 1000;
+
 type InternalCallType = FullCallType & {
     seqNum: number;
     isReturn: false;
@@ -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 {
@@ -59,6 +64,8 @@ export async function createCallFactory(
     const createWebsocket = createWebsocketFactory();
     const registerOnce = lazy(() => registerNodeClient(callFactory));
 
+    const canReconnect = !!getNodeIdLocation(nodeId);
+
     let lastReceivedSeqNum = 0;
 
     let pendingCalls: Map<number, {
@@ -71,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,
@@ -126,7 +137,11 @@ export async function createCallFactory(
         registerOnce();
 
         function onClose(error: string) {
+            callFactory.lastClosed = Date.now();
             webSocketPromise = undefined;
+            if (!canReconnect) {
+                callFactory.closedForever = true;
+            }
             for (let [key, call] of pendingCalls) {
                 pendingCalls.delete(key);
                 call.callback({
@@ -138,6 +153,14 @@ export async function createCallFactory(
                     compressed: false,
                 });
             }
+
+            let callbacks = disconnectCallbacks;
+            disconnectCallbacks = [];
+            for (let callback of callbacks) {
+                try {
+                    callback();
+                } catch { }
+            }
         }
 
         newWebSocket.addEventListener("error", e => {
@@ -159,6 +182,7 @@ export async function createCallFactory(
             await new Promise<void>(resolve => {
                 newWebSocket.addEventListener("open", () => {
                     console.log(`Connection established to ${niceConnectionName}`);
+                    callFactory.isConnected = true;
                     resolve();
                 });
                 newWebSocket.addEventListener("close", () => resolve());
@@ -166,15 +190,29 @@ export async function createCallFactory(
             });
         } else if (newWebSocket.readyState !== 1 /* OPEN */) {
             onClose(`Websocket received in closed state`);
+            callFactory.isConnected = true;
         }
     }
 
     async function send(data: Buffer) {
-        webSocketPromise = webSocketPromise || tryToReconnect();
+        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();
+
         let newWebSocket = createWebsocket(nodeId);
         await initializeWebsocket(newWebSocket);
 

package/src/callManager.ts

@@ -1,4 +1,4 @@
-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";
@@ -41,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);
     });
 
@@ -119,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/nodeCache.ts

@@ -59,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);
@@ -67,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 () => {