Hoja de trucos de la biblioteca de promesas Bluebird.js

Bluebird Bluebird es una biblioteca de promesas de alto rendimiento y repleta de funciones para JavaScript y Node.js.

Resumen de encadenamiento de métodos

promise
  .then(okFn, errFn)
  .spread(okFn, errFn)        // * Desempaqueta array en argumentos
  .catch(errFn)
  .catch(TypeError, errFn)    // * Captura de error filtrada por tipo
  .finally(fn)
  .map(function (e) { /* ... */ })  // * Iteración concurrente
  .each(function (e) { /* ... */ }) // * Iteración secuencial

Los métodos marcados con * son extensiones específicas de Bluebird que amplían el estándar ES6.

Múltiples argumentos y desempaquetado

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

Ver: Documentación de Promise.spread: Promise.spread

Combinar promesas independientes (Promise.join)

Coordina múltiples promesas independientes con una función combinadora:

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

Ver: Documentación de Promise.join: Promise.join

Métodos de colecciones de arrays

Promise.all([p]): Se resuelve cuando todas las promesas finalizan con éxito, o rechaza al primer error.
Promise.some([p], count): Se resuelve cuando un número determinado de promesas finaliza.
Promise.any([p]): Se resuelve tan pronto como cualquier promesa individual se completa con éxito.
Promise.map(array, fn, { concurrency: 5 }): Mapea elementos con concurrencia controlada.

Promise.map(urls, url => fetch(url), { concurrency: 3 })
  .then(responses => {
    // Procesar respuestas con un máximo de 3 solicitudes simultáneas
  });

Promesas de objetos (Promise.props)

Resuelve un objeto con propiedades de promesa en un objeto con los valores resueltos:

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

Promisificación (Promisification)

Convierte funciones con callbacks clásicos de Node.js en promesas modernas:

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

// Promisificar una sola función
const readFile = Promise.promisify(fs.readFile);

// Promisificar un módulo completo
Promise.promisifyAll(fs);
// Ahora fs.readFileAsync está disponible para su uso

Corrutinas (Generadores)

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;
});