express-async-router
    TypeScript icon, indicating that this package has built-in type declarations

    0.1.15 • Public • Published

    express-async-router

    express-async-router is an Express Router wrapper which automatically manage Promise.

    Getting Started

    express-async-router works exactly as Express Router. If you're not family with Express Router API, please see Router documentation.

    Installation

    express-async-router can be installed using NPM:

    $ npm install express-async-router --save

    Usage

    First import express-async-router in your project:

    var AsyncRouter = require("express-async-router").AsyncRouter;

    Then instanciate AsyncRouter:

    var router = AsyncRouter();

    You're ready to use AsyncRouter the same way as Express Router but without worrying about Promise.

    router.get("/", function (req, res) {
        return myGetOperation()
            .then(myOtherOperation);
    });
     
    router.post("/:test", function (req, res) {
        return myParametrizedOperation(req.params.test)
            .then(myOtherOperation);
    });
     
    router.use(function (req, res) {
        return myMiddlewareOperation()
            .then(myOtherOperation);
    });

    Options

    express-async-router works exactly as Express Router so it can take the same options plus some additionnals to manage how request is sent.

    By default, express-async-router sends the Promise result by using res.send(result) if headers was not already sent. You can customize this behavior by passing sender option when creating AsyncRouter.

    options.send

    Type: boolean | Default: true

    If set to false, AsyncRouter will never try to send Promise result.

    options.sender

    Type: (req, res, value) => Thenable | Default: function (req, res, value) { res.send(value); }

    If set, it will override the default AsyncRouter sender function.

    Examples:

    var router = AsyncRouter({ send: false });

    Or

    var router = AsyncRouter({ sender: mySender });
     
    function mySender(req, res, value) { 
        res.rend(value.template, value.data); 
    }
     
    router.get("/", function () {
        return myOperation().then(function (data) {
            return {
                template: "index",
                data: data
            };
        });
    });

    send

    Promise handling

    express-async-router automatically handles Promises when it can.

    param(name: string, handler: (req, res, param) => Thenable)

    A special Router.param override which automatically calls next function when returned Promise resolves. If returned Promise rejects, rejected Error is transfered to next function. If result is not a Promise, next function is immediatelly called.

    Example:

    router.param("test", function (req, res, param) {
        return getTestEntity(param)
            .then(function(entity) {
                req.test = entity;
            });
    });

    [method](name: string, handler: (req, res) => Thenable)

    A Router[method] wrapper which automatically calls next function when returned Promise resolves. If returned Promise rejects, rejected Error is transfered to next function. If result is not a Promise, next function is immediatelly called.

    Examples:

    router.get("/", function () {
        return getTestEntities();
    });
     
    router.post("/:test", function (req) {
        return getTestEntity(req.params.test);
    });

    use(...handlers[]: (req, res) => Thenable)

    use(name: string | RegExp | string[], ...handlers[]: (req, res) => Thenable)

    A Router.use wrapper which automatically calls next function when returned Promise resolves. If returned Promise rejects, rejected Error is transfered to next function. If result is not a Promise, next function is immediatelly called.

    NOTE: If you declare 3 arguments in your function, next will only be called when an error occured.

    Examples:

    router.use(function (req) {
        return validateToken(req.header("MyCustomToken"))
            .then(function (user) {
                req.user = user;
            });
    });
     
    router.use("/test", function (req) {
        return validateToken(req.header("MyCustomToken"))
            .then(function (user) {
                req.user = user;
            });
    });
     
    router.use(myCustomAuth, serveStatic(__dirname + "/public"), function (req) {
        return logToServer(req)
            .then(function () {
                console.log(req);
            });
    });
     

    use(...handlers[]: (err, req, res, next) => Thenable)

    use(name: string | RegExp | string[], ...handlers[]: (err, req, res, next) => Thenable)

    A Router.use wrapper for Error handling which automatically calls next function when returned Promise resolves. If returned Promise rejects, rejected Error is transfered to next function. If result is not a Promise, next function is immediatelly called.

    WARNING: You must declare the 4 arguments to your function to be recognized as an Error handler. This is for compatibility with Native Middlewares.

    Examples:

    router.use(function (err, req, res, next) {
        return logError(err)
            .then(function () {
                console.error(err);
                res.send(500, "An error occured!");
            });
    });
     
    router.use("/test", function (err, req, res, next) {
        return logError(err)
            .then(function () {
                console.error(err);
                res.send(500, "An error occured!");
            });
    });
     
    router.use(function (err, req, res, next) {
        return logError(err)
            .then(function () {
                console.error(err);
                res.send(500, "An error occured!");
            });
    });

    Contribute

    Install Global Dependencies

    express-router-async needs some development dependencies:

    $ npm install -g grunt-cli tsd

    Install Project dependencies

    $ npm install

    Build project

    $ grunt

    Install

    npm i express-async-router

    DownloadsWeekly Downloads

    19,649

    Version

    0.1.15

    License

    MIT

    Unpacked Size

    13.9 kB

    Total Files

    4

    Last publish

    Collaborators

    • mluce