node.js - tutorial - ¿Cómo almacenar rutas en archivos separados al usar Hapi?

node js rest api mysql

Question

Todos los ejemplos de Hapi (y similares en Express) muestran que las rutas se definen en el archivo de inicio:

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

Sin embargo, no es difícil imaginar qué tan grande puede crecer este archivo al implementar una aplicación de producción con una tonelada de rutas diferentes. Por lo tanto, me gustaría desglosar las rutas, agruparlas y almacenarlas en archivos separados, como UserRoutes.js, CartRoutes.js y luego adjuntarlas al archivo principal (agregar al objeto del servidor). ¿Cómo sugerirías separar eso y luego agregarlo?

Answer 1

Debe probar el complemento de pegamento: https://github.com/hapijs/glue . Te permite modularizar tu aplicación. Puede colocar sus rutas en subdirectorios separados y luego incluirlos como complementos de Hapi.js. También puede incluir otros complementos (Inert, Vision, Good) con Glue, así como configurar su aplicación con un objeto manifiesto (o archivo json).

Ejemplo rápido:

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

Eche un vistazo a this maravilloso artículo de Dave Stevens para obtener más detalles y ejemplos.

Answer 2

Interesante ver tantas soluciones diferentes, aquí hay otra.

Globos al rescate

Para mi último proyecto me decidí por los archivos con un patrón de nombre particular y luego los solicité al servidor uno por uno.

Importar rutas después de haber creado el objeto server

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

El patrón global **/*route*.js encontrará todos los archivos dentro y debajo del directorio de trabajo actual especificado con un nombre que contiene la ruta de la palabra y termina con el sufijo .js .

Estructura de archivos

Con la ayuda de globbing tenemos un acoplamiento suelto entre el objeto server y sus rutas. Simplemente agregue nuevos archivos de ruta y se incluirán la próxima vez que reinicie su servidor.

Me gusta estructurar los archivos de ruta de acuerdo con su ruta y nombrarlos con su método HTTP, de esta manera:

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

Ejemplo de rutas de archivo de routes/users/get-route.js

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

Pensamientos finales

Globos e iteraciones sobre archivos no son un proceso particularmente rápido, por lo tanto, vale la pena investigar una capa de almacenamiento en caché en las compilaciones de producción dependiendo de sus circunstancias.

Answer 3

Prueba el hapi-auto-route ! Es muy simple de usar y permite el prefijo en su ruta.

Answer 4

Puede crear un archivo separado para las rutas de usuario ( config/routes/user.js ):

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

Del mismo modo con el carrito. Luego cree un archivo de índice en config/routes ( config/routes/index.js ):

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

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

Luego puede cargar este archivo de índice en el archivo principal y llamar a server.route() :

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

...

server.route(routes);

Alternativamente, para config/routes/index.js route config/routes/index.js , en lugar de agregar los archivos de ruta (por ejemplo, cart , user ) manualmente, puede cargarlos dinámicamente:

const fs = require(''fs'');

let routes = [];

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

module.exports = routes;

Answer 5

Puede usar require-hapiroutes para hacer parte de la organización y cargar por usted. (Soy el autor, así que estoy un poco sesgado, lo escribí para facilitar mi vida en la gestión de rutas)

Soy un gran fan de require-directory y quería una forma de administrar mis rutas con la misma facilidad. Esto le permite mezclar y combinar rutas en sus módulos y módulos en directorios con rutas.

Entonces puedes hacer algo como esto ...

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

Luego, en su directorio podría tener un archivo de ruta como ...

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

O bien, puede mezclar y combinar asignando una propiedad de "rutas" en el módulo

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

Siempre, bueno tener opciones. Hay documentación completa en el sitio de github o require-hapiroutes para ello.

Answer 6

Sé que esto ya está aprobado. Dejo mi solución en caso de que alguien quiera una solución rápida y nueva en Hapi.

También incluí algunos NPM para que Newbees pueda ver cómo usar el server.register con varios complementos en el caso ( good + hapi-auto-route )

Instalamos algunos paquetes 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);
    });
});

En tus 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!'');
        } 
    },
];

Ahora ejecuta: node server.js

Aclamaciones

Answer 7

o puede usar un archivo de índice para cargar todas las rutas en el directorio

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;

Otros archivos en el mismo directorio como:

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

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

        }
    }
];

y que en tu raíz / índice

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