Usando ohttps://github.com/kriskowal/q biblioteca, gostaria de saber se é possível fazer algo assim:

// Module A

function moduleA_exportedFunction() {
  return promiseReturningService().then(function(serviceResults) {
    if (serviceResults.areGood) {
      // We can continue with the rest of the promise chain
    }
    else {
      performVerySpecificErrorHandling();
      // We want to skip the rest of the promise chain
    }
  });
}

// Module B

moduleA_exportedFunction()
  .then(moduleB_function)
  .then(moduleB_anotherFunction)
  .fail(function(reason) {
    // Handle the reason in a general way which is ok for module B functions
  })
  .done()
;

Basicamente, se os resultados do serviço forem ruins, eu gostaria de lidar com a falha no módulo A, usando uma lógica específica para as partes internas do módulo A, mas ainda pular as funções restantes do módulo B na cadeia de promessas.

A solução óbvia para ignorar as funções do módulo B é gerar um erro / razão do módulo A. No entanto, eu precisaria lidar com isso no módulo B. E, idealmente, eu gostaria de fazê-lo sem precisar de nenhum código extra no módulo B para este.

O que pode muito bem ser impossível :) Ou contra alguns princípios de design de Q.

Nesse caso, que tipo de alternativas você sugeriria?

Eu tenho duas abordagens em mente, mas ambas têm suas desvantagens:

Lance um erro específico do módulo A e adicione código de manipulação específico ao módulo B:

.fail(function(reason) {
  if (reason is specificError) {
    performVerySpecificErrorHandling();
  }
  else {
    // Handle the reason in a general way which is ok for module B functions
  }
})

Execute a manipulação de erro personalizada no módulo A e, após manipular o erro, lance um motivo falso de rejeição. No módulo B, adicione uma condição para ignorar o motivo falso:

.fail(function(reason) {
  if (reason is fakeReason) {
    // Skip handling
  }
  else {
    // Handle the reason in a general way which is ok for module B functions
  }
})

A solução 1 requer a adição de código específico do módulo A ao módulo B.

A solução 2 resolve isso, mas toda a abordagem de rejeição falsa parece muito imprudente.

Você pode recomendar outras soluções?