socket-function 0.5.0 → 0.7.1

package/SocketFunction.ts

@@ -1,9 +1,14 @@
 import { SocketExposedInterface, CallContextType, SocketFunctionHook, SocketFunctionClientHook, SocketExposedShape, SocketRegistered, NetworkLocation, CallerContext, SocketExposedInterfaceClass, CallType } from "./SocketFunctionTypes";
-import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./callManager";
-import { SocketServerConfig, startSocketServer } from "./socketServer";
-import { getCallFactoryNodeId, getCreateCallFactoryLocation } from "./nodeCache";
-import { getCallProxy } from "./nodeProxy";
+import { exposeClass, registerClass, registerGlobalClientHook, registerGlobalHook, runClientHooks } from "./src/callManager";
+import { SocketServerConfig, startSocketServer } from "./src/socketServer";
+import { getCallFactoryNodeId, getCreateCallFactoryLocation, getNetworkLocationHash } from "./src/nodeCache";
+import { getCallProxy } from "./src/nodeProxy";
+import { Args } from "./src/types";
+import { setDefaultHTTPCall } from "./src/callHTTPHandler";
+import { isNode } from "./src/misc";
+import { getOwnNodeId } from "./src/nodeAuthentication";
 
+module.allowclient = true;
 
 type ExtractShape<ClassType, Shape> = {
     [key in keyof Shape]: (
@@ -21,27 +26,29 @@ type PickByType<T, Value> = {
 
 export class SocketFunction {
     public static register<
-        ClassType extends SocketExposedInterfaceClass,
+        ClassInstance extends object,
         Shape extends SocketExposedShape<SocketExposedInterface, CallContext>,
         CallContext extends CallContextType
     >(
         classGuid: string,
-        classType: ClassType,
+        instance: ClassInstance,
         shape: Shape
-    ): (
+    ):
+        (
             // Essentially just returns SocketRegistered
-            ExtractShape<ClassType["prototype"], Shape> extends SocketExposedInterface
-            ? SocketRegistered<ExtractShape<ClassType["prototype"], Shape>, CallContext>
+            ExtractShape<ClassInstance, Shape> extends SocketExposedInterface
+            ? SocketRegistered<ExtractShape<ClassInstance, Shape>, CallContext>
             : {
                 error: "invalid shape";
-            } & PickByType<ExtractShape<ClassType["prototype"], Shape>, string>
+            } & PickByType<ExtractShape<ClassInstance, Shape>, string>
         ) {
-        registerClass(classGuid, classType, shape as any as SocketExposedShape);
+
+        registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
 
         let nodeProxy = getCallProxy(classGuid, async (nodeId, functionName, args) => {
-            let callFactory = getCallFactoryNodeId(nodeId);
+            let callFactory = await getCallFactoryNodeId(nodeId);
             if (!callFactory) {
-                throw new Error(`Cannot reach node ${nodeId}. Either it was established via an HTTP call, or was incorrect provided to us via another node, which should have provided us a NetworkLocation instead.`);
+                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.`);
             }
 
             let shapeObj = shape[functionName];
@@ -67,6 +74,7 @@ export class SocketFunction {
         let output: SocketRegistered = {
             context: curSocketContext,
             nodes: nodeProxy,
+            _classGuid: classGuid,
         };
 
         return output as any;
@@ -76,14 +84,34 @@ export class SocketFunction {
      *      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.
      */
-    public static expose(classType: SocketExposedInterfaceClass) {
-        exposeClass(classType);
+    public static expose(socketRegistered: SocketRegistered) {
+        exposeClass(socketRegistered);
     }
 
     public static async mount(config: SocketServerConfig) {
         await startSocketServer(config);
     }
 
+    public static async getOwnNodeId() {
+        return await getOwnNodeId();
+    }
+
+    /** Sets the default call when an http request is made, but no classGuid is set. */
+    public static setDefaultHTTPCall<
+        Registered extends SocketRegistered,
+        FunctionName extends keyof Registered["nodes"][""] & string,
+        >(
+            registered: Registered,
+            functionName: FunctionName,
+            ...args: Args<Registered["nodes"][""][FunctionName]>
+        ) {
+        setDefaultHTTPCall({
+            classGuid: registered._classGuid,
+            functionName,
+            args,
+        });
+    }
+
     public static async connect(location: NetworkLocation | { address: string; port: number }): Promise<string> {
         if (!("localPort" in location)) {
             location = {
@@ -95,6 +123,20 @@ export class SocketFunction {
         return await getCreateCallFactoryLocation(location);
     }
 
+    public static connectSync(location: NetworkLocation | { address: string; port: number }): string {
+        if (!("localPort" in location)) {
+            location = {
+                address: location.address,
+                listeningPorts: [location.port],
+                localPort: 0,
+            };
+        }
+        let tempNodeId = "syncTempNodeId_" + getNetworkLocationHash(location);
+
+        void getCreateCallFactoryLocation(location, tempNodeId);
+
+        return tempNodeId;
+    }
 
     public static addGlobalHook<CallContext extends CallContextType>(hook: SocketFunctionHook<SocketExposedInterface, CallContext>) {
         registerGlobalHook(hook as SocketFunctionHook);

package/SocketFunctionTypes.ts

@@ -1,4 +1,4 @@
-export const socket = Symbol.for("socket");
+export const socket = Symbol("socket");
 
 export type SocketExposedInterface = {
     [functionName: string]: (...args: any[]) => Promise<unknown>;
@@ -58,6 +58,7 @@ export interface SocketRegistered<ExposedType extends SocketExposedInterface = S
         curContext: DynamicCallContext | undefined;
         caller: CallerContext | undefined;
     };
+    _classGuid: string;
 }
 export type CallerContext = {
     // IMPORTANT! Do not pass nodeId to other nodes with the intention of having

package/package.json

@@ -1,13 +1,15 @@
 {
 	"name": "socket-function",
-	"version": "0.5.0",
+	"version": "0.7.1",
 	"main": "index.js",
 	"license": "MIT",
 	"dependencies": {
+		"@types/cookie": "^0.5.1",
 		"@types/node": "^18.0.0",
 		"@types/ws": "^8.5.3",
-		"debugbreak": "^0.6.3",
-		"typenode": "0.3.0",
+		"cookie": "^0.5.0",
+		"debugbreak": "^0.6.5",
+		"typenode": "^0.4.3",
 		"ws": "^8.8.0"
 	},
 	"scripts": {

package/require/CSSShim.ts

@@ -0,0 +1,18 @@
+import debugbreak from "debugbreak";
+import { compileTransformBefore } from "typenode";
+
+compileTransformBefore((contents: string, path: string, module: NodeJS.Module): string => {
+    if (path.endsWith(".css")) {
+        module.allowclient = true;
+        function injectCSS(contents: string) {
+            if (typeof document === "undefined") {
+                return;
+            }
+            let style = document.createElement("style");
+            style.innerHTML = contents;
+            document.head.appendChild(style);
+        }
+        return `(${injectCSS.toString()})(${JSON.stringify(contents)})`;
+    }
+    return contents;
+});

package/require/RequireController.ts

@@ -0,0 +1,242 @@
+import debugbreak from "debugbreak";
+import fs from "fs";
+import { SocketFunction } from "../SocketFunction";
+import { setHTTPResultHeaders } from "../src/callHTTPHandler";
+
+module.allowclient = true;
+
+declare global {
+    namespace NodeJS {
+        interface Module {
+            /** Indiciates the module is allowed clientside. */
+            allowclient?: boolean;
+
+            /** Indicates the module is definitely not allowed clientside */
+            serveronly?: boolean;
+
+            // TODO: Move seqNum into the actual compilation, and make it increment,
+            //  so the clientside can properly handle race conditions during hot reloading.
+            //  And... maybe it is useful in other cases?
+            /** Used internally by RequireController */
+            requireControllerSeqNum?: number;
+        }
+    }
+    interface Window {
+        clientsideBootTime: number;
+    }
+}
+
+export interface SerializedModule {
+    originalId: string;
+    filename: string;
+    // If a module is not allowed clientside it is likely requests will be empty,
+    //  to save effort parsing requests for modules that only exist to give better
+    //  error messages.
+    requests: {
+        // request => resolvedPath
+        [request: string]: string;
+    };
+    // NOTE: IF !allowclient && !serveronly, it might just mean we didn't add allowclient
+    //  to the module yet. BUT, if serveronly, then we know for sure we don't want it client.
+    //  So the messages and behavior will be different.
+    allowclient?: boolean;
+    serveronly?: boolean;
+    // Just for errors mostly
+    alwayssend?: boolean;
+
+    /** Only set if allowclient. */
+    source?: string;
+
+    seqNum: number;
+}
+
+let nextModuleSeqNum = 1;
+
+const requireSeqNumProcessId = "requireSeqNumProcessId_" + Date.now() + "_" + Math.random();
+
+const htmlFile = fs.readFileSync(__dirname + "/require.html").toString();
+const jsFile = fs.readFileSync(__dirname + "/require.js").toString();
+const bufferShim = fs.readFileSync(__dirname + "/buffer.js").toString();
+
+const resolvedHTMLFile = (
+    htmlFile
+        .replace(`<script src="./buffer.js"></script>`, `<script>${bufferShim}</script>`)
+        .replace(`<script src="./require.js"></script>`, `<script>${jsFile}</script>`)
+);
+
+class RequireControllerBase {
+    constructor(private rootResolvePath: string) { }
+
+    public async requireHTML(bootRequirePath?: string) {
+        let result = resolvedHTMLFile;
+        if (bootRequirePath) {
+            result = result.replace(`<!-- ENTRY_TEMPLATE -->`, `<script>require(${JSON.stringify(bootRequirePath)});</script>`);
+        }
+        return setHTTPResultHeaders(Buffer.from(result), { "Content-Type": "text/html" });
+    }
+
+    public async bufferJS() {
+        return setHTTPResultHeaders(Buffer.from(bufferShim), { "Content-Type": "text/javascript" });
+    }
+    public async requireJS() {
+        return setHTTPResultHeaders(Buffer.from(jsFile), { "Content-Type": "text/javascript" });
+    }
+
+    public async getModules(
+        pathRequests: string[],
+        alreadyHave?: {
+            requireSeqNumProcessId: string;
+            // NOTE: Highly optimized, as otherwise this can easily be KBs (I was seeing 9KB),
+            //  which is uploaded, and so can be quite slow on slow connections.
+            seqNumRanges: {
+                s: number;
+                // undefined means s + 1 (so just a single number)
+                e?: number;
+            }[];
+        },
+    ): Promise<{
+        requestsResolvedPaths: string[];
+        modules: {
+            [resolvedPath: string]: SerializedModule;
+        };
+        requireSeqNumProcessId: string;
+    }> {
+        let seqNums: { [seqNum: number]: 1 } = {};
+        if (alreadyHave?.requireSeqNumProcessId === requireSeqNumProcessId) {
+            for (let { s, e } of alreadyHave.seqNumRanges) {
+                if (e === undefined) {
+                    e = s + 1;
+                }
+                for (let i = s; i < e; i++) {
+                    seqNums[i] = 1;
+                }
+            }
+        }
+
+        let modules: {
+            [resolvedPath: string]: SerializedModule;
+        } = Object.create(null);
+        function addModule(module: NodeJS.Module) {
+            if (!module.requireControllerSeqNum) {
+                module.requireControllerSeqNum = nextModuleSeqNum++;
+            }
+            if (seqNums[module.requireControllerSeqNum]) {
+                return;
+            }
+            if (module.filename in modules) return;
+
+            // TODO: Remove unused exports. We know why the module is being requested, so we can
+            //  actually very effectively know which exports it has which will never be used.
+            //  - Of course, we would need to make the module specially, so if any new modules
+            //      use it we can know... what was removed? It becomes complicated with
+            //      lazy modules, but... it is still very important.
+
+            // IMPORTANT! Use module.filename, to strip the ".CLIENT_NAMEPSACE" extension
+            modules[module.filename] = {
+                originalId: module.id,
+                filename: module.filename,
+                // NOTE: Due to recursive sets of allowclient, it is very possible for allowclient && serveronly to be set.
+                allowclient: module.allowclient && !module.serveronly,
+                serveronly: module.serveronly,
+                requests: Object.create(null),
+                seqNum: module.requireControllerSeqNum,
+            };
+            let moduleObj = modules[module.filename];
+            if (moduleObj.allowclient) {
+                moduleObj.source = module.moduleContents;
+                if (module.filename.endsWith(".json") && !moduleObj.source) {
+                    moduleObj.source = module.moduleContents = fs.readFileSync(module.filename).toString();
+                }
+            }
+
+            // NOTE: Iterate on children even if it isn't allowed client, as the module may have children
+            //  that are allowed clientside, and that have side-effects! (Mostly for static resources)
+            //  - Surprisingly, this only increases the returned size by about 8% (probably more like 16%
+            //      if we turn source maps off), so... it's fine. And with compression most of the extra
+            //      size will go away, as paths are highly repetitive.
+            //      - And now it increases the size by much less, as we ignore any subtree which are entirely
+            //          not allowed on the client.
+            for (let request in module.requires) {
+                let requireResolvedPath = module.requires[request];
+                let requiredModule = require.cache[requireResolvedPath];
+
+                if (requiredModule) {
+                    addModule(requiredModule);
+                    moduleObj.requests[request] = requiredModule.filename;
+                } else {
+                    moduleObj.requests[request] = "";
+                }
+            }
+        }
+
+        let searchPaths: string[] = [];
+        {
+            searchPaths.push(this.rootResolvePath);
+            let pathParts = this.rootResolvePath.replaceAll("\\", "/").split("/");
+            for (let i = 0; i < pathParts.length; i++) {
+                // Skip empty path parts, to preventing the case where the path ends
+                //  with a /, which would result in "D:/test//node_modules"
+                if (!pathParts[i]) continue;
+                searchPaths.push(pathParts.slice(0, i + 1).join("/") + "/node_modules");
+            }
+        }
+
+
+        let requestsResolvedPaths: string[] = [];
+        for (let pathRequest of pathRequests) {
+            let resolvedPath = "";
+            try {
+                resolvedPath = require.resolve(pathRequest, { paths: searchPaths });
+            } catch { }
+            requestsResolvedPaths.push(resolvedPath);
+
+            function createNotFoundModule(error: string): NodeJS.Module {
+                console.warn(error);
+                return {
+                    exports: {},
+                    children: [],
+                    filename: resolvedPath,
+                    id: resolvedPath,
+                    isPreloading: false,
+                    require: null as any,
+                    loaded: true,
+                    load: null as any,
+                    parent: undefined,
+                    path: "",
+                    paths: [],
+                    requires: {},
+                    allowclient: true,
+                    moduleContents: `console.warn(${JSON.stringify(error)})`,
+                };
+            }
+
+            // TODO: We could use import() here... but that would only make the root call asynchronous,
+            //  which wouldn't prevent synchronous blocking by that much anyway...
+            //require(rootPath);
+            let clientModule = require.cache[resolvedPath];
+            if (!clientModule) {
+                clientModule = createNotFoundModule(`Module ${pathRequest} (resolved to ${resolvedPath}) was not included serverside.`);
+            }
+            if (!clientModule.allowclient) {
+                clientModule = createNotFoundModule(`Module ${pathRequest} (resolved to ${resolvedPath}) is not allowed clientside (set module.allowclient in it, or call setFlag when it is imported).`);
+            }
+
+            addModule(clientModule);
+        }
+
+        return { requestsResolvedPaths, modules, requireSeqNumProcessId };
+    }
+}
+
+export function RequireControllerFactory(rootResolvePath: string) {
+    return SocketFunction.register(
+        "RequireController-e2f811f3-14b8-4759-b0d6-73f14516cf1d",
+        new RequireControllerBase(rootResolvePath),
+        {
+            getModules: {},
+            requireHTML: {},
+            bufferJS: {},
+            requireJS: {},
+        }
+    );
+}