फ़ोल्डर में स्टोर मॉडल, index.js का उपयोग करने के लिए सभी

Question

मेरे पास एक सभ्य आकार प्रोजेक्ट है और मुझे थोड़ा पुनर्गठन करने की आवश्यकता है।

मैं नोड के लिए अपने ओआरएम के रूप में मोंगोज़ का उपयोग कर रहा हूं। मैं अपने सभी mongoose मॉडल 'मॉडल' नामक फ़ोल्डर में रखना चाहता हूं। मैंने पढ़ा है कि जब मैं ऐसा करता हूं तो मैं मॉडल फ़ोल्डर में index.js फ़ाइल डाल सकता हूं जो कि सभी मॉडलों में खींच लेगा और उन्हें स्टोर करेगा।

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

मैं कर रहा हूँ वास्तव में क्या मैं index.js में करने के लिए मेरे सभी मॉडल

index.js वापस जाने के लिए (यह है कि मैं क्या करने की कोशिश की है की जरूरत है पर अटक , यहां तक ​​कि बंद नहीं)

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; 

इसके अलावा, मैं app.js से नेवला में पास करना चाहिए के बाद से मैं मोंगो से कनेक्ट करने के वहाँ की जरूरत? अर्थात। मैं इसे index.js में फिर से आवश्यकता कर सकता हूं लेकिन मुझे यकीन नहीं है कि अलग-अलग फाइलों में एक ही मॉड्यूल की आवश्यकता है या नहीं।

संपादित करें: (यहाँ अपने मॉडल की पर है)

क्षमा करें कि मैं 'एक्सेसर' प्रकार कार्यों अपने मॉडल कक्षाओं में जोड़ने उल्लेख करना भूल गया। अर्थात। मैं प्रत्येक मॉडल के लिए एक सार्वजनिक इंटरफ़ेस प्रस्तुत करना चाहता हूं।

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

Node.js में, मॉड्यूल पहली बार वे लोड किए गए हैं के बाद कैश नहीं किया जाता। इसलिए आपको app.js. से mongoose पास करने की आवश्यकता नहीं है।

उदाहरण के लिए, में मॉडल/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. 

मॉडल में

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

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

बारे में और जानें node.js में कैशिंग कैशिंग: http://nodejs.org/api/modules.html#modules_caching

Answer 2

एक और बहुत अच्छा दृष्टिकोण एक सरल और स्पष्ट तरीके से सभी मॉडलों के कॉल करने के लिए हो सकता है इस एक:

परियोजना संरचना:

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