Using res.locals in node.js model file

Question

I am overall clueless about how and why you set up a node.js app, and how any of the app.use functions work - the tutorials on it don't explain the why of anything.

Anyway, I have socket.io, res.locals and index.js set up like so in the app.js root file.

const sockets = require('./models/socket')(io)

app.use(function (req, res, next) {
    res.locals.user_id = req.session.user_id;
    next();
});

const routes = require('./routes/index');
app.use('/', routes);

I'd like to be able to access res.locals in the socket.js model, like I can in index.js found in the routes folder.

I can't guess how to go about doing this. If anybody is able to explain how and why I can or can't that would be a bonus. Thanks!

Answer 1

Welcome to Expressjs, there are a few fundamentals you should probably research before going any further, they'll help solve some of your confusion. I'll give a brief explanation of them but I suggest you do further research. I'll then answer your actual question at the end.

Middleware and app.use

Expressjs is built upon an idea that everything is just "middleware". Middleware is a function which runs as part of a request chain. A request chain is essentially a single client request, which then goes through a chain of a number of middleware functions until it either reaches the end of the chain, exits early by returning a response to the client, or errors.

Express middleware is a function which takes the following three arguments.

• req (request) - Representing the request made by a client to your server.
• res (response) - Representing the response you will return to the client.
• next - A way of telling express that your current middleware function is done, and it should now call the next piece of middleware. This can either be called "empty" as next(); or with an error next(new Error());. If it is called empty, it will trigger the next piece of middleware, if it is called with an error then it will call the first piece of error middleware. If next is not called at the end of a piece of middleware, then the request is deemed finished and the response object is sent to the user.

app.use is a way of setting middleware, this means it will run for every request (unless next() is either not called by the previous piece of middleware for some reason, or it's called with an error). This middleware will run for any HTTP request type (GET, POST, PUT, DELETE, etc).

app.use can take multiple arguments, the important ones for beginners to learn are: app.use(func) and app.use(path, func). The former sets "global" middleware which runs no matter what endpoint (url path) the client requests, the latter (with a specific path) is run only if that specific path is hit. I.e. app.use('/hello', (req, res, next) => { res.send('world'); }); will return "world" when the endpoint "/hello" is hit, but not if the client requests "/hi". Where as app.use((req, res, next) => { res.send('world'); }); would return "world" when you hit any endpoint.

There are more complex things you can do with this, but that's the basics of attaching middleware to your application. The order they are attached to the application, is the order in which they will run.

One more thing, this will blow your mind, an express application made with the standard const app = express() can also be used as middleware. This means you can create several express applications, and then mount them using app.use to a single express application. This is pretty advanced, but does allow you to do some really great things with Express.

Why can you not access res.locals in socket.io? (The real question)

Within your middleware handler, you are setting up a res.locals.use_id property. This only lives with that individual request, you can pass it around as long as the request is alive by passing it into other functions, but outside of that request it doesn't exist. res is literally the response object that tells Express how to respond to the clients request, you can set properties of it during the request but once that HTTP request has ended it's gone.

Socket.io is a way of handling web socket requests, not standard HTTP requests. Thus, in a standard express HTTP request you will not be able to hand off the connection to anything with socket.io, because the connection is a single short lived HTTP request. Likewise, you won't be able to do the same the other way.

If you wish to find the users id in a socket.io request, you'll have to do this within the socket.io request itself.

Right now, you're entering a piece of middleware for an Express.js request, you are then calling next() which runs the next piece of express middleware, at no point does it cross over into Socket.io realms. This is often confused by tutorials because Socket.io can handle requests across the same port as Express is listening on, but the two are not crossed over. So you will need to write separate middleware for both Express.js requests chains, and socket.io request chains. There are ways of writing this code once and then writing an adapter to use it across both platforms, but that's not what you've tried to do here.

I would suggest you look at doing just nodejs and express for a time before taking on socket.io as well, otherwise you're trying to learn a whole heap of technologies all at once is quite a lot to try and take on board all at once.