node.js &express - wereldwijde modules en best practices voor applicatiestructuur

Ik heb hier een andere benadering gekozen. Ik zeg niet dat het de beste is, maar laat het me uitleggen.

1. Elk schema (en model) staat in zijn eigen bestand (module)
2. Elke groep routes voor een bepaalde REST-bron bevindt zich in een eigen bestand (module)
3. Elke routemodule is slechts require s het Mongoose-model dat het nodig heeft (slechts 1)
4. Het hoofdbestand (toegangspunt van de toepassing) is slechts require s alle routemodules om ze te registreren.
5. De Mongo-verbinding bevindt zich in het rootbestand en wordt als parameter doorgegeven aan alles wat het nodig heeft.

Ik heb twee submappen onder mijn app root - routes en schemas .

De voordelen van deze aanpak zijn:

• Je schrijft het schema maar één keer.
• U vervuilt uw hoofdapp-bestand niet met routeregistraties voor 4-5 routes per REST-bron (CRUD)
• U definieert de DB-verbinding maar één keer

Zo ziet een bepaald schemabestand eruit:

Bestand:/schemas/theaterSchema.js

module.exports = function(db) {
        return db.model('Theater', TheaterSchema());
}

function TheaterSchema () {
        var Schema = require('mongoose').Schema;

        return new Schema({
            title: { type: String, required: true },
            description: { type: String, required: true },
            address: { type: String, required: true },
            latitude: { type: Number, required: false },
            longitude: { type: Number, required: false },
            phone: { type: String, required: false }
    });
}

Hier ziet u hoe een verzameling routes voor een bepaalde bron eruitziet:

Bestand:/routes/theaters.js

module.exports = function (app, options) {

    var mongoose = options.mongoose;
    var Schema = options.mongoose.Schema;
    var db = options.db;

    var TheaterModel = require('../schemas/theaterSchema')(db);

    app.get('/api/theaters', function (req, res) {
            var qSkip = req.query.skip;
            var qTake = req.query.take;
            var qSort = req.query.sort;
            var qFilter = req.query.filter;
            return TheaterModel.find().sort(qSort).skip(qSkip).limit(qTake)
            .exec(function (err, theaters) {
                    // more code
            });
    });

    app.post('/api/theaters', function (req, res) {
      var theater;

      theater.save(function (err) {
        // more code
      });
      return res.send(theater);
    });

    app.get('/api/theaters/:id', function (req, res) {
      return TheaterModel.findById(req.params.id, function (err, theater) {
        // more code
      });
    });

    app.put('/api/theaters/:id', function (req, res) {
      return TheaterModel.findById(req.params.id, function (err, theater) {
        // more code
      });
    });

    app.delete('/api/theaters/:id', function (req, res) {
      return TheaterModel.findById(req.params.id, function (err, theater) {
        return theater.remove(function (err) {
          // more code
        });
      });
    });
};

En hier is het root-toepassingsbestand, dat de verbinding heeft geïnitialiseerd en alle routes registreert:

Bestand:app.js

var application_root = __dirname,
        express = require('express'),
        path = require('path'),
        mongoose = require('mongoose'),
        http = require('http');

var app = express();

var dbProduction = mongoose.createConnection('mongodb://here_insert_the_mongo_connection_string');

app.configure(function () {
        app.use(express.bodyParser());
        app.use(express.methodOverride());
        app.use(app.router);
        app.use(express.static(path.join(application_root, "public")));
        app.use('/images/tmb', express.static(path.join(application_root, "images/tmb")));
        app.use('/images/plays', express.static(path.join(application_root, "images/plays")));
        app.use(express.errorHandler({ dumpExceptions: true, showStack: true }));
});

app.get('/api', function (req, res) {
        res.send('API is running');
});

var theatersApi = require('./routes/theaters')(app, { 'mongoose': mongoose, 'db': dbProduction });
// more code

app.listen(4242);

Ik hoop dat dit nuttig was.