如何使用Mongoose确保MongoDB嵌套Schema中sequence字段的唯一性？

问题原因 #

你代码里用的unique: true是集合级别的索引，意思是整个集合中所有文档的这个字段值都不能重复，而不是单个文档的数组内部唯一。所以不管哪个Module的articles里的sequence，只要重复就会报错，这显然不符合你要的“单个Module的articles数组内sequence唯一”的需求。

解决方案 #

下面给两种实用的实现方式：

1. 自定义数组验证器（推荐）

直接在Schema的数组字段上添加验证函数，检查当前文档的数组内sequence是否重复：

const articleSchema = new Schema({
    // ... 你的文章字段
});

const moduleSchema = new Schema({
    // ... 你的模块字段
    articles: {
        type: [{
            article: {
                type: Schema.Types.ObjectId,
                ref: 'Article',
            },
            sequence: {
                type: Number,
                required: true
            }
        }],
        // 添加数组验证器
        validate: {
            validator: function(arr) {
                // 提取所有sequence值，用Set去重后对比长度
                const sequenceSet = new Set(arr.map(item => item.sequence));
                return sequenceSet.size === arr.length;
            },
            message: '同一个模块内的文章sequence不能重复'
        }
    }
});

const courseSchema = new Schema({
    // ... 你的课程字段
    modules: {
        type: [{
            module: {
                type: Schema.Types.ObjectId,
                ref: 'Module',
            },
            sequence: {
                type: Number,
                required: true
            }
        }],
        // 同样添加数组验证器
        validate: {
            validator: function(arr) {
                const sequenceSet = new Set(arr.map(item => item.sequence));
                return sequenceSet.size === arr.length;
            },
            message: '同一个课程内的模块sequence不能重复'
        }
    },
    // ... 其他课程字段
});

const Article = mongoose.model('Article', articleSchema);
const Module = mongoose.model('Module', moduleSchema);
const Course = mongoose.model('Course', courseSchema);

这种方式会在创建或更新文档时自动验证数组内的sequence唯一性，验证不通过会直接抛出错误。

2. 用预保存中间件检查

如果需要更灵活的逻辑，可以用Mongoose的预保存中间件，在保存前手动检查：

// 给Module添加预保存中间件
moduleSchema.pre('save', function(next) {
    const sequences = this.articles.map(item => item.sequence);
    if (new Set(sequences).size !== sequences.length) {
        return next(new Error('模块内的文章sequence重复了'));
    }
    next();
});

// 如果需要支持更新操作（比如findOneAndUpdate），还要添加对应的中间件
moduleSchema.pre('findOneAndUpdate', function(next) {
    const update = this.getUpdate();
    // 处理更新时的articles数组
    if (update.articles) {
        const sequences = update.articles.map(item => item.sequence);
        if (new Set(sequences).size !== sequences.length) {
            return next(new Error('模块内的文章sequence重复了'));
        }
    }
    next();
});

// Course的中间件同理
courseSchema.pre('save', function(next) {
    const sequences = this.modules.map(item => item.sequence);
    if (new Set(sequences).size !== sequences.length) {
        return next(new Error('课程内的模块sequence重复了'));
    }
    next();
});

courseSchema.pre('findOneAndUpdate', function(next) {
    const update = this.getUpdate();
    if (update.modules) {
        const sequences = update.modules.map(item => item.sequence);
        if (new Set(sequences).size !== sequences.length) {
            return next(new Error('课程内的模块sequence重复了'));
        }
    }
    next();
});

注意：中间件需要分别处理save和findOneAndUpdate等更新操作，因为不同的更新方法触发的中间件不一样。

补充说明 #

如果你的业务还需要保证sequence是连续的（比如从1开始，没有间隔），可以在验证器里再加一步检查：

validator: function(arr) {
    const sequences = arr.map(item => item.sequence).sort((a, b) => a - b);
    // 先检查重复
    if (new Set(sequences).size !== sequences.length) return false;
    // 再检查是否连续从1开始
    for (let i = 0; i < sequences.length; i++) {
        if (sequences[i] !== i + 1) return false;
    }
    return true;
}

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