Transforming object comparison

semi-code.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);
                    })
                });
            });
        }));
    });
}