【问题标题】:Mongoose Populate Not Populating nested array dataMongoose 填充不填充嵌套数组数据
【发布时间】:2020-06-07 22:55:38
【问题描述】:

所以我有这个引用博客的用户模型

用户模型

const mongoose = require("mongoose");
const Schema = mongoose.Schema;
const bcrypt = require("bcryptjs");

const userSchema = new Schema(
  {
    email: {
      type: String,
      required: true,
      index: {
        unique: true
      }
    },
    password: {
      type: String,
      required: true
    },
    name: {
      type: String,
      required: true
    },
    website: {
      type: String
    },
    bio: {
      type: String
    },
    blogs: [
      {
        type: Schema.Types.ObjectId,
        ref: "Blog"
      }
    ]
  },
  {
    timestamps: {
      createdAt: "created_at",
      updatedAt: "updated_at"
    }
  }
);


userSchema.pre("save", function(next) {
  const user = this;
  if (!user.isModified("password")) return next();

  bcrypt.genSalt(10, function(err, salt) {
    if (err) return next(err);

    bcrypt.hash(user.password, salt, function(err, hash) {
      if (err) return next(err);

      user.password = hash;
      next();
    });
  });
});

userSchema.methods.comparePassword = function(password, next) {
  bcrypt.compare(password, this.password, function(err, isMatch) {
    if (err) return next(err);
    next(null, isMatch);
  });
};

const User = mongoose.model("User", userSchema);
module.exports = User;

这是我的博客集合,其中引用了 cmets 模型

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const blogSchema = new Schema(
  {
    title: {
      type: String,
      required: true
    },
    body: {
      type: String,
      required: true
    },
    author: {
      type: Schema.Types.ObjectId,
      ref: "User"
    },
    likesCount: {
      type: Number
    },
    comments: [
      {
        type: Schema.Types.ObjectId,
        ref: "Comment"
      }
    ]
  },
  {
    timestamps: {
      createdAt: "created_at",
      updatedAt: "updated_at"
    }
  }
);


const Blog = mongoose.model("Blog", blogSchema);
module.exports = Blog;

这是我的 cmets 模型,它引用了用户模型

const mongoose = require("mongoose");
const Schema = mongoose.Schema;

const CommentSchema = new Schema(
  {
    body: {
      type: String,
      required: true
    },
    likesCount: {
      type: Number
    },
    user: {
      type: Schema.Types.ObjectId,
      ref: "User"
    }
  },
  {
    timestamps: {
      createdAt: "created_at",
      updatedAt: "updated_at"
    }
  }
);

const Comment = mongoose.model("Comment", CommentSchema);
module.exports = Comment;

我想要的是如果我获取用户数据我想获取博客以及评论数据 我有这个代码

exports.getCurrentUser = async (req, res) => {
  const ObjectId = mongoose.Types.ObjectId;

  const users = await User.findById({ _id: new ObjectId(req.user._id) })
    .populate({
        path: "blogs",
        model: "Blog"
      })
    .exec();

  console.log(users);

  return res.status(200).json(users);
};

但它没有填充博客

如何实现这种嵌套引用获取?

