socket-function 0.8.11 → 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/mobx/promiseToObservable.tsx

@@ -6,7 +6,9 @@ export function promiseToObservable<T>(promise: Promise<T>): { value: T | undefi
     let error: unknown;
     let result: T | undefined;
 
-    let isDoneTrigger = observable({ value: false });
+    let isDoneTrigger = observable({
+        value: false
+    });
     promise.then(
         r => {
             result = r;
@@ -37,18 +39,49 @@ export function asyncObservable<Output, Key>(maxCount: number, getValue: (key: K
     invalidate(key: Key): void;
     invalidateAll(): void;
 } {
-    let cache = cacheLimited(maxCount, (keyJSON: string) => {
-        let key = keyJSON ? JSON.parse(keyJSON) : keyJSON;
-        // We call inside another function so that synchronous errors still get wrapped in the observable
-        let value = (async () => getValue(key))();
-        return promiseToObservable(value);
-    });
+    // NOTE: Not very efficient (invalidates too much), but... makes triggering invalidations much faster/easier,
+    //  making an invalidate depend on the total render time, not the total cached state size.
+    let invalidateSeqNum = observable({ seqNum: 1 }, undefined, { deep: false, proxy: false });
+    let startingCalculating = new Set<string>();
+    let values = new Map<string, { value: Output | undefined }>();
+
     get["invalidate"] = (key: Key) => {
-        cache.invalidate(JSON.stringify(key));
+        let hash = JSON.stringify(key);
+        let value = values.get(hash);
+        if (!value) return;
+        values.delete(hash);
+        startingCalculating.delete(hash);
+        invalidateSeqNum.seqNum++;
+    };
+    get["invalidateAll"] = () => {
+        startingCalculating.clear();
+        values.clear();
+        invalidateSeqNum.seqNum++;
     };
-    get["invalidateAll"] = () => cache.invalidateAll();
     function get(key: Key) {
-        return cache(JSON.stringify(key)).value;
+        invalidateSeqNum.seqNum;
+        let hash = JSON.stringify(key);
+        let value = values.get(hash);
+        if (value) {
+            return value.value;
+        }
+        if (startingCalculating.has(hash)) {
+            throw new Error(`Cyclic access in cache`);
+        }
+        startingCalculating.add(hash);
+
+        // Not very efficient, but clearing the entire state is a lot easier to do then
+        //  keep track of the order they are accessed (and it does make MOST accesses
+        //  MUCH faster).
+        if (values.size >= maxCount) {
+            values.clear();
+            startingCalculating.clear();
+        }
+
+        // We call inside another function so that synchronous errors still get wrapped in the observable
+        value = promiseToObservable((async () => getValue(key))());
+        values.set(hash, value);
+        return value.value;
     }
     return get;
 }

package/package.json

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

package/src/caching.ts

@@ -64,22 +64,10 @@ export function cacheLimited<Output, Key>(
     //  calculating, keeping a consistent output can save (a considerable amount of) time in downstream caches.
     maxCount: number,
     getValue: (key: Key) => Output
-): {
-    (key: Key): Output;
-    invalidate(key: Key): void;
-    invalidateAll(): void;
-} {
+): (key: Key) => Output {
     let startingCalculating = new Set<Key>();
     let values = new Map<Key, Output>();
-    get["invalidate"] = (key: Key) => {
-        values.delete(key);
-        startingCalculating.delete(key);
-    };
-    get["invalidateAll"] = () => {
-        values.clear();
-        startingCalculating.clear();
-    };
-    function get(input: Key) {
+    return (input) => {
         let key = input;
         if (values.has(key)) {
             return values.get(key) as any;
@@ -103,8 +91,7 @@ export function cacheLimited<Output, Key>(
         let value = getValue(input);
         values.set(key, value);
         return value;
-    }
-    return get;
+    };
 }
 
 export function cacheWeak<Output, Key extends object>(getValue: (key: Key) => Output): (key: Key) => Output {

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;