Nodejs delay return for "require"

Question

My setup is as follows:

Nodejs Server
server.js requires utils.js
utils.js loads data from mongodb into memory and exports it
server.js uses a variable that utils.js exports

The issue that I am worried about is the fact that the mongodb call is asynchronous. utils.js returns before the mongodb call is finished, meaning that server.js will use an undefined variable when it continues execution after the require.

What is the best to address this issue? The only thing I could think of is wrapping my server.js code in a giant callback and pass that to the function that makes the mongodb call. It seems a bit messy to me, is there a better way to do it?

Code:

server.js
var utils = require("./modules/utils.js");
console.log(utils);
//Do whatever

utils.js
var mods = [];
var db = require("mongojs").connect("localhost", ["modules"]);
db.modules.find({}, function(err, modules){
    mods = modules;
});
module.exports = mods;

Could you show your code, this seems like the case is handled wrong, do not use delays use callbacks and promises instead. — Risto Novik, Apr 18 '14 at 05:48
If this is done at server start-up, why would you do it asynchronously? Require reads the file-system synchronously because it doesn't matter at server start-up time. — Esailija, Apr 18 '14 at 09:40
Database reads are done asynchronously. I don't have much choice. — Franz Payer, Apr 18 '14 at 12:17

score 5 · Accepted Answer · answered Apr 18 '14 at 05:48

What you're referring to is called "callback hell". The easiest way to get out of that is to use a Promise library that simplifies it.

I used a node package called bluebird.

var mysql = require("mysql");
var hash = require("password-hash");
var Promise = require("bluebird");
var settings = require("../settings");

Promise.promisifyAll(require("mysql/lib/Connection").prototype);
Promise.promisifyAll(require("mysql/lib/Pool").prototype);

var db_config = {
    user:settings.db.user,
    password:settings.db.password,
    database:settings.db.database
};

var con = mysql.createPool(db_config);

function query(sql) {
    return con.getConnectionAsync().then(function(connection) {
        return connection.queryAsync(sql)
        .spread(function(rows,fields) {
            return rows;
        }).finally(function() {
            connection.release();
        });
    });
}

This is a very basic database module I wrote that uses bluebird to promisify the database object.

And here's how it's used. It returns a promise! The benefit here is that not only does it return the clutter of callback hell, it makes sure that your code runs asynchronously and the function does not return before things have stopped processing, like in this case, a database query.

function login(user) {
    //check for player existance
    var query = 'SELECT p.name,p.password,p.id, pd.x, pd.y FROM player p INNER JOIN player_data pd ON p.id = pd.id WHERE p.name='+mysql.escape(user);
    return db.select(query).then(function(rows) {
        if (!rows.length) return;
        return [
            rows[0]
        ];
    });
}

Notice how you return a promise, so that you call the then or spread method to get those database values you just queried, not having to worry about if rows will be undefined by the time you want to use it.

Can you explain this a bit simpler or modify my code to work with promises? I spent the last hour reading about them and I am still utterly confused. — Franz Payer, Apr 18 '14 at 06:40

score 0 · Answer 2 · edited May 23 '17 at 12:22

As you say, you need to wrap the entire server in a callback. Node.js works this way, it's asynchronous by nature. A server needs to pass through 3 stages: init, serve and deinit. In your case, that database code goes inside the init stage. You could write something like this.

//server.js
var utils = require ("./modules/utils");

var init = function (cb){
  //init the utils module, the http server and whatever you need
  utils.init (function (error){
    if (error) return handleError (error);
    cb ();
  });
};

var serve = function (){
  //Start listening to the http requests
};

var deinit = function (cb){
  //This is typically executed when a SIGINT is received, see link1
};

init (serve);

//utils.js
//You could write a wrapper for the db instance, see link2
var mongodb = require ("mongojs");
var db;

module.exports.init = function (cb){
  db = mongodb.connect ("localhost", ["modules"]);
  db.modules.find ({}, function (err, modules){
    if (err) return cb (err);
    cb (null, modules);
  });
};

I don't recommend using promises, they are slower than raw callbacks. You don't need them at all.

link1 - SIGINT
link2 - db wrapper

"I don't recommend using promises, they are slower than raw callbacks. You don't need them at all." promotes premature optimization in lieu of known good practices (i.e. promises) — Juan Campa, Sep 28 '15 at 17:39
Using callbacks it's not an optimization, it's the way javascript works. — Gabriel Llamas, Sep 29 '15 at 17:42

Nodejs delay return for "require"

2 Answers2