在猫鼬 NodeJs 中保存 4 级嵌套模式的最佳方法是什么

Question

我有 4 级嵌套模式：

框架引用了域，域引用了控件，控件引用了子控件。

现在我一直在寻找一段时间，但我一直很困惑。

第一个问题：是否可以post框架本身的所有数据？ 第二个问题：我已经使用了 ID 引用方法，我应该切换到使用 subDocuments 吗？

框架架构：

const FrameworkSchema = new Schema({
  name: {
    type: String,
    trim: true
  },
  description: {
    type: String,
    trim: true
  },
  domain: [{
    domain: {type: Mongoose.Schema.Types.ObjectId, ref: 'Domain'}
  }],
  updated: Date,
  created: {
    type: Date,
    default: Date.now
  }
});

module.exports = Mongoose.model('Framework', FrameworkSchema);

域架构：

const DomainSchema = new Schema({
   _id: {
     type: Schema.ObjectId,
     auto: true
   },
   domainNo: {
     type: String,
    trim: true
   },
   domainName: {
    type: String,
    trim: true
   },
  domainDescription: {
    type: String,
    trim: true
  },
  framework: {
    type: Mongoose.Schema.Types.ObjectId,
    ref: 'Framework'
  },
  control: [{
     control: {type: Mongoose.Schema.Types.ObjectId, ref: 'Control'}
  }],
  updated: Date,
  created: {
    type: Date,
    default: Date.now
  }
});

module.exports = Mongoose.model('Domain', DomainSchema);

我的控制模式：

const ControlSchema = new Schema({
  _id: {
    type: Schema.ObjectId,
    auto: true
  },
  mainControl: {
    type: String
  },
    subControl: [{
        subControlNo: {type: Mongoose.Schema.Types.String, ref: 'SubControl'}
      }],
  controlDescription: {
    type: String,
    trim: true
  },
  updated: Date,
  created: {
    type: Date,
    default: Date.now
  }
});

module.exports = Mongoose.model('Control', ControlSchema);

我的子控件架构

const SubControlSchema = new Schema({
    _id: {
      type: Schema.ObjectId,
      auto: true
    },
   subControlNo: {
     type: [String]
   },
  updated: Date,
  created: {
    type: Date,
    default: Date.now
  }
});

module.exports = Mongoose.model('SubControl', SubControlSchema);

现在我正在尝试 post 来自框架的嵌套文档 api:

router.post(
  '/add',
  auth,
  role.checkRole(role.ROLES.Admin), async (req, res) => {
    try {

    const subControl = new SubControl({...req.body}); 
    const subControlDoc = await subControl.save();
    
    const control = new Control({...req.body});  // take the control data
    control.subControl.push(subControlDoc._id); // take the subControl and push the ID into the control
    const controlDoc = await control.save();

//make the subcontrol pushed into control
// make control pushed in domain

    const domain = new Domain({...req.body}); 
    domain.control.push(controlDoc._id); 
    const domainDoc = await domain.save();


    const framework = new Framework({...req.body}); 
    framework.domain.push(domainDoc._id); 
    const frameworkDoc = await framework.save(); //save the framework + domain's ID 



       res.status(200).json({
         success: true,
         message: `Framework has been added successfully!`,
         framework: frameworkDoc
       });
    } catch (error) {
      res.status(400).json({
        error
        // error: 'Your request could not be processed. Please try again.'
      });
    }
  }
);

现在我正在使用 push 将数据作为数组推送，不确定这是否是正确的方法，是否可以 post 来自框架 api 的所有数据？

试图 post 这个来自 post 人：

{
 "name": "ISO780001",
 "description": "frameworkDescription",
 "domain":
    [
    {
     "domainNo": "11",
     "domainName": "domainName00",
     "domainDescription": "domaindescu0",
     "control": [{
      "mainControl": "1-4",
      "subControl": [{
      "subControlNo": "1-4-1"
    },
    {
    "subControlNo": "1-4-2"
    }],
    "controlDescription": "controlDescriptionTest"
    },
    {
       
       "mainControl": "1-4",
      "subControl": [{
      "subControlNo": "1-4-1"
    },
    {
    "subControlNo": "1-4-2"
    }],
    "controlDescription": "controlDescriptionTest"
    }
]
  },
  {
     "domainNo": "1-2",
     "name": "domainName00",
     "description": "domaindescu0",
     "control": {
      "mainControl": "1-4",
      "subControl": [{
      "subControlNo": "1-4-1"
    },
    {
    "subControlNo": "1-4-2"
    }],
    "controlDescription": "controlDescriptionTest"
    }
  }
  ]
}

只有域、控件和子控件的 id 保存在 mongodb 中，这是它的工作原理吗我 post 所有来自一个模型的数据在这种情况下是框架？还是应该使用嵌入式方法？

Answer 1

在我有很多参考文献的情况下我会做什么（mongoose 顺便将其命名为 ref，它允许您填充）。

具有域引用的框架架构示例。

const frameworkSchema = mongoose.Schema({
    domains: [{type: mongoose.Schema.Types.ObjectId, ref: 'Domain'}],
})
const FrameworkModel = mongoose.model('Framework', frameworkSchema)

上面的

Domain指的是一个Domain模型。我们现在可以创建领域模型了。

const domainSchema = mongoose.Schema({
    _id: { type: mongoose.Schema.Types.ObjectId } //this is the default
})
const DomainModel = mongoose.model('Domain', domainSchema);

示例用法 - 我们想要获取与特定架构相关的所有域信息。

const results = FrameworkModel.findOne({ _id: 'some framework id'}).populate('domains').lean({ virtuals: true });

结果会是这样的

{ 
    _id: 'some framework id',
    name: 'name of framework',
    domains: [
        {
           _id: 'id of domain 1',
           name: 'example.com'
        },
        {
           _id: 'id of domain 2',
           name: 'example2.com'
        }
    ]
}

您还可以探索 virtuals 以了解如何将框架、域和其他控件单独维护 collections，以便轻松引用它们。这是一个比在单个文档中嵌套多个级别更好的设计。

除非必要，否则使用单独的集合比使用子文档有更多好处。（找文档更方便，更新文档更方便，当然性能也更高）

在猫鼬 NodeJs 中保存 4 级嵌套模式的最佳方法是什么

What is the best approach to save a 4 level nested schema in mongoose NodeJs

node.js

mongodb

mongoose

mongoose-schema

nodejs-server