socket-function 0.15.0 → 0.17.0

package/SocketFunction.ts

@@ -1,6 +1,6 @@
 /// <reference path="./require/RequireController.ts" />
 
-import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, CallType } from "./SocketFunctionTypes";
+import { SocketExposedInterface, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, CallerContext, FullCallType, CallType, FncType, SocketRegisterType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
 import { getCallFactory, getCreateCallFactory, getNodeId, getNodeIdLocation } from "./src/nodeCache";
@@ -84,7 +84,6 @@ export class SocketFunction {
         return caller;
     }
 
-    private static getShapeHotReloadable = new Map<string, () => SocketExposedShape<SocketExposedInterface>>();
     // 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<
@@ -113,6 +112,18 @@ export class SocketFunction {
             noFunctionMeasure?: boolean;
         }
     ): SocketRegistered<ExtractShape<ClassInstance, Shape>> & Statics {
+        void Promise.resolve().then(() => {
+            let onMount = getDefaultHooks?.().onMount;
+            if (onMount) {
+                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
+                if (!callbacks) {
+                    callbacks = [];
+                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);
+                }
+                callbacks.push(onMount);
+            }
+        });
+
         let getDefaultHooks = defaultHooksFnc && lazy(defaultHooksFnc);
         const getShape = lazy(() => {
             let shape = shapeFnc() as SocketExposedShape;
@@ -142,58 +153,76 @@ export class SocketFunction {
             });
         });
 
-        let nodeProxy = getCallProxy(classGuid, async (call) => {
-            let nodeId = call.nodeId;
-            let functionName = call.functionName;
-            let time = Date.now();
-            if (SocketFunction.logMessages) {
-                console.log(`START\t\t\t${classGuid}.${functionName} at ${Date.now()}`);
-            }
-            try {
-                let callFactory = await getCreateCallFactory(nodeId);
+        let socketCaller = SocketFunction.rehydrateSocketCaller({
+            _classGuid: classGuid,
+            _internalType: null as any,
+        }, getShape);
 
-                let shapeObj = getShape()[functionName];
-                if (!shapeObj) {
-                    throw new Error(`Function ${functionName} is not in shape`);
-                }
+        if (!config?.noAutoExpose) {
+            this.expose(socketCaller);
+        }
+        return Object.assign(socketCaller, config?.statics);
+    }
 
-                let hookResult = await runClientHooks(call, shapeObj as Exclude<SocketExposedShape[""], undefined>, callFactory.connectionId);
+    private static socketCache = new Map<string, SocketRegistered>();
+    public static rehydrateSocketCaller<Controller>(
+        socketRegistered: SocketRegisterType<Controller>,
+        // Shape is required for client hooks.
+        shapeFnc?: () => SocketExposedShape,
+    ): SocketRegistered<Controller> {
+        let cached = this.socketCache.get(socketRegistered._classGuid);
+        if (!cached) {
+            let getShape = lazy(() => shapeFnc?.());
+            let classGuid = socketRegistered._classGuid;
+            let nodeProxy = getCallProxy(classGuid, async (call) => {
+                return await SocketFunction.callFromGuid(call, classGuid, getShape());
+            });
 
-                if ("overrideResult" in hookResult) {
-                    return hookResult.overrideResult;
-                }
+            cached = {
+                nodes: nodeProxy,
+                _classGuid: classGuid,
+                _internalType: null as any,
+            };
 
-                return await callFactory.performCall(call);
-            } finally {
-                time = Date.now() - time;
-                if (SocketFunction.logMessages) {
-                    console.log(`FINISHED\t${time}ms\t${classGuid}.${functionName} at ${Date.now()}`);
-                }
-            }
-        });
+            this.socketCache.set(classGuid, cached);
+        }
+        return cached;
+    }
 
