Arquitectura de aplicaciones basada en Mongoose

Cuando entré por primera vez en Node.js, Express y Mongoose, tuve problemas para escalar mi código. La intención de mi respuesta es ayudar a alguien que está trabajando en algo más que un simple blog, pero ayudar con un proyecto escalable aún más grande.

• Siempre estoy conectado a la base de datos, no abro ni cierro conexiones cuando es necesario
• Uso index.js como el archivo raíz de una carpeta, tal como lo haríamos en otros idiomas
• los modelos se mantienen en sus propios documentos y require() d en models/index.js archivo.
• las rutas son similares a los modelos, cada nivel de ruta tiene una carpeta, que tiene un index.js archivo a su vez. Entonces es fácil organizar algo como http://example.com/api/documents/:id . También tiene más sentido cuando uno recorre la estructura de archivos.

Aquí está la estructura de lo que uso:

-- app.js
-- models/
---- index.js
---- blog.js
-- mongoose/
---- index.js
-- routes/
---- index.js
---- blog/index.js
-- public/
-- views/
---- index.{your layout engine} => I use Jade.lang
-- methods/
---- index.js => use if you'd rather write all your functions here
---- blog.js => can store more complex logic here

aplicación.js

var db = require('./mongoose'),
  express = require('express');
// note that I'm leaving out the other things like 'http' or 'path'
var app = express();

// get the routes
require('./routes')(app);
// I just require routes, without naming it as a var, & that I pass (app)

mangosta/index.js

// Mongoose connect is called once by the app.js & connection established
// No need to include it elsewhere
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost/blog');

// I have just connected, and I'm not exporting anything from here

modelos/index.js

// Logic here is to keep a good reference of what's used

// models
Blog = require('./blog');
// User = require('./user');

// exports
exports.blogModel = Blog.blogModel;
// exports.userModel = User.userModel;

modelos/blog.js

Entonces, para cada modelo en el que trabajas, creas un model.js documento y agréguelo en models/index.js sobre. Como ejemplo, he agregado un User modelo pero lo comentó.

// set up mongoose
var mongoose = require('mongoose');
var Schema = mongoose.Schema,
ObjectId = Schema.ObjectId;

var BlogSchema = Schema({
  header: {type: String },
  author: {type: String },
  text: {type: String },
  _id: { type: ObjectId } // not necessary, showing use of ObjectId
});

Blog = mongoose.model('Blog', BlogSchema);
// the above is necessary as you might have embedded schemas which you don't export

exports.blogModel = Blog;

rutas/index.js

module.exports = function(app) {
  app.get('/', function(req, res) {
    // do stuff
  });
  require('./blog')(app);
  // other routes entered here as require(route)(app);
  // we basically pass 'app' around to each route
}

rutas/blog/index.js

module.exports = function(app) {
  app.get('/blog', function(req, res) {
    // do stuff
  });
  require('./nested')(app);
  // this is for things like http://example.com/blog/nested
  // you would follow the same logic as in 'routes/index.js' at a nested level
}

uso sugerido

• modelos:para crear la lógica que trata con los documentos, es decir, crear, actualizar, eliminar y buscar.
• rutas:codificación mínima, solo donde necesito analizar datos http, crear instancias de modelos y luego enviar consultas al modelo relevante.
• métodos:para la lógica más compleja que no involucra modelos directamente. Como ejemplo, tengo un algorithms/ carpeta donde almaceno todos los algoritmos que uso en mi aplicación.

Espero que esto proporcione más claridad. Esta estructura está funcionando de maravilla para mí, ya que me resulta fácil de seguir.