how to can i handle multiple callbacks return values in nodejs?

The promise resolve function takes only one input argument, so if you need to pass in multiple stuff, you have to enclose them in a single object. Like, if you have to go with something like:

database.openCollection()
    .then(function(collection){
        var result = collection.query(something);
        var resultObject = { result: result, collection: collection };
    })
    .then(function(resultObject){
        doSomethingSyncronousWithResult(resultObject.result);
        resultObject.collection.close();
    });

You can't use Promise all if all of your stuff isn't a result of a promise resolve, you might need to go with something like this.

Disclaimer: The code example is a very poor one, but it explains the concept.

I would suggest you to learn about Promises, particularly Bluebird. You can promisify traditional callback methods.

I would also create model level functions in different files. Here's an example.

parent.js

const db = require("./connections/database");  // connection to database

const getChildForParent = function (parentId, childId, callback) {
    db.find({parent: parentId, child_id: childId}, "childrenTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

children.js

const db = require("./connections/database");  // connection to database

const getToysForChild = function (childId, callback) {
    db.find({toy_belongs_to: parentId}, "toysTable", function(err, result) {
        if (err) {
            return callback(err);
        }
        return callback(null, result);
    });
};

Then in controller you can do something like this:

const Bluebird = require("bluebird");
const Parent = require("./parent.js");
const Child = require("./child.js");

// Promisifying adds "Async" at the end of your methods' names (these are promisified)
Bluebird.promisifyAll(Parent); 
Bluebird.promisifyAll(Child);

// Just an example.
app.get("/parent/:parentId/children/:childId", function(req, res) {
    return Bluebird.try(function() {
         return User.getChildForParentAsync(req.params.parentId, req.params.childId);
    }).then(function(child) {
       return Child.getToysForChildAsync(child.child_id);
    }).then(function(toys) {
       // Do something with toys.
    });
});

Of course you can do much more with this and this is not the only way.

Also you can use Promise.all(). This method is useful for when you want to wait for more than one promise to complete.

Let's say you have a list of urls that you want to fetch and process the results after all the data has been fetched.

var urls = [url1, url2, url3, url4, url5 .......... ];
var Bluebird = require("bluebird");
var request = require("request"); // callback version library

Bluebird.promisifyAll(request);

// create a list which will keep all the promises
var promises = [];

urls.forEach(function(url) {
    promises.push(request.getAsync(url1));
});

// promises array has all the promises
// Then define what you want to do on completion.

Bluebird.all(promises).then(function(results) {
    // results is an array with result a url in an index

    // process results.
});

I would recommend to use Promises to solve that. If you need all results of all Requests, when they are all done Promise.all() will do that for you. Your basic could look like that:

var req1 = new Promise(function(res, rej){
    var req = new XMLHttpRequest()
    …
    req.addEventListener('load', function (e) {
        res(e);
    })

var req2 = //similar to the above

Promise.all([req1, req2, …]).then(function(values){
  //all requests are done here and you can do your stuff
});

You can also use the new fetch api, which creates Promises like so:

var req1 = fetch(…);
var req2 = fetch(…);
Promise.all([req1, re2, …]).then(…);