如何在同一Mongoose模型的子文档上正确使用populate？

我定义了如下Product模型：

const featureHeaderSchema = new Schema({
    header: {
        type: String,
        required: true,
    },
});
const featureSchema = new Schema({
    title: {
        type: String,
        required: true,
    },
    parentHeader: { type: Schema.Types.ObjectId, ref: "product.featureHeaders" }, // 不确定是否正确
    parentFeature: { type: Schema.Types.ObjectId, ref: "product.features" },  // 不确定是否正确
});
const productSchema = new Schema(
    {
        title: {
            type: String,
            required: true,
        },
        thumbnail: String,
        description: String,
        manufacture: { type: Schema.Types.ObjectId, ref: "user" },
        featureHeaders: {
            type: [featureHeaderSchema],
        },
        features: {
            type: [featureSchema],
        },
    },
    { timestamps: true }
);
const productModel = mongoose.model("product", productSchema);

我希望通过产品ID查询产品时，使用populate获取parentHeader和parentFeature的标题，尝试执行以下查询：

const output = await productModel
    .findById(newProduct._id)
    .populate("features.parentFeature")
    .exec();

但出现错误：MissingSchemaError: Schema hasn't been registered for model "product.features".

请问该如何正确实现需求？

解决方案 #

问题根源 #

Mongoose的populate功能仅适用于引用独立注册的模型（即通过mongoose.model()创建的模型），而你当前的featureHeaderSchema和featureSchema是嵌套在productSchema中的子文档Schema，并非独立模型，因此无法用populate关联同一文档内的子文档。

方案一：改为独立模型（推荐，适合复杂关联场景） #

将featureHeader和feature拆分为独立模型，在Product中存储它们的ObjectId数组，即可正常使用populate：

1. 定义独立模型：

// 单独定义FeatureHeader模型
const featureHeaderSchema = new Schema({
    header: {
        type: String,
        required: true,
    },
    product: { type: Schema.Types.ObjectId, ref: "product" } // 关联所属产品
});
const FeatureHeader = mongoose.model("FeatureHeader", featureHeaderSchema);

// 单独定义Feature模型
const featureSchema = new Schema({
    title: {
        type: String,
        required: true,
    },
    parentHeader: { type: Schema.Types.ObjectId, ref: "FeatureHeader" },
    parentFeature: { type: Schema.Types.ObjectId, ref: "Feature" },
    product: { type: Schema.Types.ObjectId, ref: "product" } // 关联所属产品
});
const Feature = mongoose.model("Feature", featureSchema);

// 修改Product模型，存储关联ID数组
const productSchema = new Schema(
    {
        title: {
            type: String,
            required: true,
        },
        thumbnail: String,
        description: String,
        manufacture: { type: Schema.Types.ObjectId, ref: "user" },
        featureHeaders: [{ type: Schema.Types.ObjectId, ref: "FeatureHeader" }],
        features: [{ type: Schema.Types.ObjectId, ref: "Feature" }],
    },
    { timestamps: true }
);
const productModel = mongoose.model("product", productSchema);

2. 查询时嵌套populate：

const output = await productModel
    .findById(newProduct._id)
    .populate({
        path: "features",
        populate: [
            { path: "parentHeader" },
            { path: "parentFeature" }
        ]
    })
    .populate("featureHeaders")
    .exec();

方案二：保持嵌套结构，手动关联（适合简单场景） #

如果不想拆分模型，可在查询到产品后，手动遍历features数组，从同一文档的featureHeaders和features中匹配对应的标题：

const product = await productModel.findById(newProduct._id).exec();

// 手动关联parentHeader和parentFeature的标题
product.features = product.features.map(feature => {
    // 匹配parentHeader的标题
    const parentHeader = product.featureHeaders.find(h => h._id.toString() === feature.parentHeader.toString());
    // 匹配parentFeature的标题
    const parentFeature = product.features.find(f => f._id.toString() === feature.parentFeature.toString());
    
    return {
        ...feature.toObject(),
        parentHeaderTitle: parentHeader?.header,
        parentFeatureTitle: parentFeature?.title
    };
});

console.log(product);

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