Nestjs框架: 集成 TypeORM 和 Mongoose

关注

原创 2025-07-15 13:54:50 607 阅读 AI 写同款· GEO 优化 ›

Nestjs框架: 多租户与多数据库的架构设计与实现本文介绍了在NestJS项目中实现多数据库对接的方案，重点解决多租户架构下的数据隔离与灵活切换需求。通过抽象层统一接口，结合TypeORM、Prisma和Mongoose三种ORM库，支持MySQL、PostgreSQL和MongoDB等多种数据库类型。方案采用外观模式+抽象工厂模式+策略模式，通过DatabaseModule集中管理数据库连接，根据租户ID动态切换不同数据库配置。文章详细阐述了环境变量设计、目录结构和模块实现，为复杂业务场景下的多数据库管理提供了可行方案。阅读详情

概述

虽然 Prisma 用起来非常舒服，不需要创建 repository，它就能实现很好的数据库连接
同时，它对 TypeScript 的支持也非常出色
不过，在一些极端应用场景下，尤其是在关键性数据库方面，TypeORM 的兼容性比某些其他工具要好。

集成 TypeORM

1 ) 安装依赖

$ $ npm install --save @nestjs/typeorm typeorm mysql2

2 ) 配置

环境变量 .env 的配置

DB_TYPE=mysql
DB_HOST=localhost
DB_PORT=3306
DB_USERNAME=root
DB_PASSWORD=example
DB_DATABASE=testdb
DB_AUTOLOAD=true
DB_SYNC=true

app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { TypeOrmModule, TypeOrmModuleOptions } from '@nestjs/typeorm';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { User } from './user/user.entity';

@Module({
  imports: [
    // 下面这个后续可以封装一个新的模块，来匹配 .env 和 其他配置
    ConfigModule.forRoot({  // 配置环境变量模块 
      envFilePath: '.env', // 指定环境变量文件路径 
      isGlobal: true, // 全局可用 
    }), 
    TypeOrmModule.forRootAsync({
      inject:[ConfigService],
      useFactory: (configService: ConfigService) => ({
        type: configService.get<string>('DB_TYPE'),
        host: configService.get<string>('DB_HOST'),  
        port: configService.get<number>('DB_PORT'),  
        username: configService.get<string>('DB_USERNAME'),  
        password: configService.get<string>('DB_PASSWORD'),  
        database: configService.get<string>('DB_DATABASE'),
        autoLoadEntities: Boolean(configService.get<string | boolean>('DB_AUTOLOAD', false)), 
        synchronize: Boolean(configService.get<string | boolean>('DB_SYNC', false)), 
      } as TypeOrmModuleOptions),
    }),
    TypeOrmModule.forFeature([User]),
  ],
  controllers: [AppController],
  providers: []
})

export class AppModule {}

它是通过创建 TypeOrmModule.forRootSync 并传入数据库连接配置来实现与数据库的连接
配置完成后，就可以创建对应的实体，比如创建 user 实体

3 ) 创建实体

src/user/user.entity

import { Column, Entity, PrimaryGeneratedColumn } from 'typeorm';

@Entity()
export class User {
	@PrimaryGeneratedColumn()
	id: number;

	@Column()
	username: string;

	@Column()
	password: string;
}

4 ) 编辑测试控制器

app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { User } from './user/user.entity';
import { Repository } from 'typeorm';

@Controller()
export class AppController {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}

  @Get()
  async getUsers(): Promise<any> {
    const rs = await this.userRepository.find();
    return rs;
  }
}

打开浏览器访问 localhost:3030/，得到的结果和预期一致
至此，TypeORM 的集成就算完成了

集成 Mongoose

1 ) 安装

$ npm i @nestjs/mongoose mongoose

2 ) 配置 app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { User, UserSchema } from './user/user.schema'
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    // 下面这个后续可以封装一个新的模块，来匹配 .env 和 其他配置
    ConfigModule.forRoot({  // 配置环境变量模块 
      envFilePath: '.env', // 指定环境变量文件路径 
      isGlobal: true, // 全局可用 
    }),
    MongooseModule.forRootAsync({
      inject: [ConfigService], // 注入配置服务
      useFactory: async (configService: ConfigService) => ({ 
        uri: configService.get('MONGODB_URI'),  // 从配置服务中获取连接字符串 
      }), 
      
    }),
    MongooseModule.forFeature([{ name: User.name, schema: UserSchema }])
  ],
  controllers: [AppController],
  providers: [],
})

