ultimate-express 1.3.1 → 1.3.3

package/README.md

@@ -43,9 +43,10 @@ For full table with other runtimes, check [here](https://github.com/dimdenGD/bun
 
 |  Framework           | Average        | Ping          | Query         | Body          |
 | -------------------- | -------------- | ------------- | ------------- | ------------- |
-| uws                  | 94,296.49      | 108,551.92    | 104,756.22    | 69,581.33     |
-| hyper-express        | 66,356.707     | 80,002.53     | 69,953.76     | 49,113.83     |
-| **ultimate-express** | **57,343.813** | **64,608.03** | **60,234.78** | **47,188.63** |
+| uws                  | 95,531.277     | 109,960.35    | 105,601.47    | 71,032.01     |
+| **ultimate-express (declarative)** | **86,794.997** | **108,546.44** | **105,869.75** | **45,968.8** |
+| hyper-express        | 68,959.92      | 82,547.21     | 71,685.51     | 52,647.04     |
+| **ultimate-express** | **60,839.75** | **68,938.53** | **66,173.86** | **47,406.86** |
 | h3                   | 35,423.263     | 41,243.68     | 34,429.26     | 30,596.85     |
 | fastify              | 33,094.62      | 40,147.67     | 40,076.35     | 19,059.84     |
 | hono                 | 26,576.02      | 36,215.35     | 34,656.12     | 8,856.59      |
@@ -102,7 +103,7 @@ app.listen(3000, () => {
 1. µExpress tries to optimize routing as much as possible, but it's only possible if:
 - `case sensitive routing` is enabled (it is by default, unlike in normal Express).
 - only string paths without regex characters like *, +, (), {}, etc. can be optimized.
-- only 1-level deep routers can be optimized.  
+- only 1-level deep routers can be optimized.
   
 Optimized routes can be up to 10 times faster than normal routes, as they're using native uWS router and have pre-calculated path.
 
@@ -114,8 +115,6 @@ Optimized routes can be up to 10 times faster than normal routes, as they're usi
 
 5. 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.
 
-6. Don't read `req.connection.remoteAddress` (or `req.ip` if `trust proxy` is disabled) after response is finished. In general, reading IP in uWS is quite slow (~15% slower), and you should only read it when you need it while request is still open. If you'll read it after response, it'll make µExpress read IP for every single request after, even when it's not needed.
-
 ## 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:
@@ -302,6 +301,7 @@ Almost all middlewares that are compatible with Express are compatible with µEx
 - ✅ [express-rate-limit](https://npmjs.com/package/express-rate-limit)
 - ✅ [express-subdomain](https://npmjs.com/package/express-subdomain)
 - ✅ [vhost](https://npmjs.com/package/vhost)
+- ✅ [tsoa](https://github.com/lukeautry/tsoa)
 
 Middlewares and modules that are confirmed to not work:
 

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "ultimate-express",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "The Ultimate Express. Fastest http server with full Express compatibility, based on uWebSockets.",
   "main": "src/index.js",
   "scripts": {
-    "test": "node tests/index.js"
+    "test": "node tests/index.js",
+    "dev": "node --inspect=9229 demo/index.js"
   },
   "engines": {
     "node": ">=16"
@@ -41,6 +42,7 @@
   "dependencies": {
     "@types/express": "^4.0.0",
     "accepts": "^1.3.8",
+    "acorn": "^8.12.1",
     "bytes": "^3.1.2",
     "cookie": "^1.0.1",
     "cookie-signature": "^1.2.1",
@@ -57,7 +59,7 @@
     "statuses": "^2.0.1",
     "tseep": "^1.2.2",
     "type-is": "^1.6.18",
-    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.48.0",
+    "uWebSockets.js": "github:uNetworking/uWebSockets.js#v20.49.0",
     "vary": "^1.1.2"
   },
   "devDependencies": {

package/src/declarative.js

@@ -0,0 +1,388 @@
+const acorn = require("acorn");
+const uWS = require("uWebSockets.js");
+
+const parser = acorn.Parser;
+
+const allowedResMethods = ['set', 'header', 'setHeader', 'status', 'send', 'end', 'append'];
+const allowedIdentifiers = ['query', 'params', ...allowedResMethods];
+
+// generates a declarative response from a callback
+// uWS allows creating such responses and they are extremely fast
+// since you don't even have to call into Node.js at all
+// declarative response will only be created if callback is 'simple enough'
+// simple enough means:
+// - doesnt call external functions
+// - doesnt create variables
+// - only uses req.query and req.params
+// basically, its only simple, static responses
+module.exports = function compileDeclarative(cb, app) {
+    try {
+        let code = cb.toString();
+        // convert anonymous functions to named ones to make it valid code
+        if(code.startsWith("function") || code.startsWith("async function")) {
+            code = code.replace(/function *\(/, "function __cb(");
+        }
+
+        const tokens = [...acorn.tokenizer(code, { ecmaVersion: "latest" })];
+
+        if(tokens.some(token => ['throw', 'new', 'await'].includes(token.value))) {
+            return false;
+        }
+
+        const parsed = parser.parse(code, { ecmaVersion: "latest" }).body;
+        let fn = parsed[0];
+
+        if(fn.type === 'ExpressionStatement') {
+            fn = fn.expression;
+        }
+
+        // check if it is a function
+        if (fn.type !== 'FunctionDeclaration' && fn.type !== 'ArrowFunctionExpression') {
+            return false;
+        }
+
+        const args = fn.params.map(param => param.name);
+
+        if(args.length < 2) {
+            // invalid function? doesn't have (req, res) args
+            return false;
+        }
+
+        const [req, res] = args;
+        let queryName, paramsName, queries = [], params = [];
+
+        if(fn.params[0].type === 'ObjectPattern') {
+            let query = fn.params[0].properties.find(prop => prop.key.name === 'query');
+            let param = fn.params[0].properties.find(prop => prop.key.name === 'params');
+
+            if(query?.value?.type === 'Identifier') {
+                queryName = query.value.name;
+            } else if(query?.value?.type === 'ObjectPattern') {
+                for(let prop of query.value.properties) {
+                    if(prop.value.type !== 'Identifier') {
+                        return false;
+                    }
+                    queries.push(prop.value.name);
+                }
+            } else {
+                return false;
+            }
+
+            if(param?.value?.type === 'Identifier') {
+                paramsName = param.value.name;
+            } else if(param?.value?.type === 'ObjectPattern') {
+                for(let prop of param.value.properties) {
+                    if(prop.value.type !== 'Identifier') {
+                        return false;
+                    }
+                    params.push(prop.value.name);
+                }
+            } else {
+                return false;
+            }
+        }
+
+        // check if it calls any other function other than the one in `res`
+        const callExprs = filterNodes(fn, node => node.type === 'CallExpression');
+        const resCalls = [];
+        for(let expr of callExprs) {
+            let calleeName, propertyName;
+
+            
+            // get propertyName
+            if(expr.type === 'MemberExpression') {
+                propertyName = expr.property.name;
+            } else if(expr.type === 'CallExpression') {
+                propertyName = expr.callee?.property?.name ?? expr.callee?.name;
+            }
+
+            // get calleeName
+            switch(expr.callee.type) {
+                case "Identifier":
+                    calleeName = expr.callee.name;
+                    break;
+                case "MemberExpression":
+                    if(expr.callee.object.type === 'Identifier') {
+                        calleeName = expr.callee.object.name;
+                    } else if(expr.callee.object.type === 'CallExpression') {
+                        // function call chaining
+                        let callee = expr.callee;
+                        while(callee.object.callee) {
+                            callee = callee.object.callee;
+                        }
+                        if(callee.object.type !== 'Identifier') {
+                            return false;
+                        }
+                        calleeName = callee.object.name;
+                    }
+                    break;
+                default:
+                    return false;
+            }
+            // check if calleeName is res
+            if(calleeName !== res) {
+                return false;
+            }
+
+            const obj = { calleeName, propertyName };
+            expr.obj = obj;
+            resCalls.push(obj);
+        }
+
+        // check if res property being called are
+        // - set, header, setHeader
+        // - status
+        // - send
+        // - end
+        for(let call of resCalls) {
+            if(!allowedResMethods.includes(call.propertyName)) {
+                return false;
+            }
+        }
+
+        // check if all identifiers are allowed
+        const identifiers = filterNodes(fn, node => node.type === 'Identifier').slice(args.length).map(id => id.name);
+        if(identifiers[identifiers.length - 1] === '__cb') {
+            identifiers.pop();
+        }
+        if(!identifiers.every((id, i) => 
+            allowedIdentifiers.includes(id) || 
+            id === req || 
+            id === res || 
+            (identifiers[i - 2] === req && identifiers[i - 1] === 'params') || 
+            (identifiers[i - 2] === req && identifiers[i - 1] === 'query') ||
+            id === queryName ||
+            id === paramsName ||
+            queries.includes(id) ||
+            params.includes(id)
+        )) {
+            return false;
+        }
+
+        
+        let statusCode = 200;
+        const headers = [];
+        const body = [];
+
+        // get statusCode
+        for(let call of callExprs) {
+            if(call.obj.propertyName === 'status') {
+                if(call.arguments[0].type !== 'Literal') {
+                    return false;
+                }
+                statusCode = call.arguments[0].value;
+            }
+        }
+
+        // get headers
+        for(let call of callExprs) {
+            if(call.obj.propertyName === 'header' || call.obj.propertyName === 'setHeader' || call.obj.propertyName === 'set') {
+                if(call.arguments[0].type !== 'Literal' || call.arguments[1].type !== 'Literal') {
+                    return false;
+                }
+                const sameHeader = headers.find(header => header[0] === call.arguments[0].value);
+                if(sameHeader) {
+                    sameHeader[1] = call.arguments[1].value;
+                } else {
+                    headers.push([call.arguments[0].value, call.arguments[1].value]);
+                }
+            } else if(call.obj.propertyName === 'append') {
+                if(call.arguments[0].type !== 'Literal' || call.arguments[1].type !== 'Literal') {
+                    return false;
+                }
+                headers.push([call.arguments[0].value, call.arguments[1].value]);
+            }
+        }
+
+        // get body
+        for(let call of callExprs) {
+            if(call.obj.propertyName === 'send' || call.obj.propertyName === 'end') {
+                const arg = call.arguments[0];
+                if(arg) {
+                    if(arg.type === 'Literal') {
+                        if(typeof arg.value === 'number') { // status code
+                            return false;
+                        }
+                        let val = arg.value;
+                        if(val === null) {
+                            val = '';
+                        }
+                        body.push({type: 'text', value: val});
+                    } else if(arg.type === 'TemplateLiteral') {
+                        const exprs = [...arg.quasis, ...arg.expressions].sort((a, b) => a.start - b.start);
+                        for(let expr of exprs) {
+                            if(expr.type === 'TemplateElement') {
+                                body.push({type: 'text', value: expr.value.cooked});
+                            } else if(expr.type === 'MemberExpression') {
+                                const obj = expr.object;
+                                let type;
+                                if(obj.type === 'MemberExpression') {
+                                    if(obj.property.type !== 'Identifier') {
+                                        return false;
+                                    }
+                                    type = obj.property.name;
+                                } else if(obj.type === 'Identifier') {
+                                    type = obj.name;
+                                } else {
+                                    return false;
+                                }
+                                if(type !== 'params' && type !== 'query') {
+                                    return false;
+                                }
+                                body.push({type, value: expr.property.name});
+                            } else if(expr.type === 'Identifier') {
+                                if(queries.includes(expr.name)) {
+                                    body.push({type: 'query', value: expr.name});
+                                } else if(params.includes(expr.name)) {
+                                    body.push({type: 'params', value: expr.name});
+                                } else {
+                                    return false;
+                                }
+                            } else {
+                                return false;
+                            }
+                        }
+                    } else if(arg.type === 'MemberExpression') {
+                        if(!arg.object.property) {
+                            return false;
+                        }
+                        if(arg.object.property.type !== 'Identifier' || (arg.object.property.name !== 'query' && arg.object.property.name !== 'params')) {
+                            return false;
+                        }
+                        body.push({type: arg.object.property.name, value: arg.property.name});
+                    } else if(arg.type === 'BinaryExpression') {
+                        let stuff = [];
+                        function check(node) {
+                            if(node.right.type === 'Literal') {
+                                stuff.push({type: 'text', value: node.right.value});
+                            } else if(node.right.type === 'MemberExpression')  {
+                                stuff.push({type: node.right.object.property.name, value: node.right.property.name});
+                            } else return false;
+                            if(node.left.type === 'Literal') {
+                                stuff.push({type: 'text', value: node.left.value});
+                            } else if(node.left.type === 'MemberExpression') {
+                                stuff.push({type: node.left.object.property.name, value: node.left.property.name});
+                            } else if(node.left.type === 'BinaryExpression') {
+                                return check(node.left);
+                            } else return false;
+
+                            return true;
+                        }
+                        if(!check(arg)) {
+                            return false;
+                        }
+                        body.push(...stuff.reverse());
+                    } else {
+                        return false;
+                    }
+                }
+            }
+        }
+
+        // uws doesnt support status codes other than 200 currently
+        if(statusCode != 200) {
+            return false;
+        }
+
+        let decRes = new uWS.DeclarativeResponse();
+
+        for(let header of headers) {
+            if(header[0].toLowerCase() === 'content-length') {
+                return false;
+            }
+            decRes = decRes.writeHeader(header[0], header[1]);
+        }
+
+        if(app.get('etag') && !headers.some(header => header[0].toLowerCase() === 'etag')) {
+            if(body.some(part => part.type !== 'text')) {
+                return false;
+            } else {
+                decRes = decRes.writeHeader('ETag', app.get('etag fn')(body.map(part => part.value.toString()).join('')));
+            }
+        }
+
+        if(app.get('x-powered-by')) {
+            decRes = decRes.writeHeader('x-powered-by', 'UltimateExpress');
+        }
+
+        for(let bodyPart of body) {
+            if(bodyPart.type === 'text' && String(bodyPart.value).length) {
+                decRes = decRes.write(String(bodyPart.value));
+            } else if(bodyPart.type === 'params') {
+                decRes = decRes.writeParameterValue(bodyPart.value);
+            } else if(bodyPart.type === 'query') {
+                decRes = decRes.writeQueryValue(bodyPart.value);
+            }
+        }
+
+        return decRes.end();
+    } catch(e) {
+        return false;
+    }
+}
+
+function filterNodes(node, fn) {
+    const filtered = [];
+    if(fn(node)) {
+        filtered.push(node);
+    }
+    if(node.params) {
+        for(let param of node.params) {
+            filtered.push(...filterNodes(param, fn));
+        }
+    }
+
+    if(node.body) {
+        if(Array.isArray(node.body)) {
+            for(let child of node.body) {
+                filtered.push(...filterNodes(child, fn));
+            }
+        } else {
+            filtered.push(...filterNodes(node.body, fn));
+        }
+    }
+
+    if(node.declarations) {
+        for(let declaration of node.declarations) {
+            filtered.push(...filterNodes(declaration, fn));
+        }
+    }
+
+    if(node.expression) {
+        filtered.push(...filterNodes(node.expression, fn));
+    }
+
+    if(node.callee) {
+        filtered.push(...filterNodes(node.callee, fn));
+    }
+
+    if(node.object) {
+        filtered.push(...filterNodes(node.object, fn));
+    }
+
+    if(node.property) {
+        filtered.push(...filterNodes(node.property, fn));
+    }
+
+    if(node.id) {
+        filtered.push(...filterNodes(node.id, fn));
+    }
+    if(node.init) {
+        filtered.push(...filterNodes(node.init, fn));
+    }
+    
+    if(node.left) {
+        filtered.push(...filterNodes(node.left, fn));
+    }
+    if(node.right) {
+        filtered.push(...filterNodes(node.right, fn));
+    }
+
+    if(node.arguments) {
+        for(let argument of node.arguments) {
+            filtered.push(...filterNodes(argument, fn));
+        }
+    }
+
+    return filtered;
+}

package/src/middlewares.js

@@ -42,7 +42,15 @@ function static(root, options) {
 
     return (req, res, next) => {
         const iq = req.url.indexOf('?');
-        let url = decodeURIComponent(iq !== -1 ? req.url.substring(0, iq) : req.url);
+        let url;
+        try {
+            url = decodeURIComponent(iq !== -1 ? req.url.substring(0, iq) : req.url);
+        } catch(e) {
+            if(!options.fallthrough) {
+                res.status(404);
+                return next(new Error('Not found'));
+            } else return next();
+        }
         let _path = url;
         let fullpath = path.resolve(path.join(options.root, url));
         if(options.root && !fullpath.startsWith(path.resolve(options.root))) {

package/src/request.js

@@ -351,53 +351,54 @@ module.exports = class Request extends Readable {
         if(this.#cachedHeaders) {
             return this.#cachedHeaders;
         }
-        let headers = new NullObject();
-        this.#rawHeadersEntries.forEach((val) => {
-            const key = val[0].toLowerCase();
-            const value = val[1];
-            if(headers[key]) {
+        this.#cachedHeaders = new NullObject();
+        for (let index = 0, len = this.#rawHeadersEntries.length; index < len; index++) {
+            let [key, value] = this.#rawHeadersEntries[index];   
+            key = key.toLowerCase();
+            if(this.#cachedHeaders[key]) {
                 if(discardedDuplicates.includes(key)) {
-                    return;
+                    continue;
                 }
                 if(key === 'cookie') {
-                    headers[key] += '; ' + value;
+                    this.#cachedHeaders[key] += '; ' + value;
                 } else if(key === 'set-cookie') {
-                    headers[key].push(value);
+                    this.#cachedHeaders[key].push(value);
                 } else {
-                    headers[key] += ', ' + value;
+                    this.#cachedHeaders[key] += ', ' + value;
                 }
-                return;
+                continue;
             }
             if(key === 'set-cookie') {
-                headers[key] = [value];
+                this.#cachedHeaders[key] = [value];
             } else {
-                headers[key] = value;
+                this.#cachedHeaders[key] = value;
             }
-        });
-        this.#cachedHeaders = headers;
-        return headers;
+        }
+        return this.#cachedHeaders;
     }
 
     get headersDistinct() {
         if(this.#cachedDistinctHeaders) {
             return this.#cachedDistinctHeaders;
         }
-        let headers = new NullObject();
+        this.#cachedDistinctHeaders = new NullObject();
         this.#rawHeadersEntries.forEach((val) => {
-            if(!headers[val[0]]) {
-                headers[val[0]] = [];
+            const [key, value] = val;
+            if(!this.#cachedDistinctHeaders[key]) {
+                this.#cachedDistinctHeaders[key] = [value];
+                return;
             }
-            headers[val[0]].push(val[1]);
+            this.#cachedDistinctHeaders[key].push(value);
         });
-        this.#cachedDistinctHeaders = headers;
-        return headers;
+        return this.#cachedDistinctHeaders;
     }
 
     get rawHeaders() {
         const res = [];
-        this.#rawHeadersEntries.forEach((val) => {
+        for (let index = 0, len = this.#rawHeadersEntries.length; index < len; index++) {
+            const val = this.#rawHeadersEntries[index];
             res.push(val[0], val[1]);
-        });
+        }
         return res;
     }
 }

package/src/response.js

@@ -225,7 +225,7 @@ module.exports = class Response extends Writable {
         this._res.cork(() => {
             if(!this.headersSent) {
                 const etagFn = this.app.get('etag fn');
-                if(data && !this.headers['etag'] && etagFn && !this.req.noEtag) {
+                if(etagFn && data && !this.headers['etag'] && !this.req.noEtag) {
                     this.headers['etag'] = etagFn(data);
                 }
                 const fresh = this.req.fresh;
@@ -238,8 +238,9 @@ module.exports = class Response extends Writable {
                     return;
                 }
             }
-            if(!data && this.headers['content-length']) {
-                this._res.endWithoutBody(this.headers['content-length'].toString());
+            const contentLength = this.headers['content-length'];
+            if(!data && contentLength) {
+                this._res.endWithoutBody(contentLength.toString());
             } else {
                 if(data instanceof Buffer) {
                     data = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
@@ -279,8 +280,8 @@ module.exports = class Response extends Writable {
         }
         if(typeof body === 'string') {
             const contentType = this.headers['content-type'];
-            if(!contentType){
-                this.type('html'); // string defaulting to html
+            if(!contentType) {
+                this.headers['content-type'] = 'text/html; charset=utf-8';
             } else if(!contentType.includes(';')) {
                 this.headers['content-type'] += '; charset=utf-8';
             }
@@ -361,7 +362,8 @@ module.exports = class Response extends Writable {
                     this.status(403);
                     return done(new Error('Forbidden'));
                 case 'ignore_files':
-                    if(parts.length > 1 && parts[parts.length - 1].startsWith('.')) {
+                    const len = parts.length;
+                    if(len > 1 && parts[len - 1].startsWith('.')) {
                         this.status(404);
                         return done(new Error('Not found'));
                     }
@@ -408,7 +410,7 @@ module.exports = class Response extends Writable {
         }
 
         // etag
-        if(options.etag && !this.headers['etag'] && etagFn) {
+        if(options.etag && etagFn && !this.headers['etag']) {
             this.headers['etag'] = etagFn(stat);
         }
         if(!options.etag) {
@@ -442,9 +444,10 @@ module.exports = class Response extends Writable {
                 }
                 if(ranges !== -2 && ranges.length === 1) {
                     this.status(206);
-                    this.headers['content-range'] = `bytes ${ranges[0].start}-${ranges[0].end}/${stat.size}`;
-                    offset = ranges[0].start;
-                    len = ranges[0].end - ranges[0].start + 1;
+                    const range = ranges[0];
+                    this.headers['content-range'] = `bytes ${range.start}-${range.end}/${stat.size}`;
+                    offset = range.start;
+                    len = range.end - range.start + 1;
                     ranged = true;
                 }
             }
@@ -545,9 +548,7 @@ module.exports = class Response extends Writable {
     get(field) {
         return this.headers[field.toLowerCase()];
     }
-    getHeader(field) {
-        return this.get(field);
-    }
+    getHeader = this.get;
     removeHeader(field) {
         delete this.headers[field.toLowerCase()];
         return this;
@@ -709,9 +710,7 @@ module.exports = class Response extends Writable {
 
         return this.set('content-type', ct);
     }
-    contentType(type) {
-        return this.type(type);
-    }
+    contentType = this.type;
 
     vary(field) {
         vary(this, field);

package/src/router.js

@@ -14,11 +14,16 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-const { patternToRegex, needsConversionToRegex, deprecated, findIndexStartingFrom, canBeOptimized } = require("./utils.js");
+const { patternToRegex, needsConversionToRegex, deprecated, findIndexStartingFrom, canBeOptimized, NullObject } = require("./utils.js");
 const Response = require("./response.js");
 const Request = require("./request.js");
 const { EventEmitter } = require("tseep");
-const { NullObject } = require("./utils.js");
+const compileDeclarative = require("./declarative.js");
+
+let resCodes = {}, resDecMethods = ['set', 'setHeader', 'header', 'send', 'end', 'append', 'status'];
+for(let method of resDecMethods) {
+    resCodes[method] = Response.prototype[method].toString();
+}
 
 let routeKey = 0;
 
@@ -31,6 +36,8 @@ const methods = [
 ];
 const supportedUwsMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE'];
 
+const regExParam = /:(\w+)/g;
+
 module.exports = class Router extends EventEmitter {
     constructor(settings = {}) {
         super();
@@ -264,9 +271,9 @@ module.exports = class Router extends EventEmitter {
             method = 'del';
         }
         if(!route.optimizedRouter && route.path.includes(":")) {
-            route.optimizedParams = route.path.match(/:(\w+)/g).map(p => p.slice(1));
+            route.optimizedParams = route.path.match(regExParam).map(p => p.slice(1));
         }
-        const fn = async (res, req) => {
+        let fn = async (res, req) => {
             const { request, response } = this.handleRequest(res, req);
             if(route.optimizedParams) {
                 request.optimizedParams = new NullObject();
@@ -282,16 +289,36 @@ module.exports = class Router extends EventEmitter {
             }
         };
         route.optimizedPath = optimizedPath;
-        let replacedPath = route.path.replace(/:(\w+)/g, ':x');
+        
+        let replacedPath = route.path;
+        const realFn = fn;
+        
+        // check if route is declarative
+        if(
+            optimizedPath.length === 1 && // must not have middlewares
+            route.callbacks.length === 1 && // must not have multiple callbacks
+            typeof route.callbacks[0] === 'function' && // must be a function
+            this._paramCallbacks.size === 0 && // app.param() is not supported
+            !resDecMethods.some(method => resCodes[method] !== this.response[method].toString()) && // must not have injected methods
+            this.get('declarative responses') // must have declarative responses enabled
+        ) {
+            const decRes = compileDeclarative(route.callbacks[0], this);
+            if(decRes) {
+                fn = decRes;
+            }
+        } else {
+            replacedPath = route.path.replace(regExParam, ':x');
+        }
+
         this.uwsApp[method](replacedPath, fn);
         if(!this.get('strict routing') && route.path[route.path.length - 1] !== '/') {
             this.uwsApp[method](replacedPath + '/', fn);
             if(method === 'get') {
-                this.uwsApp.head(replacedPath + '/', fn);
+                this.uwsApp.head(replacedPath + '/', realFn);
             }
         }
         if(method === 'get') {
-            this.uwsApp.head(replacedPath, fn);
+            this.uwsApp.head(replacedPath, realFn);
         }
     }
 
@@ -407,33 +434,33 @@ module.exports = class Router extends EventEmitter {
     }
 
     async _routeRequest(req, res, startIndex = 0, routes = this._routes, skipCheck = false, skipUntil) {
-        return new Promise(async (resolve) => {
-            let routeIndex = skipCheck ? startIndex : findIndexStartingFrom(routes, r => (r.all || r.method === req.method || (r.gettable && req.method === 'HEAD')) && this._pathMatches(r, req), startIndex);
-            const route = routes[routeIndex];
-            if(!route) {
-                if(!skipCheck) {
-                    // on normal unoptimized routes, if theres no match then there is no route
-                    return resolve(false);
-                }
-                // on optimized routes, there can be more routes, so we have to use unoptimized routing and skip until we find route we stopped at
-                return resolve(this._routeRequest(req, res, 0, this._routes, false, skipUntil));
+        let routeIndex = skipCheck ? startIndex : findIndexStartingFrom(routes, r => (r.all || r.method === req.method || (r.gettable && req.method === 'HEAD')) && this._pathMatches(r, req), startIndex);
+        const route = routes[routeIndex];
+        if(!route) {
+            if(!skipCheck) {
+                // on normal unoptimized routes, if theres no match then there is no route
+                return false;
             }
-            let callbackindex = 0;
-            const continueRoute = await this._preprocessRequest(req, res, route);
-            if(route.use) {
-                const strictRouting = this.get('strict routing');
-                req._stack.push(route.path);
-                req._opPath = req.path.replace(this.getFullMountpath(req), '');
-                if(strictRouting) {
-                    if(req.endsWithSlash && req.path !== '/') {
-                        req._opPath += '/';
-                    }
-                } else if(req.endsWithSlash && req.path !== '/') {
-                    req._opPath = req._opPath.slice(0, -1);
+            // on optimized routes, there can be more routes, so we have to use unoptimized routing and skip until we find route we stopped at
+            return this._routeRequest(req, res, 0, this._routes, false, skipUntil);
+        }
+        let callbackindex = 0;
+        const continueRoute = await this._preprocessRequest(req, res, route);
+        if(route.use) {
+            const strictRouting = this.get('strict routing');
+            req._stack.push(route.path);
+            req._opPath = req.path.replace(this.getFullMountpath(req), '');
+            if(strictRouting) {
+                if(req.endsWithSlash && req.path !== '/') {
+                     req._opPath += '/';
                 }
-                req.url = req._opPath + req.urlQuery;
-                if(req.url === '') req.url = '/';
+            } else if(req.endsWithSlash && req.path !== '/') {
+                req._opPath = req._opPath.slice(0, -1);
             }
+            req.url = req._opPath + req.urlQuery;
+            if(req.url === '') req.url = '/';
+        }
+        return new Promise((resolve) => {
             const next = async (thingamabob) => {
                 if(thingamabob) {
                     if(thingamabob === 'route' || thingamabob === 'skipPop') {
@@ -565,4 +592,4 @@ module.exports = class Router extends EventEmitter {
             `</body>\n` +
             `</html>\n`);
     }
-}
+}

package/src/utils.js

@@ -23,7 +23,11 @@ const etag = require("etag");
 const { Stats } = require("fs");
 
 function fastQueryParse(query, options) {
-    if(query.length <= 128) {
+    const len = query.length;
+    if(len === 0){
+        return new NullObject();
+    }
+    if(len <= 128) {
         if(!query.includes('[') && !query.includes('%5B') && !query.includes('.') && !query.includes('%2E')) {
             return querystring.parse(query);
         }
@@ -44,9 +48,9 @@ function patternToRegex(pattern, isPrefix = false) {
     }
 
     let regexPattern = pattern
-        .replace(/\./g, '\\.')
-        .replace(/\-/g, '\\-')
-        .replace(/\*/g, '(.*)') // Convert * to .*
+        .replaceAll('.', '\\.')
+        .replaceAll('-', '\\-')
+        .replaceAll('*', '(.*)') // Convert * to .*
         .replace(/:(\w+)(\(.+?\))?/g, (match, param, regex) => {
             return `(?<${param}>${regex ? regex + '($|\\/)' : '[^/]+'})`;
         }); // Convert :param to capture group
@@ -101,12 +105,13 @@ function acceptParams(str) {
     const parts = str.split(/ *; */);
     const ret = { value: parts[0], quality: 1, params: {} }
   
-    for (let i = 1; i < parts.length; ++i) {
+    for (let i = 1, len = parts.length; i < len; ++i) {
       const pms = parts[i].split(/ *= */);
-      if ('q' === pms[0]) {
-        ret.quality = parseFloat(pms[1]);
+      const [pms_0, pms_1] = pms;
+      if ('q' === pms_0) {
+        ret.quality = parseFloat(pms_1);
       } else {
-        ret.params[pms[0]] = pms[1];
+        ret.params[pms_0] = pms_1;
       }
     }
   
@@ -154,7 +159,8 @@ const defaultSettings = {
     'views': () => path.join(process.cwd(), 'views'),
     'view cache': () => process.env.NODE_ENV === 'production',
     'x-powered-by': true,
-    'case sensitive routing': true
+    'case sensitive routing': true,
+    'declarative responses': true
 };
 
 function compileTrust(val) {
@@ -218,7 +224,7 @@ function decode (path) {
 const UP_PATH_REGEXP = /(?:^|[\\/])\.\.(?:[\\/]|$)/;
 
 function containsDotFile(parts) {
-    for(let i = 0; i < parts.length; i++) {
+    for(let i = 0, len = parts.length; i < len; i++) {
         const part = parts[i];
         if(part.length > 1 && part[0] === '.') {
             return true;
@@ -341,4 +347,4 @@ module.exports = {
     findIndexStartingFrom,
     fastQueryParse,
     canBeOptimized
-};
+};