如何在Mongoose中高效关联用户、角色与权限（避免多查询）

现有以下Mongoose Schema设计：

用户Schema #

const userSchema = mongoose.Schema({
    username: {
        type: String,
        required: true,
    },
    first_name: {
        type: String,
        required: true,
    },
    last_name: {
        type: String,
        required: true,
    },
    email: {
        type: String,
        required: true,
    },
    password: {
        type: String,
        required: true,
    },
    otp: {
        type: String,
    },
    phone_number: {
        type: String,
        required: true,
    },
    resetPasswordToken: {
        type: String,
    },
    resetPasswordExpires: {
        type: Date,
    }
}, { timestamps: true });

角色Schema #

import mongoose from 'mongoose';

const roleSchema = mongoose.Schema({
    name: {
        type: String,
        required: true
    },
}, { timestamps: true })

export default mongoose.model('Role', roleSchema);

用户角色关联中间表Schema #

import mongoose from 'mongoose';

const userRoleSchema = mongoose.Schema({
    userId: {
        type: mongoose.Schema.Types.ObjectId,
        required: true,
        ref: "User",
        unique: true,
    },
    roleId: {
        type: mongoose.Schema.Types.ObjectId,
        required: true,
        ref: "Role",
        unique: true,
    }
}, { timestamps: true })

export default mongoose.model('UserRole', userRoleSchema);

目前需要替代繁琐的分步查询（查询用户→查询中间表→查询角色），直接获取包含角色名、权限信息的完整用户对象，同时还要处理User->UserPermission->Permission、Role->RolePermission->Permission这类多中间表关联场景。

方法一：使用Mongoose聚合管道（Aggregation Pipeline） #

聚合管道可以通过一次数据库请求完成所有关联查询，高效生成包含关联数据的用户对象，是多中间表场景的最优选择。

1. 查询单个用户并嵌入角色信息

const mongoose = require('mongoose');
const User = mongoose.model('User');

async function getUserWithRole(userId) {
  const userWithRole = await User.aggregate([
    // 匹配目标用户
    { $match: { _id: mongoose.Types.ObjectId(userId) } },
    // 关联用户角色中间表
    {
      $lookup: {
        from: 'userroles', // 注意：集合名是模型名的复数形式（Mongoose默认规则）
        localField: '_id',
        foreignField: 'userId',
        as: 'userRoles'
      }
    },
    // 通过中间表的roleId关联角色表
    {
      $lookup: {
        from: 'roles',
        localField: 'userRoles.roleId',
        foreignField: '_id',
        as: 'roles'
      }
    },
    // 展开角色数组（因UserRole中userId唯一，此处只会返回单个角色）
    { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
    // 整理返回字段，直接提取角色名
    {
      $project: {
        username: 1,
        first_name: 1,
        last_name: 1,
        email: 1,
        phone_number: 1,
        role: '$roles.name',
        createdAt: 1,
        updatedAt: 1,
        // 按需保留其他字段
      }
    }
  ]);

  return userWithRole[0]; // 聚合返回数组，取第一个元素
}

2. 扩展：同时获取角色权限与用户直接权限

如果需要一次性返回角色权限、用户直接权限，只需在聚合管道中添加对应的关联步骤：

async function getUserWithFullPermissions(userId) {
  const userWithPermissions = await User.aggregate([
    { $match: { _id: mongoose.Types.ObjectId(userId) } },
    // 关联用户角色
    {
      $lookup: {
        from: 'userroles',
        localField: '_id',
        foreignField: 'userId',
        as: 'userRoles'
      }
    },
    {
      $lookup: {
        from: 'roles',
        localField: 'userRoles.roleId',
        foreignField: '_id',
        as: 'roles'
      }
    },
    // 关联用户直接权限中间表与权限表
    {
      $lookup: {
        from: 'userpermissions',
        localField: '_id',
        foreignField: 'userId',
        as: 'userPermissions'
      }
    },
    {
      $lookup: {
        from: 'permissions',
        localField: 'userPermissions.permissionId',
        foreignField: '_id',
        as: 'directPermissions'
      }
    },
    // 关联角色权限中间表与权限表
    {
      $lookup: {
        from: 'rolepermissions',
        localField: 'roles._id',
        foreignField: 'roleId',
        as: 'rolePermissions'
      }
    },
    {
      $lookup: {
        from: 'permissions',
        localField: 'rolePermissions.permissionId',
        foreignField: '_id',
        as: 'roleBasedPermissions'
      }
    },
    // 合并直接权限与角色权限（可选）
    {
      $addFields: {
        allPermissions: {
          $concatArrays: ['$directPermissions', '$roleBasedPermissions']
        }
      }
    },
    { $unwind: { path: '$roles', preserveNullAndEmptyArrays: true } },
    // 整理返回字段，提取权限名称
    {
      $project: {
        username: 1,
        first_name: 1,
        last_name: 1,
        email: 1,
        phone_number: 1,
        role: '$roles.name',
        directPermissions: '$directPermissions.name',
        roleBasedPermissions: '$roleBasedPermissions.name',
        allPermissions: '$allPermissions.name',
        createdAt: 1,
        updatedAt: 1
      }
    }
  ]);

  return userWithPermissions[0];
}

方法二：使用虚拟字段（Virtuals）+ Populate #

如果场景相对简单，可以通过给UserSchema添加虚拟字段，模拟直接关联，再用populate方法获取关联数据：

1. 修改UserSchema添加虚拟字段

// 在userSchema定义后添加
userSchema.virtual('roles', {
  ref: 'Role',
  localField: '_id',
  foreignField: '_id',
  // 指定中间表模型
  through: {
    model: 'UserRole',
    localField: 'userId',
    foreignField: 'roleId'
  }
});

// 启用虚拟字段的序列化（返回JSON/对象时包含虚拟字段）
userSchema.set('toJSON', { virtuals: true });
userSchema.set('toObject', { virtuals: true });

2. 查询时使用Populate

const user = await User.findById(userId).populate('roles');
// 返回的user对象会包含roles数组，包含关联的角色信息

方案对比 #

• 聚合管道：适合复杂多中间表关联场景，一次请求完成所有查询，性能更优，且能灵活控制返回的数据结构和字段。
• 虚拟字段+Populate：代码更简洁，适合简单中间表关联，但灵活性不如聚合，嵌套关联场景下处理起来更繁琐。

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