Mongoose-baseret app-arkitektur

Da jeg først kom ind på Node.js, Express og Mongoose, kæmpede jeg med at skalere min kode. Hensigten med mit svar er at hjælpe nogen, der arbejder på mere end blot en simpel blog, men at hjælpe med et endnu større skalerbart projekt.

• Jeg er altid forbundet til databasen, jeg åbner og lukker ikke forbindelser, når det er nødvendigt
• Jeg bruger index.js som rodfilen til en mappe, ligesom vi ville gøre på andre sprog
• modeller opbevares i deres egne dokumenter og require() d i models/index.js fil.
• ruter ligner modeller, hvert ruteniveau har en mappe, som har en index.js fil på skift. Så det er nemt at arrangere noget som http://example.com/api/documents/:id . Det giver også mere mening, når man går gennem filstrukturen.

Her er strukturen for det, jeg bruger:

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

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

Så for hver model, du arbejder på, opretter du en model.js dokument, og tilføj det i models/index.js over. Som et eksempel har jeg tilføjet en User model, men kommenterede det.

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

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

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

foreslået brug

• modeller:til at skabe den logik, der omhandler dokumenterne, dvs. oprettelse, opdatering, sletning og søgning.
• ruter:minimal kodning, kun hvor jeg skal parse http-data, oprette forekomster af modeller, og så sender jeg forespørgsler til den relevante model.
• metoder:til den mere komplekse logik, der ikke direkte involverer modeller. Som et eksempel har jeg en algorithms/ mappe, hvor jeg gemmer alle de algoritmer, som jeg bruger i min app.

Håber dette giver mere klarhed. Denne struktur gør underværker for mig, da jeg finder den let at følge.