socket-function 0.8.12 → 0.8.15

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, getLocationFromNodeId, 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;
     }
 
+    /** NOTE: Only works if the call has been loaded from a url (we can't convert arbitrary nodeIds into urls,
+     *      as we have no way of knowing how to contain a nodeId). */
+    public static getHTTPCallLink(call: FullCallType): string {
+        let location = getLocationFromNodeId(call.nodeId);
+        if (!location) {
+            throw new Error(`Cannot find call location for nodeId, and so do not know where call location is. NodeId ${call.nodeId}`);
+        }
+        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/mobx/promiseToObservable.tsx

@@ -59,6 +59,7 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
         invalidateSeqNum.seqNum++;
     };
     function get(key: Key) {
+        invalidateSeqNum.seqNum;
         let hash = JSON.stringify(key);
         let value = values.get(hash);
         if (value) {

package/package.json

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

package/src/nodeCache.ts

@@ -15,6 +15,8 @@ import { MaybePromise } from "./types";
 // nodeId => 
 const nodeCache = new Map<string, {
     callFactory: MaybePromise<CallFactory>;
+    // Just used for getCallFactoryFromNodeId
+    location: NetworkLocation | undefined;
 }>();
 const locationLookup = new Map<string, MaybePromise<string>>();
 
@@ -47,6 +49,7 @@ export function registerNodeClient(callFactory: CallFactory) {
     // TODO: Maybe even preserve the address in some cases, such as if it was a domain, and is now an ip?
     nodeCache.set(nodeId, {
         callFactory,
+        location: undefined,
     });
 }
 
@@ -64,6 +67,7 @@ export function getCreateCallFactoryLocation(location: NetworkLocation, tempNode
     if (tempNodeId !== undefined) {
         nodeCache.set(tempNodeId, {
             callFactory: callFactoryPromise,
+            location,
         });
     }
 
@@ -80,6 +84,7 @@ export function getCreateCallFactoryLocation(location: NetworkLocation, tempNode
         }
         nodeCache.set(nodeId, {
             callFactory,
+            location,
         });
         return nodeId;
     });
@@ -87,6 +92,10 @@ 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;
+}
+// NOTE: Only works if the nodeId has been loaded with getCreateCallFactoryLocation
+export function getLocationFromNodeId(nodeId: string): NetworkLocation | undefined {
+    return nodeCache.get(nodeId)?.location;
 }

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;
@@ -31,4 +34,12 @@ async function main() {
     const port = 2542;
 
     await SocketFunction.mount({ port });
+
+
+    {
+        let serverId = await SocketFunction.connect({ port, address: "letx.ca" });
+        let call = Test.nodes[serverId].add[getCallObj](1, 2);
+        console.log(call);
+        console.log(await SocketFunction.getHTTPCallLink(call));
+    }
 }