Architettura dell'app basata su Mongoose

Quando sono entrato per la prima volta in Node.js, Express e Mongoose ho faticato a ridimensionare il mio codice. L'intenzione della mia risposta è aiutare qualcuno che sta lavorando su qualcosa di più di un semplice blog, ma aiutare con un progetto scalabile ancora più ampio.

• Sono sempre connesso al database, non apro e chiudo connessioni quando necessario
• Uso index.js come file radice di una cartella, proprio come faremmo in altre lingue
• i modelli sono conservati nei propri documenti e require() d nel models/index.js file.
• i percorsi sono simili ai modelli, ogni livello di percorso ha una cartella, che ha un index.js file a sua volta. Quindi è facile organizzare qualcosa come http://example.com/api/documents/:id . Ha anche più senso quando si passa attraverso la struttura del file.

Ecco la struttura di ciò che 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

app.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)

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

models/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;

models/blog.js

Quindi per ogni modello su cui lavori crei un model.js documento e aggiungilo in models/index.js sopra. Ad esempio ho aggiunto un User modello ma l'ho commentato.

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

percorsi/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
}

percorsi/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 suggerito

• modelli:per creare la logica che si occupa dei documenti, ovvero creare, aggiornare, eliminare e cercare.
• percorsi:codifica minima, solo dove devo analizzare i dati http, creare istanze di modelli e quindi inviare query al modello pertinente.
• metodi:per le logiche più complesse che non coinvolgono direttamente i modelli. Ad esempio, ho un algorithms/ cartella in cui conservo tutti gli algoritmi che utilizzo nella mia app.

Spero che questo fornisca maggiore chiarezza. Questa struttura sta facendo miracoli per me poiché la trovo facile da seguire.