Express error middleware not reached by asynchronous error - node.js

Question

I'm trying to handle all my errors in my backend in a streamlined fashion. In one of my endpoints I save some documents to my mongoose database and if there are any errors, I catch them and propagate them to my error handler by calling next(err). This works for errors outside the Promise, but not when next() is called inside the catch() clause. My endpoint is defined like this:
router.post("/", (req, res, next) => {
let listToAdd = req.body;
if (!(listToAdd instanceof Array)) {
listToAdd = [listToAdd];
}
let persons = listToAdd.map(p => {
return new Person(p)
});
Promise.all(persons.map(p => p.save()))
.then(saved => {
res.status(201).send(`Successfully saved document(s) with id(s): ${persons.map(p => p._id.toString())}`)
})
.catch(err => {
next(err); // This error never reaches my middleware
});
next(); // errors here be handled by middleware
});
My app.js, where my middleware is registered:
const express = require("express");
const cors = require("cors");
const bodyParser = require("body-parser");
const session = require('express-session');
const mongoose = require('mongoose');
const MongoStore = require('connect-mongo')(session);
// Routes
const personalFileRouter = require("./endpoints/person");
const userRouter = require("./endpoints/user");
// Custom Middleware
const {myRequestLoggingMiddleware} = require("./middleware/express_logging");
const {myErrorLoggingMiddleware} = require("./middleware/express_logging");
// Create a new express app
const app = express();
// Use CORS to allow communication to frontend
app.use(cors());
// use bodyparser to parse url body
app.use(bodyParser.json())
app.use(bodyParser.urlencoded({extended: true}));
// Use Express Sessions to track user logins
app.use(session({
secret: process.env.PRIVATE_KEY,
resave: true,
saveUninitialized: false,
store: new MongoStore({
mongooseConnection: mongoose.connection
})
}));
// Whenever we get a request on the form "/whatever" it should use the routes file to redirect
app.use("/person/", personalFileRouter);
app.use("/user/", userRouter);
app.use(myErrorLoggingMiddleware); // <-- Register my middleware last
module.exports = app;
And finally, my middleware error handler
function myErrorLoggingMiddleware(err, req, res, next) { // Never reached :(
if (res.headersSent) {
return next(err)
}
if (err instanceof mongoose.Error.ValidationError) {
validationErrorHandler(err, req, res);
} else {
defaultErrorHandler(err, req, res);
}
next();
}
exports.myErrorLoggingMiddleware = myErrorLoggingMiddleware;

Answer 1

Well, this is embarrassing. I'm not a 100% sure why, but I reckon that when I call next() below my promise, which is executed before the promise is resolved, the function has run its course and next is "used up". So when the promise later resolves, next() is an empty function that does not reference any middleware. My solution is then to simply remove the last next() and only call next inside my promise.