geonix 1.23.2 → 1.23.4

package/.vscode/settings.json

@@ -6,5 +6,6 @@
         "javascript"
     ],
     "editor.tabSize": 4,
-    "editor.detectIndentation": false
+    "editor.detectIndentation": false,
+    "editor.formatOnSave": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "geonix",
-    "version": "1.23.2",
+    "version": "1.23.4",
     "type": "module",
     "description": "",
     "bin": {

package/src/Gateway.js

@@ -1,6 +1,6 @@
 import { connection } from "./Connection.js";
 import { registry } from "./Registry.js";
-import { createTCPServer, GeonixVersion, picoid, proxyHttp, sleep } from "./Util.js";
+import { cleanupWebsocketUrl, createTCPServer, GeonixVersion, picoid, proxyHttp, sleep } from "./Util.js";
 import express, { Router } from "express";
 import { Request } from "./Request.js";
 import { HEALTH_CHECK_ENDPOINT } from "./WebServer.js";
@@ -401,10 +401,10 @@ export class Gateway {
 
                 if (verb === "ws") {
                     router.ws(uri, (ws, req) => {
-                        const url = req.originalUrl.replace(/\/\.websocket$/, "");
+                        let target = cleanupWebsocketUrl(`ws://${backend}${req.originalUrl}`);
 
-                        logger.debug("proxy.web.ws.to:", backend + req.originalUrl);
-                        this.#proxyWebsocketOverNats(`ws://${backend}${url}`, ws, req);
+                        logger.debug("proxy.web.ws.to:", target);
+                        this.#proxyWebsocketOverNats(target, ws, req);
                     });
                 } else {
                     router[verb](uri, async (req, res, _next) => {

package/src/Util.js

@@ -280,6 +280,25 @@ export async function parseMultipart(req, _options) {
     let activePart;
     let done = false;
 
+    const write = (chunk) => {
+        if (options.useMemory) {
+            activePart.body.push(chunk);
+        } else {
+            activePart.body.write(chunk);
+        }
+    };
+
+    const newPart = () => {
+        // create new part
+        const bodyFile = tempFilename();
+        activePart = {
+            headers: {},
+            bodyFile: options.useMemory ? undefined : bodyFile,
+            body: options.useMemory ? [] : createWriteStream(bodyFile, { flags: "wx" })
+        };
+        parts.push(activePart);
+    };
+
     while (stream.readable) {
         // next next chunk
         let chunk = stream.read(BUFFER_SIZE);
@@ -296,35 +315,26 @@ export async function parseMultipart(req, _options) {
             const isLastBoundary = combined[boundaryIndex + boundary.length] === 45 && combined[boundaryIndex + boundary.length + 1] === 45;
 
             if (boundaryIndex === -1) {
+                lastChunk = combined;
                 break;
             }
 
             if (boundaryIndex > 0) {
-                if (options.useMemory) {
-                    activePart.body.push(combined.slice(0, boundaryIndex));
-                } else {
-                    activePart.body.write(combined.slice(0, boundaryIndex));
-                }
+                write(combined.subarray(0, boundaryIndex));
             }
 
             if (isLastBoundary) {
-                combined = combined.slice(boundaryIndex + boundary.length + 2);
+                combined = combined.subarray(boundaryIndex + boundary.length + 2);
                 done = true;
                 break;
             }
 
-            // create new part
-            const bodyFile = tempFilename();
-            activePart = {
-                headers: {},
-                bodyFile: options.useMemory ? undefined : bodyFile,
-                body: options.useMemory ? [] : createWriteStream(bodyFile, { flags: "wx" })
-            };
-            parts.push(activePart);
+            newPart();
 
             const endOfHeaders = combined.indexOf(END_OF_HEADERS, boundaryIndex);
+
             activePart.headers = combined
-                .slice(boundaryIndex + boundary.length + 2, endOfHeaders).toString()
+                .subarray(boundaryIndex + boundary.length + 2, endOfHeaders).toString()
                 .split("\r\n")
                 .reduce((acc, val) => {
                     const [header, value] = val.split(": ");
@@ -332,18 +342,14 @@ export async function parseMultipart(req, _options) {
                     return acc;
                 }, {});
 
-            combined = combined.slice(endOfHeaders + END_OF_HEADERS.length);
+            combined = combined.subarray(endOfHeaders + END_OF_HEADERS.length);
 
             lastChunk = combined;
         }
 
         // there's no boundary in the chunk, add it to active part
         if (activePart && lastChunk.length > 0 && !done) {
-            if (options.useMemory) {
-                activePart.body.push(lastChunk);
-            } else {
-                activePart.body.write(lastChunk);
-            }
+            write(lastChunk);
             lastChunk = Buffer.alloc(0);
         }
     }
@@ -407,4 +413,14 @@ export function deepMerge(target, ...source) {
     }
 
     return target;
+}
+
+export function cleanupWebsocketUrl(url) {
+    try {
+        const parsed = new URL(url);
+        parsed.pathname = parsed.pathname.replace(/\/\.websocket$/, "");
+        return parsed.toString();
+    } catch {
+        return url;
+    }
 }

package/test/gateway.js

@@ -1,33 +1,34 @@
 import { Gateway, Service, streamToBuffer } from "../exports.js";
 import { parseMultipart } from "../src/Util.js";
 
-class TestService extends Service {
+// class TestService extends Service {
 
-    "GET /"(req, res) {
-        res.send("Hello World");
-    }
+//     "GET /"(req, res) {
+//         res.send("Hello World");
+//     }
 
-    async "POST /upload"(req, res) {
-        const parts = await parseMultipart(req, { useMemory: false });
+//     async "POST /upload"(req, res) {
+//         const parts = await parseMultipart(req, { useMemory: false });
 
-        for (const part of parts) {
-            console.log(part.body);
-        }
+//         for (const part of parts) {
+//             console.log(part.body);
+//         }
 
-        res.send("OK");
-    }
+//         res.send("OK");
+//     }
 
-}
+// }
 
-TestService.start({
-    middleware: {
-        raw: true,
-        json: false,
-        cookies: false,
-    }
-});
-Gateway.start({
-    beforeRequest: (req, res) => {
-        res.set("X-Test", "Test");
-    }
-});
+// TestService.start({
+//     middleware: {
+//         raw: true,
+//         json: false,
+//         cookies: false,
+//     }
+// });
+// Gateway.start({
+//     beforeRequest: (req, res) => {
+//         res.set("X-Test", "Test");
+//     }
+// });
+Gateway.start();

package/test/upload.js

@@ -0,0 +1,23 @@
+import { write } from "fs";
+import { Service, streamToBuffer } from "../exports.js";
+import { parseMultipart } from "../src/Util.js";
+import { writeFile } from "fs/promises";
+
+class UploadService extends Service {
+
+    async "POST /upload"(req, res) {
+        const files = await parseMultipart(req, { useMemory: false });
+
+        for (const file of files) {
+            file.body = await streamToBuffer(file.body);
+            console.log(`${file.filename} ${file.headers["content-type"]} size=${file.body.length}`);
+
+            await writeFile("/tmp/temp.pdf", file.body);
+        }
+
+        res.send("ok");
+    }
+
+}
+
+UploadService.start({ middleware: { raw: false } });

package/test/ws_auth.js

@@ -0,0 +1,21 @@
+import { Gateway, ServeStatic, Service } from "../exports.js";
+
+class ServiceFirst extends Service {
+    "WS /ws/first" = (ws) => {
+        ws.on("message", (message) => {
+            ws.send("first:" + message);
+        });
+    };
+}
+
+class ServiceSecond extends Service {
+    "WS /ws/second" = (ws) => {
+        ws.on("message", (message) => {
+            ws.send("second:" + message);
+        });
+    };
+}
+
+Gateway.start();
+ServiceFirst.start();
+ServiceSecond.start();