export class AppModule {}

3 ) 新建 mongo 服务

docker-compose.mongo.yaml

services:
	mongo:
		image: mongo
		restart: always
		environment:
			MONGO_INITDB_ROOT_USERNAME: root
			MONGO_INITDB_ROOT_PASSWORD: example
		ports:
			- 27018: 27017
			
	mongo-express:
		image: mongo-express
		restart: always
		environment:
			ME_CONFIG_MONGODB_ADMINUSERNAME: root
			ME_CONFIG_MONGODB_ADMINPASSWORD: example
			ME_CONFIG_MONGODB_URL: mongodb://root:example@mongo:27017/
			ME_CONFIG_BASICAUTH: false
		ports:
			- 8081:8081

$ docker compose -f docker-compose.mongo.yml up -d
进入

4 ) 创建数据库

打开 8081 UI 界面, 创建一个名称为 nest 的数据库

5 ）编辑 user 相关 schema

src/user/user.schema.ts

import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
import { HydratedDocument } from 'mongoose';

export type UserDocument = HydratedDocument<User>;

@Schema()
export class User {
	@Prop()
	username: string;
	
	@Prop()
	password: string;
}
export const UserSchema = SchemaFactory.createForClass(User);

6 ) 控制器的配置

app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { User } from './user/user.schema';
import { Model } from 'mongoose';

@Controller()
export class AppController {
  constructor(
    @InjectModel(User.name)
    private userModel: Model<User>
  ) {}

  @Get()
  async getUsers(): Promise<any> {
    const rs = await this.userModel.find()
    return rs;
  }
}

7 ) 创建数据并测试

添加测试数据

打开 8081 UI 界面, 在 nest 数据库中，新增相关 collection, 如新建 users，这里后面多加 s
之后，自行添加 document, 注意 “_id” 不要动，添加 username 和 password 字段就行

为管理员账号分配权限

$ docker ps | grep mongo 找到容器名
$ docker exec -it nestjs-starter-mongo-1 mongosh -u root -p 之后，输入密码
$ show dbs;
$ use nest;
$ db.createUser({user: 'root', pwd: 'example', roles: [{role: 'dbOwner', db: 'nest'}]})
- 如果返回 { ok : 1 } 就成功了

测试

localhost:3030/
能返回数据，就成功了

当然，也可按照文档上，另一种方式来配置 Schema 和其他, 如下:

集成 Mongoose 方式2

1 ）修改 app.module.ts

MongooseModule.forFeature([{ name: 'User', schema: UserSchema }])

这里的 User 和下面的 User 字符串都可以单独定义出来成一个常量

2 ) 修改 user/user.schema.ts

import mongoose, { Document } from 'mongoose';

export interface User extends Document {
  name: string;
  password: string;
}

export const UserSchema = new mongoose.Schema(
	{
		username: String,
		password: String,
	},
	{ collection: 'users' },
);

或

import mongoose from 'mongoose';

export const UserSchema = new mongoose.Schema(
	{
		username: String,
		password: String,
	},
	{ collection: 'users' },
);

3 ) 修改 app.controller.ts

import { Controller, Get } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { User } from './user/user.schema';
import { Model } from 'mongoose';

@Controller()
export class AppController {
  constructor(
    @InjectModel('User')
    private userModel: Model<User>
  ) {}

  @Get()
  async getUsers(): Promise<any> {
    const rs = await this.userModel.find()
    return rs;
  }
}

或

import { Controller, Get } from '@nestjs/common';
import { InjectModel } from '@nestjs/mongoose';
import { Model, Document as Doc } from 'mongoose';

@Controller()
export class AppController {
  constructor(
    @InjectModel('User')
    private userModel: Model<Doc>
  ) {}

  @Get()
  async getUsers(): Promise<any> {
    const rs = await this.userModel.find()
    return rs;
  }
}

