Fsbr NPM | npm.io

file structure based router for servers

Installation

$ npm i fsbr

Usage

Native

import router from 'fsbr';
import {createServer} from 'http';

const {use, register, route} = router();

use((req, res, next) => {
    //
    next();
});

register('./routes');

const server = createServer(route);
server.listen(8080);

Express

import router from 'fsbr';
import express from 'expess';

const app = express();
const {use, register, route} = router();

use((req, res, next) => {
    //
    next();
});
register('./routes');

app.use(route);
app.listen(3000);

API

fsbr(config)
router.on()
router.has()
router.use()
router.chain()
router.route()
router.register()

Library

`fsbr(config: Config)`

`Config`

	default	description
`ext`	.js	extension of middleware and listener files
`entry`	index	name of middleware files e.g. `middleware`
`dev`	false	print errors in `final` listener

Creates a new fsbr instance.

import router from 'fsbr';

const {on, use, chain, register, route} = router();

`router.on(method, path, listener)`

Registers a route. A Method can be any known HTTP method/verb or a wildcard *. Paths can contain a variable denoted via a semicolon. In this case, listeners receive a third optional argument with the resolved variable. Paths can also have a wildcard. fsbr will match every request after that.

const {on} = router();

// plain route
on('POST', '/post', (req, res) => {
    //
});

// route with id parameter
on('GET', '/user/:id', (req, res, params) => {
    const {id} = params;
});

// route with wildcard method
// any request with any HTTP method/verb on this route executes the listener
on('*', '/foo', (req, res) => {
    //
});

// route with wildcard in pathname
// any request with '/proxy/...' executes the listener
on('GET', '/proxy/*', (req, res) => {
    //
});

`router.has(method, path)`

Returns true, if the route exists.

const {has} = router();

has('POST', '/post');

`router.use(middleware)`

Registers a middleware function to the router. Middlewares with 4 parameters are considered as error listeners. Note the order. The error parameter here should be on the fourth place, unlike in other frameworks like express.

const {use} = router();

// normal middleware
use('POST', '/post', (req , res, next) => {
    // do middleware things
    next();
});

// middleware for errorhandling
// notice the fourth and last argument "error"
use('get', '/photos', (req, res, next, error) => {
    // handle error
    console.error(error);
    next();
});

`router.chain(...middlewares)`

Transforms an array of middleware functions into a single middleware function.

const {chain, on} = router();

const middlewares = [
    (req, res, next) => {
        res.data = [];
        next();
    },
    (req, res, next) => {
        res.data.push('foobar');
        next();
    },
];

on('GET', '/custom', chain(...middlewares, (req, res) => {
    console.log(res.data); // ['foobar']
}));

`router.route(req, res)`

Handle the incoming requests.

const {route} = router();

const server = createServer((req, res) => {
    route(req, res);
});
server.listen(8080);

`router.register(base, cb)`

Recursively register all routes within the base folder and call the optional callback when finished. Each directory represents a part of the URL pathname. Dynamic routes can be created by enclosing the directory name in square brackets e.g. [id]. Listeners are named by HTTP methods/verbs and export a default listening function. Middlewares can be placed alongside the listeners as index files. These files can export a single middleware function or an array of functions.

const {register} = router();

register(__dirname + '/routes', () => {
    console.log('done');
});

Example

Registering the following folder/file structure with default configuration:

routes
|
├───api
|       index.js
|       get.js
|
├───photo
|   |   index.js
│   │   get.js
│   │   post.js
│   │   delete.js
│   │
│   ├───[id]
│   │       get.js
│   │
│   └───vacation
|           index.js
│           get.js
│           post.js
│
└───user
        post.js

Would bind the following routes: