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

那怎么封装呢？

先回忆下 TypeORM 的流程：

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

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

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

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

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

如果你只是想做对单个 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 {}

然后内部就根据传入的配置来创建 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 {}

比如传入 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 {}

然后在 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;
}

给映射的表给个名字叫 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);
    }
}