这里的 User 字符串可以单独定义出去，形成一个变量

深入 mongoose 原理

@nestjs/mongoose 这个官方的包

进入 lib 目录，查看 index.ts

export * from './common';
export * from './decorators';
export * from './errors';
export * from './factories';
export * from './interfaces';
export * from './mongoose.module';
export * from './pipes';
export * from './utils';

可以看到它导出来很多方法
先看 decorators 目录
- 其中有两个装饰器非常重要，一个叫做 schema.decorator.ts
- 第二个叫 prop.decorator.ts，这两个装饰器让 @nestjs/mongoose
- 更加贴合于 NestJS 的设计思想，代码的可读性更强。

在 schema.decorator.ts 中

import * as mongoose from 'mongoose';
import { TypeMetadataStorage } from '../storages/type-metadata.storage';

/**
 * Interface defining schema options that can be passed to `@Schema()` decorator.
 */
export type SchemaOptions = mongoose.SchemaOptions;

/**
 * @Schema decorator is used to mark a class as a Mongoose schema.
 * Only properties decorated with this decorator will be defined in the schema.
 * 
 * @publicApi
 */
export function Schema(options?: SchemaOptions): ClassDecorator {
  return (target: Function) => {
    TypeMetadataStorage.addSchemaMetadata({
      target,
      options,
    });
  };
}

这里调用 TypeMetadataStorage.addSchemaMetadata 方法
进入 TypeMetadataStorage 这里可知，这里是一个工具集合，进入 addSchemaMetadata
```
addSchemaMetadata(metadata: SchemaMetadata) {
	this.compileClassMetadata(metadata);
	this.schemas.push(metadata);
}
```
- 这里metadata就是我们定义的 schema 被添加到 schemas 数组中
进入 moogoose.module.ts 核心模块，有两个核心方法
- MongooseCoreModule.forRoot
- createMongooseProviders

进入 moggoose.providers.ts 核心代码在这里

{
    provide: getModelToken(option.name, connectionName),
    useFactory: (connection: Connection) => {
      const model = connection.models[option.name]
        ? connection.models[option.name]
        : connection.model(option.name, option.schema, option.collection);
      return model;
    },
    inject: [getConnectionToken(connectionName)],
}

注意，完整代码是递归执行，里面很可能是 schema 套 schema

这里对应，https://mongoosejs.com 官网的这段代码

const mongoose = require('mongoose');
mongoose.connect('mongodb://127.0.0.1:27017/test');

const Cat = mongoose.model('Cat', { name: String });

const kitty = new Cat({ name: 'Zildjian' });
kitty.save().then(() => console.log('meow'));

上述原理代码代表了如何查找到相关的表

再看 mongoose-core.module.ts 最核心的代码

const connectionProvider = {
  provide: mongooseConnectionName,
  useFactory: async (): Promise<any> =>
    await lastValueFrom(
      defer(async () =>
        mongooseConnectionFactory(
          await this.createMongooseConnection(uri, mongooseOptions, {
            lazyConnection,
            onConnectionCreate,
          }),
          mongooseConnectionName,
        ),
      ).pipe(
        handleRetry(retryAttempts, retryDelay, verboseRetryLog),
        catchError((error) => {
          throw mongooseConnectionError(error);
        }),
      ),
    ),
};

核心在这里， createMongooseConnection, 它具体就是调用 mongoose.createConnection 创建一次连接

进入 createMongooseConnection

  private static async createMongooseConnection(
    uri: string,
    mongooseOptions: ConnectOptions,
    factoryOptions: {
      lazyConnection?: boolean;
      onConnectionCreate?: MongooseModuleOptions['onConnectionCreate'];
    },
  ): Promise<Connection> {
    const connection = mongoose.createConnection(uri, mongooseOptions);

    if (factoryOptions?.lazyConnection) {
      return connection;
    }

    factoryOptions?.onConnectionCreate?.(connection);

    return connection.asPromise();
  }

  async onApplicationShutdown() {
    const connection = this.moduleRef.get<any>(this.connectionName);
    if (connection) {
      await connection.close();
    }
  }
}