fulmine.js 5.18.0 → 5.18.2

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fulmine.js",
-    "version": "5.18.0",
+    "version": "5.18.2",
     "description": "Drop-in Express 5 replacement on uWebSockets.js. Your existing middleware keeps working.",
     "main": "src/index.js",
     "exports": {

package/src/node-shim.js

@@ -222,7 +222,9 @@ class NodeHttpResponse {
      */
     writeHeader(key, value) {
         if (!this._nodeRes.headersSent) {
-            this._nodeRes.appendHeader(key, String(value));
+            // String() because writeHeaders hands the recurring names and values over as
+            // Buffers for the uWS crossing, and node's appendHeader wants strings
+            this._nodeRes.appendHeader(String(key), String(value));
         }
         return this;
     }

package/src/request.js

@@ -914,9 +914,11 @@ module.exports = class Request extends LazyReadable {
             if (this.#responseEnded) {
                 return;
             }
-            // ab.slice(0) copies the ArrayBuffer; uWS neuters `ab` after this callback,
-            // so a Buffer.from(ab) view would corrupt data left in the Readable queue.
-            const chunk = Buffer.from(ab.slice(0));
+            // The bytes are copied because uWS neuters `ab` when this callback returns, and a
+            // view of it would corrupt whatever is still queued. Buffer.from over a view rather
+            // than ab.slice(0): the slice allocates an ArrayBuffer of its own for every chunk,
+            // which on a small body costs several times the copying it is there to do.
+            const chunk = Buffer.from(new Uint8Array(ab));
             const accepted = this.push(chunk);
             // push() may synchronously end the response via a flowing-mode listener.
             if (!accepted && !isLast && !this.#responseEnded) {

package/src/response.js

@@ -83,6 +83,32 @@ const kShapeMode =
 // request are one Map hit. Insert-only after validation, bounded; only setHeader may insert,
 // the never-throwing readers keep their plain toLowerCase
 const VALIDATED_HEADER_NAMES = new Map();
+// The names and values that recur on every response, kept as Buffers for the uWS crossing: a
+// Buffer is memcpy'd as it is, a string pays a UTF-8 scan and copy per call. A header that is
+// not here just misses the lookup and crosses as the string it was. Names must stay lowercase,
+// which is how writeHeaders receives them.
+const HEADER_NAME_BUF = { __proto__: null };
+const HEADER_VALUE_BUF = { __proto__: null };
+for (const s of ["connection", "keep-alive", "content-type", "vary", "x-powered-by", "content-encoding"]) {
+    HEADER_NAME_BUF[s] = Buffer.from(s);
+}
+for (const s of [
+    "keep-alive",
+    "timeout=10",
+    "close",
+    "Fulmine",
+    "Accept-Encoding",
+    "text/html; charset=utf-8",
+    "text/plain; charset=utf-8",
+    "application/json; charset=utf-8",
+    "application/octet-stream",
+    "gzip",
+    "br",
+    "deflate",
+    "zstd"
+]) {
+    HEADER_VALUE_BUF[s] = Buffer.from(s);
+}
 const HIGH_WATERMARK = 128 * 1024;
 // the exact string json() writes, so send() can skip recomputing the charset on it
 const JSON_UTF8 = "application/json; charset=utf-8";
@@ -714,12 +740,15 @@ module.exports = class Response extends LazyWritable {
                 this.totalSize = parseInt(value);
                 continue;
             }
+            // the recurring names and values cross as cached Buffers, see HEADER_NAME_BUF; a
+            // miss is two failed lookups and the string goes as it came
+            const name = HEADER_NAME_BUF[header] || header;
             if (Array.isArray(value)) {
                 for (const val of value) {
-                    res.writeHeader(header, val);
+                    res.writeHeader(name, HEADER_VALUE_BUF[val] || val);
                 }
             } else {
-                res.writeHeader(header, value);
+                res.writeHeader(name, HEADER_VALUE_BUF[value] || value);
             }
         }
         this.headersSent = true;