在 Nest 里集成 TypeORM

TypeORM 怎么用我们已经学会了，在 Nest 里用那不就是再封装一层的事情么？

那怎么封装呢？

# 先回忆下 TypeORM 的流程：

1.DataSource 里存放着数据库连接的配置，比如用户名、密码、驱动包、连接池配置等等。

2.而 Entity 里通过 @Entity、@PrimaryGeneratedColumn、@Column 等装饰器来建立数据库表的映射关系。

3.同时还有 Entity 之间的 @OneToOne、@OneToMany、@ManyToMany 的关系，这些会映射成数据库表通过外键、中间表来建立的关系。

4.DataSource.initialize 的时候，会和数据库服务建立连接，如果配置了 synchronize，还会生成建表 sql 语句来创建表。

5.DataSource 初始化之后就可以拿到 EntityManager 了，由它负责对各种 Entity 进行增删改查，比如 find、delete、save 等方法，还可以通过 query builder 来创建复杂的查询。

6.如果你只是想做对单个 Entity 的 CRUD，那可以拿到这个 Entity 的 Repository 类，它同样有上面的那些方法，只是只能用来操作单个 Entity。

这就是 TypeORM 的流程。

# 那如果让你把 TypeORM 的 api 封装一层，做成一个 TypeOrmModule，你会怎么封装呢？

很明显，这里的 datasource 的配置是需要手动传入的，也就是说需要做成动态模块，支持根据传入的配置来动态产生模块内容。

而动态模块的规范里就 3 种方法名： register、forRoot、forFeature。

这里很明显要用 forRoot，也就是只需要注册一次，然后这个模块会在各处被使用。

类似这样：

import { Module } from "@nestjs/common";
import { TypeOrmModule } from "xxx";

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: "mysql",
      host: "localhost",
      port: 3306,
      username: "root",
      password: "root",
      database: "test",
      entities: [],
      synchronize: true,
    }),
  ],
})
export class AppModule {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

然后内部就根据传入的配置来创建 DataSource，调用 intialize 方法，之后就拿到 EntityManager，可以做 CRUD 了。

但是 Entity 肯定会分散在各个业务模块，每个模块都通过 forRoot 引入那个模块太麻烦，我们干脆把它用 @Global 声明成全局的。

这样每个模块里就都可以注入 EntityManager 来用了，不需要 imports。

那如果我想用 Repository 的方式来 CRUD 呢？

那可以先注入 EntityManager，然后再通过 EntityManager.getRepository(XxxEntity) 来拿呀。

或者可以再做一个动态模块，传入 Entity，返回它的 Repository。

这种局部的动态模块，一般都是用 forFeature 的名字：

import { Module } from "@nestjs/common";
import { TypeOrmModule } from "xxxx";
import { UsersService } from "./users.service";
import { User } from "./user.entity";

@Module({
  imports: [TypeOrmModule.forFeature([User])],
  providers: [UsersService],
  controllers: [],
})
export class UsersModule {}

1
2
3
4
5
6
7
8
9
10
11

比如传入 User，内部通过 EntityManager.getRepository(User) 来拿到 UserEntity。

这样 UserService 里就可以通过 UserRepository 来实现增删改查了。

这个封装思路貌似挺完美。

# 那我们来看看 @nestjs/typeorm 是怎么封装的吧。

创建个 Nest 项目：

nest new nest-typeorm -p npm

然后创建一个 crud 的模块：

nest g resource user

生成的 service 里的 crud 并没有真正实现：

# 🚀我们引入 typeorm 来实现下：

npm install --save @nestjs/typeorm typeorm mysql2

typeorm、mysql2 的包我们很熟悉了，而 @nestjs/typeorm 就是把 typeorm api 封装了一层的包。

它提供了一个模块，我们在入口引入下：

# 连接配置和前几节一样，引入 User 的 Entity。

import { Module } from "@nestjs/common";
import { TypeOrmModule } from "@nestjs/typeorm";
import { AppController } from "./app.controller";
import { AppService } from "./app.service";
import { User } from "./user/entities/user.entity";
import { UserModule } from "./user/user.module";

@Module({
  imports: [
    UserModule,
    TypeOrmModule.forRoot({
      type: "mysql",
      host: "localhost",
      port: 3306,
      username: "root",
      password: "guang",
      database: "typeorm_test",
      synchronize: true,
      logging: true,
      entities: [User],
      poolSize: 10,
      connectorPackage: "mysql2",
      extra: {
        authPlugin: "sha256_password",
      },
    }),
  ],
  controllers: [AppController],
  providers: [AppService],
})
export class AppModule {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

# 然后在 User 的 Entity 里加一些映射的信息：

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

@Entity({
  name: "aaa_user",
})
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column({
    name: "aaa_name",
    length: 50,
  })
  name: string;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

给映射的表给个名字叫 aaa_user，然后有两个字段，分别是 id 和 name。

我们跑一下试试：

npm run start:dev

看到建表 sql 了没：

这部分和我们单独跑 typeorm 没啥区别：

# 然后是增删改查，我们可以注入 EntityManager：

用它来做增删改查：

import { Injectable } from '@nestjs/common';
import { InjectEntityManager } from '@nestjs/typeorm';
import { EntityManager } from 'typeorm';
import { CreateUserDto } from './dto/create-user.dto';
import { UpdateUserDto } from './dto/update-user.dto';
import { User } from './entities/user.entity';

@Injectable()
export class UserService {

  @InjectEntityManager()
  private manager: EntityManager;

  create(createUserDto: CreateUserDto) {
    this.manager.save(User, createUserDto);
  }

  findAll() {
    return this.manager.find(User)
  }

  findOne(id: number) {
    return this.manager.findOne(User, {
      where: { id }
    })
  }

  update(id: number, updateUserDto: UpdateUserDto) {
    this.manager.save(User, {
      id: id,
      ...updateUserDto
    })
  }

  remove(id: number) {
    this.manager.delete(User, id);
  }
}