Op mangoest gebaseerde app-architectuur

Toen ik voor het eerst met Node.js, Express en Mongoose begon, worstelde ik met het schalen van mijn code. De bedoeling van mijn antwoord is om iemand te helpen die aan meer dan alleen een eenvoudige blog werkt, maar om te helpen met een nog groter schaalbaar project.

• Ik ben altijd verbonden met de database, ik open en sluit geen verbindingen wanneer dat nodig is
• Ik gebruik index.js als het hoofdbestand van een map, net zoals we zouden doen in andere talen
• modellen worden bewaard in hun eigen documenten, en require() d in de models/index.js bestand.
• routes zijn vergelijkbaar met modellen, elk routeniveau heeft een map met een index.js bestand op zijn beurt. Het is dus gemakkelijk om iets als http://example.com/api/documents/:id te regelen . Het is ook logischer als je de bestandsstructuur doorloopt.

Dit is de structuur van wat ik gebruik:

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

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

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

modellen/blog.js

Dus voor elk model waaraan u werkt, maakt u een model.js document, en voeg het toe in de models/index.js boven. Als voorbeeld heb ik een User . toegevoegd model, maar heeft er commentaar op gegeven.

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

voorgesteld gebruik

• modellen:voor het maken van de logica die met de documenten omgaat, d.w.z. maken, bijwerken, verwijderen en zoeken.
• routes:minimale codering, alleen waar ik http-gegevens moet ontleden, exemplaren van modellen moet maken en vervolgens query's naar het relevante model moet sturen.
• methoden:voor de meer complexe logica waarbij niet direct modellen betrokken zijn. Als voorbeeld heb ik een algorithms/ map waarin ik alle algoritmen opsla die ik in mijn app gebruik.

Hoop dat dit meer duidelijkheid geeft. Deze structuur doet wonderen voor mij omdat ik het gemakkelijk vind om te volgen.