ultimate-express 1.4.4 → 1.4.6

package/README.md

@@ -308,7 +308,7 @@ Almost all middlewares that are compatible with Express are compatible with µEx
 - ✅ [body-parser](https://npmjs.com/package/body-parser) (use `express.text()` etc instead for better performance)
 - ✅ [cookie-parser](https://npmjs.com/package/cookie-parser)
 - ✅ [cookie-session](https://npmjs.com/package/cookie-session)
-- ✅ [compression](https://npmjs.com/package/compression)
+- 🚧 [compression](https://npmjs.com/package/compression) - in some cases may send uncompressed files
 - ✅ [serve-static](https://npmjs.com/package/serve-static) (use `express.static()` instead for better performance)
 - ✅ [serve-index](https://npmjs.com/package/serve-index)
 - ✅ [cors](https://npmjs.com/package/cors)
@@ -322,6 +322,10 @@ Almost all middlewares that are compatible with Express are compatible with µEx
 - ✅ [express-subdomain](https://npmjs.com/package/express-subdomain)
 - ✅ [vhost](https://npmjs.com/package/vhost)
 - ✅ [tsoa](https://github.com/lukeautry/tsoa)
+- ✅ [express-mongo-sanitize](https://www.npmjs.com/package/express-mongo-sanitize)
+- ✅ [helmet](https://www.npmjs.com/package/helmet)
+- ✅ [passport](https://www.npmjs.com/package/passport)
+- ✅ [morgan](https://www.npmjs.com/package/morgan)
 
 Middlewares and modules that are confirmed to not work:
 

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "ultimate-express",
-  "version": "1.4.4",
+  "version": "1.4.6",
   "description": "The Ultimate Express. Fastest http server with full Express compatibility, based on uWebSockets.",
   "main": "src/index.js",
   "scripts": {
     "test": "node tests/index.js",
-    "dev": "node --inspect=9229 demo/index.js"
+    "dev": "node --inspect=9229 demo/index.js",
+    "cover": "npm run cover:unit && npm run cover:report",
+    "cover:unit": "nyc --silent npm run test",
+    "cover:report": "nyc report --reporter=html"
   },
   "engines": {
     "node": ">=18"
@@ -42,7 +45,7 @@
   "dependencies": {
     "@types/express": "^4.0.0",
     "accepts": "^1.3.8",
-    "acorn": "^8.14.0",
+    "acorn": "^8.14.1",
     "bytes": "^3.1.2",
     "cookie": "^1.0.2",
     "cookie-signature": "^1.2.2",
@@ -54,7 +57,7 @@
     "mime-types": "^2.1.35",
     "ms": "^2.1.3",
     "proxy-addr": "^2.0.7",
-    "qs": "^6.13.1",
+    "qs": "^6.14.0",
     "range-parser": "^1.2.1",
     "statuses": "^2.0.1",
     "tseep": "^1.3.1",
@@ -65,28 +68,33 @@
   "devDependencies": {
     "@codechecks/client": "^0.1.12",
     "body-parser": "^1.20.3",
-    "compression": "^1.7.5",
+    "compression": "^1.8.0",
     "cookie-parser": "^1.4.6",
     "cookie-session": "^2.1.0",
     "cors": "^2.8.5",
     "ejs": "^3.1.10",
     "errorhandler": "^1.5.1",
     "exit-hook": "^2.2.1",
-    "express-4": "npm:express@4",
-    "express-5": "npm:express@5",
+    "express": "latest-4",
     "express-art-template": "^1.0.1",
     "express-async-errors": "^3.1.1",
     "express-dot-engine": "^1.0.8",
     "express-fileupload": "^1.5.1",
-    "express-handlebars": "^8.0.1",
-    "express-rate-limit": "^7.4.1",
+    "express-handlebars": "^8.0.2",
+    "express-mongo-sanitize": "^2.2.0",
+    "express-rate-limit": "^7.5.0",
     "express-session": "^1.18.0",
     "express-subdomain": "^1.0.6",
     "formdata-node": "^6.0.3",
+    "helmet": "^8.1.0",
     "method-override": "^3.0.0",
+    "morgan": "^1.10.0",
     "multer": "^1.4.5-lts.1",
     "mustache-express": "^1.3.2",
+    "nyc": "^17.1.0",
     "pako": "^2.1.0",
+    "passport": "^0.7.0",
+    "passport-local": "^1.0.0",
     "pkg-pr-new": "^0.0.29",
     "pug": "^3.0.3",
     "response-time": "^2.3.3",

package/src/application.js

@@ -188,6 +188,9 @@ class Application extends Router {
 
             const matchedRoute = await this._routeRequest(request, response);
             if(!matchedRoute && !response.headersSent && !response.aborted) {
+                if(request._error) {
+                    return this._handleError(request._error, null, request, response);
+                }
                 response.status(404);
                 this._sendErrorPage(request, response, `Cannot ${request.method} ${request.path}`, false);
             }

package/src/request.js

@@ -201,6 +201,9 @@ module.exports = class Request extends Readable {
         return index !== -1 ? header.slice(0, index).trim() : header.trim();
     }
 
+    set query(query) {
+        return this.#cachedQuery = query;
+    }
     get query() {
         if(this.#cachedQuery) {
             return this.#cachedQuery;
@@ -251,7 +254,7 @@ module.exports = class Request extends Readable {
         let ip = '';
         if(this.rawIp.byteLength === 4) {
             // ipv4
-            ip = this.rawIp.join('.');
+            ip = new Uint8Array(this.rawIp).join('.');
         } else if(this.rawIp.byteLength === 16) {
             // ipv6
             const dv = new DataView(this.rawIp);
@@ -262,7 +265,7 @@ module.exports = class Request extends Readable {
                 }
             }
         } else {
-            this.#cachedParsedIp = undefined; // unix sockets dont have ip
+            ip = undefined; // unix sockets dont have ip
         }
         this.#cachedParsedIp = ip;
         return ip;
@@ -348,6 +351,9 @@ module.exports = class Request extends Readable {
         return parseRange(size, range, options);
     }
 
+    set headers(headers) {
+        this.#cachedHeaders = headers;
+    }
     get headers() {
         // https://nodejs.org/api/http.html#messageheaders
         if(this.#cachedHeaders) {

package/src/response.js

@@ -81,6 +81,7 @@ module.exports = class Response extends Writable {
         this.statusText = undefined;
         this.chunkedTransfer = true;
         this.totalSize = 0;
+        this.writingChunk = false;
         this.headers = {
             'connection': 'keep-alive',
             'keep-alive': 'timeout=10'
@@ -121,62 +122,62 @@ module.exports = class Response extends Writable {
     }
 
     _write(chunk, encoding, callback) {
-        if(this.aborted) {
+        if (this.aborted) {
             const err = new Error('Request aborted');
             err.code = 'ECONNABORTED';
             return this.destroy(err);
         }
-        if(this.finished) {
+        if (this.finished) {
             const err = new Error('Response already finished');
             return this.destroy(err);
         }
+
+        this.writingChunk = true;
         this._res.cork(() => {
-            if(!this.headersSent) {
+            if (!this.headersSent) {
                 this.writeHead(this.statusCode);
                 const statusMessage = this.statusText ?? statuses.message[this.statusCode] ?? '';
                 this._res.writeStatus(`${this.statusCode} ${statusMessage}`.trim());
                 this.writeHeaders(typeof chunk === 'string');
             }
-            if(!Buffer.isBuffer(chunk) && !(chunk instanceof ArrayBuffer)) {
+    
+            if (!Buffer.isBuffer(chunk) && !(chunk instanceof ArrayBuffer)) {
                 chunk = Buffer.from(chunk);
                 chunk = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
             }
-            if(this.chunkedTransfer) {
-                // chunked transfer encoding
+    
+            if (this.chunkedTransfer) {
                 this._res.write(chunk);
-                callback();
+                this.writingChunk = false;
+                callback(null);
             } else {
-                // fixed size transfer encoding
                 const lastOffset = this._res.getWriteOffset();
                 const [ok, done] = this._res.tryEnd(chunk, this.totalSize);
-                if(done) {
-                    this.destroy();
+                if (done) {
+                    super.end();
                     this.finished = true;
-                    if(this.socketExists) this.socket.emit('close');
-                    callback();
+                    this.writingChunk = false;
+                    if (this.socketExists) this.socket.emit('close');
+                    callback(null);
+                } else if (!ok) {
+                    this._res.ab = chunk;
+                    this._res.abOffset = lastOffset;
+                    this._res.onWritable((offset) => {
+                        if (this.finished) return true;
+                        const [ok, done] = this._res.tryEnd(this._res.ab.slice(offset - this._res.abOffset), this.totalSize);
+                        if (done) {
+                            this.finished = true;
+                            if (this.socketExists) this.socket.emit('close');
+                        }
+                        if (ok) {
+                            this.writingChunk = false;
+                            callback(null);
+                        }
+                        return ok;
+                    });
                 } else {
-                    // still writing
-                    if(!ok) {
-                        // wait until uWS is ready to accept more data
-                        this._res.onWritable((offset) => {
-                            if(this.finished) {
-                                return true;
-                            }
-                            const [ok, done] = this._res.tryEnd(chunk.slice(offset - lastOffset), this.totalSize);
-                            if(done) {
-                                this.destroy();
-                                this.finished = true;
-                                if(this.socketExists) this.socket.emit('close');
-                                callback();
-                            } else if(ok) {
-                                callback();
-                            }
-                            
-                            return ok;
-                        });
-                    } else {
-                        callback();
-                    }
+                    this.writingChunk = false;
+                    callback(null);
                 }
             }
         });
@@ -229,6 +230,12 @@ module.exports = class Response extends Writable {
         return this.status(code).send(statuses.message[+code] ?? code.toString());
     }
     end(data) {
+        if(this.writingChunk) {
+            this.once('drain', () => {
+                this.end(data);
+            });
+            return;
+        }
         if(this.finished) {
             return;
         }
@@ -498,7 +505,8 @@ module.exports = class Response extends Writable {
                 opts.end = Math.max(offset, offset + len - 1);
             }
             const file = fs.createReadStream(fullpath, opts);
-            pipeStreamOverResponse(this, file, len, callback);
+            this.set('Content-Length', len);
+            file.pipe(this);
         }
     }
     download(path, filename, options, callback) {
@@ -739,60 +747,4 @@ module.exports = class Response extends Writable {
     get writableFinished() {
         return this.finished;
     }
-}
-
-function pipeStreamOverResponse(res, readStream, totalSize, callback) {
-    readStream.on('data', (chunk) => {
-        if(res.finished) {
-            return readStream.destroy();
-        }
-        res._res.cork(() => {
-            if(!res.headersSent) {
-                res.writeHead(res.statusCode);
-                const statusMessage = res.statusText ?? statuses.message[res.statusCode] ?? '';
-                res._res.writeStatus(`${res.statusCode} ${statusMessage}`.trim());
-                res.writeHeaders(true);
-            }
-            const ab = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
-        
-            const lastOffset = res._res.getWriteOffset();
-            const [ok, done] = res._res.tryEnd(ab, totalSize);
-      
-            if (done) {
-                readStream.destroy();
-                res.finished = true;
-                if(res.socketExists) res.socket.emit('close');
-                if(callback) callback();
-            } else if (!ok) {
-                readStream.pause();
-        
-                res._res.ab = ab;
-                res._res.abOffset = lastOffset;
-        
-                res._res.onWritable((offset) => {
-                    if(res.finished) {
-                        return true;
-                    }
-                    const [ok, done] = res._res.tryEnd(res._res.ab.slice(offset - res._res.abOffset), totalSize);
-                    if (done) {
-                        readStream.destroy();
-                        res.finished = true;
-                        if(res.socketExists) res.socket.emit('close');
-                        if(callback) callback();
-                    } else if (ok) {
-                        readStream.resume();
-                    }
-            
-                    return ok;
-                });
-            }
-        });
-    }).on('error', e => {
-        if(callback) callback(e);
-        if(!res.finished) {
-            res._res.close();
-            res.finished = true;
-            if(res.socketExists) res.socket.emit('error', e);
-        }
-    });
-}
+}

package/src/router.js

@@ -46,7 +46,6 @@ module.exports = class Router extends EventEmitter {
         this._paramCallbacks = new Map();
         this._mountpathCache = new Map();
         this._routes = [];
-        this.errorRoute = undefined;
         this.mountpath = '/';
         this.settings = settings;
         this._request = Request;
@@ -293,6 +292,9 @@ module.exports = class Router extends EventEmitter {
             }
             const matchedRoute = await this._routeRequest(request, response, 0, optimizedPath, true, route);
             if(!matchedRoute && !response.headersSent && !response.aborted) {
+                if(request._error) {
+                    return this._handleError(request._error, null, request, response);
+                }
                 response.status(404);
                 request.noEtag = true;
                 this._sendErrorPage(request, response, `Cannot ${request.method} ${request._originalPath}`, false);
@@ -332,20 +334,12 @@ module.exports = class Router extends EventEmitter {
         }
     }
 
-    _handleError(err, request, response) {
-        let errorRoute = this.errorRoute, parent = this.parent;
-        while(!errorRoute && parent) {
-            errorRoute = parent.errorRoute;
-            parent = parent.parent;
-        }
-        if(errorRoute) {
-            return errorRoute(err, request, response, () => {
-                if(!response.headersSent) {
-                    if(response.statusCode === 200) {
-                        response.statusCode = 500;
-                    }
-                    this._sendErrorPage(request, response, err, true);
-                }
+    _handleError(err, handler, request, response) {
+        if(handler) {
+            return handler(err, request, response, () => {
+                delete request._error;
+                delete request._errorKey;
+                return request.next();
             });
         }
         console.error(err);
@@ -405,8 +399,8 @@ module.exports = class Router extends EventEmitter {
                                         if(thingamabob === 'route') {
                                             return resolve('route');
                                         } else {
-                                            this._handleError(thingamabob, req, res);
-                                            return resolve(false);
+                                            req._error = thingamabob;
+                                            req._errorKey = route.routeKey;
                                         }
                                     }
                                     return resolveRoute();
@@ -460,7 +454,7 @@ module.exports = class Router extends EventEmitter {
         let callbackindex = 0;
 
         // avoid calling _preprocessRequest as async function as its slower
-        // but it seems like calling it as async has unintended consequence of resetting max call stack size
+        // but it seems like calling it as async has unintended, but useful consequence of resetting max call stack size
         // so call it as async when the request has been through every 300 routes to reset it
         const continueRoute = this._paramCallbacks.size === 0 && req.routeCount % 300 !== 0 ? 
             this._preprocessRequest(req, res, route) : await this._preprocessRequest(req, res, route);
@@ -513,8 +507,8 @@ module.exports = class Router extends EventEmitter {
                         req.routeCount++;
                         return resolve(this._routeRequest(req, res, routeIndex + 1, routes, skipCheck, skipUntil));
                     } else {
-                        this._handleError(thingamabob, req, res);
-                        return resolve(true);
+                        req._error = thingamabob;
+                        req._errorKey = route.routeKey;
                     }
                 }
                 const callback = route.callbacks[callbackindex++];
@@ -535,6 +529,15 @@ module.exports = class Router extends EventEmitter {
                     if(routed) return resolve(true);
                     next();
                 } else {
+                    // handle errors and error handlers
+                    if(req._error || callback.length === 4) {
+                        if(req._error && callback.length === 4 && route.routeKey >= req._errorKey) {
+                            return this._handleError(req._error, callback, req, res);
+                        } else {
+                            return next();
+                        }
+                    }
+                    
                     try {
                         // skipping routes we already went through via optimized path
                         if(!skipCheck && skipUntil && skipUntil.routeKey >= route.routeKey) {
@@ -544,16 +547,18 @@ module.exports = class Router extends EventEmitter {
                         if(out instanceof Promise) {
                             out.catch(err => {
                                 if(this.get("catch async errors")) {
-                                    this._handleError(err, req, res);
-                                    return resolve(true);
+                                    req._error = err;
+                                    req._errorKey = route.routeKey;
+                                    return next();
                                 } else {
                                     throw err;
                                 }
                             });
                         }
                     } catch(err) {
-                        this._handleError(err, req, res);
-                        return resolve(true);
+                        req._error = err;
+                        req._errorKey = route.routeKey;
+                        return next();
                     }
                 }
             }
@@ -570,10 +575,6 @@ module.exports = class Router extends EventEmitter {
 
     use(path, ...callbacks) {
         if(typeof path === 'function' || path instanceof Router || (Array.isArray(path) && path.every(p => typeof p === 'function' || p instanceof Router))) {
-            if(callbacks.length === 0 && typeof path === 'function' && path.length === 4) {
-                this.errorRoute = path;
-                return;
-            }
             callbacks.unshift(path);
             path = '';
         }