Mangouste application basée sur l'architecture

Quand je suis arrivé dans Node.js, d'Exprimer et de Mangoustes, j'ai du mal avec mise à l'échelle de mon code.
L'intention de ma réponse est pour aider quelqu'un qui travaille plus qu'un simple blog, mais pour les aider avec encore plus évolutive du projet.

• Je suis toujours connecté à la base de données, je ne suis pas ouvrir et fermer les connexions en cas de besoin
• - Je utiliser index.js comme la racine de fichier d'un dossier, tout comme on le ferait dans d'autres langues
• modèles sont conservées dans leurs propres documents, et require()d dans le models/index.js fichier.
• routes sont similaires aux modèles, chaque niveau a un dossier, qui a un index.js fichier. Il est donc facile d'organiser quelque chose comme http://example.com/api/documents/:id. Il rend également plus de sens lorsque l'on traverse la structure du fichier.

Voici la structure de ce que j'utilise:

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

Ainsi, pour chaque modèle que vous travaillez sur vous créez un model.js document, et l'ajouter dans la models/index.js ci-dessus. Comme un exemple, j'ai ajouté un User modèle, mais ont souligné qu'il.

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

utilisation suggérée

• modèles: pour la création de la logique qui traite avec les documents, c'est à dire la création, la mise à jour, la suppression et la recherche.
• routes: un codage minimal, seulement lorsque j'ai besoin d'analyser des données http, créer des instances de modèles, puis-je envoyer des requêtes pour le modèle en question.
• méthodes: pour la logique plus complexe qui ne sont pas directement liées à des modèles. Comme un exemple, j'ai une algorithms/ dossier où je stocke toutes les algorithmes que j'utilise dans mon application.

Espère que cela donne plus de clarté. Cette structure fonctionne des merveilles pour moi comme je l'ai trouver, il est facile à suivre.