Cómo abortar correctamente una cadena de promesa node.js usando Q?

Question

Estoy usando the Q module para Node.js en un intento de evitar la "pirámide de fatalidad" en escenarios en los que tengo muchos pasos. Por ejemplo:

function doTask(task, callback) 
{ 
    Q.ncall(task.step1, task) 
    .then(function(result1){ 
     return Q.ncall(task.step2, task); 
    }) 
    .then(function(result2){ 
     return Q.ncall(task.step3, task); 
    }) 
    .fail(callback).end(); 
} 

Esencialmente esto parece funcionar; si se produce un error en alguno de los pasos de la tarea, se pasa a la devolución de llamada (aunque sería bienvenido a las mejoras, ya que soy nuevo en las promesas de node.js). Sin embargo, tengo un problema cuando necesito abortar la cadena de tareas temprano. Por ejemplo, si se devuelve con éxito resultado1 puede ser que quiera llamar a la devolución de llamada temprana y abortar el resto, pero mis intentos de hacerlo no se ...

function doTask(task, callback) 
{ 
    Q.ncall(task.step1, task) 
    .then(function(result1){ 
     if(result1) 
     {// the rest of the task chain is unnecessary 
      console.log('aborting!'); 
      callback(null, result1); 
      return null; 
     } 
     return Q.ncall(task.step2, task); 
    }) 
    .then(function(result2){ 
     console.log('doing step 3...'); 
     return Q.ncall(task.step3, task); 
    }) 
    .fail(callback).end(); 
} 

En este ejemplo, veo tanto "abortar" y "haciendo el paso 3 ..." impreso.

Estoy seguro de que estoy simplemente malinterpretando algunos principios básicos aquí, por lo que agradecería cualquier ayuda. ¡Gracias!

Answer 1

Cualquier error que se tiran dentro de la cadena promesa hará que toda la pila sea abortado temprano y se le da el control de la ruta de error de devolución. (en este caso, el controlador fail()) Cuando detecta un determinado estado que hace que desee abortar la cadena de la promesa, entonces simplemente arroje un error muy específico, que atrapa en el error e ignora (si lo hace elija)

function doTask(task, callback) 
{ 
    Q.ncall(task.step1, task) 
    .then(function(result1){ 
     if(result1 == 'some failure state I want to cause abortion') 
     {// the rest of the task chain is unnecessary 
      console.log('aborting!'); 
      throw new Error('abort promise chain'); 
      return null; 
     } 
     return Q.ncall(task.step2, task); 
    }) 
    .then(function(result2){ 
     console.log('doing step 3...'); 
     return Q.ncall(task.step3, task); 
    }) 
    .fail(function(err) { 
     if (err.message === 'abort promise chain') { 
      // just swallow error because chain was intentionally aborted 
     } 
     else { 
      // else let the error bubble up because it's coming from somewhere else 
      throw err; 
     } 
    }) 
    .end(); 
} 

Answer 2

Este es un caso en el que tendrá que bifurcar, lo que significa anidar o crear una subrutina.

function doTask(task, callback) { 
    return Q.ncall(task.step1, task) 
    .then(function(result1) { 
     if (result1) return result1; 
     return Q.ncall(task.step2, task) 
     .then(function(result2) { 
      return Q.ncall(task.step3, task); 
     }) 
    }) 
    .nodeify(callback) 
} 

O

function doTask(task, callback) { 
    return Q.ncall(task.step1, task) 
    .then(function(result1) { 
     if (result1) { 
      return result1; 
     } else { 
      return continueTasks(task); 
     } 
    }) 
    .nodeify(callback) 
} 

function continueTasks(task) { 
    return Q.ncall(task.step2, task) 
    .then(function(result2) { 
     return Q.ncall(task.step3, task); 
    }) 
} 

Answer 3

Creo que solo tiene que rechazar la promesa de salir de la cadena de la promesa.

https://github.com/kriskowal/q/wiki/API-Reference#qrejectreason

también parece que .end() ha sido cambiado a .done()

function doTask(task, callback) 
{ 
    Q.ncall(task.step1, task) 
    .then(function(result1){ 
     if(result1) 
     {// the rest of the task chain is unnecessary 
      console.log('aborting!'); 
      // by calling Q.reject, your second .then is skipped, 
      // only the .fail is executed. 
      // result1 will be passed to your callback in the .fail call 
      return Q.reject(result1); 
     } 
     return Q.ncall(task.step2, task); 
    }) 
    .then(function(result2){ 
     console.log('doing step 3...'); 
     return Q.ncall(task.step3, task); 
    }) 
    .fail(callback).done(); 
}