How to access parameter list from application-level middlewares in express.js?

How to access the params in every incoming requests?

I got a middleware dedicated to checking if the record with recordId existed in my MongoDB database.
Now I wish every single request to go through this middleware with the inspiration from DRY. So I created an application-level middleware:
app.use(checkRecordsExistence)

The middleware checkRecordsExistence needs to access all param list in order to check the existence of relevant records and store them in req object for further use.

However req.params always returns {}. What is the way forward? I don't want to add it in the router-level middlewares, because it is not clean, I worship DRY.

Here is my detailed implementation.

const checkRecordsExistence = asyncHandler(async (req, res, next) => {
    const { params } = req;
    for (const key in params) {
        if (Object.hasOwnProperty.call(params, key)) {
            // Only check params corresponding to Object Id
            if (key.endsWith('Id')) {
                // Remove the "Id" suffix from the param name
                const modelNameLower = key.slice(0, -2);
                const modelName = modelNameLower.charAt(0).toUpperCase() + modelNameLower.slice(1);

                const Model = mongoose.model(modelName);
                const recordId = params[key];
                const record = await Model.findById(recordId);
                if (!record) {
                    return next(new ErrorResponse(
                        new Error(message.notFound(modelName)),
                        404
                    ));
                }
                // Attach the found record to the request object for further use
                // <=> req._class = await Class.findById(classId)
                req[`_${modelNameLower}`] = record;
                console.log(typeof(record));
            }
        }
    }
    next();
});

I can get it going well by putting the middleware in every single router-level route. But it is not clean.

express builds the req.params in steps according to the path provided to it.
When you use a middleware on the root app (app.use(...)) middleware is unaware of the :param that is set downstream.

Example:

const express = require('express')
const app = express()
const port = 3000

// use middleware before all routes
app.use(printParamsMiddleware)

// use middleware before a specific routes
//                              |
//                              v
app.get('/users/:userId', printParamsMiddleware, (req, res) => {
  res.send('in GET /user/:userId')
})

app.listen(port, () => {
  console.log(`Example app listening on port ${port}`)
})

function printParamsMiddleware(req, res, next) {
    console.log('print params', req.params)
    next()
}

curl localhost:3000/users/1234

output

Example app listening on port 3000
print params {}
print params { userId: '1234' }

From the example you can see that the req.params is set after its passes through a route with a declared path.

Solution Suggestion

I suggest you create a middleware factory that generates a custom middleware per resource

// buildCheckRecordsExistence.middleware.js
function buildCheckRecordsExistence(modelName, paramKey) {
    return async function printParamsMiddleware(req, res, next) {
        const Model = mongoose.model(modelName);
        const recordId = req.params[paramKey];

        const record = await Model.findById(recordId);
        if (!record) {
            return next(new ErrorResponse(
                new Error(message.notFound(modelName)),
                404
            ));
        }
        req[paramKey] = record;
        next();
    }
}

// users.controller.js

// create a check records middleware specific for Users
const usersCheckRecordsExistence = buildCheckRecordsExistence('Users', 'userId')

app.get('/users/:userId', usersCheckRecordsExistence, (req, res) => {
    const record = req['userId']
    res.send('in GET /users/:userId', record)
})

app.put('/users/:userId', usersCheckRecordsExistence, (req, res) => {
    const record = req['userId']
    res.send('in PUT /users/:userId', record)
})

app.delete('/users/:userId', usersCheckRecordsExistence, (req, res) => {
    const record = req['userId']
    res.send('in DELETE /users/:userId', record)
})

// no need to use check record here
app.post('/users/:userId', (req, res) => {
    res.send('in POST /users/:userId')
})

// no need to use check record here
app.get('/users', (req, res) => {
    res.send('in GET /users')
})

The key in this solutions is that you have a reusable code and you can select where to use it.

and in case of multiple resources you can append an additional middleware like so.

const usersCheckRecordsExistence = buildCheckRecordsExistence('Users', 'userId')
const projectsCheckRecordsExistence = buildCheckRecordsExistence('Projects', 'projectId')

app.get('/users/:userId/projects/:projectId', usersCheckRecordsExistence, projectsCheckRecordsExistence, (req, res) => {
   
})