Node.js 列中的Sequelize null值违反not null约束

我在尝试将like与post关联时遇到此错误

未处理的拒绝SequelizeDatabaseError:列中的值为null “userId”违反了notnull约束

现在，下面的代码获得了post id和用户id ok，我做了一个

控制台日志

。我可能做错了什么

routes/posts.js

router.post('/:userId/like/:postId', (req, res)=> {
    models.Post.findOne({
      where:{
          id: req.params.postId
      }
    })
    .then( (like) => {
        if(like){
            models.Likes.create({
                where:{
                    userId: req.params.userId,
                    postId: req.params.postId
                },
                like:true

            }).then( (result) => {
                res.status(200).send({
                    message: 'You have like this post',
                    like: result
                })
            })
        }
    }).catch( (err) => {
        res.status(401).send({
            message: "Something went wrong",
            err: err
        })
    })

})

module.exports = function(sequelize, DataTypes) {
  const Like = sequelize.define('Likes', {
    like:{
      type:DataTypes.BOOLEAN,
      allowNull:true
    },
    // userId: {
    //   type: sequelize.INTEGER,
    //   references: {
    //     model: 'Users',
    //     key: 'id'
    //   }
    // },
  }, {});
    Like.associate = function(models) {
        Like.belongsTo(models.User, {
          onDelete: "CASCADE",
          foreignKey: 'userId'

        })
        Like.belongsTo(models.Post, {
          onDelete: "CASCADE",
          foreignKey: 'likeId'

        })
    }
  return Like;
}

以下是喜欢迁移的人

  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable('Likes', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      like: {
        type: Sequelize.BOOLEAN
      },
      userId: {
        allowNull: false,
        type: Sequelize.INTEGER,
        references: {
          model: 'Users',
          key: 'id'
        }
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
  },
  down: (queryInterface, Sequelize) => {
    return queryInterface.dropTable('Likes');
  }
};

'use strict';
module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable('Posts', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      title: {
        type: Sequelize.STRING
      },
      post_content: {
        type: Sequelize.STRING
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      userId: {
        type: Sequelize.INTEGER,
        references: {
          model: 'Users',
          key: 'id'
        }
      },
      username: {
        type: Sequelize.STRING
      },
    });
  },
  down: (queryInterface, Sequelize) => {
    return queryInterface.dropTable('Posts');
  }
};

迁移后

  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable('Likes', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      like: {
        type: Sequelize.BOOLEAN
      },
      userId: {
        allowNull: false,
        type: Sequelize.INTEGER,
        references: {
          model: 'Users',
          key: 'id'
        }
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      }
    });
  },
  down: (queryInterface, Sequelize) => {
    return queryInterface.dropTable('Likes');
  }
};

'use strict';
module.exports = {
  up: (queryInterface, Sequelize) => {
    return queryInterface.createTable('Posts', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      title: {
        type: Sequelize.STRING
      },
      post_content: {
        type: Sequelize.STRING
      },
      createdAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      updatedAt: {
        allowNull: false,
        type: Sequelize.DATE
      },
      userId: {
        type: Sequelize.INTEGER,
        references: {
          model: 'Users',
          key: 'id'
        }
      },
      username: {
        type: Sequelize.STRING
      },
    });
  },
  down: (queryInterface, Sequelize) => {
    return queryInterface.dropTable('Posts');
  }
};

类似车型

'use strict';
module.exports = function(sequelize, DataTypes) {
  const Like = sequelize.define('Likes', {
    like:{
      type:DataTypes.BOOLEAN,
      allowNull:true
    }
  }, {});
    Like.associate = function(models) {
        Like.belongsTo(models.User, {
          onDelete: "CASCADE",
          sourceKey: 'userId'

        })
        Like.belongsTo(models.Post, {
          onDelete: "CASCADE",
          sourceKey: 'likeId'

        })
    }
  return Like;
}

module.exports = (sequelize, DataTypes) => {
  const Post = sequelize.define('Post', {
    title: DataTypes.STRING,
    post_content: DataTypes.STRING,
    username:  DataTypes.STRING
  }, {});
  Post.associate = function(models) {
    Post.belongsTo(models.User, {  foreignKey: 'userId',  targetKey: 'id' });
    Post.hasMany(models.Likes, {  foreignKey: 'postId',  sourceKey: 'id' });
  };
  return Post;
};

后期模型

'use strict';
module.exports = function(sequelize, DataTypes) {
  const Like = sequelize.define('Likes', {
    like:{
      type:DataTypes.BOOLEAN,
      allowNull:true
    }
  }, {});
    Like.associate = function(models) {
        Like.belongsTo(models.User, {
          onDelete: "CASCADE",
          sourceKey: 'userId'

        })
        Like.belongsTo(models.Post, {
          onDelete: "CASCADE",
          sourceKey: 'likeId'

        })
    }
  return Like;
}

module.exports = (sequelize, DataTypes) => {
  const Post = sequelize.define('Post', {
    title: DataTypes.STRING,
    post_content: DataTypes.STRING,
    username:  DataTypes.STRING
  }, {});
  Post.associate = function(models) {
    Post.belongsTo(models.User, {  foreignKey: 'userId',  targetKey: 'id' });
    Post.hasMany(models.Likes, {  foreignKey: 'postId',  sourceKey: 'id' });
  };
  return Post;
};

额外的

将发布的添加到喜欢的内容

---

