socket-function 0.7.10 → 0.7.11

package/SocketFunction.ts

@@ -25,6 +25,12 @@ type PickByType<T, Value> = {
 };
 
 export class SocketFunction {
+    public static logMessages = false;
+    public static compression: undefined | {
+        type: "gzip";
+    };
+    public static httpETagCache = false;
+
     public static register<
         ClassInstance extends object,
         Shape extends SocketExposedShape<SocketExposedInterface, CallContext>,
@@ -46,29 +52,40 @@ export class SocketFunction {
         registerClass(classGuid, instance as SocketExposedInterface, shape as any as SocketExposedShape);
 
         let nodeProxy = getCallProxy(classGuid, async (nodeId, functionName, args) => {
-            let callFactory = await getCallFactoryNodeId(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.`);
-            }
-
-            let shapeObj = shape[functionName];
-            if (!shapeObj) {
-                throw new Error(`Function ${functionName} is not in shape`);
+            let time = Date.now();
+            if (SocketFunction.logMessages) {
+                console.log(`START\t\t\t${classGuid}.${functionName}`);
             }
-
-            let call: CallType = {
-                classGuid,
-                args,
-                functionName,
-            };
-
-            let hookResult = await runClientHooks(call, shapeObj as SocketExposedShape[""]);
-
-            if ("overrideResult" in hookResult) {
-                return hookResult.overrideResult;
+            try {
+                let callFactory = await getCallFactoryNodeId(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.`);
+                }
+
+                let shapeObj = shape[functionName];
+                if (!shapeObj) {
+                    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) {
+                    return hookResult.overrideResult;
+                }
+
+                return await callFactory.performCall(call);
+            } finally {
+                time = Date.now() - time;
+                if (SocketFunction.logMessages) {
+                    console.log(`TIME\t${time}ms\t${classGuid}.${functionName}`);
+                }
             }
-
-            return await callFactory.performCall(call);
         });
 
         let output: SocketRegistered = {

package/package.json

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

package/require/require.js

@@ -440,10 +440,9 @@
         let url = new URL(endpoint);
 
         let json = JSON.stringify(values);
-        if (json.length < 6000 && false) {
+        if (json.length < 6000) {
             // NOTE: Try to use a GET, as GETs can be cached! However, if the data is too large,
             //  we have to use a post, or else the request url will be too large
-            let parameters = [];
             for (let key in values) {
                 url.searchParams.set(key, JSON.stringify(values[key]));
             }

package/spec.txt

@@ -3,6 +3,10 @@ spec.txt
 - Add a flag for rejectUnauthorized, that is off by default
 - Add the ability to specify the certs yourself (so you can specify your identity with a real cert)
     - Then use real certificates on the server
+- Fix multiple clients on the same machines
+    - Maybe we need to exchange link information
+- The login emails SHOULD redirect, if the close doesn't works
+    (due to copying the link instead of clicking it)
 
 - Other stuff
     - JSON buffer serialize, which generates an object, that allows for rehydration of buffers

package/src/CallFactory.ts

@@ -2,16 +2,19 @@ import { CallerContext, CallType, NetworkLocation } from "../SocketFunctionTypes
 import * as ws from "ws";
 import type * as net from "net";
 import { performLocalCall } from "./callManager";
-import { convertErrorStackToError, isNode } from "./misc";
+import { convertErrorStackToError, formatNumberSuffixed, isNode } from "./misc";
 import { createWebsocket, getNodeId, getTLSSocket } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
 import http from "http";
+import { SocketFunction } from "../SocketFunction";
+import { gzip } from "zlib";
 
 const retryInterval = 2000;
 
 type InternalCallType = CallType & {
     seqNum: number;
     isReturn: false;
+    compress: boolean;
 }
 
 type InternalReturnType = {
@@ -19,6 +22,8 @@ type InternalReturnType = {
     result: unknown;
     error?: string;
     seqNum: number;
+    resultSize: number;
+    compressed: boolean;
 };
 
 
@@ -76,7 +81,7 @@ export async function callFactoryFromWS(
 export interface SenderInterface {
     nodeId?: string;
 
-    send(data: string): void;
+    send(data: string | Buffer): void;
 
     on(event: "open", listener: () => void): this;
     on(event: "close", listener: (code: number, reason: Buffer) => void): this;
@@ -111,10 +116,10 @@ async function createCallFactory(
 
 
     let pendingCalls: Map<number, {
-        data: string;
+        data: Buffer;
         call: InternalCallType;
         reconnectTimeout: number | undefined;
-        callback: (result: InternalReturnType) => void;
+        callback: (resultJSON: InternalReturnType) => void;
     }> = new Map();
     // NOTE: It is important to make this as random as possible, to prevent
     //  reconnections dues to a process being reset causing seqNum collisions
@@ -138,7 +143,7 @@ async function createCallFactory(
 
     niceConnectionName = `${niceConnectionName} (${callerContext.nodeId})`;
 
-    async function sendWithRetry(reconnectTimeout: number | undefined, data: string) {
+    async function sendWithRetry(reconnectTimeout: number | undefined, data: Buffer) {
         if (!retriesEnabled) {
             webSocket.send(data);
             return;
@@ -190,6 +195,8 @@ async function createCallFactory(
                             result: undefined,
                             error: `Connection lost to ${niceConnectionName}`,
                             seqNum: call.call.seqNum,
+                            resultSize: 0,
+                            compressed: false,
                         });
                     }
                     return;
@@ -243,6 +250,8 @@ async function createCallFactory(
                                 result: undefined,
                                 error: String(e),
                                 seqNum: call.call.seqNum,
+                                resultSize: 0,
+                                compressed: false,
                             });
                         });
                     }
@@ -278,8 +287,28 @@ async function createCallFactory(
                 if (typeof message === "object" && "data" in message) {
                     message = message.data;
                 }
+                if (message instanceof Blob) {
+                    message = Buffer.from(await message.arrayBuffer());
+                }
             }
             if (message instanceof Buffer || typeof message === "string") {
+
+                let resultSize = message.length;
+
+                if (message instanceof Buffer && message[0] === 0) {
+                    // First byte of 0 means it is decompressed (as JSON can't have a first byte of 0).
+                    (message as any) = message.slice(1);
+
+                    // TODO: Add typings for DecompressionStream
+                    let DecompressionStream = (window as any).DecompressionStream;
+                    // https://stackoverflow.com/a/68829631/1117119
+                    let stream = new DecompressionStream("gzip");
+                    let blob = new Blob([message]);
+                    let decompressedStream = (await (blob.stream() as any).pipeThrough(stream));
+                    let arrayBuffer = await new Response(decompressedStream).arrayBuffer();
+                    (message as any) = Buffer.from(arrayBuffer);
+                }
+
                 let call = JSON.parse(message.toString()) as InternalCallType | InternalReturnType;
                 if (call.isReturn) {
                     let callbackObj = pendingCalls.get(call.seqNum);
@@ -287,6 +316,7 @@ async function createCallFactory(
                         console.log(`Got return for unknown call ${call.seqNum}`);
                         return;
                     }
+                    call.resultSize = resultSize;
                     callbackObj.callback(call);
                 } else {
                     if (call.seqNum <= lastReceivedSeqNum) {
@@ -302,6 +332,8 @@ async function createCallFactory(
                             isReturn: true,
                             result,
                             seqNum: call.seqNum,
+                            resultSize: resultSize,
+                            compressed: false,
                         };
                     } catch (e: any) {
                         response = {
@@ -309,10 +341,23 @@ async function createCallFactory(
                             result: undefined,
                             seqNum: call.seqNum,
                             error: e.stack,
+                            resultSize: resultSize,
+                            compressed: false,
                         };
                     }
 
-                    await sendWithRetry(call.reconnectTimeout, JSON.stringify(response));
+                    let result: Buffer;
+                    if (isNode() && call.compress && SocketFunction.compression?.type === "gzip") {
+                        response.compressed = true;
+                        result = Buffer.from(JSON.stringify(response));
+                        result = await new Promise<Buffer>((resolve, reject) =>
+                            gzip(result, (err, result) => err ? reject(err) : resolve(result))
+                        );
+                        result = Buffer.concat([new Uint8Array([0]), result]);
+                    } else {
+                        result = Buffer.from(JSON.stringify(response));
+                    }
+                    await sendWithRetry(call.reconnectTimeout, result);
                 }
                 return;
             }
@@ -339,10 +384,14 @@ async function createCallFactory(
                 classGuid: call.classGuid,
                 functionName: call.functionName,
                 seqNum,
+                compress: !!SocketFunction.compression,
             };
-            let data = JSON.stringify(fullCall);
+            let data = Buffer.from(JSON.stringify(fullCall));
             let resultPromise = new Promise((resolve, reject) => {
                 let callback = (result: InternalReturnType) => {
+                    if (SocketFunction.logMessages) {
+                        console.log(`SIZE\t${(formatNumberSuffixed(result.resultSize) + "B").padEnd(4, " ")}\t${call.classGuid}.${call.functionName}`);
+                    }
                     pendingCalls.delete(seqNum);
                     if (result.error) {
                         reject(convertErrorStackToError(result.error));

package/src/callHTTPHandler.ts

@@ -7,6 +7,9 @@ import { performLocalCall } from "./callManager";
 import { getNodeIdRaw } from "./nodeAuthentication";
 import debugbreak from "debugbreak";
 import * as cookie from "cookie";
+import { SocketFunction } from "../SocketFunction";
+import { gzip } from "zlib";
+import { formatNumberSuffixed, sha256Hash } from "./misc";
 
 const nodeIdCookie = "node-id4";
 
@@ -150,24 +153,52 @@ export async function httpCallHandler(request: http.IncomingMessage, response: h
             call
         });
 
+        let resultBuffer: Buffer;
         if (typeof result === "object" && result && result instanceof Buffer) {
-            let headers = (result as HTTPResultType)[resultHeaders];
-            if (headers) {
-                for (let headerName in headers) {
-                    response.setHeader(headerName, headers[headerName]);
-                }
-                let status = headers["status"];
-                if (status) {
-                    response.writeHead(+status);
-                    return;
-                }
-            }
-            response.write(result);
+            resultBuffer = result;
         } else {
-            response.write(JSON.stringify(result));
+            resultBuffer = Buffer.from(JSON.stringify(result));
+        }
+
+        let headers = (resultBuffer as HTTPResultType)[resultHeaders];
+        if (SocketFunction.compression?.type === "gzip" && !headers?.["Content-Encoding"]) {
+            if (request.headers["accept-encoding"]?.includes("gzip")) {
+                resultBuffer = await new Promise<Buffer>((resolve, reject) =>
+                    gzip(resultBuffer, (err, result) => err ? reject(err) : resolve(result))
+                );
+                response.setHeader("Content-Encoding", "gzip");
+            }
         }
+
+
+        // NOTE: Our ETag caching is only to reduce data sent on the wire, we evaluate the calls
+        //  every time (so it is strictly a wire cache, not computation cache)
+        response.setHeader("cache-control", "private, s-maxage=0, max-age=0, must-revalidate");
+        if (SocketFunction.httpETagCache) {
+            let hash = sha256Hash(resultBuffer);
+            response.setHeader("ETag", hash);
+            if (request.headers["if-none-match"] === hash) {
+                response.writeHead(304);
+                console.log(`CACHED HTTP response  ${formatNumberSuffixed(resultBuffer.length)}B  (${request.method}) ${url}`);
+                return;
+            }
+        }
+
+        if (headers) {
+            for (let headerName in headers) {
+                response.setHeader(headerName, headers[headerName]);
+            }
+            let status = headers["status"];
+            if (status) {
+                response.writeHead(+status);
+                return;
+            }
+        }
+        response.write(resultBuffer);
+        console.log(`HTTP response  ${formatNumberSuffixed(resultBuffer.length)}B  (${request.method}) ${url}`);
+
     } catch (e: any) {
-        console.error(`Request error`, e.stack);
+        console.log(`HTTP error  (${request.method}) ${e.stack}`);
         response.writeHead(500, String(e.message));
     } finally {
         response.end();

package/src/misc.ts

@@ -27,6 +27,34 @@ export function isNodeTrue() {
     return isNode() as true;
 }
 
+export function formatNumberSuffixed(count: number): string {
+    if (typeof count !== "number") return "0";
+    if (count < 0) {
+        return "-" + formatNumberSuffixed(-count);
+    }
+
+    let absValue = Math.abs(count);
+
+    const extraFactor = 10;
+    let divisor = 1;
+    let suffix = "";
+    if (absValue < 1000 * extraFactor) {
+
+    } else if (absValue < 1000 * 1000 * extraFactor) {
+        suffix = "K";
+        divisor = 1000;
+    } else if (absValue < 1000 * 1000 * 1000 * extraFactor) {
+        suffix = "M";
+        divisor = 1000 * 1000;
+    } else {
+        suffix = "B";
+        divisor = 1000 * 1000 * 1000;
+    }
+    count /= divisor;
+    absValue /= divisor;
+
+    return Math.round(count).toString() + suffix;
+}
 
 if (isNode()) {
     // TODO: Find a better place for this...