Mongoose-baserad app-arkitektur

När jag först kom in på Node.js, Express och Mongoose kämpade jag med att skala min kod. Avsikten med mitt svar är att hjälpa någon som arbetar med mer än bara en enkel blogg, utan att hjälpa till med ett ännu större skalbart projekt.

• Jag är alltid ansluten till databasen, jag öppnar och stänger inte anslutningar vid behov
• Jag använder index.js som rotfilen för en mapp, precis som vi skulle göra på andra språk
• modeller sparas i sina egna dokument och require() d till models/index.js fil.
• rutter liknar modeller, varje ruttnivå har en mapp som har en index.js fil i sin tur. Så det är lätt att ordna något som http://example.com/api/documents/:id . Det är också mer meningsfullt när man går igenom filstrukturen.

Här är strukturen för det jag använder:

-- 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å för varje modell som du arbetar med skapar du en model.js dokument och lägg till det i models/index.js ovan. Som ett exempel har jag lagt till en User modell men kommenterade 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
}

föreslagen användning

• modeller:för att skapa logiken som hanterar dokumenten, dvs skapa, uppdatera, ta bort och söka.
• rutter:minimal kodning, bara där jag behöver analysera http-data, skapa instanser av modeller och sedan skickar jag frågor till den relevanta modellen.
• metoder:för den mer komplexa logiken som inte direkt involverar modeller. Som ett exempel har jag en algorithms/ mapp där jag lagrar alla algoritmer som jag använder i min app.

Hoppas detta ger mer klarhet. Den här strukturen gör underverk för mig eftersom jag tycker att den är lätt att följa.