Speichern Sie Modelle in Ordner, verwenden Sie index.js, um sie alle zu benötigen

Question

Ich habe eine anständige Größe Projekt und ich muss ein wenig Umstrukturierung tun.

Ich benutze Mungo als mein ORM für Knoten. Ich würde gerne alle meine Mungo-Models in einen Ordner namens "Models" stecken. Ich habe gelesen, dass wenn ich das tue, ich eine index.js-Datei in den Modellordner legen kann, so dass alle Modelle eingezogen und gespeichert werden.

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

ich auf genau steckte immer, was ich brauche in dem index.js zu tun all

index.js meine Modelle zurück (das ist, was ich versucht habe, , nicht einmal in der Nähe)

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; 

auch soll ich in Mungo von dem app.js passieren, da ich dort mongo benötigt verbinden? I.E. Ich kann es wieder in der index.js anfordern, aber ich bin mir nicht sicher, ob die Verwendung desselben Moduls in verschiedenen Dateien eine schlechte Übung ist.

EDIT: (hier auf meinen Modelle)

Leider vergaß zu erwähnen, dass ich ‚Accessor‘ Typ Funktionen in meinen Modellklassen hinzufügen. I.E. Ich möchte für jedes Modell eine öffentliche Schnittstelle präsentieren.

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 werden die Module nach dem ersten Mal zwischengespeichert sie geladen werden. Sie müssen also nicht die mongoose aus der app.js übergeben.

Zum Beispiel in Modellen/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. 

in Modellen/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(); 
    ... 
}); 

Erfahren Sie mehr über Die Module, die in node.js zwischengespeichert werden: http://nodejs.org/api/modules.html#modules_caching

Answer 2

Ein weiterer sehr schöner Ansatz, der alle Modelle in einer einfachen und klaren Art und Weise zu nennen dies sein könnte:

Projektstruktur:

. 
├── 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); 
})