Express+Sequelize POST请求验证错误排查求助

问题概述 #

使用Express.js框架搭配Sequelize ORM开发应用，发送POST请求创建任务时，尽管请求参数符合要求，却持续收到验证错误，终端无调试输出，需排查根源。

应用目录结构 #

- app/
  - src/
    - accounts/
      - models/
        - users.js
      - routes/
        - users.js
    - tasks/
      - models/
        - tasks.js
      - routes/
        - tasks.js
      - controllers/
        - tasks.js
      - schemas/
        - tasks.js  # 验证Schema文件
    - config/
      - db.js
      - validate.js
    - index.js
  - node_modules/
  - package.json
  - package-lock.json

关键代码片段 #

验证Schema（tasks.js） #

const tasksSchema = {
    title: {
        notEmpty: true,
        errorMessage: "Title cannot be empty",
        isLength: {
            options: { min: 3 },
            errorMessage: "Title must contain at least 3 characters"
        }
    },
    content: {
        optional: true,
        isLength: {
            options: { max: 5000 },
            errorMessage: "Content must not exceed 5000 characters"
        }
    },
    userId: {
        notEmpty: true,
        errorMessage: "userId cannot be empty",
        isInt: {
            errorMessage: "userId must be an integer"
        }
    }
};

module.exports = { tasksSchema};

任务控制器（tasks.js） #

const { Task } = require('../models/tasks');
const TaskService = require('../services/tasks');
const TaskSupport = require('../supports/tasks');

const createTask = async (req, res) => {
    const task = req.body;

    try {
        const createdTask = await TaskService.createTask(task);
        console.log('createTask: createdTask:', createdTask);

        if (createdTask.error) {
            console.log('createTask: Error creating task:', createdTask.error);
            return res.status(400).send(createdTask);
        }

        const responseTask = await TaskSupport.buildTaskResponse(createdTask);
        console.log('createTask: Response task:', responseTask);
        
        return res.status(201).send(responseTask);
    } catch (err) {
        console.error('Error creating task:', err);

        if (err.status) {
            return res.status(err.status).json({
                message: err.message,
            });
        }

        return res.status(500).json({
            message: 'Error on server',
        });
    }
};

module.exports = {
    createTask,
} 

任务模型（tasks.js） #

const { DataTypes } = require('sequelize');
const sequelize = require('../../config/db');
const { User } = require('../../accounts/models/users');

const Task = sequelize.define('tasks', {
    title: {
        type: DataTypes.STRING
    },
    content: {
        type: DataTypes.TEXT
    },
    completed:{
        type: DataTypes.BOOLEAN,
        defaultValue: false
    },
    creationDate:{
        type: DataTypes.DATEONLY,
        defaultValue: DataTypes.NOW
    },
    completitionDate:{
        type: DataTypes.DATEONLY,
        allowNull: true,
        defaultValue: null
    },
});

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

module.exports = {
    Task
}

任务路由（tasks.js） #

const router = require('express').Router({ mergeParams: true });
const { createTask} = require('../controllers/tasks');
const { validate } = require('./../../config/validate');
const { checkSchema } = require('express-validator');
const { tasksSchema} = require('../schemas/tasks');

router.post('/', validate(checkSchema(tasksSchema)), createTask);

module.exports = {
    router,
};

入口文件（index.js） #

const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');
const app = express();
const { router: usersRoutes } = require('./src/accounts/routes/users');
const { router: tasksRoutes } = require('./src/tasks/routes/tasks');
const sequelize = require('./src/config/db');

app.use(bodyParser.json());
app.use(cors());

app.use('/api/users', usersRoutes);
app.use('/api/tasks', tasksRoutes);

sequelize.sync()
  .then(() => {
    console.log('Database is synced');
  })
  .catch((error) => {
    console.error('Error syncing database:', error);
  });

const PORT = process.env.PORT || 80;
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}.`);
});

请求与错误详情 #

测试请求 #

POST http://localhost:80/api/tasks/
请求体：

{
    "title": "Buy groceries",
    "content": "Buy milk, bread, and eggs.",
    "userId": 2
}

收到的错误响应 #

{
    "errors": [
        {
            "type": "field",
            "msg": "Title cannot be empty",
            "path": "title",
            "location": "body"
        },
        {
            "type": "field",
            "msg": "Title must contain at least 3 characters",
            "path": "title",
            "location": "body"
        },
        {
            "type": "field",
            "msg": "userId cannot be empty",
            "path": "userId",
            "location": "body"
        },
        {
            "type": "field",
            "msg": "userId must be an integer",
            "path": "userId",
            "location": "body"
        }
    ]
}

排查与修复方案 #

1. 检查validate.js中间件实现 #

这是最可能的根源，你未提供该文件的代码，但express-validator需要自定义中间件来执行验证链并处理错误。如果validate函数未正确执行验证或传递请求到控制器，会导致验证错误且终端无输出。

正确的validate.js实现示例：

const { validationResult } = require('express-validator');

const validate = (validations) => {
  return async (req, res, next) => {
    // 执行所有验证规则
    await Promise.all(validations.map(validation => validation.run(req)));
    
    // 收集验证错误
    const errors = validationResult(req);
    if (errors.isEmpty()) {
      // 无错误则继续执行控制器
      return next();
    }
    
    // 返回错误响应
    res.status(400).json({ errors: errors.array() });
  };
};

module.exports = { validate };

2. 确认请求的Content-Type #

确保Postman中请求的Content-Type设置为application/json：

• 在Postman中选择Body -> raw -> 下拉菜单选JSON
• 手动添加请求头Content-Type: application/json

如果未设置正确的Content-Type，body-parser.json()无法解析请求体，req.body会为空，导致验证规则判定字段缺失。

3. 验证中间件加载顺序 #

确认body-parser.json()在路由之前加载（你的入口文件已正确配置此点，但需确保无其他中间件干扰请求体解析）。

4. 调试验证流程 #

在validate.js中添加调试日志，确认请求体是否被正确解析：

const validate = (validations) => {
  return async (req, res, next) => {
    console.log('Received request body:', req.body); // 新增调试日志
    await Promise.all(validations.map(validation => validation.run(req)));
    
    const errors = validationResult(req);
    console.log('Validation errors:', errors.array()); // 新增调试日志
    if (errors.isEmpty()) {
      return next();
    }
    
    res.status(400).json({ errors: errors.array() });
  };
};

通过以上步骤，可定位到验证失败的具体原因，通常是请求体未被正确解析或验证中间件实现错误。

内容的提问来源于stack exchange，提问作者Diego