Best approach for a modular node.js/socket.io/express application

Question

Best approach for a modular node.js/socket.io/express application

I'm currectly creating an app using Node.JS that makes use of Express and Socket.io. As time progresses it's becoming increasingly difficult to deal with one file, I'm in the process of moving certain things out that I know how but was wondering on the best approach to do this.

I have a private area constructor similar to:

privateArea.js

function privateArea(props) {
    this.id = props.id;
    this.name = props.name;
    this.users = [];
}

privateArea.prototype.addUser = function(socketId) {
    this.users.push(socketId);
};

module.exports = privateArea;

I'd like to have this also have access to the socket.io variable that's been setup for use in a separate sockets.js file that can be included via the main app.js and a seperate file for express.js

So I'd like the structure as follows:

project
| app.js - joins it all together
| express.js - initialises and manages all express routing
| privateArea.js - constructor for private areas - must be able to reference socket.io
| sockets.js - initialises and manages all socket.io sockets and events

Any help/examples would be very appreciated.

Thanks

javascript
node.js
express
socket.io-1.0

Answer 1

I use socket.io and express quite often in my projects, and I've developed a template which makes things easy. I like to have a fail-over in case the socket connections drops for some reason, or if a socket connection cannot be established. So I create http channels as well as socket channels. Here's a basic module template:

module.exports = function () {
    var exported = {};

    var someFunction = function (done) {
        //.. code here..//
        if (typeof done === "function") {
            done(null, true);
        }
    };
    // export the function
    exported.someFunction = someFunction;

    var apicalls = function (app) {
        app.get("/module/someFunction", function (req, res) {
             res.header("Content-Type", "application/json");
             someFunction(function (err, response) {
                 if (err) return res.send(JSON.stringify(err));
                 res.send(JSON.stringify(response));
             });
        });
    };
    exported.apicalls = apicalls;

    var socketcalls = function (io) {
        io.on("connection", function (socket) {
            socket.on('module-someFunction', function () {
                someFunction(function (err, response) {
                    if (err) return socket.emit('module-someFunction', err);
                    socket.emit('module-someFunction', response);
                });
            });
        });
    };
    exported.socketcalls = socketcalls;

    return exported;
}

So to use this, I'd first need to include the module in my app.js file like this:

var mymod = require('./myModule.js');

And then I can enable access to this service from HTTP and over the websocket like this:

mymod.apicalls(app);   // passing express to the module
mymod.socketcalls(io); // passing socket.io to the module

Finally, from the front-end, I can check to see if I have a socket connection, and if so, I use the socket to emit "module-someFunction". If I don't have a socket connection, the front-end will do an AJAX call instead to "/module/someFunction" which will hit the same function on the server side that it would've had I used the socket connection.

As an added bonus, if I need to utilize the function within the server, I could do that as well since the function is exported. That would look like this:

mymod.someFunction(function (err, response) {
    // ... handle result here ... //
});