如何避免在循环中等待

Question

I have the following code:

const data = res?.advancedResult?.data;
for (const referential of data) {
    const entities = await EntityDAO.find({ query: { referential: referential?._id } });
    for (const entity of entities) {
        const items = await ItemDAO.find({ query: { entity: entity?._id } });
        entity.items = items.length;
    }
    referential.entities = entities.map(entity => ({ name: entity.name, items: entity.items }));
}

Since I'm using eslint I got the following error:

[eslint] Unexpected `await` inside a loop. (no-await-in-loop)

I can't use Promise.all since the iterations of a loop are not actually independent of each-other.
Is there anyway to avoid the await insid the loop so i can boost the performance? or i just should silence the error by adding /* eslint-disable no-await-in-loop */

Answer 1

It seems that you are suffering from the classic "N+1 Selects" problem. There are several ways to go about it - the last one being preferable:

• If the performance isn't an issue, just leave it as it is, and try to contest your eslint rules instead. After all, somebody did set that rule. Ask that person why that is and what problem they were trying to solve with it - maybe there's hidden wisdom behind it.
• You could parallelize the loading of Items (the inner loop), so that the Items of all Entities are loaded concurrently. However, you run the risk of getting unbounded concurrency - if the first query gets 100 Entities, you then launch 100 queries in parallel. Guard against that (see modules like p-limit ).
• You can construct flatter queries: get all Entities, gather their IDs and build a big query that amalgamates the IDs. I'm not sure what DB you're using, but you're looking for the equivalent of an SQL WHERE entity IN (value1, value2, ...) . Then, once you've got all the Items, iterate over them and assign each to its parent Entity. This way, you only get 2 queries (at the cost of more client-side complexity).

Overall, it's best to tackle the actual problem (N+1 queries), instead of bending async code to implement it. If you're writing something similar to an ORM, it may be worthwhile to explore existing implementations and how they deal with this well-researched issue.

Answer 2

Maybe you could use a map function, a map function is async and can await.

const data = res?.advancedResult?.data;
const temp = data.map(async(referential)=>{
    return await EntityDAO.find({ query: { referential: referential?._id } 
});

add here the rest...