How can I combine multiple middlewares into one?

[sadeghhosseini]

What is the standard and suggested way to combine multiple middlewares into one?
Following are the solutions that I have come across during my research and they seem to work, I need to know if there are any caveats with these methods or if there are any other better and suggested way of combining middlewares?

method 1 using connect

import connect from 'connect';
import { RequestHandler } from "express";
const combineMiddlewares = (middlewares: RequestHandler[]) => {
    var chain = connect();
    middlewares.forEach(function (middleware) {
        chain.use(middleware);
    });
    return chain;
}

method 2

import { NextFunction, Request, RequestHandler, Response } from "express";
const combineMiddlewares = (mids: RequestHandler[]) => {
    return mids.reduce((previous, current) => {
        return (req: Request, res: Response, next: NextFunction) => {
            previous(req, res, (err: any) => {
                if (err) {
                    return next(err);
                }
                current(req, res, next);
            });
        };
    });
}

Thanks in advance.

[krzysdz]

Usually if you need to use multiple middleware functions in Express, they can be passed as an array or a sequence of functions (or both).

For example here I have 3 middleware functions, 2 of which are passed as an array, in case I'd like to reuse the same set on another route without listing them all again:

import express from "express";

function m1(req, res, next) {
        console.log("middleware 1");
        next();
}
function m2(req, res, next) {
        console.log("middleware 2");
        next();
}
function m3(req, res, next) {
        console.log("middleware 3");
        next();
}
const combined = [m1, m2];

const app = express();
app.get("/", combined, m3, (req, res) => res.send("Hello world!"));

const server = app.listen(0, async () => {
        const uri = `http://127.0.0.1:${server.address().port}/`;
        const r = await fetch(uri);
        console.log(await r.text());
        server.close();
});

The Using middleware guide also contains similar examples, which I recommend checking out.

[sadeghhosseini]

Yes, I am aware of this. I was wondering if I could combine multiple middlewares into one so that I can run it imperatively(inside another middleware) for such cases as conditional middleware setting based on specific request attribute(inside req.body or etc) or run it imperatively inside the route handler(for a specific use case).
I would also appreciate it if you could give me a link to the part in code, where express executes middlewares sequentially.

[krzysdz]

Your usage of connect is very similar to creating a Router or even express() app, since connect also is an extensible HTTP server framework, so you could probably use that if you don't want additional dependencies.

You could also use next('route') or next('router') to (conditionally) skip some middleware or whole router. This however won't let you run it inside other middleware - only before or after.

const skippedSym = Symbol('skipped1');
function skipRandom(req, res, next) {
    if (Math.random() < 0.5) {
        req[skippedSym] = true;
        next('route');
    } else {
        next();
    }
}
function skipNotSkipped(req, res, next) {
    if (req[skippedSym]) { next(); }
    else { next ('route'); }
}
router.all(skipRandom, m1, m2);
router.all(skipNotSkipped, m3, m5);
router.all(m4, (req, res) => res.send('Ok'));
// 50%: m1 -> m2 -> m4 -> Ok
// 50%: m3 -> m5 -> m4 -> Ok

Sequential middleware handling

When .use(), .all() or .METHOD() is called, the arguments are flattened and pushed to Router#stack.

• Router.use()
  

  express/lib/router/index.js

  Lines 459 to 484 in 3531987

  	var callbacks = flatten(slice.call(arguments, offset));
  	if (callbacks.length === 0) {
  	throw new TypeError('Router.use() requires a middleware function')
  	}
  	for (var i = 0; i < callbacks.length; i++) {
  	var fn = callbacks[i];
  	if (typeof fn !== 'function') {
  	throw new TypeError('Router.use() requires a middleware function but got a ' + gettype(fn))
  	}
  	// add the middleware
  	debug('use %o %s', path, fn.name || '<anonymous>')
  	var layer = new Layer(path, {
  	sensitive: this.caseSensitive,
  	strict: false,
  	end: false
  	}, fn);
  	layer.route = undefined;
  	this.stack.push(layer);
  	}

