.js

/* Assuming: */

{
    user: 1,
    paymentMethod: 3
    item: 51,
    date: 1481892890, /* epoch timestamp */
    payments: [{
        payment: 44,
        amountCents: 400,
        states: [1, 3]
    }, {
        payment: 45,
        amountCents: 150
        states: [1]
    }]
}

/* Notes:
   - We're using a simplified order format here, for the sake of simplicity.
   - Object.assign({}, foo, bar) creates a merged (foo, bar) without mutating either of them, by merging them into a new object literal.
*/

/* Example 1: No arrays, transform object */

function asynchronouslyTransformObject(order) {
    return Promise.try(() => {
        return Promise.props(Object.assign({}, order, {
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item)
        }));
    });
}

/* Example 2: No arrays, construct new object */

function asynchronouslyConstructTransformedObject(order) {
    return Promise.try(() => {
        return Promise.props({
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item),
            date: order.date,
            payments: order.payments
        });
    });
}

/* Example 3: Single-depth array, transform object */

function asynchronouslyTransformObject(order) {
    return Promise.try(() => {
        return Promise.props(Object.assign({}, order, {
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item),
            payments: Promise.map(order.payments, (paymentObject) => {
                return Promise.props(Object.assign({}, paymentObject, {
                    payment: getPayment(paymentObject.payment)
                }));
            });
        }));
    });
}

/* Example 4: Single-depth array, construct new object */

function asynchronouslyConstructTransformedObject(order) {
    return Promise.try(() => {
        return Promise.props(Object.assign({}, order, {
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item),
            date: order.date,
            payments: Promise.map(order.payments, (paymentObject) => {
                return Promise.props({
                    payment: getPayment(paymentObject.payment),
                    amountCents: paymentObject.amountCents,
                    states: paymentObject.states
                });
            });
        }));
    });
}

/* Example 5: Multiple-depth array, transform object */

function asynchronouslyTransformObject(order) {
    return Promise.try(() => {
        return Promise.props(Object.assign({}, order, {
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item),
            payments: Promise.map(order.payments, (paymentObject) => {
                return Promise.props(Object.assign({}, paymentObject, {
                    payment: getPayment(paymentObject.payment),
                    states: Promise.map(paymentObject.states, (state) => {
                        return getState(state);
                    })
                }));
            });
        }));
    });
}

/* Example 6: Multiple-depth array, construct new object */

function asynchronouslyConstructTransformedObject(order) {
    return Promise.try(() => {
        return Promise.props(Object.assign({}, order, {
            user: getUser(order.user),
            paymentMethod: getPaymentMethod(order.paymentMethod),
            item: getItem(order.item),
            date: order.date,
            payments: Promise.map(order.payments, (paymentObject) => {
                return Promise.props({
                    payment: getPayment(paymentObject.payment),
                    amountCents: paymentObject.amountCents,
                    states: Promise.map(paymentObject.states, (state) => {
                        return getState(state);
                    })
                });
            });
        }));
    });
}

Style Comparison

// style 1
function asynchronouslyConstructTransformedObject(order) {
  return Promise.try(() => {
    return Promise.props(Object.assign({}, order, {
      date: order.date,
      item: getItem(order.item),
      payments: Promise.map(order.payments, (paymentObject) => {
        return Promise.props({
          payment: getPayment(paymentObject.payment),
          amountCents: paymentObject.amountCents,
          states: Promise.map(paymentObject.states, (state) => {
            return getState(state);
          })
        });
      }),
      paymentMethod: getPaymentMethod(order.paymentMethod),
      user: getUser(order.user),
    }));
  });
}

// style 2
function asynchronouslyConstructTransformedObject(order) {
  return Promise.try(() => {
    const payments = Promise.map(order.payments, paymentObject =>
      Promise.props({
        payment: getPayment(paymentObject.payment),
        amountCents: paymentObject.amountCents,
        states: Promise.map(paymentObject.states, state => getState(state)),
      }));

    return Promise.props({
      ...order,
      date: order.date,
      item: getItem(order.item),
      payments,
      paymentMethod: getPaymentMethod(order.paymentMethod),
      user: getUser(order.user),
    });
  });
}

// style 3
function asynchronouslyConstructTransformedObject(order) {
  return Promise.try(() => {
    const payments = Promise.map(order.payments, paymentObject => Promise.props({
      payment:     getPayment(paymentObject.payment),
      amountCents: paymentObject.amountCents,
      states:      Promise.map(paymentObject.states, state => getState(state)),
    }));

    return Promise.props({
                     ...order,
      date:          order.date,
      item:          getItem(order.item),
                     payments,
      paymentMethod: getPaymentMethod(order.paymentMethod),
      user:          getUser(order.user),
    });
  });
}