fulmine.js 5.1.0 → 5.1.1

package/package.json

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

package/src/application.js

@@ -388,7 +388,11 @@ class Application extends Router {
             const response = request.res;
 
             try {
-                const matchedRoute = await this._routeRequest(request, response);
+                const routed = this._routeRequest(request, response);
+                // dispatch has run its synchronous stretch inside _routeRequest by now, still
+                // under the cork uWS holds for this callback; the await below leaves it
+                response._corkNeeded = true;
+                const matchedRoute = await routed;
                 if (!matchedRoute && !response.headersSent && !response.aborted) {
                     this._endUnmatched(request, response);
                 }

package/src/request.js

@@ -140,7 +140,8 @@ module.exports = class Request extends Readable {
 
     // Flat, name then value: an array of pairs meant one array allocated per header on every
     // request, and a request carries eight or ten of them. Everything that reads this walks it two
-    // at a time.
+    // at a time. The names are lowercase by contract: uWS lowers them on the wire and the node
+    // shim lowers them in its forEach, so readers compare without lowering again.
     #rawHeadersEntries = [];
 
     /** @type {string|undefined|null} */
@@ -665,10 +666,10 @@ module.exports = class Request extends Readable {
                 const entries = this.#rawHeadersEntries;
                 for (let i = 0, len = entries.length; i < len; i += 2) {
                     const key = entries[i];
-                    // 'if-none-match'.length === 13, 'if-modified-since'.length === 17
+                    // 'if-none-match'.length === 13, 'if-modified-since'.length === 17; the
+                    // entries carry lowercase names by contract, so this compares them as they are
                     if (key.length === 13 || key.length === 17) {
-                        const lower = key.toLowerCase();
-                        if (lower === "if-none-match" || lower === "if-modified-since") {
+                        if (key === "if-none-match" || key === "if-modified-since") {
                             hasConditional = true;
                             break;
                         }
@@ -852,7 +853,8 @@ module.exports = class Request extends Readable {
         const entries = this.#rawHeadersEntries;
         for (let index = 0, len = entries.length; index < len; index += 2) {
             const value = entries[index + 1];
-            const key = entries[index].toLowerCase();
+            // lowercase by the entries' contract, see the field declaration
+            const key = entries[index];
             if (Object.hasOwn(headers, key)) {
                 if (discardedDuplicates.has(key)) {
                     continue;

package/src/response.js

@@ -175,6 +175,9 @@ module.exports = class Response extends Writable {
         }
 
         this.body = undefined;
+        // false while the uWS route handler is still in its synchronous window, where uWS holds
+        // the socket corked itself; the two uWS entry points flip it once that window closes
+        this._corkNeeded = false;
         // shared methods, not arrows: two closures and a once() wrapper here were four
         // allocations per request. EventEmitter calls listeners with this = the emitter.
         this.on("error", this._onAbortError);
@@ -272,8 +275,11 @@ module.exports = class Response extends Writable {
             if (!this.headersSent) {
                 this.writeHead(this.statusCode);
                 // "unknown" and not the bare number: node writes that reason phrase for a code it
-                // has no message for, so the raw status lines match
-                this._res.writeStatus(statusLine(this.statusCode, this.statusText));
+                // has no message for, so the raw status lines match. The default 200 with no
+                // phrase is uWS's own head, byte for byte, so it is not written at all
+                if (this.statusCode !== 200 || this.statusText !== undefined) {
+                    this._res.writeStatus(statusLine(this.statusCode, this.statusText));
+                }
                 this.writeHeaders(typeof chunk === "string");
             }
 
@@ -475,47 +481,67 @@ module.exports = class Response extends Writable {
             return this;
         }
         this.writeHead(this.statusCode);
-        this._res.cork(() => {
-            if (!this.headersSent) {
-                // freshness is not decided here. node's end() knows nothing about conditional
-                // requests, and Express answers 304 from send() and from sendFile(), each of
-                // which strips the entity headers first. Deciding it here meant res.end("body")
-                // answered 304 and dropped the body that the caller had just written.
-                // "unknown" for a code without a message, as node's status line has it
+        // uWS holds the socket corked for the synchronous window of its route handler, and
+        // cork inside cork is a passthrough: the wrapper and its closure are only paid once the
+        // answer has outlived that window, which is what _corkNeeded records
+        if (this._corkNeeded) {
+            this._res.cork(() => this._finish(data, cb));
+        } else {
+            this._finish(data, cb);
+        }
+        return this;
+    }
+
+    /**
+     * The corked tail of end(): status, headers, body and the finish events. Split out so a
+     * synchronous answer calls it straight, already inside uWS's own cork.
+     *
+     * @param {any} data
+     * @param {any} cb
+     */
+    _finish(data, cb) {
+        if (!this.headersSent) {
+            // freshness is not decided here. node's end() knows nothing about conditional
+            // requests, and Express answers 304 from send() and from sendFile(), each of
+            // which strips the entity headers first. Deciding it here meant res.end("body")
+            // answered 304 and dropped the body that the caller had just written.
+            // "unknown" for a code without a message, as node's status line has it.
+            // The default 200 with no phrase is not written at all: uWS emits the identical
+            // "HTTP/1.1 200 OK" head on its own, and the crossing costs more than it says
+            if (this.statusCode !== 200 || this.statusText !== undefined) {
                 this._res.writeStatus(statusLine(this.statusCode, this.statusText));
-                this.writeHeaders(true);
             }
-            const contentLength = this.headers["content-length"];
-            if (STATUSES_WITHOUT_BODY.has(this.statusCode) || this.statusCode < 200) {
-                // no body and no length describing one, whatever the caller passed. node decides
-                // this the same way, from the status alone, so res.status(304).end("x") sends the
-                // status and nothing else on either.
-                this._res.endWithoutBody();
-            } else if (!data && contentLength) {
-                this._res.endWithoutBody(contentLength.toString());
+            this.writeHeaders(true);
+        }
+        const contentLength = this.headers["content-length"];
+        if (STATUSES_WITHOUT_BODY.has(this.statusCode) || this.statusCode < 200) {
+            // no body and no length describing one, whatever the caller passed. node decides
+            // this the same way, from the status alone, so res.status(304).end("x") sends the
+            // status and nothing else on either.
+            this._res.endWithoutBody();
+        } else if (!data && contentLength) {
+            this._res.endWithoutBody(contentLength.toString());
+        } else {
+            if (data instanceof Buffer) {
+                data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+            }
+            if (this.req.method === "HEAD") {
+                const length = Buffer.byteLength(data ?? "");
+                this._res.endWithoutBody(length.toString());
             } else {
-                if (data instanceof Buffer) {
-                    data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
-                }
-                if (this.req.method === "HEAD") {
-                    const length = Buffer.byteLength(data ?? "");
-                    this._res.endWithoutBody(length.toString());
-                } else {
-                    this._res.end(data);
-                }
+                this._res.end(data);
             }
+        }
 
-            this.finished = true;
-            this.#socket?.emit("close");
-            this.emit("finish");
-            this.emit("close");
-            cb &&
-                queueMicrotask(() => {
-                    this.#ended = true;
-                    cb();
-                });
-        });
-        return this;
+        this.finished = true;
+        this.#socket?.emit("close");
+        this.emit("finish");
+        this.emit("close");
+        cb &&
+            queueMicrotask(() => {
+                this.#ended = true;
+                cb();
+            });
     }
 
     /**

package/src/router.js

@@ -1408,6 +1408,10 @@ module.exports = class Router extends EventEmitter {
                 } catch (err) {
                     // what a throw inside a promise executor did: reject, once
                     nativeFail.call(walk, err);
+                } finally {
+                    // whatever runs after this line is outside the cork uWS held for this
+                    // callback, so later writes have to open their own
+                    response._corkNeeded = true;
                 }
             };
         };