fulmine.js 5.21.5 → 5.21.6

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fulmine.js",
-    "version": "5.21.5",
+    "version": "5.21.6",
     "description": "Drop-in Express 5 replacement on uWebSockets.js, up to 20x faster. Same API, your middleware and framework keep working.",
     "main": "src/index.js",
     "exports": {

package/src/index.js

@@ -17,27 +17,6 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-// A project on pnpm owns the uWebSockets.js dependency itself, see `npx fulmine.js pnpm`, so the
-// one installed can drift from the one this package pins and was tested against. Said once, at
-// require time, where it reaches every deployment rather than only the ones that run verify.
-{
-    const pinned = /#v?([\d.]+)$/.exec(require("../package.json").dependencies["uWebSockets.js"])?.[1];
-    /** @type {string|undefined} */
-    let installed;
-    try {
-        // its exports map does not expose package.json, so it is read beside the entry point
-        const beside = require("path").join(require.resolve("uWebSockets.js"), "..", "package.json");
-        installed = JSON.parse(require("fs").readFileSync(beside, "utf8")).version;
-    } catch {
-        // nothing to compare against, which is not worth a warning of its own
-    }
-    if (pinned && installed && installed !== pinned) {
-        console.warn(
-            `fulmine.js: uWebSockets.js ${installed} is installed, this version was tested with ${pinned}.\n` +
-                "  On pnpm the pin is the project's own: `npx fulmine.js pnpm` writes the tested one."
-        );
-    }
-}
 const Application = require("./application.js");
 const Router = require("./router.js");
 const Route = require("./route.js");

package/src/node-shim.js

@@ -15,14 +15,36 @@ limitations under the License.
 */
 
 // A uWS-shaped request and response over node's own, for supertest and http.createServer(app).
-// Not fast and not meant to be. Where the models disagree node's gives way: cork only runs its
-// callback, a status is kept until the first byte of body
+// Not the fast path, app.listen() is, but about 1.5x Express on a hello world on Linux. Where the
+// models disagree node's gives way: cork only runs its callback, a status is kept until the first
+// byte of body
 
 const { IncomingMessage } = require("http");
+const { HEADER_NAME_BUF, HEADER_VALUE_BUF } = require("./response-utils.js");
 
 /** What µWS returns for an address nobody declared. */
 const emptyAddress = new ArrayBuffer(0);
 
+// The strings behind the Buffers writeHeaders hands over for the recurring names and values.
+// Decoded on every response they gave node a new string to check, lowercase and hash each time
+/** @type {Map<unknown, string>} */
+const HEADER_TEXT = new Map();
+for (const cache of [HEADER_NAME_BUF, HEADER_VALUE_BUF]) {
+    for (const text in cache) {
+        HEADER_TEXT.set(cache[text], text);
+    }
+}
+
+/**
+ * A header name or value as node's appendHeader takes it.
+ *
+ * @param {unknown} part
+ * @returns {string}
+ */
+function headerText(part) {
+    return typeof part === "string" ? part : (HEADER_TEXT.get(part) ?? String(part));
+}
+
 /**
  * An IP address as the four or sixteen bytes uWS hands over; unreadable comes back empty.
  *
@@ -93,6 +115,22 @@ function toArrayBuffer(chunk) {
     return /** @type {ArrayBuffer} */ (buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
 }
 
+/**
+ * A body chunk as node's write takes it: a string goes as it is and node encodes it once, with
+ * the head, anything else is copied as toArrayBuffer does.
+ *
+ * @param {ArrayBuffer|Buffer|string} chunk
+ * @returns {Buffer|string}
+ */
+function toNodeChunk(chunk) {
+    return typeof chunk === "string" ? chunk : Buffer.from(toArrayBuffer(chunk));
+}
+
+/** @param {Buffer|string} chunk */
+function byteLength(chunk) {
+    return typeof chunk === "string" ? Buffer.byteLength(chunk) : chunk.length;
+}
+
 /** uWS's HttpRequest over node's IncomingMessage. */
 class NodeHttpRequest {
     /** @type {import("http").IncomingMessage} */
@@ -241,16 +279,16 @@ class NodeHttpResponse {
     writeHeader(key, value) {
         if (!this._nodeRes.headersSent) {
             // writeHeaders hands the recurring names and values over as Buffers
-            this._nodeRes.appendHeader(String(key), String(value));
+            this._nodeRes.appendHeader(headerText(key), headerText(value));
         }
         return this;
     }
 
     /** @param {ArrayBuffer|Buffer|string} chunk @returns {boolean} false when the socket is full */
     write(chunk) {
-        const buffer = Buffer.from(toArrayBuffer(chunk));
-        this._offset += buffer.length;
-        return this._nodeRes.write(buffer);
+        const data = toNodeChunk(chunk);
+        this._offset += byteLength(data);
+        return this._nodeRes.write(data);
     }
 
     /** @param {ArrayBuffer|Buffer|string} [body] */
@@ -262,9 +300,9 @@ class NodeHttpResponse {
             this._nodeRes.end();
             return this;
         }
-        const buffer = Buffer.from(toArrayBuffer(body));
-        this._offset += buffer.length;
-        this._nodeRes.end(buffer);
+        const data = toNodeChunk(body);
+        this._offset += byteLength(data);
+        this._nodeRes.end(data);
         return this;
     }
 
@@ -298,9 +336,9 @@ class NodeHttpResponse {
         if (!this._nodeRes.headersSent && !this._nodeRes.hasHeader("Content-Length")) {
             this._nodeRes.setHeader("Content-Length", String(totalSize));
         }
-        const buffer = Buffer.from(toArrayBuffer(chunk));
-        const ok = this._nodeRes.write(buffer);
-        this._offset += buffer.length;
+        const data = toNodeChunk(chunk);
+        const ok = this._nodeRes.write(data);
+        this._offset += byteLength(data);
         const done = this._offset >= totalSize;
         if (done) {
             this._nodeRes.end();

package/src/uws.js

@@ -21,6 +21,30 @@ limitations under the License.
 /** @type {any} */
 let uWS;
 
+/**
+ * A project on pnpm owns the uWebSockets.js dependency itself, see `npx fulmine.js pnpm`, so the
+ * one installed can drift from the one this package pins and was tested against. Said once, when
+ * it is loaded: an app served through node's http never loads it and has nothing to hear.
+ */
+function warnOnDrift() {
+    const pinned = /#v?([\d.]+)$/.exec(require("../package.json").dependencies["uWebSockets.js"])?.[1];
+    /** @type {string|undefined} */
+    let installed;
+    try {
+        // its exports map does not expose package.json, so it is read beside the entry point
+        const beside = require("path").join(require.resolve("uWebSockets.js"), "..", "package.json");
+        installed = JSON.parse(require("fs").readFileSync(beside, "utf8")).version;
+    } catch {
+        // nothing to compare against, which is not worth a warning of its own
+    }
+    if (pinned && installed && installed !== pinned) {
+        console.warn(
+            `fulmine.js: uWebSockets.js ${installed} is installed, this version was tested with ${pinned}.\n` +
+                "  On pnpm the pin is the project's own: `npx fulmine.js pnpm` writes the tested one."
+        );
+    }
+}
+
 /**
  * The µWS module. H3App, DeclarativeResponse and _cfg exist at runtime but are missing from the
  * .d.ts the package ships, so it is handed back loosely typed.
@@ -29,6 +53,7 @@ let uWS;
  */
 function loadUWS() {
     if (uWS === undefined) {
+        warnOnDrift();
         uWS = /** @type {any} */ (require("uWebSockets.js"));
         try {
             // disable Uwebsockets header