This library wraps a function, suppresses node-style errors and surfaces them
in the value. This is useful when you're working with async and need the
entire map (or all tasks in parallel) not to fail because of
failure in one.
var suppressError = require('suppress-error');
function action(cb) {
cb(new Error('bad'));
}
var suppressedAction = suppressError(action);
action(function (err) {
console.log(err); // renders Error('bad')
});
suppressedAction(function (err, results) {
console.log(err); // renders null
console.log(results.error); // renders [Error: bad]
});var async = require('async'),
suppressError = require('suppress-error'),
assert = require('assert');
async.parallel({
one: suppressError(function (cb) {
setTimeout(function () {
cb(new Error('bad'));
}, 200);
}),
two: suppressError(function (cb) {
setTimeout(function () {
cb(null, 2);
}, 100);
})
}, function (err, results) {
if (err) throw err;
assert.equal(results.one.error.message, 'bad');
assert.equal(results.two.value, 2);
});Note that even though one returned an error, the final
callback was called (as async intentionally never got the error),
and the error itself is surfaced in one.error.
suppressError(Function) -> Function
The called wrapped function returns a error (which is null) as
the first argument and results as the second argument, which contains:
{
error: (Error|null), // that was passed to the cb
value: Object, // the first non-error argument (for convenience)
values: Array // all of the non-error arguments
}