Comment stocker des itinéraires dans des fichiers séparés lors de l'utilisation de Hapi?

Vous pouvez créer un fichier séparé pour l'utilisateur routes (config/routes/user.js):

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

De même avec le chariot. Puis créer un fichier d'index dans config/routes (config/routes/index.js):

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

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

Vous pouvez ensuite charger ce fichier d'index dans le fichier principal et appel server.route():

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

...

server.route(routes);

Sinon, pour config/routes/index.js, au lieu d'ajouter de la route des fichiers (par exemple cart, user) manuellement, vous pouvez les charger dynamiquement:

const fs = require('fs');

let routes = [];

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

module.exports = routes;

Vous pouvez utiliser nécessitent-hapiroutes à faire partie de l'organisation et de chargement pour vous. (Je suis l'auteur, donc je suis un peu biaisé, je l'ai écrit pour me rendre la vie plus facile dans la gestion des routes)

Je suis un grand fan de nécessitent-répertoire et de et de voulu un façon de gérer mes parcours tout aussi facilement. Cela vous permet de mélanger et assortir les itinéraires de vos modules et des modules dans des répertoires avec les routes.

Vous pouvez faire quelque chose comme ça...

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

Puis dans votre répertoire, vous pouvez avoir un fichier de route comme...

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']
  }
}];

Ou, vous pouvez mélanger et assortir par l'attribution d'une "route" de la propriété sur le 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']
  }
}];

Toujours bon d'avoir le choix. Il y a plein de documentation sur le github ou npmjs site pour cela.

Intéressant de voir autant de solutions différentes, en voici une autre.

D'expansion à la rescousse

Pour mon dernier projet que j'ai installé sur d'expansion pour les fichiers avec un nom de modèle, puis d'exiger d'eux dans le serveur un par un.

Routes d'importation après avoir créé le server objet

//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.
//...

Le glob modèle **/*route*.js trouverez tous les fichiers à l'intérieur et en dessous du répertoire de travail en cours avec un nom qui contient le mot route et se termine par le suffixe .js.

Structure du fichier

Avec l'aide de l'expansion, nous avons un couplage lâche entre les server objet et de ses itinéraires. Juste ajouter un nouvel itinéraire fichiers et ils seront inclus la prochaine fois que vous redémarrez votre serveur.

J'aime la structure de la route des fichiers en fonction de leur chemin et de les nommer avec leurs HTTP-méthode, comme suit:

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

Exemple de fichier de route routes/users/get-route.js

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

Réflexions

D'expansion et de parcourir les fichiers n'est pas particulièrement rapide, d'où une couche de mise en cache peut être utile de l'examiner dans la production construit en fonction de vos circonstances.

Je sais que c'est déjà approuvé. J'ai mis ma solution au cas où quelqu'un veut une solution rapide et de nouveau à Hapi.

Aussi j'ai inclus quelques MNP trop pour Newbees pouvez voir comment utiliser le server.register avec plusieurs plugin dans le cas ( good + hapi-auto-route )

Installé quelques packages npm:

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);
    });
});

Dans votre 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!');
        } 
    },
];

Exécuter: node server.js

Acclamations