web-dev-qa-db-fra.com

hasMany a appelé avec quelque chose qui n'est pas une instance de Sequelize.

comme vous pouvez le voir, mon problème est lié à la description du titre, j'ai créé un modèle d'utilisateur et un modèle de photo dans la suite, fondamentalement, un utilisateur peut prendre de nombreuses photos, mais chaque photo peut être liée à un seul utilisateur.

Mon modèle utilisateur

    "use strict";
var sequelize = require('./index');
var bcrypt = require('bcrypt-nodejs');
var Foto = require('./Foto');

module.exports = function (sequelize, DataTypes) {
  var User = sequelize.define("User", {
    username: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        isUnique: function (value, next) {
          var self = this;
          User.find({ where: { username: value } })
            .then(function (user) {
              // reject if a different user wants to use the same username
              if (user && self.id !== user.id) {
                return next('username already in use!');
              }
              return next();
            })
            .catch(function (err) {
              return next(err);
            });
        }
      }
    },

    email: {
      type: DataTypes.STRING,
      allowNull: false,
      unique: true,
      validate: {
        isUnique: function (value, next) {
          var self = this;
          User.find({ where: { email: value } })
            .then(function (user) {
              // reject if a different user wants to use the same email
              if (user && self.id !== user.id) {
                return next('Email already in use!');
              }
              return next();
            })
            .catch(function (err) {
              return next(err);
            });
        }
      }
    },

    typeOfUser: {
      type: DataTypes.INTEGER,
      allowNull:true,
      defaultValue:null
    },

    country: {
      type: DataTypes.STRING,
      allowNull:true,
      defaultValue:null
    },

    birthDate:{
      type: DataTypes.DATEONLY,
      allowNull:true,
      defaultValue:null
    },

    reports: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },

    points: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },

    password: {
      type: DataTypes.STRING,
      allowNull:false
    },

    numberFotos: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    }
  }, {
      classMethods: {
        generateHash: function (password) {
          return bcrypt.hashSync(password, bcrypt.genSaltSync(8), null);
        },

      },
      instanceMethods: {
        validPassword: function (password) {
          return bcrypt.compareSync(password, this.password);
        }
      }


    });

  User.hasMany(Foto,{as: 'fotos', foreignKey: 'userId'})

  return Foto;
}

Mon modèle photo

"use strict";
var sequelize = require('./index');
var bcrypt = require('bcrypt-nodejs');
var User = require('./User');


module.exports = function (sequelize, DataTypes) {
  var Foto = sequelize.define("Foto", {
    reports: {
      type: DataTypes.INTEGER,
      defaultValue: 0
    },
    image: {
      type: DataTypes.STRING,
      allowNull: false
    },
    date: {
      type: DataTypes.DATE,
      allowNull:true
    },
    position: {
      type: DataTypes.RANGE,
      allowNull: true
    }
  });

  Foto.belongsTo(User, {foreignKey: 'userId'});

  return Foto;
}
node.jspostgresqlsequelize.js
7
user8014710

Vous n'avez pas besoin de déclarer l'association sur le modèle photo:

Foto.belongsTo(User, {foreignKey: 'userId'});

Lorsque vous avez une relation 1: N entre les modèles, il vous suffit de renvoyer l'identifiant du modèle "1", dans notre cas, le modèle utilisateur, sur le modèle "N", Photos. Ce faisant:

User.hasMany(Foto,{as: 'fotos', foreignKey: 'userId'})

Crée une colonne sur votre table Foto avec le nom "userId" qui fait référence à la table utilisateur. De cette façon, les deux modèles sont associés comme vous le souhaitez.

21
Ellebkey

Vous pouvez définir des relations pour les deux modèles dans n fichier. Cela ne génère aucune erreur de cette façon.

Dans votre Foto.js, vous pouvez essayer:

...

Foto.belongsTo(User);
User.hasMany(Foto);

return Foto;
4
Toufiq

J'avais un problème similaire. Parfois, cela peut être dû au fait que dans vos index.js ou app.js les fichiers sont chargés dans un ordre spécifique, donc par exemple si vous avez une relation entre A et B, A se charge d'abord et fait référence à B, et B à son tour fait référence à A , l'erreur sera renvoyée dans le fichier B car A n'a pas encore été entièrement défini/exécuté.

La solution à cela serait de supprimer toutes les associations des fichiers de modèle et, dans votre application ou index.js, de les exiger toutes, puis de définir leurs relations.

Exemple

const entities = {
  A: require('./src/Entity/A'),
  B: require('./src/Entity/B'),
};
entities.A.belongsToMany(entities.B, {through: 'AB'});
entities.B.belongsToMany(entities.A, {through: 'AB'});
2
Dorian Jakov Stern Vukotic

Il semble que vous ayez besoin de définir les deux extrémités de la relation dans le fichier contenant la partie 1 de l'association 1: many. Autrement dit, le fichier "Utilisateur" dans votre cas.

Alors:

User.hasMany (Foto); Foto.belongsTo (utilisateur);

1
Scar Coder