Node.js - Inserting into MongoDB with a callback

What's the size of this items collection? Can it exceed the callstack size? To get your current size run:

node --v8-options | grep -B0 -A1 stack_size

The default size is 492 kB (for 32-bit) and 984 kB (for 64-bit).

To increase your callstack size try starting node with parameter:

node --max-stack-size={your-desired-size-in-bytes}

Take into consideration that node might not have time to clear callstack between each waterfall callback. Try to run callback on nextTick:

async.waterfall([
    function(callback) {
      request.get(apiUrl, function(error, response, body) {
        if (!error && response.statusCode == 200) {
          data = JSON.parse(body);
          callback(error, data.items);
        }
      });
    },
    function(data, callback) {
      removeInvalidItems(data);
      var items = convertToObj(data);
      process.nextTick(function() {   // callback on next tick
          callback(null, items);
      });
    },
    function(items, callback) {
      console.log(items);
      // Insert to collection here
    }
], function (err, result) {
    // do something here
});

All callbacks should be called for every task of async.waterfall(). It is called ONLY in successful case of your 1st waterfall task... and it's not called at all in the 3rd waterfall task.

There is no callback for these 2 calls:

removeInvalidItems(data);
items = convertToObj(data);

so I'm assuming they are not asynchronous. And since they are not async, you don't have to put them as a separate task for async.waterfall(). So here is the revised code (I'm assuming that your data conversion is correct):

async.waterfall([
    function(callback) {
        request.get(apiUrl, function(error, response, body) {
            var data;
            if (!error && response.statusCode == 200) {
                data = JSON.parse(body);
                return callback(null, data.items);
            }
            callback(error || response); // error or statusCode !== 200
        });
    },
    function(data, callback) {
        var items;

        // There is no callback for these, so I'm assuming they are not asynchronous
        removeInvalidItems(data);
        items = convertToObj(data);

        MongoClient.connect(config.db, function(err, db) {
            if (err) {
                console.log(err);
                return callback(err);
            }
            console.log("Connected correctly to server");
            db.collection('items').insert(items, function(err, result) {
                if (err || !result) {
                    console.log(err);
                    db.close();
                    return callback(err || {message: 'There is a problem inserting.'});
                }
                db.close();
                callback(null);
            });
        });
    }
], function (err, result) {
    if (err) {
        console.log(err);
    } else {
        console.log('done');
    }
});

I have found the answer to my own question here. The issue was that when I was bulk inserting data into MongoDB, I was receiving the Maximum call stack size exceeded error. The array of data I was using when running db.collection('something').insert(data, function().... was an array of Users according to a Mongoose Schema called User, so each item in this data array was created as var item = new User({});. Apparently, MongoDB did not like this. I assumed it would be the correct way to insert the data as in production this is how I would be using the data (using User objects).

To rectify the issue, I simply replaced var item = new User({}) with var item = {} so that I was just creating a new JavaScript object. This worked fine and inserted the data into the database, in the correct order, with no errors. Thanks to the people who wrote other answers, I have used those to fix and improve my callbacks!