socket-function 0.5.0

package/socketServer.ts

@@ -0,0 +1,74 @@
+import https from "https";
+import http from "http";
+import net from "net";
+import * as ws from "ws";
+import { performLocalCall } from "./callManager";
+import { CallerContext, CallType, NetworkLocation } from "./SocketFunctionTypes";
+import { callFactoryFromWS } from "./CallInstance";
+import { registerNodeClient } from "./nodeCache";
+import { getCertKeyPair } from "./nodeAuthentication";
+
+export type SocketServerConfig = {
+    port: number;
+    // public sets ip to "0.0.0.0", otherwise it defaults to "127.0.0.1", which
+    //  causes the server to only accept local connections.
+    public?: boolean;
+    ip?: string;
+} & (
+        https.ServerOptions
+    );
+
+export async function startSocketServer(
+    config: SocketServerConfig
+) {
+    let isSecure = "cert" in config || "key" in config || "pfx" in config;
+    if (!isSecure) {
+        let { key, cert } = getCertKeyPair();
+        config.key = key;
+        config.cert = cert;
+    }
+
+    // TODO: Only allow unauthorized for ip certificates, and then for domains use the domain as the nodeId,
+    //  so it is easy to read, and consistent.
+    let server = https.createServer({
+        ...config,
+        rejectUnauthorized: false,
+        requestCert: true
+    });
+    let listenPromise = new Promise<void>((resolve, error) => {
+        server.on("listening", () => {
+            resolve();
+        });
+        server.on("error", e => {
+            error(e);
+        });
+    });
+
+
+    let host = config.ip ?? "127.0.0.1";
+    if (config.public) {
+        host = "0.0.0.0";
+    }
+
+    server.on("request", (request, response) => {
+        // TODO: Handle HTTP requests
+        //  - HTTP CAN have a nodeId, simply through setting cookies
+        //      - Cookies could always be set via a request before we open
+        //          the websocket connection?
+    });
+
+    const webSocketServer = new ws.Server({
+        noServer: true,
+    });
+    server.on("upgrade", (request, socket, upgradeHead) => {
+        webSocketServer.handleUpgrade(request, socket, upgradeHead, async (ws) => {
+            let clientCallFactory = await callFactoryFromWS(ws);
+            registerNodeClient(clientCallFactory);
+        });
+    });
+
+    console.log(`Listening on ${host}:${config.port}`);
+    server.listen(config.port, host);
+
+    return await listenPromise;
+}

package/spec.txt

@@ -0,0 +1,104 @@
+spec.txt
+
+- Implement SocketFunction for NodeJS => NodeJS
+    - Publish it, and make sure we can include it correctly in non-ts projects
+        (so we need to publish the dist folders that typenode creates).
+        - We might need to emit source maps as well?
+        - Maybe we should just compile with typescript?
+- Support HTTP responses in SocketFunction
+    - Expose a http://127.0.0.1/RequireController-6016c77f-6863-47b5-a421-2abdea637436?html=./index.html&js=./index.ts endpoint
+    - RequireController will have to look through all imports, and send the files clientside
+        - Use allowclient to allow whitelisting of files, and setFlag to allow nested values. ALso compileDirFlags.ts
+    - Add handling for .css files by calling compileTransform in typenode to add a handler for .css (after adding it to require.extensions).
+- Support default HTTP function in SocketFunction, via functions.httpDefault(() => {}), so we can expose http://127.0.0.1
+
+- Other libraries
+    - JSON buffer serialize, which generates an object, that allows for rehydration of buffers
+        - Also... static classes (maybe even static resources), so structures can be sent
+
+
+
+================== SocketFunction ==================
+
+- Uses proxies, so that functions can be called before we know the shape of interface
+- Headers
+    - Support enabling "Access-Control-Allow-Credentials"/Request.credentials=include, with a hardcoded list of domains
+    - Support Access-Control-Allow-Origin, with a hardcoded list of domains
+    - Always set
+        - response.setHeader("Cross-Origin-Opener-Policy", "same-origin");
+        - response.setHeader("Cross-Origin-Embedder-Policy", "require-corp");
+        - response.setHeader("Cross-Origin-Resource-Policy", "same-site");
+    - Remember to set headers for OPTIONS, but then NOOP
+
+// NOTE: It is not possible to expose different services over different ports in the same process.
+//  Just run different processes if you want different services.
+SocketFunction.expose(ExampleController);
+// Global hooks are useful for authentication
+SocketFunction.addGlobalHook<ExampleContext>(null as SocketFunctionHook);
+// Mount only after exposing controllers and setting up hooks
+SocketFunction.mount({ port: 40981 });
+
+
+// callerId is set before each function (and part of the hook context)
+let callerId = ExampleController[socket].callerId;
+let result = await ExampleController[socket].nodes[callerId].exampleFunction("hi");
+
+
+// An object with context information is available in each call (so arguments don't have to be modified)
+//  - register will have a second generic argument that is context, so this will be typed
+ExampleController[socket].callContext
+
+
+
+// Clientside may also wish to expose controllers, possibly the same, or different.
+SocketFunction.expose(ExampleControllerClient);
+// We might also want global clientside hooks (for authentication)
+SocketFunction.addGlobalClientHook<ExampleContext>(null as SocketFunctionHook);
+let serverId = await SocketFunctions.connect({ host: "example.com", port: 40981 });
+// Cached, so it can be put in a helper function and called every time a call is made
+let serverId = SocketFunctions.connectSync({ host: "example.com", port: 40981 });
+ExampleController[socket].nodes[serverId].exampleFunction("hi server");
+// If you have multiple servers each with many endpoints, you can make helper functions like this:
+function exampleControllers() {
+    let serverId = SocketFunctions.connectSync({ host: "example.com", port: 40981 });
+    return {
+        ExampleController: ExampleController[socket].nodes[serverId],
+        ... etc, with all controllers mapped like this:
+    }
+}
+
+
+export class ExampleController {
+    // Uses both types AND shape configuration, to prevent functions from accidentally being exposed
+    //  on the public internet...
+    //  - Type checking is done to ensure no functions are exposed that aren't in your type
+    [socket] = SocketFunction.register<ExampleController, ExampleContext>("ExampleController-2a4b1bd1-d00f-4812-be32-c4466f3c354a", {
+        exampleFunction: {
+            // Hooks wrap the call, allowing them to cancel it, change arguments, change the output, run it
+            //  on another thread, check permission, etc, etc
+            //  - Hooks are asynchronously, so they can even trigger other calls, etc
+            //  - Context is passed to hooks
+            hooks: [] as SocketFunctionHook[],
+            // Client hooks run before a call, on the client. They have a different context,
+            //  because they won't have information such as caller ip, but they can wrap calls
+            //  in mostly the similar way
+            clientHooks: [] as SocketFunctionClientHook[]
+        },
+    });
+
+    async exampleFunction(arg1: string) {
+
+    }
+}
+
+// ALSO, a shim can be created to avoid exposing your source code to API users (such as webpage).
+//  - If you want, you can have your implementation import your config shape from the client file,
+//      that way you only need to write it once.
+import type * as Base from "./ExampleController";
+export class ExampleController {
+    [socket] = SocketFunction.register<Base.ExampleController, ExampleContext>("ExampleController-2a4b1bd1-d00f-4812-be32-c4466f3c354a", {
+        exampleFunction: {
+            clientHooks: [] as SocketFunctionClientHook[]
+        },
+    });
+}

