Node.js & Express.js: rupture du fichier app.js

Question

Y a-t-il une convention commune pour casser vers le haut et modularisation du fichier app.js dans une application Express.js ? Ou est-il courant pour maintenir le tout dans un seul fichier ?

Answer 1

J'ai de la mine décomposée comme suit:

~/app
|~controllers
| |-monkey.js
| |-zoo.js
|~models
| |-monkey.js
| |-zoo.js
|~views
| |~zoos
|   |-new.jade
|   |-_form.jade
|~test
|  |~controllers
|    |-zoo.js
|  |~models
|    |-zoo.js
|-index.js

J'utilise les Exportations de revenir ce qui est pertinent. Par exemple, dans les modèles que je fais:

module.exports = mongoose.model('PhoneNumber', PhoneNumberSchema);

et puis si j'ai besoin de créer un numéro de téléphone, c'est aussi simple que:

var PhoneNumber = require('../models/phoneNumber');
var phoneNumber = new PhoneNumber();

si j'ai besoin d'utiliser le schéma, puis PhoneNumber.schema

(ce qui suppose que nous travaillons sur les routes du dossier et de la nécessité d'aller de l'1 niveau vers le haut et vers le bas pour les modèles)

---

EDIT 4

L' express wiki a une liste de cadres construite au-dessus d'elle.

De ceux-là, je pense que Twitter est matador est assez bien structuré. Nous avons en fait utilisé une approche très semblable à la façon dont ils chargent des parties de l'application.

derby.js aussi semble très intéressant. Il s'apparente à meteor sans tout le battage médiatique et, de fait, donne du crédit lorsque le crédit est dû, notamment, nœud et express).

---

EDIT 3

Si vous êtes un fan de CoffeeScript (je ne suis pas) et reeeeaaaaaally voulez L&F de Rails, il y a aussi Tower.js.

---

EDIT 2

Si vous êtes familier avec les Rails et ne pas l'esprit de la purge de certains concepts, il y a de la Locomotive. C'est une lumière-poids du cadre bâti sur l'Express. Il a une structure similaire comme RoR, et transporte plus de certains de la plus rudimentaire des concepts (tels que le routage).

Ça vaut le détour même si vous ne prévoyez pas de l'utiliser.

---

EDIT 1

nodejs-express-mangouste-démo est très similaire à la façon dont j'ai la mienne structuré. Check it out.

Answer 2

Avertissement: le référencement de code que j'ai bidouillé pour le nœud knock-out, ça fonctionne, mais est loin d'être élégant ou poli.

Pour être plus précis à propos de fractionnement app.js j'ai le texte suivant app.js fichier

var express = require('express'),
    bootstrap = require('./init/bootstrap.js'),
    app = module.exports = express.createServer();

bootstrap(app);

Ceci signifie fondamentalement, je place tous mes amorçage dans un autre fichier, puis je l'amorçage du serveur.

Donc, ce n'est bootstrap ?

var configure = require("./app-configure.js"),
    less = require("./watch-less.js"),
    everyauth = require("./config-everyauth.js"),
    routes = require("./start-routes.js"),
    tools = require("buffertools"),
    nko = require("nko"),
    sessionStore = new (require("express").session.MemoryStore)()

module.exports = function(app) {
    everyauth(app);
    configure(app, sessionStore);
    less();
    routes(app, sessionStore);
    nko('/9Ehs3Dwu0bSByCS');


    app.listen(process.env.PORT);
    console.log("server listening on port xxxx");
};

Bien qu'elle partage tous le serveur d'initialisation de l'installation à nice morceaux. Plus précisément

• J'ai un morceau qui met en place tous mes à distance à l'aide de l'authentification OAuth everyauth.
• J'ai un morceau qui configure mon application (appelant fondamentalement app.configure)
• J'ai un peu de code, qui perfore moins donc ça compile tout de mon moins en css au moment de l'exécution.
• J'ai un code qui définit toutes mes itinéraires
• J'appelle ce petit module nko
• Enfin, je démarre le serveur en écoute sur un port.

Juste pour exemple, regardons le routage de fichiers

var fs = require("fs"),
    parseCookie = require('connect').utils.parseCookie;

module.exports = function(app, sessionStore) {
    var modelUrl = __dirname + "/../model/",
        models = fs.readdirSync(modelUrl),
        routeUrl = __dirname + "/../route/"
        routes = fs.readdirSync(routeUrl);

Ici, je charge tous mes modèles et les itinéraires des tableaux de fichiers.

Avertissement: readdirSync est uniquement sur ok lorsque vous appelle avant de démarrer le serveur http (avant .listen). L'appel de synchronious appels de blocage au démarrage du serveur de temps tout simplement de rendre le code plus lisible (en gros, c'est un hack)

    var io = require("socket.io").listen(app);

    io.set("authorization", function(data, accept) {
        if (data.headers.cookie) {
            data.cookie = parseCookie(data.headers.cookie);

            data.sessionId = data.cookie['express.sid'];

            sessionStore.get(data.sessionId, function(err, session) {

                if (err) {
                    return accept(err.message, false);
                } else if (!(session && session.auth)) {
                    return accept("not authorized", false)
                }
                data.session = session;
                accept(null, true);
            });
        } else {
            return accept('No cookie', false);
        }
    });

Ici, j'ai punch socket.io réellement l'autorisation d'utilisation, plutôt que de les laisser tom et jack en parler à mon socket.io server

    routes.forEach(function(file) {
        var route = require(routeUrl + file),
            model = require(modelUrl + file);

        route(app, model, io);
    });
};

Ici, je commence mes itinéraires en passant par le modèle pertinent dans chaque itinéraire objet retourné à partir du fichier de route.

Fondamentalement, le jist est vous organiser le tout dans de jolies petites modules et ensuite, l'amorçage du mécanisme.

Mon autre projet (mon blog) a un fichier init avec une structure similaire.

Avertissement: le blog est cassé et de ne pas construire, je suis en train de travailler sur elle.

Answer 3

Pour une organisation de routage maintenable, vous pouvez consulter cet article sur le module de nœud express-routescan et l’essayer. C'est la meilleure solution pour moi.