Nascent Prototype Metaverse


    1.9.5 • Public • Published


    Generic middleware/plugin framework inspired by express.js's .use()


    build status

    This module generates a single function which when called will pass the values passed to it to each of the functions specified with the .use() method. If one of the functions passes an error to the next() function the main callback will be immediately called (if specified) and no functions further in the chain will be processed.

    This is inspired by the express.js .use() method and is a generic implementation of it.


    npm install usey

    basic example

    var Usey = require('usey');
    var app = Usey();
    app.use(function (obj1, obj2, next) {
       obj1.x += 1;
       obj2.y += 1;
       return next();
    app.use(function (obj1, obj2, next) {
       obj1.x += 2;
       obj2.y += 2;
       return next();
    app({ x : 0 }, { y : 0 }, function (err, obj1, obj2) {

    named chains example

    var Usey = require('usey');
    var app = Usey();
    //do a thing, and then goto cleanup
    //going to cleanup because of this is not going to happen
    //because doThing is going to throw an error
    app.use(doThing, Usey.goto('cleanup'));
    //use the goto helper to jump to the cleanup chain when
    //and if the error chain gets hit
    app.use('error', Usey.goto('cleanup'))
    app.use('cleanup', doCleanup)
    app({ x : 0 }, function (err, obj) {
    function doThing (obj, next) {
    	//throwing an error will cause the 'error' chain
    	//to be called
    	return next(new Error("this thing failed"));
    function doCleanup (obj, next) {
    	return next();


    Create an instance

    When you create an instance by calling Usey(), it returns a function. That function has one method: .use().

    var Usey = require('usey');
    var u = Usey(); //this creates the instance function

    The Usey constructor takes an options object with the following options:

    • context : [object] this is the context (the this value) for each of the functions passed to the use() function and for the main callback.
      • By default a new empty object created when calling the usey instance function and that is used as the context for each function passed to use()
    • timeout : [number] a numeric value that specifies the maximum number of milliseconds to wait for any of the .use() specified functions to callback
    • stackNames : [boolean] if true, when .use() is called, we will use stack traces to determine where the function was defined. This information is used when debugging
    • debug : [function] an optional function that will be called with debug information. If not defined, it defaults to using the debug module.

    Add middleware/plugins/functions

    When you call the .use() method, you may pass it a single function, an array of functions or many functions as arguments.

    u.use([fn2, fn3, fn4]);
    u.use(fn5, fn6, fn7, fn8);

    Remove middleware/plugins/functions

    When you call the .unuse() method passing it a function reference, you can remove that function from the processing chain.


    Inserting / unshifting middleware/plugins/functions

    You can insert a function to specific position using .insert() or .unshift()

    //put the function f10 at the beginning of a chain
    //put the function f11 at some specific position
    u.insert(5, f11);
    //you can also to it to named chains
    u.unshift('error', logErrorMessage);
    u.insert('cleanup', 4, closeDatabase);

    Call the main function

    Now when you call u(arg1, arg2, arg3, ..., function (err, arg1, arg2, arg3, ...){}), it will in turn call, in order:

    fn1(arg1, arg2, arg3, ..., next);
    fn2(arg1, arg2, arg3, ..., next);
    fn3(arg1, arg2, arg3, ..., next);
    fn4(arg1, arg2, arg3, ..., next);
    fn5(arg1, arg2, arg3, ..., next);
    fn6(arg1, arg2, arg3, ..., next);
    fn7(arg1, arg2, arg3, ..., next);
    fn8(arg1, arg2, arg3, ..., next);
    fn9(arg1, arg2, arg3, ..., next);

    However, it will only call each function after the currently executing function calls the next() method.

    var obj = {};
    u(obj, function (err, obj) {

    Named Function Chains

    You may call the .use() method passing it a string as the first argument. That string should be the name of a chain. You can then call that chain from another.

    The named chain error is a special named chain that will be called if an error is passed to the next() callback at any time. The error named chain will be processed before the main callback will be called. This is helpful for cleaning up after errors have occurred.

    var u = Usey();
    u.use('finally', closeDatabase);
    u.use('finally', closeRedis);
    u.use('error', rollbackTransaction);
    u.use('error', goto('finally'));
    u(order, function (err) {
    function openDatabase(db) {
    	return function () {
    		var self = this
    			, next = getNext(arguments);
    		//this is hypothetical, function (err, client) {
    			if (err) {
    				return next(err);
    			self.db = client;
    			return next();
    function beginTransaction() {
    	var next = getNext(arguments);
    function goto(name) {
    	return function () {
    		var next = getNext(arguments);
    function getNext(a) {
    	return a[a.length -1];

    http server example

    var Usey = require('usey')
       , responseTime = require('response-time')
    var app = Usey();
    app.use(responseTime()) //this middleware adds a X-Response-Time http header
       .use(Redirect) //this middleware attaches .redirect() to the response object
       .use(Router(app)) //this middleware attaches .get() and .post() methods to app
       .use(_404) //this middleware is called last
    app.get('/test', function (req, res, next) {
       return res.end('hello');
    app.get('/redirect-me', function (req, res, next) {
       return res.redirect('');
    var server = http.createServer(app)
    function Redirect(req, res, next) {
       //append redirect method to response object
       res.redirect = function (url) {
          res.writeHead(302, {
             Location : url
       return next();
    function Router(app) {
       var routes = [];
       ['get', 'post'].forEach(function (method) {
          app[method] = addRoute.bind(app, method)
       app.add = addRoute;
       function addRoute (method, path, handler) {
             method : method.toUpperCase()
             , path : path
             , handler : handler
          return app;
       return function (req, res, next) {
          var route;
          for (var x = 0; x < routes.length; x ++ ){
             route = routes[x];
             if (route.method == req.method && route.path == req.url) {
                return route.handler(req, res, next);
          return next();
    function _404 (req, res, next) {
       res.end('File not found');




    npm i usey

    DownloadsWeekly Downloads






    Unpacked Size

    31 kB

    Total Files


    Last publish


    • wankdanker