Express配合Postman提交数组批量删除数据库已存在条目问题求助

当前代码仅适配接收单条JSON对象格式的请求，当提交数组格式的多条数据时，req.body为数组类型，直接读取req.body.assetId会返回undefined，因此触发了你观测到的SQL查询异常。
同时你的现有代码直接拼接SQL语句，存在SQL注入风险，优化时会同步修复该问题。

1. 前置检查：确保Express已配置JSON解析中间件 #

在你的服务入口文件（通常是app.js/server.js）中确认存在以下配置，否则无法正常解析JSON格式的请求体：

app.use(express.json());

2. 修改控制器逻辑（item.controller.js） #

新增单条/批量请求的判断逻辑，适配两种请求格式：

const Item = require("../models/item.model.js");

// 单条处理逻辑抽离为复用函数
const handleSingleItem = (itemData, callback) => {
  const item = new Item({
    itemId: itemData.assetId,
    botId: itemData.botId,
  });
  Item.IsReserved(item, callback);
};

exports.IsReserved = async (req, res) => {
  // Validate request
  if (!req.body || (Array.isArray(req.body) && req.body.length === 0)) {
    return res.status(400).send({
      message: "Content can not be empty!"
    });
  }

  try {
    // 判断是否为批量请求
    if (Array.isArray(req.body)) {
      // 提取所有assetId调用批量处理方法
      const assetIds = req.body.map(item => item.assetId);
      Item.batchDeleteReserved(assetIds, (err, data) => {
        if (err) {
          return res.status(500).send({
            message: err.message || "Some error occurred while processing batch items."
          });
        }
        res.send(data);
      });
    } else {
      // 走原有单条处理逻辑
      handleSingleItem(req.body, (err, data) => {
        if (err) {
          return res.status(500).send({
            message: err.message || "Some error occurred while processing the item."
          });
        }
        res.send(data);
      });
    }
  } catch (err) {
    res.status(500).send({
      message: err.message || "Server internal error"
    });
  }
};

3. 修改模型层逻辑（item.model.js） #

新增批量处理方法，同时修复原有SQL注入风险，改用参数化查询：

const sql = require("./db.js");

function Item(itemData) {
  this.itemId = itemData.itemId;
  this.botId = itemData.botId;
}

// 原有单条处理方法，改用参数化查询避免注入
Item.IsReserved = (RItem, result) => {
    sql.query(`SELECT * FROM ReservedItems WHERE itemId = ?`, [RItem.itemId], (err, res) => {
        if (err) {
          console.log("error: ", err);
          result(err, null);
          return;
        }
        if(res.length){
            sql.query(`DELETE FROM ReservedItems WHERE itemId = ?`, [RItem.itemId], (err, deleteRes) => {
                if (err) {
                    console.log("error: ", err);
                    result(err, null);
                    return;
                }
                result(null, { deletedId: RItem.itemId, ...RItem });
            });
        }
        else{
            result(null, { message: "nothing to do"});
        }
    });
};

// 新增批量处理方法
Item.batchDeleteReserved = (assetIds, result) => {
  // 生成对应数量的占位符
  const placeholders = assetIds.map(() => '?').join(',');
  sql.query(`SELECT * FROM ReservedItems WHERE itemId IN (${placeholders})`, assetIds, (err, selectRes) => {
    if (err) {
      console.log("error: ", err);
      result(err, null);
      return;
    }
    if (selectRes.length === 0) {
      return result(null, { message: "nothing to do", deletedCount: 0 });
    }
    // 批量删除存在的条目
    sql.query(`DELETE FROM ReservedItems WHERE itemId IN (${placeholders})`, assetIds, (err, deleteRes) => {
      if (err) {
        console.log("error: ", err);
        result(err, null);
        return;
      }
      result(null, { 
        message: "batch delete completed", 
        deletedCount: deleteRes.affectedRows,
        deletedIds: assetIds 
      });
    });
  });
};

module.exports = Item;

• 提交单条JSON对象：原有逻辑保持兼容，运行结果不变
• 提交数组格式的多条数据：会自动走批量处理逻辑，一次性查询并删除所有匹配的条目

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