• Router.all() and Router.METHOD()
  

  express/lib/router/index.js

  Lines 502 to 524 in 3531987

  	proto.route = function route(path) {
  	var route = new Route(path);
  	var layer = new Layer(path, {
  	sensitive: this.caseSensitive,
  	strict: this.strict,
  	end: true
  	}, route.dispatch.bind(route));
  	layer.route = route;
  	this.stack.push(layer);
  	return route;
  	};
  	// create Router#VERB functions
  	methods.concat('all').forEach(function(method){
  	proto[method] = function(path){
  	var route = this.route(path)
  	route[method].apply(route, slice.call(arguments, 1));
  	return this;
  	};
  	});

Later on a request, the stack is iterated in a while route to execute layers sequentially and handle next('router') to skip the router. Every function passed to .use() is a layer and functions passed to Router.all() and Router.METHOD() are wrapped in a Route, which is then a layer (see the code above).

express/lib/router/index.js

Lines 177 to 291 in 3531987

	function next(err) {
	var layerError = err === 'route'
	? null
	: err;
	// remove added slash
	if (slashAdded) {
	req.url = req.url.slice(1)
	slashAdded = false;
	}
	// restore altered req.url
	if (removed.length !== 0) {
	req.baseUrl = parentUrl;
	req.url = protohost + removed + req.url.slice(protohost.length)
	removed = '';
	}
	// signal to exit router
	if (layerError === 'router') {
	setImmediate(done, null)
	return
	}
	// no more matching layers
	if (idx >= stack.length) {
	setImmediate(done, layerError);
	return;
	}
	// max sync stack
	if (++sync > 100) {
	return setImmediate(next, err)
	}
	// get pathname of request
	var path = getPathname(req);
	if (path == null) {
	return done(layerError);
	}
	// find next matching layer
	var layer;
	var match;
	var route;
	while (match !== true && idx < stack.length) {
	layer = stack[idx++];
	match = matchLayer(layer, path);
	route = layer.route;
	if (typeof match !== 'boolean') {
	// hold on to layerError
	layerError = layerError || match;
	}
	if (match !== true) {
	continue;
	}
	if (!route) {
	// process non-route handlers normally
	continue;
	}
	if (layerError) {
	// routes do not match with a pending error
	match = false;
	continue;
	}
	var method = req.method;
	var has_method = route._handles_method(method);
	// build up automatic options response
	if (!has_method && method === 'OPTIONS') {
	appendMethods(options, route._options());
	}
	// don't even bother matching route
	if (!has_method && method !== 'HEAD') {
	match = false;
	}
	}
	// no match
	if (match !== true) {
	return done(layerError);
	}
	// store route for dispatch on change
	if (route) {
	req.route = route;
	}
	// Capture one-time layer values
	req.params = self.mergeParams
	? mergeParams(layer.params, parentParams)
	: layer.params;
	var layerPath = layer.path;
	// this should be done for the layer
	self.process_params(layer, paramcalled, req, res, function (err) {
	if (err) {
	next(layerError || err)
	} else if (route) {
	layer.handle_request(req, res, next)
	} else {
	trim_prefix(layer, layerError, layerPath, path)
	}
	sync = 0
	});
	}

If the layer is a Route, it iterates over its own stack to call the middleware functions and handle next('route'), next('router') and errors.

express/lib/router/route.js

Lines 101 to 154 in 3531987

	Route.prototype.dispatch = function dispatch(req, res, done) {
	var idx = 0;
	var stack = this.stack;
	var sync = 0
	if (stack.length === 0) {
	return done();
	}
	var method = typeof req.method === 'string'
	? req.method.toLowerCase()
	: req.method
	if (method === 'head' && !this.methods['head']) {
	method = 'get';
	}
	req.route = this;
	next();
	function next(err) {
	// signal to exit route
	if (err && err === 'route') {
	return done();
	}
	// signal to exit router
	if (err && err === 'router') {
	return done(err)
	}
	// max sync stack
	if (++sync > 100) {
	return setImmediate(next, err)
	}
	var layer = stack[idx++]
	// end of layers
	if (!layer) {
	return done(err)
	}
	if (layer.method && layer.method !== method) {
	next(err)
	} else if (err) {
	layer.handle_error(err, req, res, next);
	} else {
	layer.handle_request(req, res, next);
	}
	sync = 0
	}
	};