node.js &express - modules globaux et meilleures pratiques pour la structure des applications

J'ai adopté une autre approche ici. Je ne dis pas que c'est le meilleur, mais laissez-moi vous expliquer.

1. Chaque schéma (et modèle) est dans son propre fichier (module)
2. Chaque groupe de routes pour une ressource REST particulière se trouve dans son propre fichier (module)
3. Chaque module d'itinéraire ne fait que require c'est le modèle Mangouste dont il a besoin (seulement 1)
4. Le fichier principal (point d'entrée de l'application) require s tous les modules de routage pour les enregistrer.
5. La connexion Mongo se trouve dans le fichier racine et est passée en paramètre à tout ce qui en a besoin.

J'ai deux sous-dossiers sous la racine de mon application - routes et schemas .

Les avantages de cette approche sont :

• Vous n'écrivez le schéma qu'une seule fois.
• Vous ne polluez pas votre fichier d'application principal avec des enregistrements d'itinéraires pour 4-5 itinéraires par ressource REST (CRUD)
• Vous ne définissez la connexion à la base de données qu'une seule fois

Voici à quoi ressemble un fichier de schéma particulier :

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

Voici à quoi ressemble une collection de routes pour une ressource particulière :

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

Et voici le fichier d'application racine, qui a initialisé la connexion et enregistre toutes les routes :

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

J'espère que cela vous a été utile.