socket-function 1.1.49 → 1.2.0

package/src/dist/callHTTPHandler.ts.cache

@@ -0,0 +1,264 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule && mod.default) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.setHTTPResultHeaders = exports.httpCallHandler = exports.getCurrentHTTPRequest = exports.getNodeIdsFromRequest = exports.getServerLocationFromRequest = exports.setDefaultHTTPCall = void 0;
+const callManager_1 = require("./callManager");
+const SocketFunction_1 = require("../SocketFunction");
+const zlib_1 = __importDefault(require("zlib"));
+const misc_1 = require("./misc");
+const nodeCache_1 = require("./nodeCache");
+const createSingleton_1 = require("./createSingleton");
+// Shared across copies of this package, so the default HTTP call set through one copy is used by
+//  the HTTP handler of any other copy. See createSingleton.
+const defaultHTTPCall = (0, createSingleton_1.createSingleton)("callHTTPHandler.defaultHTTPCall", 1, () => ({ call: undefined }));
+function setDefaultHTTPCall(call) {
+    defaultHTTPCall.get().call = call;
+}
+exports.setDefaultHTTPCall = setDefaultHTTPCall;
+function getServerLocationFromRequest(request) {
+    let host = request.headers.host;
+    if (!host) {
+        throw new Error(`Missing host in request headers`);
+    }
+    let port = 443;
+    if (host.includes(":")) {
+        port = +host.split(":")[1];
+        host = host.split(":")[0];
+    }
+    return {
+        address: host,
+        // This is OUR location, so whatever they connected to us... we must be listening on!
+        //  (and the localPort doesn't matter in this case)
+        port,
+    };
+}
+exports.getServerLocationFromRequest = getServerLocationFromRequest;
+function getNodeIdsFromRequest(request) {
+    var _a;
+    // TODO: Support passing signed proof of userCertificate via headers in the HTTP request.
+    //  THAT WAY HTTP can have consistent nodeIds, instead of making them randomly every time!
+    //  (This isn't needed or possible for websockets, but they stay open, so calling functions
+    //      after they open to set the nodeId is possible, and preferred).
+    let remoteAddress = (_a = request.socket.remoteAddress) === null || _a === void 0 ? void 0 : _a.split(":").pop();
+    if (!remoteAddress) {
+        throw new Error(`Missing remoteAddress`);
+    }
+    const nodeId = (0, nodeCache_1.getClientNodeId)(remoteAddress);
+    const serverLocation = getServerLocationFromRequest(request);
+    // IMPORTANT! Not the actual local id, but is the id the client called
+    const localNodeId = (0, nodeCache_1.getNodeId)(serverLocation.address, serverLocation.port);
+    return { nodeId, localNodeId };
+}
+exports.getNodeIdsFromRequest = getNodeIdsFromRequest;
+// Shared across copies of this package, so getCurrentHTTPRequest works even when the call was set
+//  up by a different copy's HTTP handler. See createSingleton.
+const requests = (0, createSingleton_1.createSingleton)("callHTTPHandler.requests", 1, () => new Map()).get();
+function getCurrentHTTPRequest() {
+    return requests.get(SocketFunction_1.SocketFunction.getCaller());
+}
+exports.getCurrentHTTPRequest = getCurrentHTTPRequest;
+async function httpCallHandler(request, response) {
+    var _a;
+    try {
+        // Always set x-frame-options, to prevent iframe embedding click hijacking
+        response.setHeader("X-Frame-Options", "SAMEORIGIN");
+        // Don't keep alive, to prevent issues with zombie sockets.
+        response.setHeader("Connection", "close");
+        // CORS bs (due to having to explictly allow subdomains)
+        {
+            response.setHeader("Strict-Transport-Security", "max-age=63072000; includeSubDomains; preload");
+            response.setHeader("Cross-Origin-Opener-Policy", SocketFunction_1.SocketFunction.COOP);
+            response.setHeader("Cross-Origin-Embedder-Policy", SocketFunction_1.SocketFunction.COEP);
+            let origin = request.headers.origin || request.headers.referer;
+            let allowed = false;
+            if (!origin) {
+                // I guess it's a script, so just allow it (as it could easily set any header it wanted anyways)
+                allowed = true;
+                origin = "*";
+            }
+            else {
+                let host = request.headers.host;
+                if (!host) {
+                    throw new Error("Missing host in request headers");
+                }
+                let hostDomain = (0, misc_1.getRootDomain)(host);
+                let originDomain = (0, misc_1.getRootDomain)(origin);
+                allowed = hostDomain === originDomain;
+                if (!allowed) {
+                    console.log(`Rejected CORS, hostDomain: ${hostDomain} !== ${originDomain}`);
+                }
+            }
+            // Allow if it has no origin, as that means it isn't a CORS request?
+            if (allowed) {
+                response.setHeader("Cross-Origin-Resource-Policy", "cross-origin");
+            }
+            else {
+                response.setHeader("Cross-Origin-Resource-Policy", "same-site");
+            }
+            response.setHeader("vary", "Access-Control-Request-Headers");
+            response.setHeader("Access-Control-Allow-Origin", allowed ? origin : "");
+            if (allowed) {
+                response.setHeader("Access-Control-Allow-Credentials", "true");
+                response.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS");
+                response.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization, Content-Length, X-Requested-With, x-uncompressed-content-length, Cookie");
+            }
+            response.setHeader("Access-Control-Expose-Headers", "x-uncompressed-content-length");
+        }
+        let urlBase = request.url;
+        if (!urlBase) {
+            throw new Error("Missing URL");
+        }
+        let protocol = "https";
+        let url = protocol + "://" + request.headers.host + request.url;
+        if (SocketFunction_1.SocketFunction.logMessages) {
+            console.log(`HTTP request (${request.method}) ${url}`);
+        }
+        let urlObj = new URL(url);
+        let payload = await new Promise((resolve, reject) => {
+            let data = [];
+            request
+                .on("data", chunk => data.push(chunk))
+                .on("end", () => resolve(Buffer.concat(data)))
+                .on("error", (err) => reject(err));
+        });
+        const { nodeId, localNodeId } = getNodeIdsFromRequest(request);
+        let caller = {
+            nodeId,
+            localNodeId,
+        };
+        let classGuid = urlObj.searchParams.get("classGuid");
+        let functionName = urlObj.searchParams.get("functionName");
+        let args = urlObj.searchParams.get("args");
+        if (!classGuid) {
+            let defaultCall = defaultHTTPCall.get().call;
+            if (defaultCall) {
+                classGuid = defaultCall.classGuid;
+                functionName = defaultCall.functionName;
+                args = defaultCall.args;
+            }
+            else {
+                throw new Error("Missing classGuid in URL query");
+            }
+        }
+        if (!functionName) {
+            throw new Error("Missing functionName in URL query");
+        }
+        if (!args) {
+            args = [];
+        }
+        else {
+            if (typeof args === "string") {
+                args = JSON.parse(args);
+            }
+        }
+        if (payload.length > 0) {
+            args = JSON.parse(payload.toString())["args"];
+        }
+        let call = {
+            nodeId,
+            classGuid,
+            functionName,
+            args,
+        };
+        if ((0, callManager_1.isDataImmutable)(call)) {
+            /** ETag cache, BUT, hashes only the input. Only valid for fully immutable resources
+             *      (ex data storage, as any endpoints that run code could have that code change).
+             *      - Shouldn't be needed, but I am seeing chrome fail to cache a lot of requests,
+             *          which could cost us multiple dollars in server costs from atlas.
+            */
+            response.setHeader("cache-control", "public, max-age=15206400, immutable");
+            let hash = (0, misc_1.sha256Hash)(Buffer.from(JSON.stringify(call)));
+            response.setHeader("ETag", hash);
+            if (request.headers["if-none-match"] === hash) {
+                response.writeHead(304);
+                console.log(`CACHED Immutable HTTP response (${request.method}) ${url}`);
+                return;
+            }
+        }
+        requests.set(caller, request);
+        let result;
+        try {
+            result = await (0, callManager_1.performLocalCall)({
+                caller,
+                call
+            });
+        }
+        finally {
+            requests.delete(caller);
+        }
+        let resultBuffer;
+        if (typeof result === "object" && result && result instanceof Buffer) {
+            resultBuffer = result;
+        }
+        else {
+            resultBuffer = Buffer.from(JSON.stringify(result));
+        }
+        let headers = resultBuffer[resultHeaders];
+        // 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 for HTTP, not a computation cache)
+        if (SocketFunction_1.SocketFunction.HTTP_ETAG_CACHE) {
+            response.setHeader("cache-control", "private, max-age=0, must-revalidate");
+            let hash = (0, misc_1.sha256Hash)(resultBuffer);
+            response.setHeader("ETag", hash);
+            if (request.headers["if-none-match"] === hash) {
+                response.writeHead(304);
+                console.log(`CACHED HTTP response  ${(0, misc_1.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;
+            }
+        }
+        let uncompressedLength = resultBuffer.length;
+        if (SocketFunction_1.SocketFunction.HTTP_COMPRESS && ((_a = request.headers["accept-encoding"]) === null || _a === void 0 ? void 0 : _a.includes("gzip")) && !(headers === null || headers === void 0 ? void 0 : headers["Content-Encoding"])) {
+            // NOTE: This is a BIT slow. To speed it up, functions can use an internal cache, according to their function,
+            //  and return a Buffer (which they can as any cast to make the returned type allowed, as returned Buffers will
+            //  just be treated like a buffer of JSON data).
+            //  - The caller should use getCurrentHTTPRequest first though, to check if gzip is allowed
+            response.setHeader("Content-Encoding", "gzip");
+            resultBuffer = await new Promise((resolve, reject) => {
+                zlib_1.default.gzip(resultBuffer, {}, (err, result) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    else {
+                        resolve(result);
+                    }
+                });
+            });
+        }
+        response.setHeader("Content-Length", resultBuffer.length.toString());
+        if (!response.getHeader("X-Uncompressed-Content-Length")) {
+            response.setHeader("X-Uncompressed-Content-Length", uncompressedLength.toString());
+        }
+        response.write(resultBuffer);
+        if (SocketFunction_1.SocketFunction.logMessages) {
+            console.log(`HTTP response  ${(0, misc_1.formatNumberSuffixed)(resultBuffer.length)}B  (${request.method}) ${url}`);
+        }
+    }
+    catch (e) {
+        console.log(`HTTP error  (${request.method}) ${e.stack}`);
+        response.writeHead(500, String(e.message).replace(/[^\x20-\x7E]/g, ""));
+    }
+    finally {
+        response.end();
+    }
+}
+exports.httpCallHandler = httpCallHandler;
+const resultHeaders = Symbol("resultHeaders");
+function setHTTPResultHeaders(result, headers) {
+    result[resultHeaders] = headers;
+    return result;
+}
+exports.setHTTPResultHeaders = setHTTPResultHeaders;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"callHTTPHandler.js","sourceRoot":"","sources":["callHTTPHandler.ts"],"names":[],"mappings":"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","sourcesContent":["import http from \"http\";\nimport tls from \"tls\";\nimport { CallerContext, CallType, FullCallType } from \"../SocketFunctionTypes\";\nimport { isDataImmutable, performLocalCall } from \"./callManager\";\nimport { SocketFunction } from \"../SocketFunction\";\nimport { gzip } from \"zlib\";\nimport zlib from \"zlib\";\nimport { formatNumberSuffixed, getRootDomain, sha256Hash } from \"./misc\";\nimport { getClientNodeId, getNodeId } from \"./nodeCache\";\nimport { createSingleton } from \"./createSingleton\";\n\n// Shared across copies of this package, so the default HTTP call set through one copy is used by\n//  the HTTP handler of any other copy. See createSingleton.\nconst defaultHTTPCall = createSingleton(\"callHTTPHandler.defaultHTTPCall\", 1, () => ({ call: undefined as CallType | undefined }));\n\nexport function setDefaultHTTPCall(call: CallType) {\n    defaultHTTPCall.get().call = call;\n}\n\nexport function getServerLocationFromRequest(request: http.IncomingMessage) {\n    let host = request.headers.host;\n    if (!host) {\n        throw new Error(`Missing host in request headers`);\n    }\n    let port = 443;\n    if (host.includes(\":\")) {\n        port = +host.split(\":\")[1];\n        host = host.split(\":\")[0];\n    }\n    return {\n        address: host,\n        // This is OUR location, so whatever they connected to us... we must be listening on!\n        //  (and the localPort doesn't matter in this case)\n        port,\n    };\n}\n\nexport function getNodeIdsFromRequest(request: http.IncomingMessage) {\n    // TODO: Support passing signed proof of userCertificate via headers in the HTTP request.\n    //  THAT WAY HTTP can have consistent nodeIds, instead of making them randomly every time!\n    //  (This isn't needed or possible for websockets, but they stay open, so calling functions\n    //      after they open to set the nodeId is possible, and preferred).\n    let remoteAddress = request.socket.remoteAddress?.split(\":\").pop();\n    if (!remoteAddress) {\n        throw new Error(`Missing remoteAddress`);\n    }\n    const nodeId = getClientNodeId(remoteAddress);\n\n    const serverLocation = getServerLocationFromRequest(request);\n    // IMPORTANT! Not the actual local id, but is the id the client called\n    const localNodeId = getNodeId(serverLocation.address, serverLocation.port);\n    return { nodeId, localNodeId };\n}\n\n// Shared across copies of this package, so getCurrentHTTPRequest works even when the call was set\n//  up by a different copy's HTTP handler. See createSingleton.\nconst requests = createSingleton(\"callHTTPHandler.requests\", 1, () => new Map<CallerContext, http.IncomingMessage>()).get();\nexport function getCurrentHTTPRequest(): http.IncomingMessage | undefined {\n    return requests.get(SocketFunction.getCaller());\n}\n\nexport async function httpCallHandler(request: http.IncomingMessage, response: http.ServerResponse) {\n    try {\n        // Always set x-frame-options, to prevent iframe embedding click hijacking\n        response.setHeader(\"X-Frame-Options\", \"SAMEORIGIN\");\n        // Don't keep alive, to prevent issues with zombie sockets.\n        response.setHeader(\"Connection\", \"close\");\n\n        // CORS bs (due to having to explictly allow subdomains)\n        {\n            response.setHeader(\"Strict-Transport-Security\", \"max-age=63072000; includeSubDomains; preload\");\n            response.setHeader(\"Cross-Origin-Opener-Policy\", SocketFunction.COOP);\n            response.setHeader(\"Cross-Origin-Embedder-Policy\", SocketFunction.COEP);\n\n            let origin = request.headers.origin || request.headers.referer;\n            let allowed = false;\n            if (!origin) {\n                // I guess it's a script, so just allow it (as it could easily set any header it wanted anyways)\n                allowed = true;\n                origin = \"*\";\n            } else {\n                let host = request.headers.host;\n                if (!host) {\n                    throw new Error(\"Missing host in request headers\");\n                }\n                let hostDomain = getRootDomain(host);\n                let originDomain = getRootDomain(origin);\n                allowed = hostDomain === originDomain;\n                if (!allowed) {\n                    console.log(`Rejected CORS, hostDomain: ${hostDomain} !== ${originDomain}`);\n                }\n            }\n\n            // Allow if it has no origin, as that means it isn't a CORS request?\n            if (allowed) {\n                response.setHeader(\"Cross-Origin-Resource-Policy\", \"cross-origin\");\n            } else {\n                response.setHeader(\"Cross-Origin-Resource-Policy\", \"same-site\");\n            }\n\n            response.setHeader(\"vary\", \"Access-Control-Request-Headers\");\n            response.setHeader(\"Access-Control-Allow-Origin\", allowed ? origin : \"\");\n\n            if (allowed) {\n                response.setHeader(\"Access-Control-Allow-Credentials\", \"true\");\n                response.setHeader(\"Access-Control-Allow-Methods\", \"GET, POST, PUT, DELETE, OPTIONS\");\n                response.setHeader(\"Access-Control-Allow-Headers\", \"Content-Type, Authorization, Content-Length, X-Requested-With, x-uncompressed-content-length, Cookie\");\n            }\n            response.setHeader(\"Access-Control-Expose-Headers\", \"x-uncompressed-content-length\");\n        }\n\n\n        let urlBase = request.url;\n        if (!urlBase) {\n            throw new Error(\"Missing URL\");\n        }\n\n        let protocol = \"https\";\n        let url = protocol + \"://\" + request.headers.host + request.url;\n\n        if (SocketFunction.logMessages) {\n            console.log(`HTTP request (${request.method}) ${url}`);\n        }\n        let urlObj = new URL(url);\n\n        let payload = await new Promise<Buffer>((resolve, reject) => {\n            let data: Buffer[] = [];\n            request\n                .on(\"data\", chunk => data.push(chunk))\n                .on(\"end\", () => resolve(Buffer.concat(data)))\n                .on(\"error\", (err) => reject(err))\n                ;\n        });\n\n        const { nodeId, localNodeId } = getNodeIdsFromRequest(request);\n\n        let caller: CallerContext = {\n            nodeId,\n            localNodeId,\n        };\n\n        let classGuid = urlObj.searchParams.get(\"classGuid\");\n        let functionName = urlObj.searchParams.get(\"functionName\");\n        let args: string | unknown[] | null = urlObj.searchParams.get(\"args\");\n\n        if (!classGuid) {\n            let defaultCall = defaultHTTPCall.get().call;\n            if (defaultCall) {\n                classGuid = defaultCall.classGuid;\n                functionName = defaultCall.functionName;\n                args = defaultCall.args;\n            } else {\n                throw new Error(\"Missing classGuid in URL query\");\n            }\n        }\n        if (!functionName) {\n            throw new Error(\"Missing functionName in URL query\");\n        }\n\n        if (!args) {\n            args = [];\n        } else {\n            if (typeof args === \"string\") {\n                args = JSON.parse(args) as unknown[];\n            }\n        }\n\n        if (payload.length > 0) {\n            args = JSON.parse(payload.toString())[\"args\"] as unknown[];\n        }\n\n        let call: FullCallType = {\n            nodeId,\n            classGuid,\n            functionName,\n            args,\n        };\n\n        if (isDataImmutable(call)) {\n            /** ETag cache, BUT, hashes only the input. Only valid for fully immutable resources\n             *      (ex data storage, as any endpoints that run code could have that code change).\n             *      - Shouldn't be needed, but I am seeing chrome fail to cache a lot of requests,\n             *          which could cost us multiple dollars in server costs from atlas.\n            */\n            response.setHeader(\"cache-control\", \"public, max-age=15206400, immutable\");\n            let hash = sha256Hash(Buffer.from(JSON.stringify(call)));\n            response.setHeader(\"ETag\", hash);\n            if (request.headers[\"if-none-match\"] === hash) {\n                response.writeHead(304);\n                console.log(`CACHED Immutable HTTP response (${request.method}) ${url}`);\n                return;\n            }\n        }\n\n        requests.set(caller, request);\n        let result: unknown;\n        try {\n            result = await performLocalCall({\n                caller,\n                call\n            });\n        } finally {\n            requests.delete(caller);\n        }\n\n        let resultBuffer: Buffer;\n        if (typeof result === \"object\" && result && result instanceof Buffer) {\n            resultBuffer = result;\n        } else {\n            resultBuffer = Buffer.from(JSON.stringify(result));\n        }\n\n        let headers = (resultBuffer as HTTPResultType)[resultHeaders];\n\n        // NOTE: Our ETag caching is only to reduce data sent on the wire, we evaluate the calls\n        //  every time (so it is strictly a wire cache for HTTP, not a computation cache)\n        if (SocketFunction.HTTP_ETAG_CACHE) {\n            response.setHeader(\"cache-control\", \"private, max-age=0, must-revalidate\");\n            let hash = sha256Hash(resultBuffer);\n            response.setHeader(\"ETag\", hash);\n            if (request.headers[\"if-none-match\"] === hash) {\n                response.writeHead(304);\n                console.log(`CACHED HTTP response  ${formatNumberSuffixed(resultBuffer.length)}B  (${request.method}) ${url}`);\n                return;\n            }\n        }\n\n        if (headers) {\n            for (let headerName in headers) {\n                response.setHeader(headerName, headers[headerName]);\n            }\n            let status = headers[\"status\"];\n            if (status) {\n                response.writeHead(+status);\n                return;\n            }\n        }\n        let uncompressedLength = resultBuffer.length;\n        if (SocketFunction.HTTP_COMPRESS && request.headers[\"accept-encoding\"]?.includes(\"gzip\") && !headers?.[\"Content-Encoding\"]) {\n            // NOTE: This is a BIT slow. To speed it up, functions can use an internal cache, according to their function,\n            //  and return a Buffer (which they can as any cast to make the returned type allowed, as returned Buffers will\n            //  just be treated like a buffer of JSON data).\n            //  - The caller should use getCurrentHTTPRequest first though, to check if gzip is allowed\n            response.setHeader(\"Content-Encoding\", \"gzip\");\n            resultBuffer = await new Promise<Buffer>((resolve, reject) => {\n                zlib.gzip(resultBuffer, {}, (err, result) => {\n                    if (err) {\n                        reject(err);\n                    } else {\n                        resolve(result);\n                    }\n                });\n            });\n        }\n        response.setHeader(\"Content-Length\", resultBuffer.length.toString());\n        if (!response.getHeader(\"X-Uncompressed-Content-Length\")) {\n            response.setHeader(\"X-Uncompressed-Content-Length\", uncompressedLength.toString());\n        }\n        response.write(resultBuffer);\n        if (SocketFunction.logMessages) {\n            console.log(`HTTP response  ${formatNumberSuffixed(resultBuffer.length)}B  (${request.method}) ${url}`);\n        }\n\n    } catch (e: any) {\n        console.log(`HTTP error  (${request.method}) ${e.stack}`);\n        response.writeHead(500, String(e.message).replace(/[^\\x20-\\x7E]/g, \"\"));\n    } finally {\n        response.end();\n    }\n}\n\n\nconst resultHeaders = Symbol(\"resultHeaders\");\ntype HTTPResultType = Buffer & { [resultHeaders]?: { [header: string]: string } };\n\nexport function setHTTPResultHeaders(\n    result: HTTPResultType,\n    headers: { [header: string]: string },\n): HTTPResultType {\n    result[resultHeaders] = headers;\n    return result;\n}"]}
+ /* _JS_SOURCE_HASH = "3d6960a14b632f45ab1c002bb5e7c9352f6f554aa8be29835b13cad26a35b297"; */

package/src/dist/callManager.ts.cache

@@ -0,0 +1,159 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+//exports.runServerHooks = exports.runClientHooks = exports.unregisterGlobalClientHook = exports.registerGlobalClientHook = exports.unregisterGlobalHook = exports.registerGlobalHook = exports.exposeClass = exports.registerClass = exports.isDataImmutable = exports.performLocalCall = exports.shouldCompressCall = exports.getCallFlags = void 0;
+const SocketFunction_1 = require("../SocketFunction");
+const measure_1 = require("./profiling/measure");
+const format_1 = require("./formatting/format");
+const createSingleton_1 = require("./createSingleton");
+// Shared across copies of this package, so a call routed through one copy can find a class
+//  (and its hooks) registered through another copy. See createSingleton.
+const classes = (0, createSingleton_1.createSingleton)("callManager.classes", 1, () => ({})).get();
+const exposedClasses = (0, createSingleton_1.createSingleton)("callManager.exposedClasses", 1, () => new Set()).get();
+const globalHooks = (0, createSingleton_1.createSingleton)("callManager.globalHooks", 1, () => []).get();
+const globalClientHooks = (0, createSingleton_1.createSingleton)("callManager.globalClientHooks", 1, () => []).get();
+function getCallFlags(call) {
+    var _a;
+    return (_a = classes[call.classGuid]) === null || _a === void 0 ? void 0 : _a.shape[call.functionName];
+}
+exports.getCallFlags = getCallFlags;
+function shouldCompressCall(call) {
+    var _a, _b;
+    return (_b = (_a = classes[call.classGuid]) === null || _a === void 0 ? void 0 : _a.shape[call.functionName]) === null || _b === void 0 ? void 0 : _b.compress;
+}
+exports.shouldCompressCall = shouldCompressCall;
+async function performLocalCall(config) {
+    const { call, caller } = config;
+    let classDef = classes[call.classGuid];
+    if (!classDef) {
+        throw new Error(`Class ${call.classGuid} not found. Have ${Object.keys(classes).join(", ")}`);
+    }
+    if (!exposedClasses.has(call.classGuid)) {
+        throw new Error(`Class ${call.classGuid} not exposed. Call SocketFunction.expose (serverside) with this class. Exposed classes: ${Array.from(exposedClasses).join(", ")}`);
+    }
+    let controller = classDef.controller;
+    let functionShape = classDef.shape[call.functionName];
+    if (!functionShape) {
+        throw new Error(`Function ${call.functionName} not exposed in ${call.classGuid}. Add it to the 3rd argument of SocketFunction.expose.`);
+    }
+    if (!controller[call.functionName]) {
+        throw new Error(`Function ${call.functionName} does not exist`);
+    }
+    let serverContext = await (0, exports.runServerHooks)(call, caller, functionShape);
+    if ("overrideResult" in serverContext) {
+        for (let callback of serverContext.onResult) {
+            await callback(serverContext.overrideResult);
+        }
+        if ("overrideResult" in serverContext) {
+            return serverContext.overrideResult;
+        }
+    }
+    // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously
+    let result = (0, SocketFunction_1._setSocketContext)(caller, () => {
+        return controller[call.functionName](...call.args);
+    });
+    for (let callback of serverContext.onResult) {
+        await callback(result);
+    }
+    if ("overrideResult" in serverContext) {
+        return serverContext.overrideResult;
+    }
+    return await result;
+}
+exports.performLocalCall = performLocalCall;
+function isDataImmutable(call) {
+    var _a, _b;
+    return !!((_b = (_a = classes[call.classGuid]) === null || _a === void 0 ? void 0 : _a.shape[call.functionName]) === null || _b === void 0 ? void 0 : _b.dataImmutable);
+}
+exports.isDataImmutable = isDataImmutable;
+function registerClass(classGuid, controller, shape, config) {
+    var _a;
+    if (!((_a = globalThis.isHotReloading) === null || _a === void 0 ? void 0 : _a.call(globalThis)) && classes[classGuid]) {
+        console.warn(`Class ${classGuid} already registered. This is normal if you are using multiple copies of socket-function at once.`);
+        return;
+    }
+    if (!(config === null || config === void 0 ? void 0 : config.noFunctionMeasure)) {
+        let niceClassName = controller.constructor.name || classGuid;
+        for (let functionName of Object.keys(shape)) {
+            if (functionName === "constructor")
+                continue;
+            let fnc = controller[functionName];
+            if (typeof fnc !== "function")
+                continue;
+            controller[functionName] = (0, measure_1.measureWrap)(fnc, `${niceClassName}().${functionName}`);
+        }
+    }
+    classes[classGuid] = {
+        controller,
+        shape,
+    };
+}
+exports.registerClass = registerClass;
+function exposeClass(exposedClass) {
+    exposedClasses.add(exposedClass._classGuid);
+}
+exports.exposeClass = exposeClass;
+function registerGlobalHook(hook) {
+    globalHooks.push(hook);
+}
+exports.registerGlobalHook = registerGlobalHook;
+function unregisterGlobalHook(hook) {
+    let index = globalHooks.indexOf(hook);
+    if (index >= 0) {
+        globalHooks.splice(index, 1);
+    }
+}
+exports.unregisterGlobalHook = unregisterGlobalHook;
+function registerGlobalClientHook(hook) {
+    globalClientHooks.push(hook);
+}
+exports.registerGlobalClientHook = registerGlobalClientHook;
+function unregisterGlobalClientHook(hook) {
+    let index = globalClientHooks.indexOf(hook);
+    if (index >= 0) {
+        globalClientHooks.splice(index, 1);
+    }
+}
+exports.unregisterGlobalClientHook = unregisterGlobalClientHook;
+exports.runClientHooks = (0, measure_1.measureWrap)(async function runClientHooks(callType, hooks, connectionId) {
+    var _a;
+    let context = { call: callType, connectionId, onResult: [] };
+    let clientHooks = ((_a = hooks.clientHooks) === null || _a === void 0 ? void 0 : _a.slice()) || [];
+    if (!hooks.noClientHooks) {
+        clientHooks = globalClientHooks.concat(clientHooks);
+        for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {
+            if (otherClientHook) {
+                clientHooks.push(otherClientHook);
+            }
+        }
+    }
+    for (let hook of clientHooks) {
+        let time = Date.now();
+        await (0, measure_1.measureBlock)(async () => {
+            await hook(context);
+        }, `clientHook|${hook.name || hook.toString().slice(0, 100)}`);
+        time = Date.now() - time;
+        if (time > 500) {
+            console.warn(`Slow (${(0, format_1.formatTime)(time)}) client hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);
+        }
+        // NOTE: See ClientHookContext.overrideResult for why we break here
+        if ("overrideResult" in context) {
+            break;
+        }
+    }
+    return context;
+});
+exports.runServerHooks = (0, measure_1.measureWrap)(async function runServerHooks(callType, caller, hooks) {
+    let hookContext = { call: callType, onResult: [] };
+    for (let hook of globalHooks.concat(hooks.hooks || [])) {
+        let time = Date.now();
+        await (0, SocketFunction_1._setSocketContext)(caller, () => hook(hookContext));
+        time = Date.now() - time;
+        if (time > 500) {
+            console.warn(`Slow (${(0, format_1.formatTime)(time)}) server hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);
+        }
+        // NOTE: See HookContext.overrideResult for why we don't break here
+    }
+    return hookContext;
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"callManager.js","sourceRoot":"","sources":["callManager.ts"],"names":[],"mappings":"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","sourcesContent":["/// <reference path=\"../hot/HotReloadController.ts\" />\nimport { CallerContext, CallType, ClientHookContext, FullCallType, FunctionFlags, HookContext, SocketExposedInterface, SocketExposedInterfaceClass, SocketExposedShape, SocketFunctionClientHook, SocketFunctionHook, SocketRegistered } from \"../SocketFunctionTypes\";\nimport { _setSocketContext } from \"../SocketFunction\";\nimport { entries, isNode } from \"./misc\";\nimport debugbreak from \"debugbreak\";\nimport { measureBlock, measureWrap } from \"./profiling/measure\";\nimport { formatTime } from \"./formatting/format\";\nimport { createSingleton } from \"./createSingleton\";\n\n// Shared across copies of this package, so a call routed through one copy can find a class\n//  (and its hooks) registered through another copy. See createSingleton.\nconst classes = createSingleton(\"callManager.classes\", 1, () => ({} as {\n    [classGuid: string]: {\n        controller: SocketExposedInterface;\n        shape: SocketExposedShape;\n    }\n})).get();\nconst exposedClasses = createSingleton(\"callManager.exposedClasses\", 1, () => new Set<string>()).get();\n\nconst globalHooks = createSingleton(\"callManager.globalHooks\", 1, () => [] as SocketFunctionHook[]).get();\nconst globalClientHooks = createSingleton(\"callManager.globalClientHooks\", 1, () => [] as SocketFunctionClientHook[]).get();\n\nexport function getCallFlags(call: CallType): FunctionFlags | undefined {\n    return classes[call.classGuid]?.shape[call.functionName];\n}\nexport function shouldCompressCall(call: CallType) {\n    return classes[call.classGuid]?.shape[call.functionName]?.compress;\n}\n\nexport async function performLocalCall(\n    config: {\n        call: FullCallType;\n        caller: CallerContext;\n    }\n): Promise<unknown> {\n    const { call, caller } = config;\n    let classDef = classes[call.classGuid];\n\n    if (!classDef) {\n        throw new Error(`Class ${call.classGuid} not found. Have ${Object.keys(classes).join(\", \")}`);\n    }\n\n    if (!exposedClasses.has(call.classGuid)) {\n        throw new Error(`Class ${call.classGuid} not exposed. Call SocketFunction.expose (serverside) with this class. Exposed classes: ${Array.from(exposedClasses).join(\", \")}`);\n    }\n\n    let controller = classDef.controller;\n    let functionShape = classDef.shape[call.functionName];\n    if (!functionShape) {\n        throw new Error(`Function ${call.functionName} not exposed in ${call.classGuid}. Add it to the 3rd argument of SocketFunction.expose.`);\n    }\n\n    if (!controller[call.functionName]) {\n        throw new Error(`Function ${call.functionName} does not exist`);\n    }\n\n    let serverContext = await runServerHooks(call, caller, functionShape);\n    if (\"overrideResult\" in serverContext) {\n        for (let callback of serverContext.onResult) {\n            await callback(serverContext.overrideResult);\n        }\n        if (\"overrideResult\" in serverContext) {\n            return serverContext.overrideResult;\n        }\n    }\n\n    // NOTE: We purposely don't await inside _setSocketContext, so the context is reset synchronously\n    let result = _setSocketContext(caller, () => {\n        return controller[call.functionName](...call.args);\n    });\n    for (let callback of serverContext.onResult) {\n        await callback(result);\n    }\n\n    if (\"overrideResult\" in serverContext) {\n        return serverContext.overrideResult;\n    }\n    return await result;\n}\n\nexport function isDataImmutable(call: CallType) {\n    return !!classes[call.classGuid]?.shape[call.functionName]?.dataImmutable;\n}\n\nexport function registerClass(classGuid: string, controller: SocketExposedInterface, shape: SocketExposedShape, config?: {\n    noFunctionMeasure?: boolean;\n}) {\n    if (!globalThis.isHotReloading?.() && classes[classGuid]) {\n        console.warn(`Class ${classGuid} already registered. This is normal if you are using multiple copies of socket-function at once.`);\n        return;\n    }\n\n    if (!config?.noFunctionMeasure) {\n        let niceClassName = controller.constructor.name || classGuid;\n        for (let functionName of Object.keys(shape)) {\n            if (functionName === \"constructor\") continue;\n            let fnc = controller[functionName];\n            if (typeof fnc !== \"function\") continue;\n            controller[functionName] = measureWrap(fnc, `${niceClassName}().${functionName}`);\n        }\n    }\n    classes[classGuid] = {\n        controller,\n        shape,\n    };\n}\n\nexport function exposeClass(exposedClass: SocketRegistered) {\n    exposedClasses.add(exposedClass._classGuid);\n}\n\nexport function registerGlobalHook(hook: SocketFunctionHook) {\n    globalHooks.push(hook);\n}\nexport function unregisterGlobalHook(hook: SocketFunctionHook) {\n    let index = globalHooks.indexOf(hook);\n    if (index >= 0) {\n        globalHooks.splice(index, 1);\n    }\n}\nexport function registerGlobalClientHook(hook: SocketFunctionClientHook) {\n    globalClientHooks.push(hook);\n}\nexport function unregisterGlobalClientHook(hook: SocketFunctionClientHook) {\n    let index = globalClientHooks.indexOf(hook);\n    if (index >= 0) {\n        globalClientHooks.splice(index, 1);\n    }\n}\n\nexport const runClientHooks = measureWrap(async function runClientHooks(\n    callType: FullCallType,\n    hooks: Exclude<SocketExposedShape[\"\"], undefined>,\n    connectionId: { nodeId: string },\n): Promise<ClientHookContext> {\n    let context: ClientHookContext = { call: callType, connectionId, onResult: [] };\n\n    let clientHooks = hooks.clientHooks?.slice() || [];\n    if (!hooks.noClientHooks) {\n        clientHooks = globalClientHooks.concat(clientHooks);\n        for (let otherClientHook of globalHooks.concat(hooks.hooks || []).map(x => x.clientHook)) {\n            if (otherClientHook) {\n                clientHooks.push(otherClientHook);\n            }\n        }\n    }\n    for (let hook of clientHooks) {\n        let time = Date.now();\n        await measureBlock(async () => {\n            await hook(context);\n        }, `clientHook|${hook.name || hook.toString().slice(0, 100)}`);\n        time = Date.now() - time;\n        if (time > 500) {\n            console.warn(`Slow (${formatTime(time)}) client hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);\n        }\n        // NOTE: See ClientHookContext.overrideResult for why we break here\n        if (\"overrideResult\" in context) {\n            break;\n        }\n    }\n\n    return context;\n});\n\nexport const runServerHooks = measureWrap(async function runServerHooks(\n    callType: FullCallType,\n    caller: CallerContext,\n    hooks: Exclude<SocketExposedShape[\"\"], undefined>,\n): Promise<HookContext> {\n    let hookContext: HookContext = { call: callType, onResult: [] };\n    for (let hook of globalHooks.concat(hooks.hooks || [])) {\n        let time = Date.now();\n        await _setSocketContext(caller, () => hook(hookContext));\n        time = Date.now() - time;\n        if (time > 500) {\n            console.warn(`Slow (${formatTime(time)}) server hook: ${JSON.stringify(hook.name || hook.toString().slice(0, 100))} for ${callType.classGuid}.${callType.functionName}(...)`);\n        }\n        // NOTE: See HookContext.overrideResult for why we don't break here\n    }\n    return hookContext;\n});"]}
+ /* _JS_SOURCE_HASH = "0287d257bb18707524dbc4504587f3bd6edeec3a80e538b9f5824a795c92c51e"; */

package/src/dist/certStore.ts.cache

@@ -0,0 +1,59 @@
+"use strict"; var console = (function shimConsole() {             let baseConsole = globalThis.console;             if (typeof window !== "undefined")                 return baseConsole;             let name = __filename.replaceAll("\\", "/").split("/").pop();             let dirName = __dirname.replaceAll("\\", "/").split("/").pop();             let context = {                 __FILE__: __filename,                 __DIR__: __dirname,                 __NAME__: name,                 __DIRNAME__: dirName             };             let newConsole = {                 ...baseConsole             };             for (let shim of ["log", "info", "warn", "error"]) {                 newConsole[shim] = (...args) => {                     args.push(context);                     baseConsole[shim](...args);                 };             }             newConsole.__context = context;             return newConsole;         })(); "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true , configurable: true});
+exports.watchTrustedCertificates = exports.getTrustedCertificates = exports.trustCertificate = void 0;
+const tls = __importStar(require("tls"));
+const misc_1 = require("./misc");
+let trustedCerts = new Set();
+let watchCallbacks = new Set();
+/** Must be populated before the server starts */
+function trustCertificate(cert) {
+    cert = cert.toString();
+    if (trustedCerts.has(cert))
+        return;
+    trustedCerts.add(cert);
+    let certs = getTrustedCertificates();
+    for (let callback of watchCallbacks) {
+        callback(certs);
+    }
+}
+exports.trustCertificate = trustCertificate;
+function getTrustedCertificates() {
+    let certs = [];
+    if ((0, misc_1.isNode)()) {
+        certs.push(...tls.rootCertificates);
+    }
+    certs.push(...Array.from(trustedCerts));
+    return certs;
+}
+exports.getTrustedCertificates = getTrustedCertificates;
+function watchTrustedCertificates(callback) {
+    watchCallbacks.add(callback);
+    callback(getTrustedCertificates());
+    return () => watchCallbacks.delete(callback);
+}
+exports.watchTrustedCertificates = watchTrustedCertificates;
+//# sourceMappingURL=data:application/json;base64,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
+ /* _JS_SOURCE_HASH = "4d43b17493f838041477a97682e019b4468e7e00fd98aeb9f8685feef8bdcaa1"; */