プロミスチェーンのエラーオブジェクトを正規化する方法は？

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. 間の冗長なコードを持っているI私の実際の使用例私は2つ以上の呼び出しをチェーンしなければならず、コードのピラミッド形は間違いなくコールバック地獄のように見え始めます。

---

EDIT：、もう少し明確にするために、ここで私が想像するが、達成することはできません解決策：

Answer 1

：

Answer 2

あなたがで実証されているパターンを回避したい場合あなたの例はあなたのために2つの他のオプションがあるようです：

あなたのライブラリは、図のようにあなたのライブラリを正しく伝播し、正規化できる1つの関数を構築しますすべての既知のエラー：

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); 
     }])); 
    }); 
} 

私は後者がより良いあなたのニーズに合うかもしれませんね。あなたが探しているソリューションは

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

である。しかし、これはかなりある

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 3

あなたは青い鳥フィルターキャッチ使用することができますhttp://bluebirdjs.com/docs/api/catch.html#filtered-catch

をそして、このような何かにあなたのコードを変更します醜い。とにかくエラーハンドラがエラーを再現するとすれば、まだ最適ではない、

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); 

これをライブラリメソッドの約束と組み合わせることができます。代替策として

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);