【问题讨论】:

    标签: node.js mongodb mongoose nosql


    【解决方案1】:

    我认为问题在于模型必须是模型引用,而不是模型名称。所以它必须是model: Blog 而不是model: "Blog"

    另外我建议你重新设计你的模式,因为你有很多模型之间的引用。当您添加、插入或删除博客或评论时,您必须进行 2 次 db 调用。

    我会从用户架构中删除博客字段,并从博客架构中删除 cmets 字段,并像这样设置虚拟填充:

    用户架构:

    const userSchema = new Schema(
      {
        email: {
          type: String,
          required: true,
          index: {
            unique: true
          }
        },
        password: {
          type: String,
          required: true
        },
        name: {
          type: String,
          required: true
        },
        website: {
          type: String
        },
        bio: {
          type: String
        }
      },
      {
        timestamps: {
          createdAt: "created_at",
          updatedAt: "updated_at"
        },
        toJSON: {
          virtuals: true
        }
      }
    );
    
    userSchema.virtual("blogs", {
      ref: "Blog",
      foreignField: "author",
      localField: "_id"
    });
    

    博客架构:

    const blogSchema = new Schema(
      {
        title: {
          type: String,
          required: true
        },
        body: {
          type: String,
          required: true
        },
        author: {
          type: Schema.Types.ObjectId,
          ref: "User"
        },
        likesCount: {
          type: Number
        }
      },
      {
        timestamps: {
          createdAt: "created_at",
          updatedAt: "updated_at"
        },
        toJSON: { virtuals: true }
      }
    );
    
    blogSchema.virtual("comments", {
      ref: "Comment",
      foreignField: "blog",
      localField: "_id"
    });
    

    请注意,我在两个架构中都添加了 toJSON: { virtuals: true } 选项。

    现在您可以使用以下查询获取用户的博客与 cmets:

      const user = await User.findById(req.user._id)
        .populate({
          path: "blogs",
          populate: "comments"
        })
        .select("-password")
        .exec();
    

    测试:

    假设您是这些示例文档。

    db={
      "users": [
        {
          "_id": "5e53b1726f41c765fc4def9c",
          "email": "user1@gmail.com",
          "password": "$2a$10$.heEhkN2BhxZiw8upgjGQe.r3Gt78JVfuAqLqf6lHwireaKJSrrTO",
          "name": "User1"
        },
        {
          "_id": "5e53b1906f41c765fc4def9d",
          "email": "user2@gmail.com",
          "password": "$2a$10$tEaXpoeH5iXVzqmzozAFOOu.Nxb32Ssy1XS5CAqad7qqanHQkrqjK",
          "name": "User2"
        },
        {
          "_id": "5e53b1996f41c765fc4def9e",
          "email": "user3@gmail.com",
          "password": "$2a$10$4s34RLnSd75WeG8K.gzxxeixkruplzW0vpb7PJR/aL1d3Ia31wj.W",
          "name": "User3"
        }
      ],
      "blogs": [
        {
          "_id": "5e53b26c6f41c765fc4def9f",
          "title": "Blog1 Title",
          "body": "Blog1 Body",
          "author": "5e53b1726f41c765fc4def9c"
        },
        {
          "_id": "5e53b2896f41c765fc4defa1",
          "title": "Blog2 Title",
          "body": "Blog2 Body",
          "author": "5e53b1726f41c765fc4def9c"
        }
      ],
      "comments": [
        {
          "_id": "5e53b2f86f41c765fc4defa3",
          "body": "Comment1 (user2 on user1's blog1)",
          "user": "5e53b1906f41c765fc4def9d",
          "blog": "5e53b26c6f41c765fc4def9f"
        },
        {
          "_id": "5e53b3246f41c765fc4defa4",
          "body": "Comment2 (user3 on user1's blog1)",
          "user": "5e53b1996f41c765fc4def9e",
          "blog": "5e53b26c6f41c765fc4def9f"
        },
        {
          "_id": "5e53b34c6f41c765fc4defa5",
          "body": "Comment3 (user2 on user1's blog2)",
          "user": "5e53b1906f41c765fc4def9d",
          "blog": "5e53b2896f41c765fc4defa1"
        }
      ]
    }
    

    _id: "5e53b1726f41c765fc4def9c" 的用户的结果将是这样的:

    {
        "_id": "5e53b1726f41c765fc4def9c",
        "email": "user1@gmail.com",
        "name": "User1",
        "created_at": "2020-02-24T11:20:18.343Z",
        "updated_at": "2020-02-24T11:20:18.343Z",
        "__v": 0,
        "blogs": [
            {
                "_id": "5e53b26c6f41c765fc4def9f",
                "title": "Blog1 Title",
                "body": "Blog1 Body",
                "author": "5e53b1726f41c765fc4def9c",
                "created_at": "2020-02-24T11:24:28.895Z",
                "updated_at": "2020-02-24T11:24:28.895Z",
                "__v": 0,
                "comments": [
                    {
                        "_id": "5e53b2f86f41c765fc4defa3",
                        "body": "Comment1 (user2 on user1's blog1)",
                        "user": "5e53b1906f41c765fc4def9d",
                        "blog": "5e53b26c6f41c765fc4def9f",
                        "created_at": "2020-02-24T11:26:48.506Z",
                        "updated_at": "2020-02-24T11:26:48.506Z",
                        "__v": 0
                    },
                    {
                        "_id": "5e53b3246f41c765fc4defa4",
                        "body": "Comment2 (user3 on user1's blog1)",
                        "user": "5e53b1996f41c765fc4def9e",
                        "blog": "5e53b26c6f41c765fc4def9f",
                        "created_at": "2020-02-24T11:27:32.305Z",
                        "updated_at": "2020-02-24T11:27:32.305Z",
                        "__v": 0
                    }
                ],
                "id": "5e53b26c6f41c765fc4def9f"
            },
            {
                "_id": "5e53b2896f41c765fc4defa1",
                "title": "Blog2 Title",
                "body": "Blog2 Body",
                "author": "5e53b1726f41c765fc4def9c",
                "created_at": "2020-02-24T11:24:57.078Z",
                "updated_at": "2020-02-24T11:24:57.078Z",
                "__v": 0,
                "comments": [
                    {
                        "_id": "5e53b34c6f41c765fc4defa5",
                        "body": "Comment3 (user2 on user1's blog2)",
                        "user": "5e53b1906f41c765fc4def9d",
                        "blog": "5e53b2896f41c765fc4defa1",
                        "created_at": "2020-02-24T11:28:12.551Z",
                        "updated_at": "2020-02-24T11:28:12.551Z",
                        "__v": 0
                    }
                ],
                "id": "5e53b2896f41c765fc4defa1"
            }
        ],
        "id": "5e53b1726f41c765fc4def9c"
    }
    

    另一种选择是使用 MongoDB 聚合框架。 使用此选项,您可以删除我为虚拟填充添加的选项。

    Playground

      const users = await User.aggregate([
        {
          $match: {
            _id: req.user._id
          }
        },
        {
          $project: {
            password: 0
          }
        },
        {
          $lookup: {
            from: "blogs",
            let: {
              userId: "$_id"
            },
            pipeline: [
              {
                $match: {
                  $expr: {
                    $eq: ["$$userId", "$author"]
                  }
                }
              },
              {
                $lookup: {
                  from: "comments",
                  let: {
                    blogId: "$_id"
                  },
                  pipeline: [
                    {
                      $match: {
                        $expr: {
                          $eq: ["$blog", "$$blogId"]
                        }
                      }
                    }
                  ],
                  as: "comments"
                }
              }
            ],
            as: "blogs"
          }
        }
      ]);
    

    users[0] 会得到与选项 1 相同的结果。

    【讨论】:

    • 感谢 virtual one 确实有效..虽然我自己尝试过 virtual 在它对博客有效但对 cme​​ts 无效..再次感谢
    • @YashGupta 欢迎您。如果您也可以为答案投票,我将不胜感激。
    猜你喜欢
    • 2015-03-26
    • 2019-01-31
    • 2019-12-06
    • 2018-06-07
    • 2016-10-12
    • 2019-09-23
    • 1970-01-01
    • 2016-03-01
    相关资源
    最近更新 更多