node.js &express - globale moduler og bedste praksis for applikationsstruktur

Jeg har valgt en anden tilgang her. Jeg siger ikke, at det er det bedste, men lad mig forklare.

1. Hvert skema (og model) er i sin egen fil (modul)
2. Hver gruppe af ruter for en bestemt REST-ressource er i deres egen fil (modul)
3. Hvert rutemodul require er Mongoose-modellen, den har brug for (kun 1)
4. Hovedfilen (applikationens indgangspunkt) require s alle rutemoduler for at registrere dem.
5. Mongo-forbindelsen er i rodfilen og sendes som parameter til det, der har brug for det.

Jeg har to undermapper under min app-rod - routes og schemas .

Fordelene ved denne tilgang er:

• Du skriver kun skemaet én gang.
• Du forurener ikke din hovedapp-fil med ruteregistreringer for 4-5 ruter pr. REST-ressource (CRUD)
• Du definerer kun DB-forbindelsen én gang

Sådan ser en bestemt skemafil ud:

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

Sådan ser en samling af ruter for en bestemt ressource ud:

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

Og her er rodapplikationsfilen, som initialiserede forbindelsen og registrerer alle ruter:

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

Håber dette var nyttigt.