I have a python background and is currently migrating to node.js. I have problem adjusting to node.js due to its asynchronous nature.
For example, I am trying to return a value from a MySQL function.
function getLastRecord(name) { var connection = getMySQL_connection(); var query_str = "SELECT name, " + "FROM records " + "WHERE (name = ?) " + "LIMIT 1 "; var query_var = [name]; var query = connection.query(query_str, query_var, function (err, rows, fields) { //if (err) throw err; if (err) { //throw err; console.log(err); logger.info(err); } else { //console.log(rows); return rows; } }); //var query = connection.query(query_str, function (err, rows, fields) { } var rows = getLastRecord('name_record'); console.log(rows);
After some reading up, I realize the above code cannot work and I need to return a promise due to node.js's asynchronous nature. I cannot write node.js code like python. How do I convert getLastRecord() to return a promise and how do I handle the returned value?
In fact, what I want to do is something like this;
if (getLastRecord() > 20> { console.log("action"); }
How can this be done in node.js in a readable way?
I would like to see how promises can be implemented in this case using bluebird.
5 Answers
Answers 1
This is gonna be a little scattered, forgive me.
First, assuming this code uses the mysql driver API correctly, here's one way you could wrap it to work with a native promise:
function getLastRecord(name) { return new Promise(function(resolve, reject) { // If you use bluebird, it comes with a Promise.try helper // for avoiding this. The *point* of this try is to make // sure that all errors get handled by the promise chain. // Functions using nodebacks have a concept of "unchecked" // errors that get thrown rather than passed to the callback // but this is considered Bad Form in promise-land try { var connection = getMySQL_connection(); var query_str = "SELECT name, " + "FROM records " + "WHERE (name = ?) " + "LIMIT 1 "; var query_var = [name]; connection.query(query_str, query_var, function (err, rows, fields) { // Call reject on error states, // call resolve with results if (err) { return reject(err); } resolve(rows); }); } catch (err) { reject(err); } }); } getLastRecord('name_record').then(function(rows) { // now you have your rows, you can see if there are <20 of them }).catch((err) => setImmediate(() => { throw err; })); // Throw async to escape the promise chain
So one thing: You still have callbacks. Callbacks are just functions that you hand to something to call at some point in the future with arguments of its choosing. So the function arguments in xs.map(fn), the (err, result) functions seen in node and the promise result and error handlers are all callbacks. This is somewhat confused by people referring to a specific kind of callback as "callbacks," the ones of (err, result) used in node core in what's called "continuation-passing style", sometimes called "nodebacks" by people that don't really like them.
For now, at least (async/await is coming eventually), you're pretty much stuck with callbacks, regardless of whether you adopt promises or not.
Also, I'll note that promises aren't immediately, obviously helpful here, as you still have a callback. Promises only really shine when you combine them with Promise.all and promise accumulators a la Array.prototype.reduce. But they do shine sometimes, and they are worth learning.
Answers 2
You don't need to use promises, you can use a callback function, something like that:
function getLastRecord(name, next) { var connection = getMySQL_connection(); var query_str = "SELECT name, " + "FROM records " + "LIMIT 1 "; var query_var = [name]; var query = connection.query(query_str, query_var, function (err, rows, fields) { //if (err) throw err; if (err) { //throw err; console.log(err); logger.info(err); next(err); } else { //console.log(rows); next(null, rows); } }); //var query = connection.query(query_str, function (err, rows, fields) { } getLastRecord('name_record', function(err, data) { if(err) { // handle the error } else { // handle your data } });
Answers 3
I have modified your code to use Q(NPM module) promises. I Assumed your 'getLastRecord()' function that you specified in above snippet works correctly.
You can refer following link to get hold of Q module
Click here : Q documentation
var q = require('q'); function getLastRecord(name) { var deferred = q.defer(); // Use Q var connection = getMySQL_connection(); var query_str = "SELECT name, " + "FROM records " + "WHERE (name = ?) " + "LIMIT 1 "; var query_var = [name]; var query = connection.query(query_str, query_var, function (err, rows, fields) { //if (err) throw err; if (err) { //throw err; deferred.reject(err); } else { //console.log(rows); deferred.resolve(rows); } }); //var query = connection.query(query_str, function (err, rows, fields) { return deferred.promise; } // Call the method like this getLastRecord('name_record') .then(function(rows){ // This function get called, when success console.log(rows); },function(error){ // This function get called, when error console.log(error); });
Answers 4
To answer your initial question: How can this be done in node.js in a readable way?
There is a library called co, which gives you the possibility to write async code in a synchronous workflow. Just have a look and npm install co.
The problem you face very often with that approach, is, that you do not get Promise back from all the libraries you like to use. So you have either wrap it yourself (see answer from @Joshua Holbrook) or look for a wrapper (for example: npm install mysql-promise)
(Btw: its on the roadmap for ES7 to have native support for this type of workflow with the keywords async await, but its not yet in node: node feature list.)
Answers 5
This can be achieved quite simply, for example with bluebird, as you asked:
var Promise = require('bluebird'); function getLastRecord(name) { return new Promise(function(resolve, reject){ var connection = getMySQL_connection(); var query_str = "SELECT name, " + "FROM records " + "WHERE (name = ?) " + "LIMIT 1 "; var query_var = [name]; var query = connection.query(query_str, query_var, function (err, rows, fields) { //if (err) throw err; if (err) { //throw err; console.log(err); logger.info(err); reject(err); } else { resolve(rows); //console.log(rows); } }); //var query = connection.query(query_str, function (err, rows, fields) { }); } getLastRecord('name_record') .then(function(rows){ if (rows > 20) { console.log("action"); } }) .error(function(e){console.log("Error handler " + e)}) .catch(function(e){console.log("Catch handler " + e)});