如何应用具有引用的模型的验证？

Question

我想对当前应用验证 schema.What 是我可以使用验证器进行验证并在未输入 projectMembers 时显示错误消息的方法吗？

projectMembers: [{
        user: {
            type: Schema.Types.ObjectId,
            ref: 'User',
            required: true,
        },
        userRole: {
            type: Schema.Types.ObjectId,
            ref: 'UserRole',
            required: true,
        },
    }],

用户模型

const userSchema = new Schema({
    username: {
        type: String,
        required: true,
        minlength: 3,
        validate: {
            validator: (username) => {
                return username.length >= 3
            },
            msg: () => {
                return 'UserName length less than 3 characters'
            }
        }
    },
    email: {
        type: String,
        required: true,
        unique: true,
        minlength: 7,
        validate: {
            validator: (email) => {
                return validator.isEmail(email)
            },
            msg: () => {
                return 'Enter a valid email'
            }
        }
    },
    password: {
        type: String,
        required: true,
        minlength: 8,
        validate: {
            validator: (password) => {
                return password.length >= 8
            }
        },
        msg: function () {
            return 'Enter atleast 8 charcters'
        }
    })

用户角色模型

const UserRoleSchema = new Schema({
    userRole: {
        type: String,
        required: true,
        validate: {
            validator: (userRole) => {
                return userRole.length >= 0
            },
            msg: () => {
                return 'User Role should be selected'
            }
        }
    }
})

const UserRole = mongoose.model('UserRole', UserRoleSchema)
module.exports = UserRole

Answer 1

假设您的 projectMembers 在名为 Project 的模型中。

您可以像这样在架构中设置所需的错误消息：

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const projectSchema = new Schema({
  name: {
    type: String,
    required: true
  },
  projectMembers: [
    {
      user: {
        type: Schema.Types.ObjectId,
        ref: "User",
        required: [true, "User is required"]
      },
      userRole: {
        type: Schema.Types.ObjectId,
        ref: "UserRole",
        required: [true, "User Role is required"]
      }
    }
  ]
});

const Project = mongoose.model("Project", projectSchema);

module.exports = Project;

并且在post项目路由中，可以使用mongoose的doc.validateSync()方法进行验证

这是一个示例：

router.post("/project", async (req, res) => {
  const { name, projectMembers } = req.body;

  const project = new Project({ name, projectMembers });

  const { errors } = project.validateSync();

  if (errors) {
    let convertedErrors = [];
    for (field in errors) {
      convertedErrors.push(errors[field].message);
    }

    return res.send({ errors: convertedErrors });
  }

  //todo: do whatever you want

  res.send();
});

如果你发送一个没有用户角色的请求到这个正文的路由：

{
 "name": "project name",
 "projectMembers": [{
    "user": "5dc12a0aa875cd0ca8b871ea"
 }] 
}

您将收到以下回复：

{
    "errors": [
        "User Role is required"
    ]
}

并且如果您使用此正文将没有用户角色和用户的请求发送到此路由：

{
 "name": "project name",
 "projectMembers": [{}] 
}

您将收到以下回复：

{
    "errors": [
        "User Role is required",
        "User is required"
    ]
}

如何应用具有引用的模型的验证？

How to apply validation of a Model which is having a ref?

mongoose

mongodb

express

mongoose-schema