Comment organiser un nœud application qui utilise sequelize?

La courte histoire de

L'astuce dans ce cas est de ne pas initialiser le modèle dans le fichier mais simplement de fournir le nécessaire de l'information pour son initialisation et de laisser un module centralisé prendre soin des modèles d'installation et de l'instanciation.

Afin que les étapes sont les suivantes:

• Avez plusieurs fichiers de Modèle aux données du modèle, comme les champs, les relations et les options.
• Ont un singleton module qui permet de charger tous les fichiers de configuration et toutes les classes du modèle et les relations.
• Installation de votre singleton module à l'app.js fichier.
• Obtenir le modèle de classes à partir de la singleton module ne pas utilisation require sur vos fichiers de modèle, de charger les modèles de la singleton à la place.

La longue histoire

Voici une description plus détaillée de cette solution avec le code source correspondant:

http://jeydotc.github.io/blog/2012/10/30/EXPRESS-WITH-SEQUELIZE.html

EDIT: C'est un très vieux la réponse! (lire vers le bas pour info)

Qu'il est vieux et limitée à bien des égards!

• Première, comme @jinglesthula mentionné dans les commentaires (et je l'ai vécu aussi) - il y a des problèmes exigeant de ces fichiers. C'est parce que require ne fonctionne pas de la même manière que readdirSync!

• Deuxième - vous très limitée dans les relations - le code ne fournit pas options à ces associations afin de vous INCAPABLE pour créer belongsToMany comme il se doit through de la propriété. Vous pouvez faire la plupart de base assocs.

• Troisième - vous sont très limitées dans le modèle des relations! Si vous lisez attentivement le code, vous verrez que les relations est un Objet au lieu d'une Tableau, donc si vous voulez faire plus d'un associations du même type (comme d'avoir deux fois belongsTo) - vous ne pouvez pas!

• Quatrième - Vous n'avez pas besoin que singleton truc. Chaque module nodejs est un singleton par lui-même, donc tout cela est assez complexe pour aucune raison.

Vous devriez voir la Ferme de la réponse! (Le lien vers l'article est cassé, mais je vais le fixer avec cet échantillon officiel de sequelize: https://github.com/sequelize/express-example/blob/master/models/index.js - vous pouvez parcourir l'ensemble du projet pour avoir une idée de ce qui se passe).

p.s.
Je suis en train de modifier ce post car il est upvoted que les gens ne voient même pas toutes les nouvelles réponses (comme je l'ai fait).

Edit: Viens de modifier le lien vers une copie de la même post, mais dans une Page Github

J'ai créer un package sequelize-se connecter pour aider les gens à composer avec ce problème. Il suit la Sequelize suggéré convention ici: http://sequelize.readthedocs.org/en/1.7.0/articles/express/

En outre, il a également des fonctions un peu plus comme la Mangouste en termes de son interface. Il vous permet de spécifier un ensemble de lieux où vos modèles sont situés et vous permet également de définir une correspondance personnalisée fonction pour correspondre à votre modèle fichiers.

L'utilisation est essentiellement comme ceci:

var orm = require('sequelize-connect');

orm.discover = ["/my/model/path/1", "/path/to/models/2"];      //1 to n paths can be specified here
orm.connect(db, user, passwd, options);                        //initialize the sequelize connection and models

Ensuite, vous pouvez accéder aux modèles et sequelize comme suit:

var orm       = require('sequelize-connect');
var sequelize = orm.sequelize;
var Sequelize = orm.Sequelize;
var models    = orm.models;
var User      = models.User;

J'espère que cela aide quelqu'un à sortir.

Je l'ai configuré comme Ferme et les documents décrivent.

Mais j'ai eu le bac d'alimentation supplémentaire de problème que dans mes méthodes d'instance et les méthodes de la classe que je voudrais joindre les modèles dans chaque fonction, j'aurais besoin d'exiger le fichier d'index pour obtenir une prise d'autres objets de base de données.

Résolu en les rendant accessibles à tous les modèles.

var Config = require('../config/config');
var fs = require('fs');
var path = require('path');
var Sequelize = require('sequelize');
var _ = require('lodash');
var sequelize;
var db = {};
var dbName, dbUsername, dbPassword, dbPort, dbHost;
//set above vars
var sequelize = new Sequelize(dbName, dbUsername, dbPassword, {
dialect: 'postgres', protocol: 'postgres', port: dbPort, logging: false, host: dbHost,
define: {
classMethods: {
db: function () {
return db;
},
Sequelize: function () {
return Sequelize;
}
}
}
});
fs.readdirSync(__dirname).filter(function(file) {
return (file.indexOf('.') !== 0) && (file !== 'index.js');
}).forEach(function(file) {
var model = sequelize.import(path.join(__dirname, file));
db[model.name] = model;
});
Object.keys(db).forEach(function(modelName) {
if ('associate' in db[modelName]) {
db[modelName].associate(db);
}
});
module.exports = _.extend({
sequelize: sequelize,
Sequelize: Sequelize
}, db);

Et dans le fichier de modèle

var classMethods = {
createFromParams: function (userParams) {
var user = this.build(userParams);
return this.db().PromoCode.find({where: {name: user.promoCode}}).then(function (code) {
user.credits += code.credits;
return user.save();
});
}
};
module.exports = function(sequelize, DataTypes) {
return sequelize.define("User", {
userId: DataTypes.STRING,
}, {  tableName: 'users',
classMethods: classMethods
});
};

J'ai seulement fait cela pour les méthodes de classe, mais vous pouvez également faire la même chose pour les méthodes d'instance.

Exemple de modèle sequelize

JS:

'use strict';
const getRole   = require('../helpers/getRole')
const library   = require('../helpers/library')
const Op        = require('sequelize').Op
module.exports = (sequelize, DataTypes) => {
var User = sequelize.define('User', {
AdminId: DataTypes.INTEGER,
name: {
type: DataTypes.STRING,
validate: {
notEmpty: {
args: true,
msg: 'Name must be filled !!'
},
}
},
email: {
type: DataTypes.STRING,
validate: {
notEmpty: {
args: true,
msg: 'Email must be filled !!'
},
isUnique: function(value, next) {
User.findAll({
where:{
email: value,
id: { [Op.ne]: this.id, }
}
})
.then(function(user) {
if (user.length == 0) {
next()
} else {
next('Email already used !!')
}
})
.catch(function(err) {
next(err)
})
}
}
},
password: {
type: DataTypes.STRING,
validate: {
notEmpty: {
args: true,
msg: 'Password must be filled !!'
},
len: {
args: [6, 255],
msg: 'Password at least 6 characters !!'
}
}
},
role: {
type: DataTypes.INTEGER,
validate: {
customValidation: function(value, next) {
if (value == '') {
next('Please choose a role !!')
} else {
next()
}
}
}
},
gender: {
type: DataTypes.INTEGER,
validate: {
notEmpty: {
args: true,
msg: 'Gender must be filled !!'
},
}
},
handphone: {
type: DataTypes.STRING,
validate: {
notEmpty: {
args: true,
msg: 'Mobile no. must be filled !!'
},
}
},
address: DataTypes.TEXT,
photo: DataTypes.STRING,
reset_token: DataTypes.STRING,
reset_expired: DataTypes.DATE,
status: DataTypes.INTEGER
}, {
hooks: {
beforeCreate: (user, options) => {
user.password = library.encrypt(user.password)
},
beforeUpdate: (user, options) => {
user.password = library.encrypt(user.password)
}
}
});
User.prototype.check_password = function (userPassword, callback) {
if (library.comparePassword(userPassword, this.password)) {
callback(true)
}else{
callback(false)
}
}
User.prototype.getRole = function() {
return getRole(this.role)
}
User.associate = function(models) {
User.hasMany(models.Request)
}
return User;
};

---

Je suis à la recherche d'un exemple de nodejs application qui utilise le sequelize ORM.

Vous pourriez être intéressé à regarder le PEAN.JS passe-partout de solution.

• https://github.com/StetSolutions/pean

PEAN.JS est un full-stack JavaScript open-source solution, qui fournit un point de départ solide pour PostgreSQL, Node.js, Express, et AngularJS en fonction des applications.

La PEAN projet est un fork de la MEAN.JS projet (à ne pas confondre avec la MOYENNE.IO ou la générique MOYENNE de la pile).

• https://github.com/meanjs/mean

PEAN remplace MongoDB et la Mangouste ORM avec PostgreSQL et Sequelize. Un des principaux avantages de l'MEAN.JS projet est l'organisation elle offre à une pile qui a beaucoup de pièces mobiles.