如何用Express.js和Mongoose仅传Application ID实现对象嵌入存储

现有代码 #

Role Schema #

import mongoose from "mongoose";

const roleSchema = mongoose.Schema({
    name: {
        type: String,
        required: true
    },
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "Users"
    },
    applications: [{
        type: mongoose.Schema.Types.ObjectId,
        ref: "Applications"
    }]
}, { timestamps: true });

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

Applications Schema #

import mongoose from 'mongoose';

const applicationSchema = mongoose.Schema(
  {
    name: {
      type: String,
      required: true,
    },
    parent: {
      type: Number,
      required: false,
    },
    order: {
      type: Number,
      required: false,
    },
    appRoleId: [
      {
        type: mongoose.Schema.Types.ObjectId,
        ref: 'Roles',
      },
    ],
  },
  { timestamps: true }
);

export default mongoose.model('Applications', applicationSchema);

当前POST请求 #

POST http://localhost:3000/role
Content-Type: application/json

{
    "name": "administrator testing",
    "applications": [
        "636341e4b8f0b311829f5cb8"
    ]
}

当前控制器代码 #

export const saveRole = async (req, res) => {
  const app = await Application.find();
  const role = new Role(req.body);
  // console.log(role);
  for (const roles of role) {
    const newRole = await Role.create({ ...roles });
    //add app to role
    foundApp.role.push(newRole._id);
    await foundApp.save();
  }
  // res.json(foundApp);
};

需求 #

仅传入Application ID，自动将对应的完整Application对象嵌入到Role的applications字段中，预期MongoDB中的数据格式为：

applications字段是一个数组，每个元素为完整的Application文档，包含_id、name、parent、order、createdAt、updatedAt等所有字段。

解决方案 #

步骤1：修改Role Schema #

要实现嵌入存储，需将applications字段从ObjectId数组改为子文档数组，结构与Applications Schema匹配：

import mongoose from "mongoose";

// 定义Application子文档结构，和独立的Applications Schema一致
const applicationSubSchema = mongoose.Schema({
    name: {
        type: String,
        required: true
    },
    parent: {
        type: Number,
        required: false
    },
    order: {
        type: Number,
        required: false
    }
}, { timestamps: true });

const roleSchema = mongoose.Schema({
    name: {
        type: String,
        required: true
    },
    user: {
        type: mongoose.Schema.Types.ObjectId,
        ref: "Users"
    },
    applications: [applicationSubSchema] // 改为子文档数组，存储完整对象
}, { timestamps: true });

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

步骤2：重写saveRole控制器 #

根据传入的ID查询完整Application文档，嵌入到Role中，同时维护反向关联：

import Role from '../models/Role.js';
import Application from '../models/Application.js';

export const saveRole = async (req, res) => {
  try {
    const { name, applications: appIds, user } = req.body;
    
    // 根据传入的ID批量查询对应的Application
    const targetApps = await Application.find({
      _id: { $in: appIds }
    });
    
    // 校验：如果传入的ID有不存在的，返回错误提示
    if (targetApps.length !== appIds.length) {
      return res.status(400).json({ message: '部分应用ID无效' });
    }
    
    // 创建Role，直接嵌入查询到的完整Application对象
    const newRole = await Role.create({
      name,
      user,
      applications: targetApps
    });
    
    // 更新Applications的反向关联，将当前Role ID加入appRoleId数组
    await Application.updateMany(
      { _id: { $in: appIds } },
      { $push: { appRoleId: newRole._id } }
    );
    
    res.status(201).json(newRole);
  } catch (err) {
    res.status(500).json({ message: err.message });
  }
};

关键说明 #

• 原控制器逻辑错误：new Role(req.body)生成的是单个实例，不是数组，for...of循环会直接报错；foundApp未定义，也未正确处理数据关联。
• 嵌入存储的核心是将子文档直接存入父文档，而非仅存ID，修改Schema是前提。
• 批量查询和更新能提升效率，同时校验ID有效性避免无效数据存入。

内容的提问来源于stack exchange，提问作者very beginner code