node.js &express - globální moduly a osvědčené postupy pro strukturu aplikací

Zde jsem zvolil jiný přístup. Neříkám, že je to nejlepší, ale dovolte mi to vysvětlit.

1. Každé schéma (a model) je ve vlastním souboru (modulu)
2. Každá skupina tras pro konkrétní prostředek REST je ve vlastním souboru (modulu)
3. Každý modul trasy pouze require s modelem Mongoose, který potřebuje (pouze 1)
4. Hlavní soubor (vstupní bod aplikace) pouze require všechny moduly trasy k jejich registraci.
5. Připojení Mongo je v kořenovém souboru a je předáno jako parametr všemu, co ho potřebuje.

V kořenovém adresáři aplikace mám dvě podsložky - routes a schemas .

Výhody tohoto přístupu jsou:

• Schéma napíšete pouze jednou.
• Neznečišťujete svůj hlavní soubor aplikace registrací tras pro 4–5 tras na prostředek REST (CRUD)
• Připojení DB definujete pouze jednou

Takto vypadá konkrétní soubor schématu:

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

Takto vypadá kolekce tras pro konkrétní zdroj:

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

A zde je soubor kořenové aplikace, který inicializoval připojení a registroval všechny trasy:

Soubor: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);

Doufám, že to bylo užitečné.