Sign Up for Free

RunKit +

Try any Node.js package right in your browser

This is a playground to test code. It runs a full Node.js environment and already has all of npm’s 400,000 packages pre-installed, including outcome with all npm packages installed. Try it out:

var outcome = require("outcome")

This service is provided by RunKit and is not affiliated with npm, Inc or the package authors.

outcome v0.0.18

DRY error handling

Outcome.js is a simple flow-control library which wraps your .callback(err, result) functions.


  • Write less code for handling errors.
  • Easier to maintain.
  • Keep error handling code separate.

Basic Example

Here's the traditional method of handling errors:

var fs = require('fs');

function doSomething(path, callback) {

    fs.realpath(path, onRealPath);

    function onRealPath(err, path) {
        if(err) return callback(err);
        fs.lstat(path, onStat);

    function onStat(err, stats) {
        if(err) return callback(err);
        callback(err, stats);


doSomething('/path/to/something', function(err, result) {
    //inline with result handling - yuck
    if(err) {

        //do something with error

    //do something with result

The outcome.js way:

var fs  = require('fs'),
outcome = require('outcome');

function doSomething(path, callback) {

    //wrap the callback around an error handler so any errors in *this* function
    //bubble back up to the callback - I'm lazy and I don't wanna write this stuff...
    var on = outcome.error(callback);

    //on success, call onRealPath. Any errors caught will be sent back
    fs.realpath(path, on.success(onRealPath));

    function onRealPath(path) {

        //ONLY call onStat if we've successfuly grabbed the file stats
        fs.lstat(path, on.success(onStat));

    function onStat(stats) {

        //no errors, so send a response back
        callback(null, stats);

var on = outcome.error(function(error) {
    //do something with error

doSomething('/path/to/something', on.success(function(response) {
    //do something with result



  • listeners - Object of listeners you want to attach to outcome.

var onResult = outcome({
    //called when an error is caught
    error: function(error) {

    //called when an error is NOT present
    success: function(result, thirdParam) {

    //called back when an error, or result is present
    callback: function(err, result, thirdParam) {

As shown in the example above, you can also wrap-around an existing callback:

var onResult = outcome.error(function(error) {
success(function(result, thirdParam) {
callback(function(error, result, thirdParam) {

By default, any unhandled errors are thrown. To get around this, you'll need to listen for an unhandledError:

outcome.on('unhandledError', function(error) {
    //report bugs here..., then throw again.

fs.stat('s'+__filename, outcome.success(function() {



Called when on error/success. Same as function(err, data) { }

Here's a redundant example:

fs.stat(__filename, outcome.error(function(err) {
    //handle error
}).success(function(data) {
    //handle result
}.callback(function(err, result) {
    //called on fn complete regardless if there's an error, or success


Called on Success.

var onOutcome = outcome.success(function(data, anotherParam, andAnotherParam) {
    //handle success data

onOutcome(null, "success!", "more data!", "more results..");


Called on error.

var onOutcome = outcome.error(function(err) {

onOutcome(new Error("something went wrong...")); 


Custom response handler

outcome.handle(function(response) {
    if(response.errors) this.error(response);
    if( this.success(response);

CoffeeScript Example

outcome = require "outcome"

doSomething(path, callback) ->
    on = outcome.error callback

    # first get the realpath
    fs.realpath path, on.success onRealPath

    # on real path, get stats
    onRealPath(path) -> fs.lstat path, on.success onStat

    # on stat, finish
    onStat(stats) -> callback null, stats

# call do something
doSomething '/path/to/something', outcome 

    success: (statis) ->
        # do something

    error: (error) ->
        # do something else


Calling .error(), .success(), .callback() generates a new function which copies the previous listeners. Checkout fs-test in the examples folder.


RunKit is a free, in-browser JavaScript dev environment for prototyping Node.js code, with every npm package installed. Sign up to share your code.
Sign Up for Free