stewardess

serial async flow control

Stewardess

She keeps track of your serial async methods.

Also provies a small bag of peanuts and half a can of soda.

npm install stewardess

var stewardess = require('stewardess')
 
function first(next) {
  console.log('first');
  next();
}
 
function second(next) {
  console.log('second');
  next();
}
 
function third(next) {
  console.log('third');
  next();
}
 
stewardess(
  first,
  second,
  third
).run();
stewardess(
  function(next) {
    // this function goes second 
    next();
  }
)
.add(function(next) {
  // this function goes third 
  next();
})
.addBefore(function(next) {
  // this function goes first 
  next();
}),
.before(function() {
  // this is called before each function 
})
.after(function() {
  // this is after before each function 
})
.done(function() {
  // this is called when all methods finish 
})
.error(function(err) {
  // if any method throws an error, 
  // or calls next(err), it ends up here 
})
.final(function() {
  // this is called after done or error is called 
})
.context({'some':'object'}) // set this-ness for all callbacks 
.run(); // this starts it 
stewardess(
  function(meowmixnext) {
    meow === 'meow';
    mix.meow === 'mix';
    mix.meow = mix.meow.toUpperCase();
    next();
  },
  function(meowmixnext) {
    meow === 'meow';
    mix.meow === 'MIX';
    next();
  }
)
.after(function(meowmix) {
  // before, after, and done also get arguments 
})
.error(function(errmeowmix) {
  // error gets arguments with the error 
})
.run('meow', {meow: 'mix'});

Here is an example of using stewardess to provide middleware for an http server. It gives the length of each piece of middleware and for the entire request.

"use strict";
 
var http = require('http')
  , stewardess = require('./index')
 
var handle = stewardess(
  function(reqresnext) {
    req.startTime = process.hrtime();
    next();
  },
  function(reqresnext) {
    console.log(req.url + ' requested');
    next();
  },
  function(reqresnext) {
    if (req.headers && /^curl/.test(req.headers['user-agent'])) {
      res.end('yur usin curl!');
      next('break'); // fire 'done' and stop 
    } else {
      next();
    }
  },
  function(reqresnext) {
    res.end('oh hai');
    next();
  }
)
.before(function(reqres) {
  req.= req.+ 1 || 1;
  req.lastStart = process.hrtime();
})
.after(function(reqres) {
  var t = process.hrtime(req.lastStart);
  console.log('middleware ' + req.+ ' took %d seconds and %d ms', t[0], t[1]/1000000);
})
.done(function(reqres) {
  var t = process.hrtime(req.startTime);
  console.log(req.url + ' served in %d seconds and %d ms', t[0], t[1]/1000000);
})
.done(function(reqres) {
  console.log(req.url + ' served with status ' + res.statusCode);
  console.log();
})
.bind();
 
http.Server(handle).listen(8080);
stewardess(
  function(optionsnext) {
    options.meow = 'mix';
    next('skip');
  },
  function(optionsnext) {
    throw new Error('should never run');
  }, 
  function(optionsnext) {
    console.log(options.meow);
  }
)
.run({});
stewardess(function(next) {
    // this will repeat infinitely 
    next('repeat');
}).run();
stewardess(
  function(optionsnext) {
    options.meow = 'mix';
    next('break');
  },
  function(optionsnext) {
    throw new Error("should never run");
  }
)
.done(function(options) {
  assert.equal(options.meow, 'mix');
})
.run({});

This allows for a pattern of checking and filling a cache.

var cache = null;
 
var checkCache = stewardess(
  function checkCache(next) {
    if (cache) {
      return next('skip');
    }
    next();
  },
 
  function setCache(next) {
    cache = 8;
    next('previous');
  },
 
  function useCache(next) {
    assert.equal(cache, 8);
    next();
  }
)
.bind();
function myRillyCoolPlugin(stewardesspluginOptions) {
  if (pluginOptions.rilly === 'ossum') {
    console.log('yur ossum');
  }
 
  stewardess
  .before(function(optionsname) {
    console.log('entering ' + name);
  })
  .after(function(optionsname) {
    console.log('leaving ' + name);
  })
  .done(function(options) {
    console.log('all done!');
  });
}
 
var pluginOptions = {
  rilly: 'ossum'
}
 
stewardess(
  function first(optionsnext) {
    options.foo = 'bar';
  },
  function second(optionsnext) {
    options.baz = 'bam';
  },
  function third(optionsnext) {
    options.fish = 'sticks';
  }
)
.plugin(myRillyCoolPlugin, pluginOptions)
.run({});

All of the builtin stewardess plugins require the first argument to be an object.

stewardess(
  function first(optionsnext) {
    setTimeout(next, 100);
  },
  function second(optionsnext) {
    for (var i = 0; i < 10000; ++i) {
      Math.pow(i);
    }
    next();
  }
)
.plugin(stewardess.plugins.timer) // print the milliseconds taken for each method 
.plugin(stewardess.plugins.hrTimer) // same as timer, but with nanosecond precision 
.plugin(stewardess.plugins.overallTime) // print the time for the entire stack to run 
.run({});

Stewardess will recognize mongoose queries, and run them for you. You just need to make sure the first parameter is an object, and call comment to tell stewardess which property to store the results under.

stewardess(
 
  MongoosePersonModel
    .find()
    .select({ name: 1, age: 1 })
    .sort('age')
    .comment('people'), // this tells stewardess where to put the results 
 
  function printPeople(optionsnext) {
    options.people.forEach(function(person) {
      console.log(person.name, person.age);
    });
    next();
  }
 
)
.run({});

Run npm test. Requires mocha.

stewardess is published under an MIT style license.