Node.js 将一对多进行续集并显示

我是关系数据库的新手。我使用NodeJS和express作为后端，RESTAPI和数据库是Postgresql。我使用Sequelize进行连接和模型。我创建了两个模型，一个是学生模型，另一个是课程模型。我的目标是一个学生可以有多个课程，并希望防止重复的学生姓名，电话，电子邮件。我成功连接到数据库，能够发布、获取、更新、删除学生和课程模型。从测试的应用程序，我使用邮递员。但我不确定，我是否正确处理了学生和课程之间的关系。我也不知道如何显示两个表之间的关系。如果有人帮我，我会很高兴的

我想这样显示我的个人信息：

{
  "students": [
    {
      "id": 1,
      "name": "Anni Anonen",
      "birthday": "1992-02-28",
      "address": "Kivakatu 1",
      "zipcode": "00500",
      "city": "Helsinki",
      "phone": "+358506760702",
      "email": "anni.anonen@testing.fi",
      "courses": [1,2,3] //SHOW COURSES LIKE THIS
    },
    {
      "id": 2,
      "name": "Ville Anonen",
      "birthday": "2000-03-28",
      "address": "Hämeentie 1",
      "zipcode": "00510",
      "city": "Helsinki",
      "phone": "+358508660702",
      "email": "ville.anonen@testing.fi",
      "courses": [3]
    },
    {
      "id": 3,
      "name": "Tapani Kumpu",
      "birthday": "1999-05-28",
      "address": "Jokukatu 17",
      "zipcode": "00560",
      "city": "Helsinki",
      "phone": "+358502330702",
      "email": "tapani.kumpu@testing.fi",
      "courses": [1,4]
    }

  ],
  "courses": [
    {
      "id": 1,
      "name": "Gymnastics 1",
      "startdate": "2020-01-01",
      "enddate": "2020-02-10"
    },
    {
      "id": 2,
      "name": "Gymnastics 2",
      "startdate": "2020-01-01",
      "enddate": "2020-02-10"
    },
    {
      "id": 3,
      "name": "Fitness 1",
      "startdate": "2020-02-01",
      "enddate": "2020-02-20"
    },
    {
      "id": 4,
      "name": "Dance 1",
      "startdate": "2020-05-01",
      "enddate": "2020-05-02"
    }
  ]
}

这是我的型号

const sequelize = require("sequelize");

var con = new sequelize("school", "postgres", "password", {
  host: "localhost",
  dialect: "postgres",

  pool: {
    max: 5,
    min: 0,
    idle: 10000
  }
});

const Student = con.define("student", {
  name: {
    type: sequelize.STRING,
    allowNull: false
  },
  birthday: {
    type: sequelize.DATEONLY,
    allowNull: false
  },
  address: {
    type: sequelize.STRING,
    allowNull: false
  },
  zipcode: {
    type: sequelize.INTEGER,
    allowNull: false
  },
  city: {
    type: sequelize.STRING,
    allowNull: false
  },
  phone: {
    type: sequelize.BIGINT,
    allowNull: false
  },

  email: {
    type: sequelize.STRING,
    allowNull: false,
    validate: {
      isEmail: true
    }
  }
});

const Course = con.define("course", {
  id: {
    type: sequelize.INTEGER,
    primaryKey: true
  },
  name: { type: sequelize.STRING },
  startdate: { type: sequelize.DATEONLY },
  enddate: { type: sequelize.DATEONLY },
  studentId: { type: sequelize.INTEGER, foreignKey: true }
});

Student.hasMany(Course);
Course.belongsTo(Student);

//con.sync({ force: true });

module.exports = { Student, Course };

这是express server

require（“dotenv”）.config（）；
const express=要求（“express”）；
常量app=express（）；
const morgan=要求（“摩根”）；
常数头盔=要求（“头盔”）；
const cors=要求（“cors”）；
const{Student，Course}=require（“./db”）；
//应用程序米德尔威尔
应用程序使用（摩根（“普通”））；
应用（头盔（））；
应用程序使用（cors（））；
使用（express.json（））//体分析器
//学生
app.get（“/students”），异步（req，res，next）=>{
试一试{
等待Student.findAll（）。然后（docs=>{
常数响应={
计数：docs.length，
学生：博士
};
res.json（响应）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.get（“/students/：id”），异步（req，res，next）=>{
const id=req.params.id；
试一试{
findByPk（id）.then（数据=>{
控制台日志（数据）；
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.put（“/students/：id”），异步（req，res）=>{
const id=req.params.id；
const update=req.body；
试一试{
等待Student.update（update，{where:{id}}）。然后（data=>{
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.delete（“/students/：id”），异步（req，res，next）=>{
const id=req.params.id；
试一试{
destroy（{where:{id}}）。然后（data=>{
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.post（“/students”），异步（请求、恢复、下一步）=>{
试一试{
const logs=新学员（要求正文）；
const entry=wait logs.save（）；
res.json（条目）；
}捕获（错误）{
如果（error.name==“ValidationError”）{
物质状态（422）；
}
下一步（错误）；
}
});
//课程
app.get（“/courses”，异步（请求、恢复、下一步）=>{
试一试{
等待Course.findAll（）。然后（docs=>{
常数响应={
计数：docs.length，
课程：博士
};
res.json（响应）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.get（“/courses/：id”），异步（req，res，next）=>{
const id=req.params.id；
试一试{
Course.findByPk（id）.then（data=>{
控制台日志（数据）；
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.put（“/courses/：id”），异步（req，res，next）=>{
const id=req.params.id；
const update=req.body；
试一试{
等待课程。更新（更新，{where:{id}}）。然后（数据=>{
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.delete（“/courses/：id”），异步（req，res，next）=>{
const id=req.params.id；
试一试{
destroy（{where:{id}}）。然后（data=>{
res.json（数据）；
});
}捕获（错误）{
console.log（错误）；
}
});
app.post（“/courses”，异步（请求、恢复、下一步）=>{
试一试{
常量日志=新课程（要求正文）；
const entry=wait logs.save（）；
res.json（条目）；
}捕获（错误）{
如果（error.name==“ValidationError”）{
物质状态（422）；
}
下一步（错误）；
}
});
const port=process.env.port | 5000；
app.listen（端口，（）=>console.log（‘嗯……应该是多对多关系吗？课程有很多学生，学生有很多课程？我应该怎么做？我在这个领域真的很新。嗯……应该是多对多关系吗？课程有很多学生，学生有很多课程？我应该怎么做？我在这个领域真的很新。