socket-function 0.8.13 → 0.8.14

package/SocketFunction.ts

@@ -1,7 +1,7 @@
-import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType } from "./SocketFunctionTypes";
+import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType, FullCallType } from "./SocketFunctionTypes";
 import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
 import { SocketServerConfig, startSocketServer } from "./src/webSocketServer";
-import { getCallFactoryNodeId, getCreateCallFactoryLocation, getNetworkLocationHash } from "./src/nodeCache";
+import { getCallFactoryFromNodeId, getCreateCallFactoryLocation, getNetworkLocationHash } from "./src/nodeCache";
 import { getCallProxy } from "./src/nodeProxy";
 import { Args } from "./src/types";
 import { setDefaultHTTPCall } from "./src/callHTTPHandler";
@@ -53,13 +53,15 @@ export class SocketFunction {
 
         registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
 
-        let nodeProxy = getCallProxy(classGuid, async (nodeId, functionName, args) => {
+        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}`);
             }
             try {
-                let callFactory = await getCallFactoryNodeId(nodeId);
+                let callFactory = await getCallFactoryFromNodeId(nodeId);
                 if (!callFactory) {
                     throw new Error(`Cannot reach node ${nodeId}. It might have been incorrect provided to us via another node, which should have provided us a NetworkLocation instead.`);
                 }
@@ -69,12 +71,6 @@ export class SocketFunction {
                     throw new Error(`Function ${functionName} is not in shape`);
                 }
 
-                let call: CallType = {
-                    classGuid,
-                    args,
-                    functionName,
-                };
-
                 let hookResult = await runClientHooks(call, shapeObj as SocketExposedShape[""]);
 
                 if ("overrideResult" in hookResult) {
@@ -99,6 +95,20 @@ export class SocketFunction {
         return output as any;
     }
 
+    /** Gets HTTP call link */
+    public static async getHTTPCallLink(call: FullCallType): Promise<string> {
+        let factory = await getCallFactoryFromNodeId(call.nodeId);
+        if (!factory) {
+            throw new Error(`Cannot find call factory for nodeId, and so do not know where call location is. NodeId ${call.nodeId}`);
+        }
+        let location = factory.location;
+        let url = new URL(`https://${location.address}:${location.listeningPorts[0]}`);
+        url.searchParams.set("classGuid", call.classGuid);
+        url.searchParams.set("functionName", call.functionName);
+        url.searchParams.set("args", JSON.stringify(call.args));
+        return url.toString();
+    }
+
     /** Expose should be called before your mounting occurs. It mostly just exists to ensure you include the class type,
      *      so the class type's module construction runs, which should trigger register. Otherwise you would have
      *      to add additional imports to ensure the register call runs.

package/SocketFunctionTypes.ts

@@ -2,12 +2,20 @@ module.allowclient = true;
 
 import debugbreak from "debugbreak";
 import * as tls from "tls";
+import { getCallObj } from "./src/nodeProxy";
+import { Args } from "./src/types";
 
 export const socket = Symbol("socket");
 
 export type SocketExposedInterface = {
     [functionName: string]: (...args: any[]) => Promise<unknown>;
 };
+export type SocketInternalInterface = {
+    [functionName: string]: {
+        [getCallObj]: (...args: any[]) => FullCallType;
+        (...args: any[]): Promise<unknown>;
+    }
+}
 export type SocketExposedInterfaceClass = {
     //new(): SocketExposedInterface;
     new(): unknown;
@@ -28,6 +36,9 @@ export interface CallType {
     //  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>): Promise<void>;
@@ -56,7 +67,11 @@ export interface SocketRegistered<ExposedType extends SocketExposedInterface = S
     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).
-        [nodeId: string]: ExposedType;
+        [nodeId: string]: {
+            [functionName in keyof ExposedType]: ExposedType[functionName] & {
+                [getCallObj]: (...args: Args<ExposedType[functionName]>) => FullCallType;
+            }
+        };
     };
     context: {
         // If undefined we are not synchronously in a call

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "socket-function",
-	"version": "0.8.13",
+	"version": "0.8.14",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {

package/src/nodeCache.ts

@@ -87,6 +87,6 @@ export function getCreateCallFactoryLocation(location: NetworkLocation, tempNode
 
 
 // TODO: Give a special error if the nodeId has been seen, but is only one-way (from HTTP requests).
-export async function getCallFactoryNodeId(nodeId: string): Promise<CallFactory | undefined> {
+export async function getCallFactoryFromNodeId(nodeId: string): Promise<CallFactory | undefined> {
     return await nodeCache.get(nodeId)?.callFactory;
 }

package/src/nodeProxy.ts

@@ -1,29 +1,52 @@
 import { lazy } from "./caching";
-import { SocketExposedInterface } from "../SocketFunctionTypes";
+import { FullCallType, SocketExposedInterface, SocketInternalInterface } from "../SocketFunctionTypes";
 
 type CallProxyType = {
-    [controllerName: string]: SocketExposedInterface;
+    [nodeId: string]: SocketInternalInterface;
 };
 
+export const getCallObj = Symbol.for("getCallObj");
+
 let proxyCache = new Map<string, CallProxyType>();
-export function getCallProxy(id: string, callback: (controllerName: string, functionName: string, args: unknown[]) => Promise<unknown>): CallProxyType {
+export function getCallProxy(id: string, callback: (callType: FullCallType) => Promise<unknown>): CallProxyType {
     let value = proxyCache.get(id);
     if (!value) {
-        let controllerCache = new Map<string, CallProxyType[""]>();
+        let nodeCache = new Map<string, CallProxyType[""]>();
         value = new Proxy(Object.create(null), {
-            get(target, controllerName) {
-                if (typeof controllerName !== "string") return undefined;
-                let controller = controllerCache.get(controllerName);
-                if (!controller) {
-                    controller = new Proxy(Object.create(null), {
+            get(target, nodeId) {
+                if (typeof nodeId !== "string") return undefined;
+                let nodeProxy = nodeCache.get(nodeId);
+                if (!nodeProxy) {
+                    nodeProxy = new Proxy(Object.create(null), {
                         get(target, functionName) {
                             if (typeof functionName !== "string") return undefined;
-                            return (...args: unknown[]) => callback(controllerName, functionName, args);
+                            return Object.assign(
+                                (...args: unknown[]) => {
+                                    let call: FullCallType = {
+                                        classGuid: id,
+                                        nodeId,
+                                        functionName,
+                                        args,
+                                    };
+                                    return callback(call);
+                                },
+                                {
+                                    [getCallObj]: (...args: unknown[]) => {
+                                        let call: FullCallType = {
+                                            classGuid: id,
+                                            nodeId,
+                                            functionName,
+                                            args,
+                                        };
+                                        return call;
+                                    }
+                                }
+                            );
                         }
                     }) as CallProxyType[""];
-                    controllerCache.set(controllerName, controller);
+                    nodeCache.set(nodeId, nodeProxy);
                 }
-                return controller;
+                return nodeProxy;
             },
         }) as CallProxyType;
         proxyCache.set(id, value);

package/test/client.ts

@@ -10,6 +10,7 @@ import { Test } from "./shared";
 import "../require/CSSShim";
 import "./client.css";
 import { isNode } from "../src/misc";
+import { getCallObj } from "../src/nodeProxy";
 
 module.allowclient = true;
 
@@ -23,6 +24,8 @@ void main();
 async function main() {
     if (isNode()) return;
 
+    SocketFunction.rejectUnauthorized = false;
+
     SocketFunction.expose(Test);
 
     console.log("cool");

package/test/server.ts

@@ -16,11 +16,14 @@ import "../require/CSSShim";
 
 // Import clientside files, so they can be whitelisted
 import "./client";
+import { getCallObj } from "../src/nodeProxy";
 
 
 void main();
 
 async function main() {
+    SocketFunction.rejectUnauthorized = false;
+
     SocketFunction.expose(Test);
 
     RequireController._classGuid;