在create call In解析器中，您没有给它必要的值，您有一个where子句，但实际上没有给它所需的userId的值。。看起来模型中唯一的值是您在resolver中创建调用时设置的布尔值。您没有为它提供必要的值，您有一个where子句，但实际上没有为它提供所需用户ID的值。。看起来模型中唯一的值是您设置的布尔值

我算出了

我只是使用了

body

而不是

params

作为

postId

router.post('/like', (req, res)=> {

    models.Likes.create({
        postId: req.body.postId,
        userId:  req.user.id,
        like:true
    }).then( (result) => {
        res.status(200).send({
            message: 'You have like this post',
            like: result
        });
    }).catch( (err) => {
        res.status(401).send({
            message: "Something went wrong",
            err: err
        })
    })

})

将我的同类型号更改为此，我使用的是sourceKey而不是外键

router.post('/:userId/like/:postId', (req, res)=> {
    models.Post.findOne({
      where:{
          id: req.params.postId
      }
    })
    .then( (like) => {
        if(like){
            models.Likes.create({
                where:{
                    userId: req.params.userId,
                    postId: req.params.postId
                },
                like:true

            }).then( (result) => {
                res.status(200).send({
                    message: 'You have like this post',
                    like: result
                })
            })
        }
    }).catch( (err) => {
        res.status(401).send({
            message: "Something went wrong",
            err: err
        })
    })

})

module.exports = function(sequelize, DataTypes) {
  const Like = sequelize.define('Likes', {
    like:{
      type:DataTypes.BOOLEAN,
      allowNull:true
    },
    // userId: {
    //   type: sequelize.INTEGER,
    //   references: {
    //     model: 'Users',
    //     key: 'id'
    //   }
    // },
  }, {});
    Like.associate = function(models) {
        Like.belongsTo(models.User, {
          onDelete: "CASCADE",
          foreignKey: 'userId'

        })
        Like.belongsTo(models.Post, {
          onDelete: "CASCADE",
          foreignKey: 'likeId'

        })
    }
  return Like;
}

所以现在我可以喜欢一篇帖子了，它将把

postId

和

usersId

一起附加到likes表上

像这样

我想出来了

我只是使用了

body

而不是

params

作为

postId

router.post('/like', (req, res)=> {

    models.Likes.create({
        postId: req.body.postId,
        userId:  req.user.id,
        like:true
    }).then( (result) => {
        res.status(200).send({
            message: 'You have like this post',
            like: result
        });
    }).catch( (err) => {
        res.status(401).send({
            message: "Something went wrong",
            err: err
        })
    })

})

将我的同类型号更改为此，我使用的是sourceKey而不是外键

router.post('/:userId/like/:postId', (req, res)=> {
    models.Post.findOne({
      where:{
          id: req.params.postId
      }
    })
    .then( (like) => {
        if(like){
            models.Likes.create({
                where:{
                    userId: req.params.userId,
                    postId: req.params.postId
                },
                like:true

            }).then( (result) => {
                res.status(200).send({
                    message: 'You have like this post',
                    like: result
                })
            })
        }
    }).catch( (err) => {
        res.status(401).send({
            message: "Something went wrong",
            err: err
        })
    })

})

module.exports = function(sequelize, DataTypes) {
  const Like = sequelize.define('Likes', {
    like:{
      type:DataTypes.BOOLEAN,
      allowNull:true
    },
    // userId: {
    //   type: sequelize.INTEGER,
    //   references: {
    //     model: 'Users',
    //     key: 'id'
    //   }
    // },
  }, {});
    Like.associate = function(models) {
        Like.belongsTo(models.User, {
          onDelete: "CASCADE",
          foreignKey: 'userId'

        })
        Like.belongsTo(models.Post, {
          onDelete: "CASCADE",
          foreignKey: 'likeId'

        })
    }
  return Like;
}

所以现在我可以喜欢一篇帖子了，它将把

postId

和

usersId

一起附加到likes表上

像这样

---

对不起，格雷格，我真的不明白你的意思。因为这个

router.post（'/:userId/like/:posted'）

获取了用户id和post id，我可以看到它可以很好地检索数据，我应该做什么？我该如何重写它以使其工作，从而将like附加到post？like表是否有名为userID和likeID的列？您的关联中有它们，但不在模型列列表中。。在Likes模型中设置的唯一值如下：true，无论您在where子句中执行什么操作，都没有在模型中设置这些值，错误表示列userId是必需的，因此您需要设置它，我想我不知道为什么这些列没有在您的模型中列出..我不明白为什么在create调用中有一个where子句用于LIKEB，因为它们在迁移中已定义：（这太让人困惑了，让我看看我能做些什么。我会提供更多信息。对不起，格雷格，我真的不明白你的意思。因为这

router.post（'/:userId/like/:postId'））

获取用户id和post id，我可以看到它可以很好地检索数据。我应该做什么？我应该如何重写它以使其工作，这样它会将like附加到post？like表中是否有名为userID和likeID的列？它们在关联中，但不在模型列列表中。您正在设置的唯一值你的Likes模型是这样的：是的，无论你在where子句中做什么，都没有在模型中设置那些值，错误是说列userId是必需的，所以你需要设置它，我想我不知道为什么那些列没有在你的模型中列出。我不明白为什么你在对likebeth的create调用中有where子句迁移中定义的eir：（这太令人困惑了，让我看看我能做些什么。我将提供更多信息。