如何標準化承諾鏈中的錯誤對象？

Question

我想使用承諾將調用鏈接到不同的庫。在失敗的情況下，庫方法返回一個描述錯誤的對象，但依賴於庫的不同字段。

爲了一致地向被調用者報告任何錯誤，我想規範化所有的錯誤對象遵循一個通用的格式。但我不知道如何以優雅的方式使用Bluebird和/或標準諾言API來做到這一點。

在這裏僞JS是我：

var methodAFromLibX_Async = Promise.promisify(...); 
var methodBFromLibY_Async = Promise.promisify(...); 

methodAFromLibX_Async(...) 
.then(function(result) { 
    methodBFromLibY_Async(...) 
    .then(function(result) { ... }) 
    .catch(normalizeAndSendErrorFromLibY); 
}) 
.catch(normalizeAndSendErrorFromLibX); 

上面的代碼似乎工作，但：

1. 我有normalizeAndSendErrorFromLibY和normalizeAndSendErrorFromLibX
2. 我之間的冗餘代碼我真正的用例我必須連鎖超過2個電話，並且代碼的金字塔形狀肯定開始看起來像一個回撥地獄...

---

編輯：爲了更加清楚一點，在這裏我設想的解決方案，但無法實現：

Answer 1

你正在尋找解決的辦法是

return methodAFromLibX_Async(…) 
.then(function(result) { 
    return methodBFromLibY_Async(…) 
    .then(function(result) { 
      return methodCFromLibX_Async(…) 
      .catch(normalizeAndThrowErrorFromLibX); 
    }, normalizeAndThrowErrorFromLibY); 
}, normalizeAndThrowErrorFromLibX) 
.then(reportSuccess, reportError); 

但是，這是相當醜陋。鑑於您的錯誤處理程序重新拋出錯誤，您也可以使用

return methodAFromLibX_Async(…) 
.catch(normalizeAndThrowErrorFromLibX) 
.then(function(result) { 
    return methodBFromLibY_Async(…) 
    .catch(normalizeAndThrowErrorFromLibY) 
    .then(function(result) { 
      return methodCFromLibX_Async(…) 
      .catch(normalizeAndThrowErrorFromLibX); 
    }); 
}) 
.then(reportSuccess, reportError); 

這仍然不是最佳的。您不希望在每次調用這些函數時都放置.catch(normalise)，並且您不希望被迫將它們嵌套。所以更好的因素在他們自己的功能：

function withRejectionHandler(fn, normalise) { 
    return function() { 
     return fn.apply(this, arguments).catch(normalise); 
    }; 
} 
var methodA = withRejectionHandler(methodAFromLibX_Async, normalizeAndThrowErrorFromLibX); 
var methodB = withRejectionHandler(methodBFromLibY_Async, normalizeAndThrowErrorFromLibY); 
var methodA = withRejectionHandler(methodCFromLibX_Async, normalizeAndThrowErrorFromLibX); 

return methodA(…).then(methodB).then(methodC).then(reportSuccess, reportError); 

你可以將它與庫方法的promisification結合起來。

Answer 2

如果你想避免你正在展示的格局你的例子似乎有另外兩個選項適用於你：

你promisify你的庫如圖所示，在你的鏈中正確地傳播錯誤，然後構建一個能夠正常化的函數全部個已知錯誤：

var methodAFromLibX_Async = Promise.promisify(...); 
var methodBFromLibY_Async = Promise.promisify(...); 

methodAFromLibX_Async(...) 
.then(function(result) { 
    return methodBFromLibY_Async(...) 
    .then(function(result) { ... }) 
}) 
.catch(function(err){ 
    if (hasLibXShape(err)){ 
    return Promise.reject(normalizeLibXErr(err)); 
    } else if (hasLibYShape(err)){ 
    return Promise.reject(normalizeLibYErr(err)); 
    } 
}) 
.catch(function(normalizedErr){ 
    // handle normalized error 
}); 

另一種選擇是手動promisify庫中的方法和這裏正常化錯誤：

function promisifiedMethodA(/*...args*/){ 
    var args = [].slice.call(arguments); 
    return new Promise(function(resolve, reject){ 
     methodA.apply(null, args.concat([function(err, data){ 
      if (err) return reject(normalizeMethodAError(err)); 
      resolve(data); 
     }])); 
    }); 
} 

讀你的最新評論我想後者可能適合您的需求更好。

Answer 3

你可以使用藍鳥過濾陷阱：http://bluebirdjs.com/docs/api/catch.html#filtered-catch

而更改您的代碼是這樣的：

var methodAFromLibX_Async = Promise.promisify(...); 
var methodBFromLibY_Async = Promise.promisify(...); 

methodAFromLibX_Async(...) 
.then(function(result) { 
    return methodBFromLibY_Async(...); 
}).then(function(result) { 
    ... 
}).catch({code: 'X_Async', message: 'bad lib X'}, function(e) { 
    //If it is a methodAFromLibX_AsyncError, will end up here because 

}).catch({code: 'Y_Async', message: 'bad lib Y'}, function(e) { 
    //Will end up here if a was never declared at all 

}).catch(function(e) { 
    //Generic catch-the rest, error wasn't methodAFromLibX_AsyncError nor 
    //methodBFromLibY_AsyncError 
}); 

Answer 4

作爲一個替代的解決方案，使用藍鳥的Promise.coroutine：

/* Bergi's solution to normalize */ 
function withRejectionHandler(fn, normalise) { 
    return function() { 
     return fn.apply(this, arguments).catch(normalise); 
    }; 
} 
var methodA = withRejectionHandler(methodAFromLibX_Async, normalizeAndThrowErrorFromLibX); 
var methodB = withRejectionHandler(methodBFromLibY_Async, normalizeAndThrowErrorFromLibY); 
var methodA = withRejectionHandler(methodCFromLibX_Async, normalizeAndThrowErrorFromLibX); 

/* use of coroutine to sequence the work */ 
var workflow = Promise.coroutine(function*() { 
    var resA = yield methodA(...); 
    var resB = yield methodB(...); 
    var resC = yield methodC(...); 

    reportSuccess(resA, resB, resC); 
}); 

workflow().catch(reportError);