Question

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

用户模型

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;

这是我的博客收藏，其中包含对评论模型的引用

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;

这是我的评论模型，其中引用了用户模型

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);
};

但博客不多

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

Answer 1

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

我还建议您重新设计架构，因为模型之间有很多引用。添加，插入或删除博客或评论时，您将必须进行2次数据库调用。

我将从用户架构中删除博客字段，并从博客架构中删除评论字段，并按如下所示设置虚拟填充：

用户架构：

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 }选项。

现在，您可以通过以下查询获得带有评论的用户博客：

  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相同的结果。

猫鼬填充不填充嵌套数组数据

1 个答案: