Architettura app basata su Mongoose

Question

Questa non è una domanda concreta di codice/app, si tratta solo dell'architettura di app comune.

Sto cercando di capire il modo corretto di organizzare la mia applicazione mangusta. Come io sono nuovo a mangusta, è così che lo faccio ora:

nucleo/settings.js

var mongoose = require('mongoose'); 
exports.mongoose = mongoose; 
mongoose.connect('mongodb://localhost/blog'); 
exports.db = mongoose.connection; 

nucleo/models.js

settings = require("./settings"); 

// post schema 
var postSchema = settings.mongoose.Schema({ 
    header: String, 
    author: String, 
    text: String 
}) 

//compiling our schema into a Model 
exports.post = settings.mongoose.model('post', postSchema) 

core/db-layer.js

settings = require("./core/settings"); 
models = require("./core/models"); 

exports.function = createAndWriteNewPost(function(callback) { 
    settings.db.on('error', console.error.bind(console, 'connection error:')); 
    settings.db.once('open', function callback() { 
     new models.post({ 
      header: 'header', 
      author: "author", 
      text: "Hello" 
     }).save(function(err, post) { 
      callback('ok'); 
     }); 
    }); 
}); 

percorsi/post.js

db = reqiure("../core/db.js") 

exports.get = function(req, res) { 
    db.createAndWriteNewPost(function(status){ 
    res.render('add_material', { 
     //blah blah blah   
     }); 
    }); 
}; 

app.js

var post = require ('routes/post.js') 
... 
app.get('/post', post.get); 

Quindi, questo codice è stato estremamente semplificata (anche non testato) solo per mostrare il mio pensiero attuale architettura. Non è un'app concreta, solo qualcosa come creare un post sul blog astratto. Ecco come funziona:

app.js --> routes/post.js <--> core/db-layer.js 
            | 
            v 
           core/models.js <--> core/settings.js 

Sembra un po 'superfluo per me. Potresti suggerire una struttura di app più ottimale? Grazie.

Answer 1

che è praticamente come vado su di esso, con alcune differenze:

• non credo che si può avere l'ascoltatore aperta all'interno della vostra funzione nel db-layer. Quello che generalmente faccio quando si utilizza una connessione persistente come la tua è avviare l'applicazione stessa nel gestore db open. Se non si desidera utilizzare connessioni persistenti, utilizzare createConnection nella funzione db layer e assicurarsi di chiuderlo prima di chiamare il callback. Non sono sicuro di essere chiaro. Fammi sapere se vuoi un esempio di codice.
• Questo è più di un consiglio generale node.js, ma tengo la mia stringa di connessione al database e altra configurazione in un file JSON e lo richiedono ovunque sia necessario. Probabilmente non avrai più bisogno di un altro file settings.js dopo.
• È inoltre possibile utilizzare le funzioni dello schema (http://mongoosejs.com/docs/api.html#schema_Schema-method) per codificare alcune funzionalità dell'app nei propri modelli.

Answer 2

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

• Sono sempre collegato alla base di dati, non mi connessioni aperte e si chiudono quando necessario
• Io uso index.js come root file di una cartella, proprio come faremmo in altre lingue
• modelli sono conservati nei propri documenti e require() nel file models/index.js.
• percorsi sono simili ai modelli, ogni livello di percorso ha una cartella, che ha a sua volta un file index.js. Quindi è facile organizzare qualcosa come http://example.com/api/documents/:id. Ha anche più senso quando si passa attraverso la struttura dei file.

Ecco la struttura di quello che io 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 

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

modelli/blog.js

Quindi per ogni modello che si lavora su si crea un documento model.js, e aggiungere nella models/index.js sopra. Ad esempio ho aggiunto un modello User ma 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 
} 

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

hanno suggerito l'uso

modelli
• : per creare la logica che si occupa dei documenti, ovvero la creazione, l'aggiornamento, l'eliminazione e la ricerca.
• percorsi: codifica minima, solo dove è necessario analizzare i dati http, creare istanze di modelli e quindi inviare query al modello pertinente.
metodi
• : per la logica più complessa che non coinvolge direttamente i modelli. Ad esempio, ho una cartella algorithms/ in cui memorizzo tutti gli algoritmi che utilizzo nella mia app.

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