Mongoose aggregate $lookup关联嵌套数组仅首项生效问题

在Mongoose中使用aggregate聚合的$lookup操作关联模型内嵌数组字段时，现有写法仅对数组第一个索引项生效，会丢失其余数组项与原字段属性。
定义的User、Product模型Schema如下：

// user schema
const UserSchema = new mongoose.Schema(
  {
    name: { type: String, default: "", required: true},
    password: { type: String, default: "" },
  },
  {
    toJSON : {
      virtuals : true
    },
    timestamps: true,
  }
);

module.exports = {
  UserModel: mongoose.model("user", UserSchema),
};

// products schema
const buyerSchema = new mongoose.Schema(
  {
    user: { type: mongoose.Types.ObjectId, ref: "user", required: true },
    count: { type: Number, default: 1 },
  },
  {
    toJSON: {
      virtuals: true,
    },
    timestamps: true,
  }
);

const productSchema = new mongoose.Schema(
  {
    buyers: { type: [buyerSchema], default: "", required: true},
    name: { type: String, default: "", ref: "user" },
    price : { type: Number, required: true} },
  {
    toJSON : {
      virtuals : true
    },
    timestamps: true,
  }
);

module.exports = {
  ProductModel: mongoose.model("product", productSchema),
};

原有错误聚合写法：

const products = await ProductModel.aggregate([
  {
    $match: {},
  },
  {
     $lookup: {
       from: "users",
       localField: "buyers.user",
       foreignField: "_id",
       as: "buyers.user",
     },
  },
]);

直接调用.find({})的正常返回结果中，buyers数组包含所有购买记录，每条记录保留count、_id、时间戳等字段，user字段存储用户ID；使用上述聚合代码后，buyers数组仅返回1条关联到的用户文档，丢失了原有的count等购买记录属性，其余购买记录全部消失。

$lookup的as参数作用是将关联查询到的结果整体赋值给指定路径的字段，直接覆盖该路径原有值，不会自动遍历内嵌数组逐个替换子项属性。
当把as设置为buyers.user时，MongoDB会直接把所有匹配到的用户文档（自动去重）赋值到buyers.user路径，直接覆盖整个buyers数组的原有结构，导致数组内原有的count、_id、时间戳等字段全部丢失，也不会保留多条购买记录。

推荐使用MongoDB 3.6+支持的管道式$lookup方案，无需拆分数组即可保留所有原有字段，性能更好：

const products = await ProductModel.aggregate([
  { $match: {} },
  {
    $lookup: {
      from: "users",
      // 声明变量，传入当前商品下所有购买者的用户ID集合
      let: { buyerUserIds: "$buyers.user" },
      pipeline: [
        // 匹配ID在传入列表内的用户
        { $match: { $expr: { $in: ["$_id", "$$buyerUserIds"] } } },
        // 按需过滤敏感字段，比如密码不要返回给前端
        { $project: { password: 0 } }
      ],
      // 关联结果先存入临时字段，避免覆盖原有数据
      as: "matchedUsers"
    }
  },
  {
    $addFields: {
      // 遍历重写buyers数组，保留原有字段同时替换user为关联文档
      buyers: {
        $map: {
          input: "$buyers",
          as: "buyerItem",
          in: {
            $mergeObjects: [
              // 先保留当前购买记录的所有原有字段（count、_id、时间戳等）
              "$$buyerItem",
              {
                // 找到ID匹配的用户文档，替换原有的userID值
                user: {
                  $arrayElemAt: [
                    {
                      $filter: {
                        input: "$matchedUsers",
                        cond: { $eq: ["$$this._id", "$$buyerItem.user"] }
                      }
                    },
                    0
                  ]
                }
              }
            ]
          }
        }
      }
    }
  },
  // 聚合完成后删除临时存储的用户列表字段
  { $project: { matchedUsers: 0 } }
]);

如果使用的MongoDB版本低于3.6，可以使用$unwind拆分数组后关联再重组的方案，性能略低于上述方案：

const products = await ProductModel.aggregate([
  { $match: {} },
  // 将buyers数组拆分为单条文档，每条文档对应一条购买记录
  { $unwind: "$buyers" },
  // 按单条购买记录的userID关联用户
  {
    $lookup: {
      from: "users",
      localField: "buyers.user",
      foreignField: "_id",
      as: "buyers.user"
    }
  },
  // $lookup返回的是数组，用户ID唯一所以取第一个元素即可
  { $set: { "buyers.user": { $arrayElemAt: ["$buyers.user", 0] } } },
  // 按商品ID分组，将拆分后的购买记录重新拼为buyers数组
  {
    $group: {
      _id: "$_id",
      name: { $first: "$name" },
      price: { $first: "$price" },
      createdAt: { $first: "$createdAt" },
      updatedAt: { $first: "$updatedAt" },
      __v: { $first: "__v" },
      buyers: { $push: "$buyers" }
    }
  }
]);

• 关联查询用户数据时，必须过滤密码、令牌等敏感字段，避免数据泄露
• 不要直接将$lookup的as参数指向内嵌数组的子属性路径，该操作会直接覆盖路径下的原有数据结构，不会自动做数组项的一一映射
• 关联前确认字段类型一致：buyers.user存储的是ObjectId类型时，users集合的_id也必须为同类型，否则会出现匹配失败的问题

内容的提问来源于stack exchange，提问作者Anna w.t