Forma simples de reduzir o boilerplate de promises em JS

function sayMyName (firstName, lastName, callback) {
  const jessy = "Jessy";
  console.log(`${firstName} ${lastName}`);
  callback(jessy);
}

sayMyName("Walter", "White", function (person) { // Callbacks podem ser executadas direto na chamada ou passadas como valor
  console.log(`You're goddamn right, ${person}`)
});

// Walter White
// You're goddamn right, Jessy

function reqListener () {
  console.log(this.responseText);
}

var xhr = new XMLHttpRequest();
xhr.addEventListener("load", reqListener); // Executa o callback assim que o evento é chamado
xhr.open("GET", "http://www.example.org/example.txt");
xhr.send();

exports.ordersHistory = (rows, count) => {
  const orders = rows.map( order => {
    return order.getProducts()
    .then( products => Object.assign({}, order.toJSON(), { product: products.find( i => i) }));
  }); // Contém um array de promises

  return Promise.all(orders) // Aqui contém um array de pedidos já resolvidos
  .then( returnedOrders => {

    const theOrders = returnedOrders.map( ord => {
      return OrderStatus.findById(ord.orderStatusId)
      .then( orderStatus => {
        const query = {
          where: { ProductId: ord.product.id }
        };
        return ProductUrl.findAll(query)
        .then( images => {
          const product = ord.product.toJSON();
          product.images = images.map( i => i.toJSON());
          return Object.assign({}, ord, { orderStatus: orderStatus.toJSON() }, { product });
        }); // product
      }); // orderStatus
    }); // ord
    return Promise.all(theOrders);
  });
}

...
doPayment: req => {
  const { body } = req;
  const { productId, UserId, productQuantity, mercadoPago, shippingType } = body;
  const { doPayment } = require('../MercadoPago/mercadoPago.model');

  const shippingAmount = Number(body.shippingAmount.includes(',') ? body.shippingAmount.replace(',', '.') : body.shippingAmount);
  const shippingDays = Number(body.shippingDays);

  return startTransaction( async ( transaction => {

    let response;
    try {
      const user = await (sequelize.models.User.findById(UserId, { transaction }));

      const addresses = await (user.getAddresses());
      if (addresses.length !== 2 ) throw 'Complete o seu cadastro!';

      const product = await (Product.findById(productId, { transaction }));

      const canBuy = await (user.canBuyProduct(product, transaction));

      if (!canBuy) throw 'Você já está em processo de pagamento. Aguarde até 10 minutos e tente novamente.';

      const currentProduct = await (Product.getCurrentProductWithoutStatus(transaction));

      console.log(`Product Quantity -> ${productQuantity}`);
      console.log(`Product -> ${product.id} | currentProduct -> ${currentProduct.id}`);

      if (productQuantity < 0 || productQuantity === undefined) throw 'Quantidade de produtos inválido!';
      if (productQuantity > currentProduct.purchaseLimit) throw 'Quantidade selecionada maior do que o limite por usuário';
      if (_.isEmpty(currentProduct) || product.id !== currentProduct.id) throw 'Parece que este produto não está mais ativo';
      if (currentProduct.stockQty <= 0) {
        const isAbleToQueue = await (user.isAbleToQueue(currentProduct, transaction));

        if (!isAbleToQueue) throw 'Todos os produtos foram vendidos. Você já está na fila de espera, aguarde para ser notificado caso haja desistência (:';
        else throw 'sendNotification';
      }

      response = await (doPayment(mercadoPago));
      const status = response.status;
      const billingTrackingNumber = response.id;

      const userStatistics = await (sequelize.models.UserStatistics.getByUser(user, transaction));

      const analytics = await (sequelize.models.Analytics.getTodaysAnalytics(transaction));

      //passou nas validações -> criar order
      const newOrder = Object.assign(
        {},
        _.omit(body, ['productQuantity', 'productId', 'mercadoPago', ]),
        { totalAmount: parseFloat((currentProduct.discountedPrice * productQuantity) + shippingAmount) },
        { paymentTime: new Date() }, { inQueue: false }, { billingTrackingNumber }
      );

      const order = await (Order.create(newOrder, { transaction }));

      const orderItem = {
        OrderId: order.id,
        ProductId: product.id,
        productQuantity: productQuantity
      };

      const createdOrderItem = await (OrderItem.create(orderItem, { transaction }));

      const orderStatus = await (OrderStatus.getByDescription(status, { transaction }));

      await (order.setOrderStatus(orderStatus.id, { transaction }));

      if (status !== 'rejected') {
        // Decrement no estoque
        await (currentProduct.decrement('stockQty', { transaction, by: productQuantity }));
        // Incrementando o total de compras
        await (currentProduct.increment('totalBought', { transaction, by: productQuantity }));
        // Incrementando o total economizado pelo user
        await (user.increment('totalSaved', { transaction, by: Number(currentProduct.storePrice - currentProduct.discountedPrice)}));
        // Incrementando o total compartilhado pelo user
        await (user.increment('totalBought', { transaction, by: productQuantity }));
        // Incrementando o total de compras do user
        await (userStatistics.increment('totalBought', { transaction, by: productQuantity }));
        // Incrementando o total de compras no total
        await (analytics.increment('totalBought', { transaction, by: productQuantity }));
        await (analytics.increment('totalAmount', { transaction, by: order.totalAmount }));
      }

    } catch (err) {
      console.log(err);
      throw err;
    }
    // Se o response vier com sucesso, commit no transaction, senão 'throw err';
    return response;
  }));
}
...