如何基于Mongoose与Node.js实现MongoDB自定义变更日志并捕获文档修改前后差异

嘿，这个需求在Node.js + Mongoose的技术栈下完全能落地，我给你分享几个项目里常用的实现思路，都是经过验证的：

Mongoose的中间件（Hooks）是实现这个需求的核心工具，我们可以在文档保存/更新前后捕获数据快照，对比差异后写入日志集合。

步骤1：定义变更日志模型 #

首先创建一个专门存储变更记录的集合模型，用来统一管理所有文档的变更历史：

const mongoose = require('mongoose');

const changeLogSchema = new mongoose.Schema({
  collectionName: { type: String, required: true }, // 发生变更的集合名称
  documentId: { type: mongoose.Schema.Types.ObjectId, required: true }, // 目标文档ID
  changes: [{
    field: { type: String, required: true }, // 变更的字段名
    oldValue: mongoose.Schema.Types.Mixed, // 变更前的值
    newValue: mongoose.Schema.Types.Mixed, // 变更后的值
    message: String // 自定义提示（比如"姓名已修改"）
  }],
  changedAt: { type: Date, default: Date.now }, // 变更时间
  changedBy: String // 可选：记录操作人ID/名称
});

const ChangeLog = mongoose.model('ChangeLog', changeLogSchema);

步骤2：在目标模型中添加钩子逻辑 #

针对你需要记录变更的模型（比如用户模型），通过Mongoose的pre和post钩子实现快照保存与差异对比：

处理普通save操作 #

const userSchema = new mongoose.Schema({
  name: String,
  age: Number,
  email: String
});

// 保存更新前的文档快照
userSchema.pre('save', function(next) {
  // 新建文档无需记录变更，跳过快照保存
  if (!this.isNew) {
    this._original = this.toObject({ transform: false });
  }
  next();
});

// 保存后对比快照，生成变更日志
userSchema.post('save', async function(doc) {
  if (doc.isNew) return;
  
  const original = doc._original;
  const changes = [];

  // 自定义字段对比逻辑，根据业务需求调整
  if (original.name !== doc.name) {
    changes.push({
      field: 'name',
      oldValue: original.name,
      newValue: doc.name,
      message: '姓名已修改'
    });
  }
  if (original.age !== doc.age) {
    changes.push({
      field: 'age',
      oldValue: original.age,
      newValue: doc.age,
      message: '年龄已修改'
    });
  }

  // 有变更才写入日志
  if (changes.length > 0) {
    await ChangeLog.create({
      collectionName: 'users',
      documentId: doc._id,
      changes: changes
    });
  }
});

const User = mongoose.model('User', userSchema);

处理findOneAndUpdate类更新操作 #

这类操作不会触发save钩子，需要单独处理：

// 保存更新前的文档快照
userSchema.pre('findOneAndUpdate', async function(next) {
  const originalDoc = await this.model.findOne(this.getQuery());
  if (originalDoc) {
    this._original = originalDoc.toObject({ transform: false });
  }
  next();
});

// 更新后对比快照，生成日志
userSchema.post('findOneAndUpdate', async function() {
  if (!this._original) return;
  
  // 获取更新后的完整文档
  const updatedDoc = await this.model.findOne(this.getQuery());
  const changes = [];

  if (this._original.name !== updatedDoc.name) {
    changes.push({
      field: 'name',
      oldValue: this._original.name,
      newValue: updatedDoc.name,
      message: '姓名已修改'
    });
  }
  // 其他字段对比逻辑...

  if (changes.length > 0) {
    await ChangeLog.create({
      collectionName: 'users',
      documentId: updatedDoc._id,
      changes: changes
    });
  }
});

进阶优化：封装成可复用插件 #

如果多个模型都需要变更日志功能，把逻辑封装成Mongoose插件可以避免重复代码：

// 定义变更日志插件
const changeLogPlugin = (schema, options) => {
  const LogModel = options.logModel || mongoose.model('ChangeLog');
  const collectionName = options.collectionName || schema.collection.name;
  // 自定义字段提示映射
  const fieldMessages = options.fieldMessages || {};

  // 通用快照保存逻辑
  schema.pre(['save', 'findOneAndUpdate', 'updateOne'], async function(next) {
    if (this.op === 'save' && !this.isNew) {
      this._original = this.toObject({ transform: false });
    } else if (['findOneAndUpdate', 'updateOne'].includes(this.op)) {
      const originalDoc = await this.model.findOne(this.getQuery());
      if (originalDoc) this._original = originalDoc.toObject({ transform: false });
    }
    next();
  });

  // 通用差异对比与日志生成逻辑
  schema.post(['save', 'findOneAndUpdate', 'updateOne'], async function(doc) {
    const original = this._original;
    if (!original) return;

    // 获取更新后的文档（save操作直接用doc，update类操作需要重新查询）
    const currentDoc = this.op === 'save' ? doc : await this.model.findOne(this.getQuery());
    const changes = [];

    // 遍历原始字段，跳过MongoDB内部字段
    Object.keys(original).forEach(key => {
      if (key === '_id' || key === '__v') return;
      // 深对比字段值（避免嵌套对象对比失效）
      if (JSON.stringify(original[key]) !== JSON.stringify(currentDoc[key])) {
        changes.push({
          field: key,
          oldValue: original[key],
          newValue: currentDoc[key],
          message: fieldMessages[key] || `${key}已修改`
        });
      }
    });

    if (changes.length > 0) {
      await LogModel.create({
        collectionName,
        documentId: currentDoc._id,
        changes
      });
    }
  });
};

// 在用户模型中使用插件
userSchema.plugin(changeLogPlugin, {
  fieldMessages: {
    name: '姓名已修改',
    age: '年龄已修改',
    email: '邮箱已修改'
  }
});

注意事项 #

• 嵌套字段处理：如果文档有多层嵌套对象，上面的JSON.stringify对比可能不够灵活，可以使用deep-diff这类npm包实现递归差异对比。
• 性能优化：高并发场景下，同步写入日志可能影响主业务性能，可以用BullMQ等队列工具异步处理日志插入。
• 敏感字段过滤：密码、手机号等敏感字段要在对比逻辑中跳过，避免泄露。
• 批量更新场景：updateMany这类批量操作无法获取单个文档的原始快照，需要先查询所有匹配文档，再逐个处理变更日志。

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