Using async/await + Bluebird to promisifyAll

Question

I'm constructing a library that uses async/await, and i would like to know if it is possible to use native modules like fs with the async/await. I know that async/await it's just Promises in the background, so... is there a native way to promisify a method or function? Currently i'm using the Bluebird, but i don't know if it's a bad pattern. Example:

const Bluebird = require("bluebird");
const { access } = require("fs");

const accessAsync = Bluebird.promisify(access);

async function checkInput(options) {
  await accessAsync(options.file);
  /// etc
  return options;
}

module.exports = (options) => {
  Promise.resolve(options)
    .then(checkInput)
};

I'm combining both native Promises and Bluebird. Should i only use Bluebird?

Thanks.

Answer 1

By all means, bluebird is designed to work with native promises. The use case you describe is not only supported - but is a design goal of Bluebird.

Bluebird's promises implement then according to the Promises/A+ spec, which is guaranteed to work with await. Moreoever, you can pass native promises to bluebird and it'll work just fine.

Answer 2

Using Bluebird as well as Promises is only increasing your over head. means bluebird is sufficient enough to handle other promises.

Thanks

Answer 3

I'm constructing a library that uses async/await, and i would like to know if it is possible to use native modules like fs with the async/await.

Yes. You can do it even simpler with Bluebird than in your example:

let fs = Promise.promisifyAll(require('fs'));

// and in async function:
let contents = await fs.readFileAsync('file.txt', 'utf-8');

Note that you need to add Async at the end of the method names.

Or you can use the mz module, without needing to add Async to the methods. See:

• https://www.npmjs.com/package/mz

There are many modules that you can require once you npm install mz - for example you can require('mz/fs') and it instantly lets you use the fs module version that returns promises instead of taking callbacks. Combined with async await it lets you do things like:

let fs = require('mz/fs');

// and in async function:
let contents = await fs.readFile('file.txt', 'utf-8');

The above code is still non-blocking.

See this answer where I show an example of mz version of the crypto module and explain it in more detail:

• Which functions could work as synchronous in node.js?

See example:

let crypto = require('mz/crypto');

async function x() {
  let bytes = await crypto.randomBytes(4);
  console.log(bytes);
}

You can do the same with many other modules, including:

• child_process
• crypto
• dns
• fs
• readline
• zlib

I know that async/await it's just Promises in the background, so... is there a native way to promisify a method or function?

Soon Node will support that natively - see PR #5020 Adding Core support for Promises:

• https://github.com/nodejs/node/pull/5020

but in the meantime you can use mz.

For more context see also the Issue #7549 v1: executing async functions without callbacks should return promises:

• https://github.com/nodejs/node-v0.x-archive/issues/7549

See also the Node's Promises Working Group Repository:

• https://github.com/nodejs/promises

Update: It seems that the PR 5020 mentioned above is not going to land in Node any time soon - thanks to Benjamin Gruenbaum for pointing it out in the comments. So it seems that using Bluebird's promisify and promisifyAll and the helpful mz module will be the only easy way to use modern features of the language with the core modules of Node. Fortunately they work very well so it's not a big problem.