expressjs-plus

v1.0.2

Published

4 years ago

A pluggable expansion to express js aimed at adding much needed features and helpers.

0High
0Medium
0Low

amri

middleware express helper error handling error-handling

Description

The main feature of this library is the getMiddlewareVersion function which facilitates passing variables between middlewares seamlessly. A great feature of this library is that it allows its users to create their own handlers for passing variables.

Usage

var express = require('express');
var ExpressPlus = require('expressjs-plus').ExpressPlus;
var app = express();
// simple handler example
var userHandler = function (param, paramsArray, req, res) {
    if (param !== 'user') return false;
    paramsArray.push("USER WAS FOUND!");
    return true;
};

// this handler allows you to pass res.locals properties between your middlewares seemingly,
// it the parameter was found in locals, it attaches it to paramsArray.
var resLocalsHandler = function (param, paramsArray, req, res) {
    if (param in res.locals) {
        paramsArray.push(res.locals[param]);
        return true;
    } else return false;
};
var appPlus = new ExpressPlus(app, [userHandler, resLocalsHandler], []);
var regularFunction = function (user, id, cb) {
    return cb(null, {response: {user: user, id: id}, status: 200, resLocalsVar: "passVar"});
};

// resLocalsVar was passed in a previous method
var regularFunction2 = function (resLocalsVar, user, id, cb) {
    // now you can have access to it
    console.log(resLocalsVar);
    return cb(null);
};

// the responder at the end will use res.locals.status and res.locals.response to issue an HTTP response
app.use(appPlus.GMV(regularFunction), appPlus.GMV(regularFunction2), appPlus.responder);

// adds error handlers, it will add a default error handler along with the list of error handlers passed
// in this case, no error handlers were passed
appPlus.setErrorHandlers();

app.listen(3001, function () {
    console.log('Listening!');
});

Another example for a paramHandler

function userHandler(param, paramsArray, req){
    if(param === 'user'){
        paramsArray.push(req.user);
        return true;
    }else{
        return false;
    }
}

Install

npm install expressjs-plus

ExpressPlus

Kind: global class

ExpressPlus

new exports.ExpressPlus(app, passedParamHandlers, passedErrorHandlers)

This function abstracts the constraints of express middleware signature and allows you to easily pass variables between middlewares without ugly code. It introduces a neat pattern for passing these variables.

| Param | Type | Description | | --- | --- | --- | | app | Object | express app object | | passedParamHandlers | Array | array of functions in the format of @see lastHandler | | passedErrorHandlers | Array | array of middlewares |

expressPlus.HTTPError

Kind: instance class of ExpressPlus

new this.HTTPError(status, errCode)

Generic error handler

| Param | Type | Description | | --- | --- | --- | | status | Number | HTTP error code | | errCode | String | errorCode, the error handler should handle this |

expressPlus.getMiddlewareVersion ⇒

Returns a middleware version of the function passed, this function replaces the last parameter with a callback function to work with express js.

Kind: instance property of ExpressPlus
Returns: function

| Param | Type | Description | | --- | --- | --- | | func | function | the function to be converted |

Example

function regularFunc(someVar, cb){
    console.log(someVar);
    return cb(null, {response: someVar+="addedString"});
}
// middleware version of regularFunc
var func = GMV(regularFunc);

// func will behave like this
function mw(req, res, next){
    let someVar = req.query.someVar;
    console.log(someVar);
    res.locals.response = someVar+="addedString";
    return next();
}

expressPlus.getMiddlewareVersionPromise ⇒

Similar to GMV @see GMV but accepts promises instead

Kind: instance property of ExpressPlus
Returns: function

| Param | Type | Description | | --- | --- | --- | | promise | Promise | the promise to be converted |

Example

function regularPromise = (someVar) => {
// you can use co as well
    return new Promise((resolve, reject) => {
        resolve({ response: {user: user, id: id}, status: 123 });
    });
}
// middleware version of regularFunc
var func = GMVPromise(regularFunc);