Group sum and transform json object with values in nested array

You can do like this:

var orders = [{orderId:"01",date:"2017-01-02T06:00:00.000Z",items:[{itemId:100,itemCost:12,itemQuantity:10},{itemId:102,itemCost:25,itemQuantity:4}]},{orderId:"02",date:"2017-01-08T06:00:00.000Z",items:[{itemId:100,itemCost:15,itemQuantity:2},{itemId:101,itemCost:20,itemQuantity:5},{itemId:102,itemCost:25,itemQuantity:1}]},{orderId:"03",date:"2017-02-08T06:00:00.000Z",items:[{itemId:100,itemCost:15,itemQuantity:2},{itemId:101,itemCost:20,itemQuantity:5},{itemId:102,itemCost:25,itemQuantity:1}]}];

// First, map your orders by items
var items = {};
orders.forEach(function(order) {

    // set the month of each order
    var month = new Date(order.date);
    month = ('0' + (month.getMonth() + 1)).slice(-2) + '/' +  String(month.getFullYear()).slice(-2);
    
    // for each item in this order
    order.items.forEach(function(item) {
    
        // here we already have both keys: "id" and "month"
        // then, we make sure they have an object to match
        var id = item.itemId;
        if (!items[id]) {
            items[id] = {};
        }
        if (!items[id][month]) {
            items[id][month] = { cost:0, quantity:0 };
        }
        
        // keep calculating the total cost
        items[id][month].cost += item.itemCost * item.itemQuantity;
        items[id][month].quantity += item.itemQuantity;
    });
});

// Now, we format the calculated values to your required output:
var result = Object.keys(items).map(function(id) {
    var obj = {
        itemId: id,
        period: Object.keys(items[id]).map(function(month) {
            items[id][month].month = month;
            return items[id][month];
        }),
    };
    return obj;
});

console.log(result);

Hope it helps.

I think the other answers out there do a pretty good job from the vanilla angle, so I wanted to take a stab at a more lodash-intensive approach since you mentioned it as a tag. This is mainly just a fun challenge, but I hope the solution is elegant enough for you to lift components from.

Before we begin, I'll be using both the vanilla lodash module and the functional programming flavor of lodash. Let fp be the functional programming module and _ be vanilla (and let orders be your original data structure). Also, as a challenge, I'll do my best to minimize vanilla JS methods and arrow funcs to maximize lodash methods and function creation methods.

First, let's get all the items in a row, paired with their order information:

const items = _.flatMap(orders, o=> _.map(o.items, i=> [i, o]));

I know I said I wanted to minimize arrow functions, but I couldn't think of any other way to get the order object to the end of the chain. Challenge yourself to rewrite the above in terms of a composition (e.g. fp.compose or _.flow) and see what happens.

I'd say now's as good a time as any to group up our pairs by the item id:

const id_to_orders = _.groupBy(items, fp.get('[0].itemId'));

Here, fp.get('[0].itemId') gives us a function which, given an array, returns the itemId of the first element (in our case, we have a list of pairs, the first element of which is the item, the second of which is the relevant order object). Therefore, id_to_orders is a map from an item's ID to a list of all the times it was ordered.

This id_to_orders map looks pretty close to the data structure we're after. At a high level, all that's left is transforming the order data for each item into the quantity and cost, grouped by month.

const result = _.mapValues(id_map, fp.flow(
    // Arrange the item's orders into groups by month
    fp.groupBy(month)

    // We're done with the order objects, so fp.get('[0]') filters them
    // out, and the second function pairs the item's cost and quantity
  , fp.mapValues(fp.flow(
        fp.map(fp.flow(fp.get('[0]'), i=> [i.itemCost, i.itemQuantity]))

        // Sum up the cost (left) and quantity (right) for the item for the month
      , fp.reduce(add_pair, [0, 0])))

    // These last couple lines just transform the resulting data to look
    // closer to the desired structure.
  , _.toPairs
  , fp.map(([month, [cost, count]])=> ({month, cost, count}))
));

And the helpers month and add_pair referenced above:

function month([item, order]){
  const date  = new Date(order.date)
      , month = date.getMonth() + 1
      , year  = date.getFullYear().toString().slice(-2);
  return `${month}/${year}`;
}

function add_pair(p1, p2){
  return [p1[0] + p2[0], p1[1] + p2[1]];
}

Just out of curiosity (or sadism), let's see what this whole thing would look like chained together as a single pipeline:

const get_order_data = fp.flow(
    fp.flatMap(o=> _.map(o.items, i=> [i, o]))
  , fp.groupBy(fp.get('[0].itemId'))
  , fp.mapValues(fp.flow(
        fp.groupBy(month)
      , fp.mapValues(fp.flow(
            fp.map(fp.flow(fp.get('[0]'), i=> [i.itemCost, i.itemQuantity]))
          , fp.reduce(add_pair, [0, 0])))
      , _.toPairs
      , fp.map(([month, [cost, count]])=> ({month, cost, count})))
));

const result = get_order_data(orders);

You'll notice this composed version has a lot more fp (as opposed to _). If you're curious why it's easier this way, I encourage you to read the lodash FP guide.

jsfiddle with everything.

Finally, if you'd like to transform the result from the code above exactly into the output format you mentioned in your post, here's what I recommend:

const formatted = _.keys(result).map(k=> ({itemId: k, periods: result[k]}));