together

Run consecutive callback code as if it was synchronous to avoid nesting.

npm install together
1 downloads in the last week
5 downloads in the last month

togetherjs

togetherjs is an experiment that allows you to avoid multiple nested callbacks by wrapping your calls to asynchronous functions with synchronous ones.

install

npm install together

example

Before you might have callback heavy code such as:

    tcp.send("syn", function(syn) {
        console.log("received", syn);
            tcp.send("syn-ack", function(synack) {
                console.log("received", synack);
                tcp.send("ack", function(ack) {
                    console.log("received", synack);
                });
            });
    });

With togetherjs, the callbacks are just written as if they block until they are complete.

var tcp = { send: function(data, callback) { console.log("sending", data); callback(data); } }; 

var seq = require("together").seq;

seq([tcp, console], function(tcp, console) {
    var syn = {}; var synack = {}; var ack = {};
    tcp.send("syn", this(syn));
    console.log("received %s", syn);
    tcp.send("syn-ack", this(synack));
    console.log("received %s", synack);    
    tcp.send("ack", this(ack));
    console.log("received %s", ack);    
});

 

node tcp_together.js 
sending syn
received syn
sending syn-ack
received syn-ack
sending ack
received ack

usage

Include the sequence wrapper:

var seq = require("together").seq;

Pass in an array of objects with functions that you want to wrap.

seq([imports], togetherBlock(imports) { ... });

seq([import1, import2], togetherBlock(import1, import2) { ... });

The order of your import must match those of your togetherBlock.

WARNING: If you use any asynchronous callbacks in your togetherBlock but forget to define them in imports, together will not wrap them up properly and will be executed out of order.

Your togetherBlock will receive wrapped up versions of your imports that do not execute immediately. When you need to pass in a callback, pass in this.

var seq = require("together").seq;
var timers = require("timers");

seq([console, timers], function(console, timers) {
        console.log("Hello");
        timers.setTimeout(this, 1000); 
        console.log("World");
});

You can capture callback arguments by providing objects to place values inside. Pass these into the this in the same order of your callback. If your callback takes in callback(data, protocol) then provide this(data, protocol), ensuring that data and prtocol are objects. This feature is not the most reliable and still needs a better solution.

In this example, all the callbacks return one argument which is then available for callbacks that follow.

var seq = require("together").seq;
var osi = {seq: 0, wrap: function(protocol, data, callback) {this.seq++; callback("[" + protocol + "@" + this.seq + ":" + data + "]");  }};

seq([console, osi], function(console, osi) {
    var mac = {};    var ip = {}; var http = {};
    osi.wrap("mac", "12acbbd334", this(mac));
    osi.wrap("ip", mac, this(ip));
    osi.wrap("http", ip, this(http));

    console.log("%s", mac);
    console.log("%s", ip);
    console.log("%s", http);
});

 

node tcp_params_together.js

[mac@1:12acbbd334]

[ip@2:[mac@1:12acbbd334]]

[http@3:[ip@2:[mac@1:12acbbd334]]]

limitations

This code is not production ready.

Yet to be tested on any libraries.

Callback values are not implemented properly - the objects passed are 'fake' rather than primitives.

npm loves you