Promise.map

index.js

// add Promise.map that resolves your promises in a map.
Object.assign(Promise, {
  map: function(objectPromiseMap) {
    var keys = Object.keys(objectPromiseMap);
    return new Promise(function(resolve) {
      Promise.all(
        keys.map(function(key) {
          return objectPromiseMap[key].catch(function(error) {
            return Promise.resolve(error);
          });
        })
      ).then(function(promiseResultList) {
        resolve(
          promiseResultList.reduce(function(target, promiseResult, index) {
            target[keys[index]] = promiseResult;
            return target;
          }, {})
        );
      });
    });
  }
});

// alternative 2 returns a a promise map with errors array
Object.assign(Promise, {
  map2: function(objectPromiseMap) {
    var keys = Object.keys(objectPromiseMap);
    var target = { errors: [] };
    return new Promise(function(resolve) {
      Promise.all(
        keys.map(function(key) {
          return objectPromiseMap[key].catch(function(error) {
            target.errors.push(error);
            return Promise.resolve(undefined);
          });
        })
      ).then(function(promiseResultList) {
        resolve(
          promiseResultList.reduce(function(_target, promiseResult, index) {
            _target[keys[index]] = promiseResult;
            return _target;
          }, target)
        );
      });
    });
  }
});

index.spec.js

require("./index.js");
var assert = require("assert");

describe("Promise.map", () => {
  it(" should be able to resolve promise and errors in a map", done => {
    Promise.map({
      promise_one: new Promise(resolve => {
        resolve("promise 1 success");
      }),
      promise_two: new Promise((resolve, reject) => {
        reject(new Error("promise 2 fails"));
      }),
      promise_three: new Promise((resolve, reject) => {
        setTimeout(() => {
          reject(new Error("promise 3 fails"));
        }, 200);
      }),
      promise_four: new Promise(resolve => {
        setTimeout(() => {
          resolve("promise 4 success");
        }, 200);
      })
    }).then(resolve => {
      assert(
        resolve.promise_one === "promise 1 success",
        "expected 'promise 1 success' got " + resolve.promise_one
      );
      assert(
        resolve.promise_two instanceof Error,
        "expected 'instanceof Error' got " + typeof resolve.promise_two
      );
      assert(
        resolve.promise_three instanceof Error,
        "expected 'instanceof Error' got " + typeof resolve.promise_three
      );
      assert(
        resolve.promise_four === "promise 4 success",
        "expected 'promise 4 success' got " + resolve.promise_four
      );
      done();
    });
  });
});

describe("Promise.map2", () => {
  it(" should be able to resolve promise and errors in a map", done => {
    Promise.map2({
      promise_one: new Promise(resolve => {
        resolve("promise 1 success");
      }),
      promise_two: new Promise((resolve, reject) => {
        reject(new Error("promise 2 fails"));
      }),
      promise_three: new Promise((resolve, reject) => {
        setTimeout(() => {
          reject(new Error("promise 3 fails"));
        }, 200);
      }),
      promise_four: new Promise(resolve => {
        setTimeout(() => {
          resolve("promise 4 success");
        }, 200);
      })
    }).then(resolve => {
      assert(
        resolve.promise_one === "promise 1 success",
        "expected 'promise 1 success' got " + resolve.promise_one
      );
      assert(
        typeof resolve.promise_two === "undefined",
        "expected 'undefined' " + resolve.promise_two
      );
      assert(
        typeof resolve.promise_three === "undefined",
        "expected 'undefined' " + resolve.promise_three
      );
      assert(
        resolve.promise_four === "promise 4 success",
        "expected 'promise 4 success' got " + resolve.promise_four
      );
      done();
    });
  });
});