-        let output: SocketRegistered = {
-            nodes: nodeProxy,
-            _classGuid: classGuid,
-        };
+    private static async callFromGuid<FncT extends FncType>(
+        call: FullCallType<FncT>,
+        classGuid: string,
+        shape?: SocketExposedShape,
+    ): Promise<ReturnType<FncType>> {
+        let nodeId = call.nodeId;
+        let functionName = call.functionName;
+        let time = Date.now();
+        if (SocketFunction.logMessages) {
+            console.log(`START\t\t\t${classGuid}.${functionName} at ${Date.now()}`);
+        }
+        try {
+            let callFactory = await getCreateCallFactory(nodeId);
 
-        void Promise.resolve().then(() => {
-            let onMount = getDefaultHooks?.().onMount;
-            if (onMount) {
-                let callbacks = SocketFunction.onMountCallbacks.get(classGuid);
-                if (!callbacks) {
-                    callbacks = [];
-                    SocketFunction.onMountCallbacks.set(classGuid, callbacks);
-                }
-                callbacks.push(onMount);
+            let shapeObj = shape?.[functionName];
+            // NOTE: Actually... this just means the client doesn't have a definition for it. The server
+            //  might, so call it, and let them throw if it is unrecognized.
+            // if (!shapeObj) {
+            //     throw new Error(`Function ${functionName} is not in shape`);
+            // }
+
+            let hookResult = await runClientHooks(call, shapeObj as Exclude<SocketExposedShape[""], undefined>, callFactory.connectionId);
+
+            if ("overrideResult" in hookResult) {
+                return hookResult.overrideResult;
             }
-        });
 
-        let result = output as any as SocketRegistered;
-        if (!config?.noAutoExpose) {
-            this.expose(result);
+            return await callFactory.performCall(call);
+        } finally {
+            time = Date.now() - time;
+            if (SocketFunction.logMessages) {
+                console.log(`FINISHED\t${time}ms\t${classGuid}.${functionName} at ${Date.now()}`);
+            }
         }
-        return Object.assign(result, config?.statics);
     }
 
     public static onNextDisconnect(nodeId: string, callback: () => void) {

package/SocketFunctionTypes.ts

@@ -42,12 +42,13 @@ export type SocketExposedShape<ExposedType extends SocketExposedInterface = Sock
     };
 };
 
-export interface CallType {
+export type FncType = (...args: any[]) => Promise<unknown>;
+export interface CallType<FncT extends FncType = FncType, FncName extends string = string> {
     classGuid: string;
-    functionName: string;
+    functionName: FncName;
     args: unknown[];
 }
-export interface FullCallType extends CallType {
+export interface FullCallType<FncT extends FncType = FncType, FncName extends string = string> extends CallType<FncT, FncName> {
     nodeId: string;
 }
 
@@ -72,6 +73,11 @@ export interface SocketFunctionClientHook<ExposedType extends SocketExposedInter
     (config: ClientHookContext<ExposedType>): MaybePromise<void>;
 }
 
+export interface SocketRegisterType<ExposedType = any> {
+    _classGuid: string;
+    _internalType: ExposedType;
+}
+
 export interface SocketRegistered<ExposedType = any> {
     nodes: {
         // NOTE: Don't pass around nodeId to other nodes, instead pass around NetworkLocation (which they
@@ -83,7 +89,11 @@ export interface SocketRegistered<ExposedType = any> {
         };
     };
     _classGuid: string;
+    _internalType: ExposedType;
 }
+export type ControllerPick<T extends SocketRegistered, K extends keyof T["_internalType"]> = (
+    SocketRegistered<Pick<T["_internalType"], K>>
+);
 export type CallerContext = Readonly<CallerContextBase>;
 export type CallerContextBase = {
     // IMPORTANT! Do not pass nodeId to other nodes with the intention of having

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.15.0",
+	"version": "0.17.0",
 	"main": "index.js",
 	"license": "MIT",
 	"note1": "note on node-forge fork, see https://github.com/digitalbazaar/forge/issues/744 for details",

package/src/batching.ts

@@ -149,7 +149,12 @@ export function batchFunction<Arg, Result = void>(
         let curPrevPromise = prevPromise;
         let args: Arg[] = [arg];
         let promise = Promise.resolve().then(async () => {
-            await curPrevPromise;
+            // Ignore the error. New callers don't care about errors in previous calls,
+            //  as they are unrelated to the current call, and just break valid calls
+            //  due to invalid calls.
+            try {
+                await curPrevPromise;
+            } catch { }
             await delay(curDelay, "immediateShortDelays");
             // Reset batching, as we once we start the function we can't accept args. `prevPromise` will block
             //  the next batch from starting before we finish.