Memorizza i modelli nella cartella, usa index.js per richiederli tutti

Question

Ho un progetto di dimensioni decenti e devo fare una piccola ristrutturazione.

Sto usando mangusta come ORM per il nodo. Vorrei mettere tutti i miei modelli di mangusta in una cartella chiamata "modelli". Ho letto che, quando lo faccio, posso inserire un file index.js nella cartella dei modelli in modo tale che sia in grado di richiamare tutti i modelli e memorizzarli.

app.js:

... 
var mongoose = require('mongoose'); 
var models = require('./models')(mongoose); 

app.configure(function() { 
    mongoose.connect(dbPath, function(err) { 
    if (err) throw err; 
    }); 
    ... 
}); 

// include models in my routes so I need access 
... 

mi sto bloccato su esattamente che cosa ho bisogno di fare nei index.js di restituire tutti i miei modelli

index.js (questo è quello che ho provato , non è nemmeno vicino)

function Models(mongoose) { 
    var Counters = require('./counters')(mongoose); 
    var User = require('./user')(mongoose); 
    var Token = require('./token')(mongoose); 
    var Team = require('./team')(mongoose); 
    var Role = require('./role')(); 
    var Layer = require('./layer')(mongoose, counters); 
    var Feature = require('./feature')(mongoose, counters, async); 


} 

module.exports = Models; 

Inoltre devo passare lucertolone dalle app.js da quando avevo bisogno c'è di connettersi a mongo? OSSIA Posso richiederlo di nuovo nel file index.js ma non sono sicuro che richiedere lo stesso modulo in file diversi sia una cattiva pratica.

EDIT: (qui è su dei miei modelli)

dispiace dimenticato di dire che aggiungo funzioni 'di accesso' di tipo nelle mie classi del modello. OSSIA Vorrei presentare un'interfaccia pubblica per ciascun modello.

user.js:

module.exports = function(mongoose) { 

    // Creates a new Mongoose Schema object 
    var Schema = mongoose.Schema; 

    // Collection to hold users 
    var UserSchema = new Schema({ 
     username: { type: String, required: true }, 
     password: { type: String, required: true }, 
    },{ 
     versionKey: false 
    } 
); 

    // Creates the Model for the User Schema 
    var User = mongoose.model('User', UserSchema); 

    var getUserById = function(id, callback) { 
    User.findById(id, callback); 
    } 

    var getUserByUsername = function(username, callback) { 
    var query = {username: username}; 
    User.findOne(query, callback); 
    } 


    return { 
    getUserById: getUserById, 
    getUserByUsername: getUserByUsername 
    } 
} 

Answer 1

In node.js, moduli vengono memorizzate nella cache dopo la prima volta che vengono caricati. Quindi non è necessario passare il mongoose dall'app.js.

Per esempio, nei modelli/index.js:

require('./counters') 
exports.User = require('./user') 
require('./token'); 
require('./team'); 
require('./role'); 
require('./layer'); 
require('./feature'); 
// I prefer to use a loop to require all the js files in the folder. 

nei modelli/user.js:

var mongoose = require('mongoose'); 
var userSchema = mongoose.Schema({ 
    // ... Define your schema here 
}); 

var User = module.exports = mongoose.model('User', userSchema); 
module.exports.getUserById = function(id, callback) { 
    User.findById(id, callback); 
} 

module.exports.getUserByUsername = function(username, callback) { 
    var query = {username: username}; 
    User.findOne(query, callback); 
} 

in app.js:

var mongoose = require('mongoose'); 
var models = require('./models'); 

mongoose.connect(dbPath, function(err) { 
    if (err) throw err; 
}); 

// Yes! You can use the model defined in the models/user.js directly 
var UserModel = mongoose.model('User'); 

// Or, you can use it this way: 
UserModel = models.User; 

app.get('/', function(req, res) { 
    var user = new UserModel(); 
    user.name = 'bob'; 
    user.save(); 
    // UserModel.getUserByUsername(); 
    ... 
}); 

Per saperne di più su la cache dei moduli in node.js: http://nodejs.org/api/modules.html#modules_caching

Answer 2

Un altro approccio molto bello per chiamare tutti i modelli in modo semplice e chiaro potrebbe essere questa:

Struttura del progetto:

. 
├── app.js 
└── models 
   ├── Role.js 
   ├── Team.js 
   └── User.js 

app.js

const fs = require('fs'); 
const path = require('path'); 

const modelsPath = path.resolve(__dirname, 'models') 
fs.readdirSync(modelsPath).forEach(file => { 
    require(modelsPath + '/' + file); 
})