How to store routes in separate files when using Hapi?

Question

All of the Hapi examples (and similar in Express) shows routes are defined in the starting file:

var Hapi = require('hapi');

var server = new Hapi.Server();
server.connection({ port: 8000 });

server.route({
  method: 'GET',
  path: '/',
  handler: function (request, reply) {
    reply('Hello, world!');
  }
});

server.route({
  method: 'GET',
  path: '/{name}',
  handler: function (request, reply) {
    reply('Hello, ' + encodeURIComponent(request.params.name) + '!');
  }
});

server.start(function () {
  console.log('Server running at:', server.info.uri);
});

However, it's not hard to image how large this file can grow when implementing production application with a ton of different routes. Therefore I would like to break down routes, group them and store in separate files, like UserRoutes.js, CartRoutes.js and then attach them in the main file (add to server object). How would you suggest to separate that and then add?

score 105 · Accepted Answer · edited Aug 16 '17 at 09:48

105

You can create a separate file for user routes (config/routes/user.js):

module.exports = [
    { method: 'GET', path: '/users', handler: function () {} },
    { method: 'GET', path: '/users/{id}', handler: function () {} }
];

Similarly with cart. Then create an index file in config/routes (config/routes/index.js):

var cart = require('./cart');
var user = require('./user');

module.exports = [].concat(cart, user);

You can then load this index file in the main file and call server.route():

var routes = require('./config/routes');

...

server.route(routes);

Alternatively, for config/routes/index.js, instead of adding the route files (e.g. cart, user) manually, you can load them dynamically:

const fs = require('fs');

let routes = [];

fs.readdirSync(__dirname)
  .filter(file => file != 'index.js')
  .forEach(file => {
    routes = routes.concat(require(`./${file}`))
  });

module.exports = routes;

edited Aug 16 '17 at 09:48

René Hoffmann

2,766
2
20
43

answered Jan 04 '15 at 16:28

Gergo Erdosi

40,904
21
118
94

7

Note that what Gergo is doing here is just standard Javascript, not specific to Hapi. – Lawrence Sep 11 '15 at 17:56
and what if I have some Joi validation or Global variables in my external handlers? should I include require('joi') in every external file? – Magico Apr 22 '16 at 14:18
1

@Magico for the Joi library you will need to include it in every external file. The global variables would work the same so you would still have access to them in the `require`d modules. – adam-beck May 23 '16 at 13:35
1

clean, classic, best way so far. – Achmad Naufal Syafiq Sep 18 '17 at 11:02
Works like a charm.. Thx – CodeHacker Nov 03 '17 at 16:07
In my project, I used the import keyword in index.js file to get the external routes. it didn't work. Then I used require it worked. I would like to know why it didn't work with import. What is the difference between require and import. why it didn't work with import. – nzhmz Dec 01 '17 at 05:40
@nzhmz I think you already got your answers, but if you haven't , Node.js only supports ECMAScript 5, so you need to transpile your application to it with some of tools like babel. More detail you can find on https://stackoverflow.com/questions/54384073/import-not-working-on-node-js-version-11-8-0 – Tekraj Shrestha Feb 10 '22 at 14:29

score 15 · Answer 2 · answered Oct 29 '15 at 07:33

You should try Glue plugin: https://github.com/hapijs/glue. It allows you to modularize your application. You can place your routes in separate subdirectories and then include them as Hapi.js plugins. You can also include other plugins (Inert, Vision, Good) with Glue as well as configure your application with a manifest object (or json file).

Quick exapmple:

server.js:

var Hapi = require('hapi');
var Glue = require('glue');

var manifest = {
    connections: [{
        port: 8080
    }],
    plugins: [
        { inert: [{}] },
        { vision: [{}] },
        { './index': null },
        {
            './api': [{
                routes: {
                    prefix: '/api/v1'
                }
            }]
        }
    ]
};


var options = {
    relativeTo: __dirname + '/modules'
};

Glue.compose(manifest, options, function (err, server) {
    server.start(function(err) {
        console.log('Server running at: %s://%s:%s', server.info.protocol, server.info.address, server.info.port);
    });
});

./modules/index/index.js:

exports.register = function(server, options, next) {
    server.route({
        method: 'GET',
        path: '/',
        handler: require('./home')
    });
});

exports.register.attributes = {
    pkg: require('./package.json')
};

./modules/index/package.json:

{
    "name": "IndexRoute",
    "version": "1.0.0"
}

./modules/index/home.js:

exports.register = function(req, reply) {
    reply.view('home', { title: 'Awesome' });
});

Have a look at this wonderful article by Dave Stevens for more details and examples.

score 7 · Answer 3 · answered Oct 19 '15 at 15:54

You can use require-hapiroutes to do some of the organization and loading for you. (I am the author so I am a little biased, I wrote it to make my life easier in managing routes)

I am a big fan of require-directory and and wanted a way to manage my routes just as easily. This lets you mix and match routes in your modules and modules in directories with routes.

You can then do something like this...

var routes = require('./routes');
server.route(routes.routes);

Then in your directory you could have a route file like...

module.exports = [
{
  method : 'GET',
  path : '/route1',
  handler : routeHandler1,
  config : {
    description: 'my route description',
    notes: 'Important stuff to know about this route',
    tags : ['app']
  }
},
{
  method : 'GET',
  path : '/route2',
  handler : routeHandler2,
  config : {
    description: 'my route description',
    notes: 'Important stuff to know about this route',
    tags : ['app']
  }
}];

