能否在Mongoose Schema中引用其他数据库集合？（NestJS/Mongoose 7.1.0）

核心思路 #

NestJS的Mongoose模块原生支持多数据库连接，通过为不同数据库指定唯一connectionName区分连接，再通过手动跨库查询或**Mongoose跨库引用（populate）**两种方式，实现其他数据库集合对基准库内容的关联调用。

步骤1：配置多数据库连接 #

在根模块（app.module.ts）中，通过MongooseModule.forRoot为基准库和其他数据库分别配置连接，并指定不同的connectionName：

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { PrimaryDbModule } from './primary-db/primary-db.module';
import { SecondaryDbModule } from './secondary-db/secondary-db.module';

@Module({
  imports: [
    // 基准库连接，指定connectionName为'primary'
    MongooseModule.forRoot('mongodb://localhost:27017/primary_db', {
      connectionName: 'primary',
    }),
    // 次级数据库连接，指定connectionName为'secondary'
    MongooseModule.forRoot('mongodb://localhost:27017/secondary_db', {
      connectionName: 'secondary',
    }),
    PrimaryDbModule,
    SecondaryDbModule,
  ],
})
export class AppModule {}

步骤2：定义基准库的Schema与服务 #

以基准库的User集合为例，创建对应模块、Schema和服务，并导出服务供其他模块调用：

1. 基准库Schema #

// primary-db/schemas/user.schema.ts
import { Schema } from 'mongoose';

export const UserSchema = new Schema({
  name: { type: String, required: true },
  email: { type: String, unique: true, required: true },
});

2. 基准库模块 #

// primary-db/primary-db.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UserSchema } from './schemas/user.schema';
import { UserService } from './user.service';

@Module({
  imports: [
    // 关联基准库连接，注册User模型
    MongooseModule.forFeature([{ name: 'User', schema: UserSchema }], 'primary'),
  ],
  providers: [UserService],
  exports: [UserService], // 导出服务，允许其他模块注入使用
})
export class PrimaryDbModule {}

3. 基准库服务 #

// primary-db/user.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { User } from './interfaces/user.interface';

@Injectable()
export class UserService {
  constructor(
    // 指定使用基准库的连接获取User模型
    @InjectModel('User', 'primary') private userModel: Model<User>,
  ) {}

  // 根据ID查询基准库用户
  async findById(userId: string): Promise<User> {
    return this.userModel.findById(userId).exec();
  }
}

步骤3：实现次级数据库对基准库的引用 #

提供两种常用实现方式，可根据场景选择：

方式1：手动跨库查询（简单场景首选） #

在次级数据库的服务中，注入基准库的服务，手动关联查询基准库内容。以次级库的Order集合关联基准库User为例：

1. 次级库Schema

// secondary-db/schemas/order.schema.ts
import { Schema } from 'mongoose';

export const OrderSchema = new Schema({
  userId: { type: String, required: true }, // 存储基准库User的ID
  amount: { type: Number, required: true },
  orderDate: { type: Date, default: Date.now },
});

2. 次级库模块

// secondary-db/secondary-db.module.ts
import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { OrderSchema } from './schemas/order.schema';
import { OrderService } from './order.service';
import { PrimaryDbModule } from '../primary-db/primary-db.module';

@Module({
  imports: [
    // 关联次级库连接，注册Order模型
    MongooseModule.forFeature([{ name: 'Order', schema: OrderSchema }], 'secondary'),
    PrimaryDbModule, // 导入基准库模块，使用其User服务
  ],
  providers: [OrderService],
})
export class SecondaryDbModule {}

3. 次级库服务（关联查询）

// secondary-db/order.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Order } from './interfaces/order.interface';
import { UserService } from '../primary-db/user.service';

@Injectable()
export class OrderService {
  constructor(
    @InjectModel('Order', 'secondary') private orderModel: Model<Order>,
    private userService: UserService, // 注入基准库的User服务
  ) {}

  // 查询订单并关联基准库用户信息
  async findOrderWithUser(orderId: string): Promise<(Order & { user: any }) | null> {
    const order = await this.orderModel.findById(orderId).exec();
    if (!order) return null;
    // 手动调用基准库服务查询用户
    const user = await this.userService.findById(order.userId);
    return { ...order.toObject(), user };
  }
}

方式2：Mongoose跨库Populate（适合复杂关联场景） #

Mongoose 7.1.0支持跨数据库的populate操作，需在Schema中定义引用，并在查询时指定基准库的模型：

1. 修改次级库Schema

// secondary-db/schemas/order.schema.ts
import { Schema, Types } from 'mongoose';

export const OrderSchema = new Schema({
  userId: { 
    type: Types.ObjectId, 
    ref: 'User', // 声明引用基准库的User集合
    required: true 
  },
  amount: { type: Number, required: true },
  orderDate: { type: Date, default: Date.now },
});

2. 修改次级库服务（使用populate）

// secondary-db/order.service.ts
import { Injectable } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model } from 'mongoose';
import { Order } from './interfaces/order.interface';
import { User } from '../primary-db/interfaces/user.interface';

@Injectable()
export class OrderService {
  constructor(
    @InjectModel('Order', 'secondary') private orderModel: Model<Order>,
    // 注入基准库的User模型
    @InjectModel('User', 'primary') private userModel: Model<User>,
  ) {}

  // 使用populate跨库关联查询
  async findOrderWithUser(orderId: string): Promise<any> {
    return this.orderModel.findById(orderId)
      .populate({
        path: 'userId',
        model: this.userModel, // 指定使用基准库的User模型
      })
      .exec();
  }
}

注意事项 #

1. 权限与连接：确保数据库连接字符串的账号拥有对应数据库的读写权限。
2. 事务支持：跨数据库事务仅在MongoDB 4.0+的副本集/分片集群中支持，使用时需确保连接配置符合要求。
3. Populate限制：跨库populate必须显式指定基准库的模型，否则Mongoose会默认在当前数据库中查找集合。

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