Node JS Promise.all e forEach

Eu tenho uma estrutura parecida com uma matriz que expõe métodos assíncronos. As chamadas de método assíncrono retornam estruturas de matriz que, por sua vez, expõem mais métodos assíncronos. Estou criando outro objeto JSON para armazenar valores obtidos dessa estrutura e, portanto, preciso ter cuidado ao manter o controle de referências em retornos de chamada.

Codifiquei uma solução de força bruta, mas gostaria de aprender uma solução mais idiomática ou limpa.

1. O padrão deve ser repetido para n níveis de aninhamento.
2. Preciso usar a promessa.all ou alguma técnica semelhante para determinar quando resolver a rotina de fechamento.
3. Nem todo elemento envolverá necessariamente fazer uma chamada assíncrona. Portanto, em uma promessa aninhada. Tudo que eu não posso simplesmente fazer atribuições aos meus elementos do array JSON com base no índice. No entanto, preciso usar algo como promessa.all no forEach aninhado para garantir que todas as atribuições de propriedade tenham sido feitas antes de resolver a rotina de fechamento.
4. Estou usando a lib de promessa do bluebird, mas isso não é um requisito

Aqui está um código parcial -

var jsonItems = [];

items.forEach(function(item){

  var jsonItem = {};
  jsonItem.name = item.name;
  item.getThings().then(function(things){
  // or Promise.all(allItemGetThingCalls, function(things){

    things.forEach(function(thing, index){

      jsonItems[index].thingName = thing.name;
      if(thing.type === 'file'){

        thing.getFile().then(function(file){ //or promise.all?

          jsonItems[index].filesize = file.getSize();

É bastante direto com algumas regras simples:

• Sempre que você criar uma promessa em um then, devolva-a - qualquer promessa que você não retornar não será esperada do lado de fora.
• Sempre que você cria várias promessas, .allelas - dessa forma, espera por todas as promessas e nenhum erro de qualquer uma delas é silenciado.
• Sempre que você aninha thens, normalmente pode retornar no meio - as thencadeias geralmente têm no máximo 1 nível de profundidade.
• Sempre que você executa IO, deve ser com uma promessa - ou deve ser uma promessa ou deve usar uma promessa para sinalizar sua conclusão.

E algumas dicas:

• O mapeamento é melhor feito com do .mapque comfor/push - se você estiver mapeando valores com uma função,map permite expressar concisamente a noção de aplicar ações uma a uma e agregar os resultados.
• A simultaneidade é melhor do que a execução sequencial se for gratuita - é melhor executar as coisas simultaneamente e esperar por elas Promise.alldo que executar as coisas uma após a outra - cada uma esperando antes da próxima.

Ok, então vamos começar:

var items = [1, 2, 3, 4, 5];
var fn = function asyncMultiplyBy2(v){ // sample async action
    return new Promise(resolve => setTimeout(() => resolve(v * 2), 100));
};
// map over forEach since it returns

var actions = items.map(fn); // run the function over all items

// we now have a promises array and we want to wait for it

var results = Promise.all(actions); // pass array of promises

results.then(data => // or just .then(console.log)
    console.log(data) // [2, 4, 6, 8, 10]
);

// we can nest this of course, as I said, `then` chains:

var res2 = Promise.all([1, 2, 3, 4, 5].map(fn)).then(
    data => Promise.all(data.map(fn))
).then(function(data){
    // the next `then` is executed after the promise has returned from the previous
    // `then` fulfilled, in this case it's an aggregate promise because of 
    // the `.all` 
    return Promise.all(data.map(fn));
}).then(function(data){
    // just for good measure
    return Promise.all(data.map(fn));
});

// now to get the results:

res2.then(function(data){
    console.log(data); // [16, 32, 48, 64, 80]
});

Aqui está um exemplo simples usando reduzir. Ele é executado em série, mantém a ordem de inserção e não requer Bluebird.

/**
 * 
 * @param items An array of items.
 * @param fn A function that accepts an item from the array and returns a promise.
 * @returns {Promise}
 */
function forEachPromise(items, fn) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item);
        });
    }, Promise.resolve());
}

E use-o assim:

var items = ['a', 'b', 'c'];

function logItem(item) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            resolve();
        })
    });
}

forEachPromise(items, logItem).then(() => {
    console.log('done');
});

Achamos útil enviar um contexto opcional para o loop. O contexto é opcional e compartilhado por todas as iterações.

function forEachPromise(items, fn, context) {
    return items.reduce(function (promise, item) {
        return promise.then(function () {
            return fn(item, context);
        });
    }, Promise.resolve());
}

Sua função de promessa seria semelhante a esta:

function logItem(item, context) {
    return new Promise((resolve, reject) => {
        process.nextTick(() => {
            console.log(item);
            context.itemCount++;
            resolve();
        })
    });
}

Eu passei pela mesma situação. Resolvi usando dois Promise.All ().

Acho que foi uma solução muito boa, então publiquei no npm: https://www.npmjs.com/package/promise-foreach

Acho que seu código será mais ou menos assim

var promiseForeach = require('promise-foreach')
var jsonItems = [];
promiseForeach.each(jsonItems,
    [function (jsonItems){
        return new Promise(function(resolve, reject){
            if(jsonItems.type === 'file'){
                jsonItems.getFile().then(function(file){ //or promise.all?
                    resolve(file.getSize())
                })
            }
        })
    }],
    function (result, current) {
        return {
            type: current.type,
            size: jsonItems.result[0]
        }
    },
    function (err, newList) {
        if (err) {
            console.error(err)
            return;
        }
        console.log('new jsonItems : ', newList)
    })

Apenas para complementar a solução apresentada, no meu caso eu queria buscar vários dados do Firebase para uma lista de produtos. Aqui está como eu fiz:

useEffect(() => {
  const fn = p => firebase.firestore().doc(`products/${p.id}`).get();
  const actions = data.occasion.products.map(fn);
  const results = Promise.all(actions);
  results.then(data => {
    const newProducts = [];
    data.forEach(p => {
      newProducts.push({ id: p.id, ...p.data() });
    });
    setProducts(newProducts);
  });
}, [data]);