Or, you can mix and match by assigning to a "routes" property on the module

module.exports.routes = [
{
  method : 'GET',
  path : '/route1',
  handler : routeHandler1,
  config : {
    description: 'my route description',
    notes: 'Important stuff to know about this route',
    tags : ['app']
  }
},
{
  method : 'GET',
  path : '/route2',
  handler : routeHandler2,
  config : {
    description: 'my route description',
    notes: 'Important stuff to know about this route',
    tags : ['app']
  }
}];

Always, good to have options. There is full documentation on the github or npmjs site for it.

score 2 · Answer 4 · answered Oct 20 '15 at 11:25

or you can use a index file to load all the routes in the directory

index.js

/**
 * Module dependencies.
 */
const fs = require('fs');
const path = require('path');
const basename  = path.basename(__filename);

const routes = fs.readdirSync(__dirname)
.filter((file) => {
    return (file.indexOf('.') !== 0) && (file !== basename);
})
.map((file) => {
    return require(path.join(__dirname, file));
});

module.exports = routes;

other files in the same directory like:

module.exports =  [
    {
        method: 'POST',
        path:  '/api/user',
        config: {

        }
    },
    {
        method: 'PUT',
        path:  'api/user/{userId}',
        config: {

        }
    }
];

and than in your root/index

const Routes = require('./src/routes');
/**
* Add all the routes
*/
for (var route in Routes) {
    server.route(Routes[route]);
}

score 1 · Answer 5 · answered Mar 25 '16 at 10:05

Interesting to see so many different solutions, here is another one.

Globbing to the rescue

For my latest project I settled on globbing for files with a particular name pattern and then requiring them into the server one by one.

Import routes after having created the `server` object

// Construct and setup the server object.
// ...

// Require routes.
Glob.sync('**/*route*.js', { cwd: __dirname }).forEach(function (ith) {
    const route = require('./' + ith);
    if (route.hasOwnProperty('method') && route.hasOwnProperty('path')) {
        console.log('Adding route:', route.method, route.path);
        server.route(route);
    }
});

// Start the server.
// ...

The glob pattern **/*route*.js will find all files within and below the specified current working directory with a name that contains the word route and ends with the suffix .js.

File structure

With the help of globbing we have a loose coupling between the server object and its routes. Just add new route files and they will be included the next time you restart your server.

I like to structure the route files according to their path and naming them with their HTTP-method, like so:

server.js
routes/
    users/
        get-route.js
        patch-route.js
        put-route.js
    articles/
        get-route.js
        patch-route.js
        put-route.js

Example route file `routes/users/get-route.js`

module.exports = {
    method: 'GET',
    path: '/users',
    config: {
        description: 'Fetch users',
        // ...
    },
    handler: function (request, reply) {
        // ...
    }
};

Final thoughts

Globbing and iterating over files is not a particularly fast process, hence a caching layer may be worth investigating in production builds depending on your circumstances.

score 1 · Answer 6 · edited Nov 13 '19 at 21:16

1

Try hapi-auto-route plugin! It's is very simple to use and allow prefix in your route path.

_{Full disclosure: I am the author of this plugin}

edited Nov 13 '19 at 21:16

OneHoopyFrood

3,829
3
24
39

answered Apr 04 '17 at 08:00

sitrakay

1,731
1
9
3

score 0 · Answer 7 · answered Aug 17 '17 at 04:43

I know this is already approved. I put down my solution in case someone wants a quick fix and new to Hapi.

Also I included some NPM too so Newbees can see how to to use the server.register with multiple plugin in the case ( good + hapi-auto-route )

Installed some npm packages:

npm i -S hapi-auto-route

npm i -S good-console

npm i -S good


// server.js
'use strict';

const Hapi = require('hapi');
const Good = require('good');
const AutoRoute = require('hapi-auto-route');

const server = new Hapi.Server();

server.connection(
    {   
        routes: { cors: true }, 
        port: 3000, 
        host: 'localhost',
        labels: ['web']
    }
);

server.register([{
    register: Good,
    options: {
        reporters: {
            console: [{
                module: 'good-squeeze',
                name: 'Squeeze',
                args: [{
                    response: '*',
                    log: '*'
                }]
            }, {
                module: 'good-console'
            }, 'stdout']
        }
    }
}, {
    register: AutoRoute,
    options: {}
}], (err) => {

     if (err) {
        throw err; // something bad happened loading the plugin
    }

    server.start((err) => {

        if (err) {
            throw err;
        }
        server.log('info', 'Server running at: ' + server.info.uri);
    });
});

In your routes/user.js

module.exports = 
[   
     {  
        method: 'GET',
        path: '/',
        handler: (request, reply) => {
            reply('Hello, world!');
        } 
    },  
     {  
        method: 'GET',
        path: '/another',
        handler: (request, reply) => {
            reply('Hello, world again!');
        } 
    },
];

Now run: node server.js

Cheers

How to store routes in separate files when using Hapi?

7 Answers7

index.js

Globbing to the rescue

Import routes after having created the `server` object

File structure

Example route file `routes/users/get-route.js`

Final thoughts

Linked

How to store routes in separate files when using Hapi?

7 Answers7

index.js

Globbing to the rescue

Import routes after having created the server object

File structure

Example route file routes/users/get-route.js

Final thoughts

Linked

Import routes after having created the `server` object

Example route file `routes/users/get-route.js`