node.js - tutorial - npm

Cómo separar las rutas y modelos de app.js usando NodeJS y Express

Question

Estoy creando una aplicación usando Node y Express. Sin embargo, puedo ver que pronto será difícil administrar todas las rutas que se colocan dentro de app.js He colocado todos mis modelos en un subdirectorio /models .

Aquí está la estructura actual de mi aplicación:

app.js
models
  -- products
  -- customers
  -- ...
public
views
node_modules

En app.js :

var express = require(''express''),
    routes = require(''./routes''),
    user = require(''./routes/user''),
    http = require(''http''),
    path = require(''path''),
    EmployeeProvider = require(''./models/employeeprovider'').EmployeeProvider,
    Products = require(''./models/products'').Products,
    Orders = require(''./models/orders'').Orders,
    Customers = require(''./models/customers'').Customers,
    checkAuth = function(req, res, next) {
      if (!req.session.user_id) {
        res.send(''You are not authorized to view this page'');
      } else {
        next();
      }
    };

var app = express();

Luego, algunas configuraciones como port , directorio de views , motor de renderizado, etc.

Más abajo en app.js tengo las rutas:

app.get(''/product/edit'', auth, function(req, res) {
  Products.findAll(function(error, prds) {
    res.render(''product_edit'', {
      title: ''New Product'',
      products: prds
    });
  });
});

En la parte superior, estoy asignando los contenidos de models/products.js a una variable, todo funciona bien. Sin embargo, mantener todas las rutas dentro de app.js no es ideal. Pero si muevo las rutas a routes/product.js y cargo los modelos de Products :

var prod = require(''../models/products.js'');

Me sale un error al decir que el objeto no tiene el método findAll .

¿Qué estoy haciendo mal? ¿Cómo puedo eliminar las rutas de app.js ?

Answer 1

A partir del Router expreso 4.x se agrega para apoyar su caso.

Un objeto de enrutador es una instancia aislada de middleware y rutas. Puede considerarlo como una "miniaplicación", que solo puede realizar funciones de enrutamiento y middleware. Cada aplicación Express tiene un enrutador de aplicaciones integrado.

Ejemplo del sitio expressjs :

// routes/calendarRouter.js

var express  = require(''express'');
var router = express.Router();

// invoked for any requested passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});

// will handle any request that ends in /events
// depends on where the router is "use()''d"
router.get(''/events'', function(req, res, next) {
  // ..
});

module.exports = router;

Luego en app.js:

// skipping part that sets up app

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

// only requests to /calendar/* will be sent to our "router"
app.use(''/calendar'', calendarRouter);

// rest of logic

Answer 2

Como no me gusta la repetición, esto es lo que hago:

// app.js
//...
var routes = requireDir(''./routes''); // https://www.npmjs.org/package/require-dir
for (var i in routes) app.use(''/'', routes[i]);
//...

Y cada archivo en rutas es como:

// routes/someroute.js
var express  = require(''express'');
var router   = express.Router();

router.get(''/someroute'', function(req, res) {
    res.render(''someview'', {});
});

module.exports = router;

De esta forma puedes evitar largas listas repetitivas como esta:

app.use(''/''           , require(''./routes/index''));
app.use(''/repetition'' , require(''./routes/repetition''));
app.use(''/is''         , require(''./routes/is''));
app.use(''/so''         , require(''./routes/so''));
app.use(''/damn''       , require(''./routes/damn''));
app.use(''/boring''     , require(''./routes/boring''));

Editar: estos largos ejemplos suponen que cada archivo de ruta contiene algo como lo siguiente:

var router = express.Router();
router.get(''/'', function(req, res, next) {
    // ...
    next();
});
module.exports = router;

Todos ellos podrían montarse en "raíz", pero para ellos es "raíz", en realidad es una ruta específica dada a app.use , porque puede montar rutas en rutas específicas (esto también admite cosas como especificar la ruta con un regex, Express es bastante limpio en lo que respecta a lo que puede hacer con el enrutamiento).

Answer 3

Puedo sugerirle esta estructura de archivos (de acuerdo con las aplicaciones web modulares con Node.js y Express de tjholowaychuk ):

app.js
   modules
      users
         index.js
         model.js
      users-api
         index.js
      static-pages
         index.js

user-api y static-pages exportan aplicaciones expressjs, puede montarlas fácilmente en app.js. En el módulo de users , puede describir algunas operaciones de acceso a datos y todos los métodos de manipulación con la entidad de usuario (como crear, actualizar, etc.). Nuestro módulo API usará todos estos métodos.

Y aquí está el código de muestra del archivo app.js (sin elementos expresos comunes, solo rutas de montaje de diferentes módulos):

var express = require(''express'');
var app = express();

// mount all the applications
app.use(''/api/v1'', require("user-api"));
app.use(require("static-pages"));

app.listen(3000);

Para usar sus módulos de esta manera, debe iniciar su aplicación de la siguiente manera NODE_PATH=modules node app.js (pongo esta línea en el archivo package.json en la sección de scripts).

Aquí está el código de muestra del módulo de users :

index.js

User = require("./model");

module.exports = {
    get: function(id, callback) {
        User.findOne(id, function(err, user) {
           callback(err, user);
        });
    },
    create: function(data, callback) {
        // do whatever with incoming data here
        data = modifyDataInSomeWay(data);
        var newUser = new User(data);
        newUser.save(function(err, savedUser) {
            // some logic here
            callback(err, savedUser); 
        });
    }
};

model.js (¡con cosas de Mangosta, por supuesto, por supuesto!)

var mongoose = require(''mongoose'');
var Schema = mongoose.Schema;

var User = new Schema({
    firstname   : {type: String, required: false},
    lastname    : {type: String, required: false},
    email       : {type: String, required: true}
});

module.exports = mongoose.model(''user'', User);

Y un ejemplo del módulo user-api (aquí está la parte principal de la respuesta sobre la separación de rutas y modelos).

var users = require("users");

var express = require("express");
var app = module.exports = express(); // we export new express app here!

app.post(''/users'', function(req, res, next) {
    // try to use high-level calls here
    // if you want something complex just create another special module for this
    users.create(req.body, function(err, user) {
        if(err) return next(err); // do something on error
        res.json(user); // return user json if ok
    });
});

Y ejemplo de static-pages . Si no va a construir un tipo de interfaz REST, puede simplemente crear varios módulos que solo renderizarán páginas.

var express = require("express");
var app = module.exports = express(); // we export new express app here again!

app.get(''/'', function(req, res, next) {
    res.render(''index'', {user: req.user});
});

app.get(''/about'', function(req, res, next) {
    // get data somewhere and put it in the template
    res.render(''about'', {data: data});
});

Por supuesto, puedes hacer lo que quieras con los módulos. La idea principal sobre expressjs es usar muchas aplicaciones pequeñas en lugar de una sola.

Acerca de los módulos de nodejs puedes leer y docs .

Espero que esto ayude.