ultimate-express 1.1.5 → 1.1.6

package/README.md

@@ -16,7 +16,7 @@ To make sure µExpress matches behavior of Express in all cases, we run all test
 
 Similar projects based on uWebSockets:
 
-- `express` on Bun - since Bun uses uWS for its HTTP module, Express is about 2.5 times faster than on Node.js with 25k req/sec instead of 10k req/sec normally, but still slower than µExpress at 60k req/sec because it doesn't do uWS-specific optimizations.
+- `express` on Bun - since Bun uses uWS for its HTTP module, Express is about 2.5 times faster than on Node.js with 27k req/sec instead of 10k req/sec normally, but still slower than µExpress at 70k req/sec because it doesn't do uWS-specific optimizations.
 - `hyper-express` - while having a similar API to Express, it's very far from being a drop-in replacement, and implements most of the functionality differently. This creates a lot of random quirks and issues, making the switch quite difficult. Built in middlewares are also very different.
 - `uwebsockets-express` - this library is closer to being a drop-in replacement, but misses a lot of APIs, depends on Express by calling it's methods under the hood and doesn't try to optimize routing by using native uWS router.
 
@@ -41,13 +41,8 @@ Also tested on a [real-world application](https://nekoweb.org) with templates, s
 In a lot of cases, you can just replace `require("express")` with `require("ultimate-express")` and everything works the same. But there are some differences:
 
 - `case sensitive routing` is enabled by default.
-- Depending on how you send response, `Content-Length` header may be overwritten or not sent at all:
-- - on simple responses with res.send(), res.json(), etc. it's set automatically (any value you set with res.set() is overwritten)
-- - on streaming responses (piping, res.sendFile()) it's not sent because uWS uses chunked transfer encoding instead
-- - on responses without body, it *is* sent (useful for HEAD requests)
 - request body is only read for POST, PUT and PATCH requests by default. You can add additional methods by setting `body methods` to array with uppercased methods.
-- For HTTPS, instead of doing this:
-
+- For HTTPS, instead of doing this:  
 ```js
 const https = require("https");
 const express = require("express");
@@ -96,6 +91,13 @@ Optimized routes can be up to 10 times faster than normal routes, as they're usi
 
 4. By default, µExpress creates 1 (or 0 if your CPU has only 1 core) child thread to improve performance of reading files. You can change this number by setting `threads` to a different number in `express()`, or set to 0 to disable thread pool (`express({ threads: 0 })`). Threads are shared between all express() instances, with largest `threads` number being used. Using more threads will not necessarily improve performance. Sometimes not using threads at all is faster, please [test](https://github.com/wg/wrk/) both options.
 
+## WebSockets
+
+Since you don't create http server manually, you can't properly use http.on("upgrade") to handle WebSockets. To solve this, there's currently 2 options:
+
+- There's currently another library in works: [Ultimate WS](https://github.com/dimdenGD/ultimate-ws) that implements `ws` module. It's same concept as this library, but for WebSockets: fast drop-in replacement for `ws` module with support for uExpress upgrades.
+- You can simply use `app.uwsApp` to access uWebSockets.js `App` instance and call its `ws()` method directly.
+
 ## Compatibility
 
 In general, basically all features and options are supported. Use [Express 4.x documentation](https://expressjs.com/en/4x/api.html) for API reference.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-express",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "The Ultimate Express. Fastest http server with full Express compatibility, based on uWebSockets.",
   "main": "src/index.js",
   "scripts": {

package/src/application.js

@@ -179,11 +179,11 @@ class Application extends Router {
 
     #createRequestHandler() {
         this.uwsApp.any('/*', async (res, req) => {
-
             const request = new this._request(req, res, this);
             const response = new this._response(res, request, this);
             request.res = response;
             response.req = request;
+            
             res.onAborted(() => {
                 const err = new Error('Request aborted');
                 err.code = 'ECONNABORTED';

package/src/index.js

@@ -22,7 +22,6 @@ const Request = require("./request.js");
 const Response = require("./response.js");
 
 Application.Router = function(options) {
-
     return new Router(options);
 }
 

package/src/response.js

@@ -98,27 +98,61 @@ module.exports = class Response extends Writable {
             err.code = 'ECONNABORTED';
             return this.destroy(err);
         }
-        if(!Buffer.isBuffer(chunk)) {
-            chunk = Buffer.from(chunk);
-        }
+        const isString = typeof chunk === 'string';
+        let isChunkedTransfer = true, totalSize;
         this._res.cork(() => {
             if(!this.headersSent) {
                 this.writeHead(this.statusCode);
                 this._res.writeStatus(this.statusCode.toString());
                 for(const header in this.headers) {
                     if(header === 'content-length') {
+                        // if content-length is set, disable chunked transfer encoding, since size is known
+                        isChunkedTransfer = false;
+                        totalSize = parseInt(this.headers[header]);
                         continue;
                     }
                     this._res.writeHeader(header, this.headers[header]);
                 }
                 if(!this.headers['content-type']) {
-                    this._res.writeHeader('content-type', 'text/html' + (typeof chunk === 'string' ? `; charset=utf-8` : ''));
+                    this._res.writeHeader('content-type', 'text/html' + (isString ? `; charset=utf-8` : ''));
                 }
                 this.headersSent = true;
             }
-            const ab = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
-            this._res.write(ab);
-            callback();
+            if(!Buffer.isBuffer(chunk) && !(chunk instanceof ArrayBuffer)) {
+                chunk = Buffer.from(chunk);
+                chunk = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+            }
+            if(isChunkedTransfer) {
+                // chunked transfer encoding
+                this._res.write(chunk);
+                callback();
+            } else {
+                // fixed size transfer encoding
+                const lastOffset = this._res.getWriteOffset();
+                const [ok, done] = this._res.tryEnd(chunk, totalSize);
+                if(done) {
+                    this.destroy();
+                    this.socket.emit('close');
+                    callback();
+                } else {
+                    // still writing
+                    if(!ok) {
+                        // wait until uWS is ready to accept more data
+                        this._res.onWritable((offset) => {
+                            const [ok, done] = this._res.tryEnd(chunk.slice(offset - lastOffset), totalSize);
+                            if(done) {
+                                this.destroy();
+                                this.socket.emit('close');
+                                callback();
+                            } else if(ok) {
+                                callback();
+                            }
+                        });
+                    } else {
+                        callback();
+                    }
+                }
+            }
         });
     }
     writeHead(statusCode, statusMessage, headers) {