Folha de dicas da biblioteca de promessas Bluebird.js

Bluebird Bluebird é uma biblioteca de promessas de alto desempenho e repleta de recursos para JavaScript e Node.js.

Visão geral de encadeamento de métodos

promise
  .then(okFn, errFn)
  .spread(okFn, errFn)        // * Desempacota array em argumentos individuais
  .catch(errFn)
  .catch(TypeError, errFn)    // * Captura de erro filtrada por tipo
  .finally(fn)
  .map(function (e) { /* ... */ })  // * Iteração concorrente
  .each(function (e) { /* ... */ }) // * Iteração sequencial

Os métodos marcados com * são extensões exclusivas do Bluebird que vão além da especificação ES6.

Múltiplos argumentos e desempacotamento (Promise.spread)

Promise.resolve(['foo', 'bar'])
  .spread((item1, item2) => {
    console.log(item1, item2); // 'foo', 'bar'
  });

Consulte: Documentação do Promise.spread: Promise.spread

Combinando promessas independentes (Promise.join)

Coordena múltiplas promessas independentes com uma assinatura fixa:

Promise.join(
  getPictures(),
  getMessages(),
  getTweets(),
  (pics, msgs, tweets) => {
    return { pics, msgs, tweets };
  }
);

Consulte: Documentação do Promise.join: Promise.join

Métodos de coleções de arrays

Promise.all([p]): Resolve quando todas as promessas são concluídas com sucesso, ou rejeita no primeiro erro.
Promise.some([p], count): Resolve quando uma quantidade específica de promessas é concluída com sucesso.
Promise.any([p]): Resolve assim que qualquer promessa individual é concluída com sucesso.
Promise.map(array, fn, { concurrency: 5 }): Mapeia elementos com concorrência controlada.

Promise.map(urls, url => fetch(url), { concurrency: 3 })
  .then(responses => {
    // Processar respostas com no máximo 3 requisições simultâneas
  });

Promessas em objetos (Promise.props)

Resolve um objeto contendo promessas em um objeto com as propriedades resolvidas:

Promise.props({
  photos: getPhotos(),
  posts: getPosts()
}).then(result => {
  console.log(result.photos, result.posts);
});

Promisificação (Promisification)

Converte funções com callbacks tradicionais do Node.js em promessas modernas:

const fs = require('fs');
const Promise = require('bluebird');

// Promisificar uma única função
const readFile = Promise.promisify(fs.readFile);

// Promisificar um módulo inteiro
Promise.promisifyAll(fs);
// Agora fs.readFileAsync está disponível para uso imediato

Corrotinas (Generators)

const loginUser = Promise.coroutine(function* (email, password) {
  const user = yield User.findOne({ email }).exec();
  const valid = yield user.comparePassword(password);
  if (!valid) throw new Error('Invalid credentials');
  return user;
});