如何避免Mongoose销售与订单模型间的循环依赖问题

问题描述 #

我正在开发一个库存管理系统，包含Sales（销售）和Orders（订单）两个Mongoose模型：

• 销售模型存储账单核心数据，关联多个订单ID
• 订单模型存储单个商品的购买信息
  我希望通过post save钩子实现两个模型的互相更新，但目前因两个模型文件互相require导致循环依赖错误。

现有代码示例 #

sale.model.js

// fileName sale.model.js

const ordersModel = require("./orders.model")
const connection = require("./database/connection")

const SaleSchema = new mongoose.Schema(
  {
    store: { type: mongoose.Types.ObjectId, required: true, ref: "stores" },
    customerName: { type: String, required: true },
    customerPhone: { type: String, required: true },
    totalDiscount: { type: Number },
    orders: [{ type: mongoose.Types.ObjectId, ref: "orders" }],
   
  },
  {
    timestamps: true,
  }
);

saleSchema.post("save",async function(doc){
 //some actions on order model
 const order = await ordersModel.findOne({doc.orders[0],{})
})

module.exports = connection.model(saleSchema)

orders.model.js

//file name : orders.model.js

const salesModel = require("./sales.model")
const connection = require("./database/connection")

const ordersSchema = new mongoose.Schema(
  {
    orderNumber : {type : String}
   
  },
  {
    timestamps: true,
  }
);

ordersSchema.post("save",async function(doc){
 //some actions on sales model
 const sale = await sales.findOne({order : doc._id},{})
 //send email for this sale
})

module.exports = connection.model(saleSchema)

解决方法 #

方案一：使用Mongoose内置的模型获取方法 #

Mongoose会自动注册已加载的模型，你可以在钩子内部通过mongoose.model(模型名)直接获取，无需提前require：

修改sale.model.js：

// fileName sale.model.js
const connection = require("./database/connection")
const mongoose = connection

const SaleSchema = new mongoose.Schema(
  {
    store: { type: mongoose.Types.ObjectId, required: true, ref: "stores" },
    customerName: { type: String, required: true },
    customerPhone: { type: String, required: true },
    totalDiscount: { type: Number },
    orders: [{ type: mongoose.Types.ObjectId, ref: "orders" }],
   
  },
  {
    timestamps: true,
  }
);

SaleSchema.post("save", async function(doc){
  // 直接通过模型名获取Orders模型
  const Orders = mongoose.model("orders");
  const order = await Orders.findOne({ _id: doc.orders[0] });
  // 执行你的业务操作
})

module.exports = connection.model("sales", SaleSchema)

修改orders.model.js：

//file name : orders.model.js
const connection = require("./database/connection")
const mongoose = connection

const ordersSchema = new mongoose.Schema(
  {
    orderNumber : {type : String}
   
  },
  {
    timestamps: true,
  }
);

ordersSchema.post("save", async function(doc){
  // 直接通过模型名获取Sales模型
  const Sales = mongoose.model("sales");
  const sale = await Sales.findOne({ orders: doc._id });
  // 执行发送邮件等操作
})

module.exports = connection.model("orders", ordersSchema)

方案二：将钩子逻辑抽离到独立服务模块 #

把两个模型的钩子逻辑移到单独的文件，避免模型文件互相引用：

1. 创建model-hooks.js：

const mongoose = require("./database/connection");

// 注册Sales的post save钩子
function registerSaleHooks() {
  const Sale = mongoose.model("sales");
  Sale.schema.post("save", async function(doc) {
    const Orders = mongoose.model("orders");
    const order = await Orders.findOne({ _id: doc.orders[0] });
    // 执行业务操作
  });
}

// 注册Orders的post save钩子
function registerOrderHooks() {
  const Orders = mongoose.model("orders");
  Orders.schema.post("save", async function(doc) {
    const Sales = mongoose.model("sales");
    const sale = await Sales.findOne({ orders: doc._id });
    // 执行发送邮件等操作
  });
}

module.exports = { registerSaleHooks, registerOrderHooks };

2. 在项目启动文件（如app.js）中先加载所有模型，再注册钩子：

// 先加载所有模型，确保Mongoose已注册它们
require("./sale.model");
require("./orders.model");

// 注册钩子逻辑
const { registerSaleHooks, registerOrderHooks } = require("./model-hooks");
registerSaleHooks();
registerOrderHooks();

方案三：延迟require到钩子内部 #

将模型的require语句从文件顶部移到钩子函数内部，避免初始化时的循环引用：

修改sale.model.js：

// fileName sale.model.js
const connection = require("./database/connection")

const SaleSchema = new mongoose.Schema(
  {
    store: { type: mongoose.Types.ObjectId, required: true, ref: "stores" },
    customerName: { type: String, required: true },
    customerPhone: { type: String, required: true },
    totalDiscount: { type: Number },
    orders: [{ type: mongoose.Types.ObjectId, ref: "orders" }],
   
  },
  {
    timestamps: true,
  }
);

SaleSchema.post("save", async function(doc){
  // 延迟加载Orders模型，避免循环依赖
  const ordersModel = require("./orders.model");
  const order = await ordersModel.findOne({ _id: doc.orders[0] });
  // 执行业务操作
})

module.exports = connection.model("sales", SaleSchema)

修改orders.model.js：

//file name : orders.model.js
const connection = require("./database/connection")

const ordersSchema = new mongoose.Schema(
  {
    orderNumber : {type : String}
   
  },
  {
    timestamps: true,
  }
);

ordersSchema.post("save", async function(doc){
  // 延迟加载Sales模型
  const salesModel = require("./sales.model");
  const sale = await salesModel.findOne({ orders: doc._id });
  // 执行发送邮件等操作
})

module.exports = connection.model("orders", ordersSchema)

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