如何通过更新Skill模型自动同步Course模型中的关联技能名称？

我拥有Skill和Course两个Mongoose模型，当更新任意已有Skill的name字段时，希望自动更新已关联该技能的Course对象中skills数组内对应的name字段。如何实现这一自动同步？

Course模型 #

const courseSchema = new mongoose.Schema(
    {
        name: {
            type: String,
            required: true,
            trim: true,
        },
        description: {
            type: String,
        },
        
        skills: [
            {
                name: { type: String },
                id: { type: mongoose.Schema.Types.ObjectId, ref: 'Skill' },
            },
        ],
    }
);

Skill模型 #

const Course = require('./course.model');

const skillSchema = new mongoose.Schema(
    {
        name: {
            type: String,
            required: true,
            trim: true,
        },
        description: {
            type: String,
        },
        points: {
            type: Number,
        },
    },
    {
        timestamps: true,
    }
);

现有技能更新函数 #

module.exports.updateSkillById = async (req, res) => {
    const updates = Object.keys(req.body);
    const allowedUpdates = ['name', 'description', 'points'];
    const isValidOperation = updates.every((update) =>
        allowedUpdates.includes(update)
    );
    if (!isValidOperation) {
        return res.status(400).send({ error: 'Invalid updates!' });
    }
    try {
        const skill = await Skill.findOneAndUpdate(req.params.id, req.body, {
            new: true,
            runValidators: true,
        });
        if (!skill) {
            return res.status(404).send();
        }
      
        res.send(skill);
    } catch (err) {
        res.status(400).send(err);
    }
};

解决方案 #

方法一：在更新函数中手动同步（快速实现） #

直接修改现有更新函数，检测到name字段被更新时，同步更新所有关联该Skill的Course记录：

module.exports.updateSkillById = async (req, res) => {
    const updates = Object.keys(req.body);
    const allowedUpdates = ['name', 'description', 'points'];
    const isValidOperation = updates.every((update) =>
        allowedUpdates.includes(update)
    );
    if (!isValidOperation) {
        return res.status(400).send({ error: 'Invalid updates!' });
    }
    try {
        const skill = await Skill.findOneAndUpdate(req.params.id, req.body, {
            new: true,
            runValidators: true,
        });
        if (!skill) {
            return res.status(404).send();
        }

        // 新增：同步更新Course中对应的skill name
        if (updates.includes('name')) {
            await Course.updateMany(
                { 'skills.id': req.params.id }, // 匹配关联该Skill的Course
                { $set: { 'skills.$.name': skill.name } } // 使用$定位符更新数组中匹配的元素
            );
        }
      
        res.send(skill);
    } catch (err) {
        res.status(400).send(err);
    }
};

特点：实现简单，仅针对当前接口生效；但如果有其他更新Skill的入口（比如后台脚本、其他接口），需要重复编写同步逻辑。

方法二：使用Mongoose中间件（全局自动同步） #

在Skill模型中添加post钩子，覆盖所有更新场景，只要Skill的name被修改就自动同步Course：

const Course = require('./course.model');

const skillSchema = new mongoose.Schema(
    {
        name: {
            type: String,
            required: true,
            trim: true,
        },
        description: {
            type: String,
        },
        points: {
            type: Number,
        },
    },
    {
        timestamps: true,
    }
);

// 处理findOneAndUpdate操作后的同步
skillSchema.post('findOneAndUpdate', async function(doc) {
    const update = this.getUpdate();
    // 检查是否更新了name字段
    if (update.name) {
        await Course.updateMany(
            { 'skills.id': doc._id },
            { $set: { 'skills.$.name': update.name } }
        );
    }
});

// 处理save操作后的同步（比如通过skill.save()更新的场景）
skillSchema.post('save', async function(doc) {
    // 检查name字段是否被修改
    if (doc.isModified('name')) {
        await Course.updateMany(
            { 'skills.id': doc._id },
            { $set: { 'skills.$.name': doc.name } }
        );
    }
});

const Skill = mongoose.model('Skill', skillSchema);
module.exports = Skill;

特点：全局生效，无需在每个更新接口中重复编写逻辑；需注意Mongoose钩子的触发条件（比如findOneAndUpdate默认不触发save钩子，需单独处理）。

注意事项 #

1. 索引优化：为Course模型的skills.id字段添加索引，提升updateMany的查询效率：

courseSchema.index({ 'skills.id': 1 });

2. 原子性保障：若需确保Skill更新和Course同步的原子性（避免Skill更新成功但Course同步失败），可使用MongoDB事务（要求MongoDB版本≥4.0，且部署为副本集/分片集群）。
3. 性能考量：若关联该Skill的Course数量极大，updateMany可能存在性能瓶颈，可考虑用异步队列（如Redis Queue）延迟处理同步操作。

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