Mongoose与MongoDB：执行bulkWrite时忽略类型转换错误

当使用Mongoose的bulkWrite导入外部数据时，单个文档的类型转换错误（比如示例中stock字段的字符串转数字失败）会导致整个批量操作中断，无法继续处理后续有效文档。要实现“跳过无效文档、继续执行批量操作”的需求，可以通过以下几种方式解决：

方法1：预验证并过滤无效文档 #

在执行bulkWrite前，先逐个验证每个文档是否符合Schema规则，过滤掉不符合的文档，从源头避免验证错误。

修改示例代码如下：

const mongoose = require("mongoose");

const data = [
  { description: "nice product", stock: 10, product_id: "01" },
  { description: "useful product", stock: "error will be generated", product_id: "02" }
];

const InventorySchema = new mongoose.Schema({
  description: String,
  stock: Number,
  product_id: { type: String, unique: true }
});
const Inventory = mongoose.model("Inventory", InventorySchema);

const upsertData = async () => {
  // 过滤并验证有效文档
  const validOperations = [];
  for (const product of data) {
    const inventory = new Inventory(product);
    try {
      // 执行Mongoose的验证逻辑
      await inventory.validate();
      validOperations.push({
        updateOne: {
          filter: { product_id: product.product_id },
          update: { $set: product },
          upsert: true
        }
      });
    } catch (err) {
      console.log(`跳过无效文档 ${product.product_id}：${err.message}`);
    }
  }

  // 对有效文档执行批量操作
  if (validOperations.length > 0) {
    await Inventory.bulkWrite(validOperations);
    console.log("批量操作完成");
  }
};

mongoose.connection.once("open", async () => {
  await upsertData();
  mongoose.connection.close();
});

这种方式利用Mongoose模型的validate()方法提前校验每个文档，将无效文档过滤后再执行批量操作，确保不会因单个错误中断整个流程。

方法2：使用MongoDB原生驱动+无序批量操作 #

绕过Mongoose的预验证，直接使用MongoDB原生驱动的bulkWrite，并设置ordered: false（无序操作）。这样即使部分文档执行失败，其他文档仍会继续处理，同时可以捕获失败的文档信息。

修改示例代码如下：

const mongoose = require("mongoose");

const data = [
  { description: "nice product", stock: 10, product_id: "01" },
  { description: "useful product", stock: "error will be generated", product_id: "02" }
];

const InventorySchema = new mongoose.Schema({
  description: String,
  stock: Number,
  product_id: { type: String, unique: true }
});
const Inventory = mongoose.model("Inventory", InventorySchema);

const upsertData = async () => {
  // 获取MongoDB原生集合对象
  const collection = mongoose.connection.collection("inventories");
  
  const operations = data.map(product => ({
    updateOne: {
      filter: { product_id: product.product_id },
      update: { $set: product },
      upsert: true
    }
  }));

  try {
    // 执行无序批量操作，单个失败不影响其他
    const result = await collection.bulkWrite(operations, { ordered: false });
    console.log(`成功处理${result.nModified + result.upsertedCount}个文档`);
    if (result.writeErrors.length > 0) {
      console.log("失败的文档：", result.writeErrors);
    }
  } catch (err) {
    // 无序模式下，只有严重错误才会进入catch，部分失败会在result.writeErrors中返回
    console.log("批量操作遇到严重错误：", err);
  }
};

mongoose.connection.once("open", async () => {
  await upsertData();
  mongoose.connection.close();
});

ordered: false会让MongoDB并行处理批量操作，单个文档的写入错误不会中断整个任务，失败的信息会被收集到返回结果的writeErrors中，方便后续排查。

方法3：给Schema添加字段转换逻辑 #

在Schema中为可能出错的字段设置转换函数，尝试将外部数据转换为符合要求的类型，转换失败则标记为无效或设置默认值。

比如修改stock字段的定义：

const InventorySchema = new mongoose.Schema({
  description: String,
  stock: {
    type: Number,
    // 尝试将输入转换为数字，转换失败则设为undefined（后续可过滤）
    set: value => {
      const num = Number(value);
      return isNaN(num) ? undefined : num;
    },
    // 可选：设置默认值
    default: 0
  },
  product_id: { type: String, unique: true }
});

之后再结合方法1的预验证，就能自动处理大部分类型不匹配的情况，减少无效文档的出现。

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