Como fazer uma função esperar até que um retorno de chamada seja chamado usando node.js

Eu tenho uma função simplificada que se parece com isso:

function(query) {
  myApi.exec('SomeCommand', function(response) {
    return response;
  });
}

Basicamente, eu quero chamar myApi.exec, e retornar a resposta que é dada no lambda de retorno de chamada. No entanto, o código acima não funciona e simplesmente retorna imediatamente.

Apenas por uma tentativa muito tola, tentei o abaixo que não funcionou, mas pelo menos você entendeu o que estou tentando alcançar:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  while (!r) {}
  return r;
}

Basicamente, qual é uma boa maneira 'node.js / event driven' de fazer isso? Quero que minha função aguarde até que o retorno de chamada seja chamado e retorne o valor que foi passado para ele.

A maneira "bom node.js / event driven" de fazer isso é não esperar .

Como quase todo o resto ao trabalhar com sistemas controlados por eventos como o nó, sua função deve aceitar um parâmetro de retorno de chamada que será chamado quando o cálculo for concluído. O chamador não deve esperar que o valor seja "retornado" no sentido normal, mas sim enviar a rotina que manipulará o valor resultante:

function(query, callback) {
  myApi.exec('SomeCommand', function(response) {
    // other stuff here...
    // bla bla..
    callback(response); // this will "return" your value to the original caller
  });
}

Então você não o usa assim:

var returnValue = myFunction(query);

Mas assim:

myFunction(query, function(returnValue) {
  // use the return value here instead of like a regular (non-evented) return value
});

Uma maneira de conseguir isso é agrupar a chamada da API em uma promessa e usá-la awaitpara aguardar o resultado.

// let's say this is the API function with two callbacks,
// one for success and the other for error
function apiFunction(query, successCallback, errorCallback) {
    if (query == "bad query") {
        errorCallback("problem with the query");
    }
    successCallback("Your query was <" + query + ">");
}

// myFunction wraps the above API call into a Promise
// and handles the callbacks with resolve and reject
function apiFunctionWrapper(query) {
    return new Promise((resolve, reject) => {
        apiFunction(query,(successResponse) => {
            resolve(successResponse);
        }, (errorResponse) => {
            reject(errorResponse)
        });
    });
}

// now you can use await to get the result from the wrapped api function
// and you can use standard try-catch to handle the errors
async function businessLogic() {
    try {
        const result = await apiFunctionWrapper("query all users");
        console.log(result);

        // the next line will fail
        const result2 = await apiFunctionWrapper("bad query");
    } catch(error) {
        console.error("ERROR:" + error);
    }
}

// call the main function
businessLogic();

Resultado:

Your query was <query all users>
ERROR:problem with the query

verifique isso: https://github.com/luciotato/waitfor-ES6

seu código com wait.for: (requer geradores, sinalizador --harmony)

function* (query) {
  var r = yield wait.for( myApi.exec, 'SomeCommand');
  return r;
}

Se você não quiser usar a chamada de retorno, use o módulo "Q".

Por exemplo:

function getdb() {
    var deferred = Q.defer();
    MongoClient.connect(databaseUrl, function(err, db) {
        if (err) {
            console.log("Problem connecting database");
            deferred.reject(new Error(err));
        } else {
            var collection = db.collection("url");
            deferred.resolve(collection);
        }
    });
    return deferred.promise;
}


getdb().then(function(collection) {
   // This function will be called afte getdb() will be executed. 

}).fail(function(err){
    // If Error accrued. 

});

Para mais informações, consulte: https://github.com/kriskowal/q

Se você deseja que seja muito simples e fácil, sem bibliotecas sofisticadas, esperar que as funções de retorno de chamada sejam executadas no nó, antes de executar outro código, é assim:

//initialize a global var to control the callback state
var callbackCount = 0;
//call the function that has a callback
someObj.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});
someObj2.executeCallback(function () {
    callbackCount++;
    runOtherCode();
});

//call function that has to wait
continueExec();

function continueExec() {
    //here is the trick, wait until var callbackCount is set number of callback functions
    if (callbackCount < 2) {
        setTimeout(continueExec, 1000);
        return;
    }
    //Finally, do what you need
    doSomeThing();
}

Nota: Essa resposta provavelmente não deve ser usada no código de produção. É um truque e você deve saber sobre as implicações.

Existe o módulo uvrun (atualizado para as versões mais recentes do Nodejs aqui ) onde você pode executar uma única rodada de loop do loop do evento principal do libuv (que é o loop principal do Nodejs).

Seu código ficaria assim:

function(query) {
  var r;
  myApi.exec('SomeCommand', function(response) {
    r = response;
  });
  var uvrun = require("uvrun");
  while (!r)
    uvrun.runOnce();
  return r;
}

(Você pode usar um método alternativo uvrun.runNoWait(). Isso pode evitar alguns problemas com o bloqueio, mas requer 100% da CPU.)

Observe que essa abordagem invalida todo o objetivo do Nodejs, ou seja, ter tudo assíncrono e sem bloqueio. Além disso, isso pode aumentar muito a profundidade do seu pilha de chamadas, para que você possa acabar com estouros de pilha. Se você executar essa função recursivamente, definitivamente encontrará problemas.

Veja as outras respostas sobre como redesenhar seu código para fazê-lo "corretamente".

Esta solução aqui provavelmente é útil apenas quando você faz testes e esp. deseja ter código sincronizado e serial.

Desde o nó 4.8.0, você pode usar o recurso do ES6 chamado gerador. Você pode seguir este artigo para obter conceitos mais aprofundados. Mas basicamente você pode usar geradores e promessas para fazer esse trabalho. Estou usando o bluebird para promisificar e gerenciar o gerador.

Seu código deve estar bem, como no exemplo abaixo.

const Promise = require('bluebird');

function* getResponse(query) {
  const r = yield new Promise(resolve => myApi.exec('SomeCommand', resolve);
  return r;
}

Promise.coroutine(getResponse)()
  .then(response => console.log(response));

supondo que você tenha uma função:

var fetchPage(page, callback) {
   ....
   request(uri, function (error, response, body) {
        ....
        if (something_good) {
          callback(true, page+1);
        } else {
          callback(false);
        }
        .....
   });


};

você pode usar retornos de chamada como este:

fetchPage(1, x = function(next, page) {
if (next) {
    console.log("^^^ CALLBACK -->  fetchPage: " + page);
    fetchPage(page, x);
}
});

Isso anula o objetivo de não bloquear IO - você está bloqueando quando não precisa de bloqueio :)

Você deve aninhar seus retornos de chamada em vez de forçar o node.js a aguardar ou chamar outro retorno de chamada dentro do retorno de chamada em que precisa do resultado r.

As chances são de que, se você precisar forçar o bloqueio, está pensando em sua arquitetura errada.

Usar async e aguardar é muito mais fácil.

router.post('/login',async (req, res, next) => {
i = await queries.checkUser(req.body);
console.log('i: '+JSON.stringify(i));
});

//User Available Check
async function checkUser(request) {
try {
    let response = await sql.query('select * from login where email = ?', 
    [request.email]);
    return response[0];

    } catch (err) {
    console.log(err);

  }

}