नेवला-आधारित ऐप आर्किटेक्चर

जब मैं पहली बार Node.js, Express और Mongoose में आया तो मुझे अपने कोड को स्केल करने में कठिनाई हुई। मेरे उत्तर का उद्देश्य किसी ऐसे व्यक्ति की मदद करना है जो केवल एक साधारण ब्लॉग से अधिक पर काम कर रहा है, बल्कि इससे भी बड़े स्केलेबल प्रोजेक्ट में मदद करना है।

• मैं हमेशा डेटाबेस से जुड़ा रहता हूं, जरूरत पड़ने पर मैं कनेक्शन नहीं खोलता और बंद नहीं करता
• मैं index.js का उपयोग करता हूं किसी फ़ोल्डर की रूट फ़ाइल के रूप में, ठीक वैसे ही जैसे हम अन्य भाषाओं में करते हैं
• मॉडल अपने स्वयं के दस्तावेज़ों में रखे जाते हैं, और require() d models/index.js . में फ़ाइल।
• मार्ग मॉडल के समान होते हैं, प्रत्येक मार्ग स्तर में एक फ़ोल्डर होता है, जिसमें एक index.js होता है बदले में फ़ाइल। इसलिए http://example.com/api/documents/:id जैसी किसी चीज़ को व्यवस्थित करना आसान है . जब कोई फ़ाइल संरचना के माध्यम से जाता है तो यह अधिक समझ में आता है।

मैं जो उपयोग करता हूं उसकी संरचना यहां दी गई है:

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

मॉडल/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;

मॉडल/blog.js

इसलिए हर उस मॉडल के लिए जिस पर आप काम करते हैं, एक model.js बनाएं दस्तावेज़, और इसे models/index.js . में जोड़ें ऊपर। उदाहरण के तौर पर मैंने एक User जोड़ा है मॉडल लेकिन टिप्पणी की।

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

मार्ग/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
}

मार्ग/ब्लॉग/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
}

सुझाया गया उपयोग

• मॉडल:दस्तावेज़ों से संबंधित तर्क बनाने के लिए, यानी बनाना, अपडेट करना, हटाना और खोजना।
• मार्ग:न्यूनतम कोडिंग, केवल वहीं जहां मुझे http डेटा को पार्स करने की आवश्यकता है, मॉडल के उदाहरण बनाएं, और फिर मैं संबंधित मॉडल को प्रश्न भेजता हूं।
• तरीके:अधिक जटिल तर्क के लिए जिसमें सीधे तौर पर मॉडल शामिल नहीं होते हैं। उदाहरण के तौर पर, मेरे पास एक algorithms/ है फ़ोल्डर जहां मैं अपने ऐप में उपयोग किए जाने वाले सभी एल्गोरिदम संग्रहीत करता हूं।

आशा है कि यह और स्पष्टता प्रदान करता है। यह संरचना मेरे लिए अद्भुत काम कर रही है क्योंकि मुझे इसका पालन करना आसान लगता है।