I am not going to highlight pros of promises and cons of callbacks. There is plenty of good reading about this topic out there. I was recently writing simple Node module and decided to learn promises during its implementation. The result\u00a0 can be interesting as comparison of Promises vs Callbacks approach applied to the same problems, because project contains<\/p>\n
These are glued with Gulp build system to execute tests with all possible combinations. So for example Callbacks based test is executed also against Promises based module.<\/p>\n
I named the project Jasstor<\/strong>. I am planning to use it for storage credentials into JSON file, hashing and verification of credentials<\/a>. It stores user name, hashed password and user\u2019s role in string format. Here is Github branch dedicated to this blog post<\/a>, so that it\u2019ll stay consistent. Please bear in mind, that I am learning Node development, ES6 features, Promises and Gulp on this project. So I could easily miss handy tricks or misused some features.<\/p>\n Project uses these main technologies:<\/p>\n I decided to have these constraints for Promises<\/p>\n When function signatures follow Node JS patters, it allows for promisification of modules<\/a>. Such modules can be integrated into promise chain easily. But at the same time API isn\u2019t tied to Promises at all. I like this approach because both camps (Promises or Callbacks fans) are happy.<\/p>\n Let\u2019s take a look at code. I will explain and compare only most verbose use case and leave the rest for curios readers. You can find the code here<\/a>.<\/p>\n Enough talking, let\u2019s take a look at code. I\u2019ll start with tests explanation as it promotes TDD thinking. Use case should test if existing password is overwritten when credentials for same user are stored. There are these phases in the test:<\/p>\n Important here is promisification<\/a> of It was slight surprise to me that Promises actually doesn\u2019t enable for less verbose code. Few facts are pretty obvious to me after this comparison:<\/p>\n Now I am going to compare code that was tested by tests above.<\/p>\n Here we have ES6 class Same implementation packed into Promises is more verbose (hopefully I missed some tricks that could made it shorter). I like again simplified\u00a0error handling. You maybe spot\u00a0 that Promises are very nice approach that could totally change style of your programming. But I have to admit that I am not 100% sold to it yet. It took me some time to wrap my head around the concept. Promises also seem to me slightly more verbose than callbacks. When you have functions with one parameter and return value, you can nicely chain them with just passing function references into Promise chain. But mostly you don\u2019t have such comfortable APIs and you end up doing \u201cflattened callbacks pyramid\u201d.<\/p>\n I would suggest to try Promises on your project (or small library) and make own opinion. Examples aren\u2019t enough challenging to push the Promises into its limits.<\/p>\n\n
\n
describe<\/code><\/strong> and it<\/code><\/strong> will be used with callbacks.<\/li>\n\n
Callback vs Promises \u2013 Tests comparison<\/h2>\n
\n
Callbacks based test<\/a><\/h2>\n
var credentialsFile = 'testCredentials.txt';\r\n\r\nvar checkError = function(err, done) {\r\n if (err) {\r\n done(err);\r\n }\r\n};\r\n\r\nvar readPassword = (credentialsFile, done, callback) => {\r\n fs.readFile(credentialsFile, (err, data) => {\r\n checkError(err, done);\r\n var jsonData = JSON.parse(data);\r\n callback(jsonData.user.password);\r\n });\r\n};\r\ndescribe('jasstor', () => {\r\n var jasstor = new Jasstor(credentialsFile);\r\n\r\n describe('when creadentials file already exist', () => {\r\n beforeEach(done => {\r\n fs.unlink(credentialsFile, () => {\r\n jasstor.saveCredentials('user', 'password', 'role', done);\r\n });\r\n });\r\n\r\n it('should overwrite existing password', done => {\r\n readPassword(credentialsFile, done, (originalPassword) => {\r\n jasstor.saveCredentials('user', 'password1', 'role', err => {\r\n checkError(err, done);\r\n readPassword(credentialsFile, done, (newPassword) => {\r\n newPassword.should.be.ok;\r\n originalPassword.should.be.ok;\r\n newPassword.should.not.equal(originalPassword);\r\n done();\r\n });\r\n });\r\n });\r\n });\r\n });\r\n});<\/pre>\njasstor<\/strong><\/code> is testing object and jasstor.saveCredentials()<\/strong><\/code> is testing function. There is created helper function readPassword<\/code><\/strong> because password needs to be read twice during test. Pretty straight forward callbacks pyramid. I don\u2019t like calling checkError<\/code><\/strong><\/code> at the beginning of each callback. Annoying Node pattern.<\/p>\nPromises based test<\/a><\/h2>\n
var fs = Bluebird.promisifyAll(require('fs'));\r\nvar credentialsFile = 'testCredentials.txt';\r\n\r\nvar readPassword = (credentialsFile, userName, done) => {\r\n return fs.readFileAsync(credentialsFile)\r\n .then(JSON.parse)\r\n .then(jsonData => {\r\n return jsonData[userName].password;\r\n }).catch(done);\r\n};\r\n\r\nvar ignoreCallback = () => {};\r\n\r\ndescribe('jasstor tested with promises', () => {\r\n var jasstor = Bluebird.promisifyAll(new Jasstor(credentialsFile));\r\n\r\n describe('when creadentials file already exist', () => {\r\n beforeEach(done => {\r\n fs.unlinkAsync(credentialsFile)\r\n .finally(() => {\r\n jasstor.saveCredentials('user', 'password', 'role', done);\r\n }).catch(ignoreCallback);\r\n });\r\n\r\n it('should overwrite existing password', done => {\r\n var originalPassword = readPassword(credentialsFile, 'user', done);\r\n var newPassword;\r\n jasstor.saveCredentialsAsync('user', 'password1', 'role')\r\n .then(() => {\r\n newPassword = readPassword(credentialsFile, 'user', done);\r\n newPassword.should.be.ok;\r\n originalPassword.should.be.ok;\r\n newPassword.should.not.equal(originalPassword);\r\n done();\r\n }).catch(done);\r\n });\r\n });\r\n});<\/pre>\nfs<\/strong><\/code> library (first line). It patches fs<\/code><\/strong> module to have additional methods with Async<\/strong><\/code> suffix. These methods return Promise and doesn\u2019t take callback as parameter. This effectively converts existing API to promise based API. Same is done to testing object jasstor<\/code><\/strong>.<\/p>\n\n
catch<\/code><\/strong> block as function reference.<\/li>\nCallback vs Promises \u2013 Node module comparison<\/h2>\n
Callbacks based code<\/a><\/h2>\n
var hashPassword = (password, callback) => {\r\n bcrypt.genSalt(10, (err, salt) => bcrypt.hash(password, salt, callback));\r\n};\r\n\r\nvar readJsonFile = (storageFile, callback) => {\r\n fs.exists(storageFile, (result) => {\r\n if (result === false) {\r\n callback(null, {});\r\n } else {\r\n fs.readFile(storageFile, (err, data) => {\r\n var jsonData = JSON.parse(data);\r\n callback(err, jsonData);\r\n });\r\n }\r\n });\r\n};\r\n\r\nmodule.exports = class Jasstor {\r\n constructor(storageFile) {\r\n this.storageFile = storageFile;\r\n }\r\n\r\n saveCredentials(user, password, role, callback) {\r\n readJsonFile(this.storageFile, (err, jsonData) => {\r\n hashPassword(password, (err, hash) => {\r\n jsonData[user] = {\r\n password: hash,\r\n role: role\r\n };\r\n var jsonDataString = JSON.stringify(jsonData);\r\n\r\n fs.writeFile(this.storageFile, jsonDataString, callback);\r\n });\r\n });\r\n }\r\n};<\/pre>\nJasstor<\/strong><\/code> with constructor and method that saves credentials into JSON file. There are two helper methods hashPassword<\/code><\/strong> and readJsonFile<\/strong><\/code> to help with repetitive tasks across the Jasstor<\/code><\/strong> class. We can see callback pyramid again. It is slightly simplified by helper functions.<\/p>\nPromises based code<\/a><\/h2>\n
var fs = Bluebird.promisifyAll(require('fs'));\r\nvar bcrypt = Bluebird.promisifyAll(require('bcrypt'));\r\n\r\nvar hashPassword = password => {\r\n return new Promise(resolve => {\r\n bcrypt.genSaltAsync(10)\r\n .then(salt => {\r\n return bcrypt.hashAsync(password, salt);\r\n }).then(resolve);\r\n });\r\n};\r\n\r\nvar readJsonFile = storageFile => {\r\n return new Promise((resolve, reject) => {\r\n fs.exists(storageFile, result => {\r\n if (result === true) {\r\n fs.readFileAsync(storageFile)\r\n .then(JSON.parse)\r\n .then(resolve)\r\n .catch(reject);\r\n } else {\r\n resolve({});\r\n }\r\n });\r\n });\r\n};\r\n\r\nmodule.exports = class Jasstor {\r\n constructor(storageFile) {\r\n this.storageFile = storageFile;\r\n }\r\n\r\n saveCredentials(user, password, role, callback) {\r\n readJsonFile(this.storageFile).then(jsonData => {\r\n hashPassword(password).then(hash => {\r\n jsonData[user] = {\r\n password: hash,\r\n role: role\r\n };\r\n return jsonData;\r\n }).then(JSON.stringify)\r\n .then(jsonDataString => {\r\n fs.writeFile(this.storageFile, jsonDataString, callback);\r\n }).catch(callback);\r\n }).catch(callback);\r\n }\r\n};<\/pre>\nfs.exists<\/code><\/strong> isn\u2019t promisified. If you take a look at its API<\/a>, callback doesn\u2019t have error as first parameter. I suspect, this is why fs.existsAsync<\/code><\/strong> doesn\u2019t work correctly. Not sure if this is limitation of Bluebird promises library I am using or Promises A+ specification.<\/p>\nConclusion<\/h2>\n