Simplify foreach to update a mongoDB doc that has nested objects and arrays

Question

I want to update the value of the 'shouldSendAlert' key in a mongoDB document that is in the following structure:

{
    "_id" : ObjectId("5c61c4db46d18e1092c5b024"),
    "service" : "SRVPVD",
    "menu" : [ 
        {
            "sub" : [ 
                {
                    "options" : [ 
                        {
                            "item" : [ 
                                {
                                    "name" : "",
                                    "actions" : [ 
                                        {
                                            "name" : "communicateClient",
                                            "value" : true
                                        }, 
                                        {
                                            "name" : "shouldSendAlert",
                                            "value" : false
                                        }
                                    ]
                                }
                            ],
                            "name" : "Technology Support"
                        }, 
                        {
                            "item" : [ 
                                {
                                    "name" : "",
                                    "actions" : [ 
                                        {
                                            "name" : "communicateClient",
                                            "value" : true
                                        }
                                    ]
                                }
                            ],
                            "name" : "Company Support"
                        }
                    ],
                    "name" : "Support"
                }, 
                {
                    "name" : " FAQ"
                }
            ],
            "name" : "Help"
        }
    ]
}

I managed to achieve this goal, with a multiple $elemMatch query and using a foreach for each array within JSON to get to 'shouldSendAlert':

{
    let menuItems = db.getCollection('menumodels').find({menu: {$elemMatch: {name: 'Help',sub: {$elemMatch: {name: 'Support',motivos: {$elemMatch: {name: 'Technology Support'}}}}}}});

    menuItems.forEach((r) => {
        r.menu.forEach(menuItem => {
            if (menuItem.name == 'Help') {
                menuItem.sub.forEach(sub => {
                    if (sub.name == 'Support') {
                        sub.motivos.forEach(motivo => {
                            if (motivo.name == "Technology Support") {
                                motivo.item[0].actions.forEach(action => {
                                    if (action.name == 'shouldSendAlert') {
                                        action.value = true;
                                        db.getCollection('menumodels').update({_id: r._id}, {$set: {menu: r.menu}})
                                    }
                                })
                            }
                        })
                    }
                })
            }
        })
    });
}

Is it necessary, in terms of performance, to do this operation in a more intelligent way? Use all of these $elemMatch and foreach within foreach, significantly impact performance?

Thanks for the tips.

Answer 1

I don’t know if mongoDB has functions that help in this case, but you can do a function that looks for a path in an object and returns the value you find.

In the example I created below I added an argument that I usually use to have a pointer to an object created by me to make sure that the search failed. Note that in this function, if the result you are looking for is undefined and that is a result that you want to return the function has to be adjusted. But in the case that shows in the question this does what you look for.

const complexObject = {
  foo: [{
    bar: 'baz',
    nestedFoo: {
      hello: 'world'
    }
  }]
};

function findPathValue(obj, path, noValue) {
  return path.split('.').reduce((value, key) => {
    const keyValue = value[key];
    return typeof keyValue === 'undefined' ? noValue : keyValue;
  }, obj);
};
const noResult = {};

const willFind = findPathValue(complexObject, 'foo.0.nestedFoo.hello', noResult);
const willFail = findPathValue(complexObject, 'foo.bar.baz', noResult);

console.log(willFind, willFind === noResult); // world false
console.log(willFail, willFail === noResult); // {} true