ultimate-express 1.3.2 → 1.3.4

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:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ultimate-express",
-  "version": "1.3.2",
+  "version": "1.3.4",
   "description": "The Ultimate Express. Fastest http server with full Express compatibility, based on uWebSockets.",
   "main": "src/index.js",
   "scripts": {
@@ -42,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",
@@ -58,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

@@ -38,11 +38,18 @@ function static(root, options) {
         options.extensions = options.extensions.map(ext => ext.startsWith('.') ? ext.slice(1) : ext);
     }
     options.root = root;
-    options.skipEncodePath = true;
 
     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/response.js

@@ -539,8 +539,12 @@ module.exports = class Response extends Writable {
         }
         return this;
     }
-    header = this.set;
-    setHeader = this.set;
+    header(field, value) {
+        return this.set(field, value);
+    }
+    setHeader(field, value) {
+        return this.set(field, value);
+    }
     get(field) {
         return this.headers[field.toLowerCase()];
     }

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;
 
@@ -268,7 +273,7 @@ module.exports = class Router extends EventEmitter {
         if(!route.optimizedRouter && route.path.includes(":")) {
             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();
@@ -284,16 +289,36 @@ module.exports = class Router extends EventEmitter {
             }
         };
         route.optimizedPath = optimizedPath;
-        let replacedPath = route.path.replace(regExParam, ':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);
         }
     }
 

package/src/utils.js

@@ -159,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) {