Node.js 有许多人打电话说'；它不是Sequelize.Model的实例

大家可以看到，我的问题与标题描述有关，我在sequelize中创建了一个用户模型和一个Foto模型，基本上一个用户可以拍摄多个Foto，但每个Foto只能与一个用户相关

我的用户模型

    "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;
}

"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;
}

我的foto车型

    "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;
}

"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;
}

---

您不需要在照片模型上声明关联：

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

当模型之间存在1:N关系时，您只需要引用“1”模型中的id，在我们的案例中是用户模型，在“N”模型中是照片。这样做：

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

---

将在Foto表上创建一个名为“userId”的列，该列引用用户表。通过这种方式，两个模型可以根据需要进行关联。

您可以在一个文件中定义两个模型的关系。它不会以这种方式抛出任何错误

在Foto.js中，您可以尝试：

...

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

return Foto;

---

似乎需要在包含1:many关联的1部分的文件中定义关系的两端。也就是说，您案例中的“用户”文件

因此：

hasMany（Foto）；

---

Foto.belongsTo（用户）

我也有类似的问题。有时这可能是因为在index.js或app.js中，文件是按特定顺序加载的，因此，例如，如果a和B之间存在关系，a首先加载并引用B，而B反过来引用a，则会在B文件中引发错误，因为a尚未完全定义/执行

解决方案是从模型文件中删除所有关联，在应用程序或index.js中需要所有关联，然后定义它们之间的关系

范例

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'});

---

所以我得到了这个错误，我花了一些时间来处理这个错误。我意识到我犯了错误，因为我错误地引用了模型。Sequelize区分大小写，因此如果使用大写字母创建模型，请确保在整个引用过程中保持一致

我还想指出，你可以试试这个

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

---

以上所有解决方案都不适用于我的场景（可能适用于其他设置）。我偶然发现了这篇文章，它指出在应用关联之前必须定义并导出模型。使用一个单独的

extra setup.js

文件来定义关联，对我来说很有效

---

我遇到了很多问题，但我改用sequelize CLI生成这种格式的模型，然后我发现创建关联要容易得多，因为索引文件处理了所有问题，而

静态关联（{PersonalDetail}）

模型本身已经要求将模型放在一个位置，您只需解构它们，因此无需在文件顶部添加任何内容

这个youtube视频真的帮了我的忙

---

嗯，谢谢你回答得很好，我刚刚创建了这个关联，让用户与fotoCan相关。请详细说明为什么我不应该在子表模型中使用belongsTo？是否可以在父模式和子模式中都添加关系？@KetavChotaliya 1。并不是说您“不能”使用

belongsTo

，而是在依赖模型上放置ide外键的1:N关系上。在这个具体的例子中，主要的模型是

User

，因为没有

User

，就不可能有

Photos

。2.是的，您可以在两个模型上添加关系。让我们举一个例子，1。我想在我们的案例中选择一张与他的父关系类似的用户详细信息的特定照片。那时候该怎么办？2.如果我可以在两个模型中定义关系，那么sequalize抛出一个错误，如上所述。我认为一个文件用于所有模型不是一个好方法，特别是在中型项目中。我所说的“一个文件”是指“一个模型文件”这涉及到它们之间的关系。当两个模型之间存在循环依赖关系时，就会出现此问题，例如在用户模型中输入'const Photo=require（'./User'），在照片模型中输入'const User=require（'./Photo'），要解决此问题，有两个选项：1-定义belongTo，并在一个模型中输入多个。2-在每个模型中定义关系，但在函数中定义关系，并在index.js中调用此函数，例如，在需要两个模型（如本文中发布的解决方案）后，这正是我的想法。谢谢分享您的解决方案。@Dorian，我可以确认此解决方案有效。。。但实施这一点有点令人沮丧（不要误解我，我不是有意冒犯你）。例如，如果您想了解

EntityA

，必须检查

/src/Entity/A

和

index.js

。如果你能把

EntityA

的关联也放到

/src/Entity/A

中，那不是很好吗？最重要的是，如果您有许多具有关联的实体，

index.js

可能非常庞大。