package/storagePath.ts

@@ -0,0 +1,11 @@
+import os from "os";
+import fs from "fs";
+import { lazy } from "./caching";
+
+export const getAppFolder = lazy(() => {    
+    const path = os.homedir() + "/socket-function/";
+    if(!fs.existsSync(path)) {
+        fs.mkdirSync(path);
+    }
+    return path;
+});

package/test.ts

@@ -0,0 +1,87 @@
+import { getArgs } from "./args";
+import { SocketFunction } from "./SocketFunction";
+
+//todonext;
+// Test the server and client
+//  - I guess we will want to be able to namespace identifies so we can test
+//      multiple on the same machine... Let's not use yargs, just argv parsing should be okay?
+
+class Test {
+    memberVariable = 5;
+
+    async add(lhs: number, rhs: number) {
+        return lhs + rhs;
+    }
+
+    async callMe() {
+        let caller = TestClass.context.caller?.nodeId;
+        if (!caller) {
+            throw new Error("No caller?");
+        }
+        console.log(`Caller is ${caller}`);
+        void (async () => {
+            let seqNum = 1;
+            while (true) {
+                console.log(`Calling client at ${seqNum}`);
+                await TestClass.nodes[caller].callBack();
+                await new Promise(resolve => setTimeout(resolve, 1000));
+                seqNum++;
+            }
+        })();
+    }
+
+    async callBack() {
+        console.log(`Got callback at ${Date.now()}`);
+    }
+}
+
+export const TestClass = SocketFunction.register(
+    "80d9f328-72df-4baa-8be8-019c1003d4a2",
+    Test,
+    {
+        add: {
+            // hooks: [
+            //     async (config) => {
+
+            //     }
+            // ]
+        },
+        callMe: {
+            clientHooks: [
+                async (config) => {
+                    config.call.reconnectTimeout = 2000;
+                }
+            ]
+        },
+        callBack: {
+
+        },
+        //fncNotAsync: {},
+        //notAFnc: {},
+    }
+);
+
+void main();
+
+//todonext
+// - Get case where there will never be a reconnection working
+
+async function main() {
+    SocketFunction.expose(Test);
+    const port = 2542;
+    if (getArgs().identity === "server") {
+        await SocketFunction.mount({ port });
+    } else {
+        let serverId = await SocketFunction.connect({ port, address: "localhost" });
+        let test = await TestClass.nodes[serverId].add(1, 2);
+        console.log(`${test}=${1 + 2}`);
+
+        // while (true) {
+        //     let test = await TestClass.nodes[serverId].add(1, 2);
+        //     console.log(`${test}=${1 + 2}`);
+        //     await new Promise(resolve => setTimeout(resolve, 1000));
+        // }
+
+        await TestClass.nodes[serverId].callMe();
+    }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+    "compilerOptions": {
+        "strict": true,
+        "module": "CommonJS",
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "moduleResolution": "node",
+        "target": "es2018",
+        "lib": [
+            "ESNext",
+            "dom",
+            "dom.iterable"
+        ],
+        "jsx": "react",
+        "alwaysStrict": true,
+        "jsxFactory": "preact.createElement",
+        "jsxFragmentFactory": "preact.Fragment",
+        "types": [
+            "node",
+        ],
+        "experimentalDecorators": true,
+        "emitDecoratorMetadata": false,
+        "skipLibCheck": true,
+        "inlineSourceMap": true,
+        "inlineSources": true,
+    },
+}

package/types.ts

@@ -0,0 +1,9 @@
+export type MaybePromise<T> = T | Promise<T>;
+
+export type Args<T> = T extends (...args: infer V) => any ? V : never;
+
+export type AnyFunction = (...args: any) => any;
+
+export function canHaveChildren(value: unknown): value is object {
+    return typeof value === "object" && value !== null || typeof value === "function";
+}