數據庫 · Nest.js 中文文檔

## 數據庫 `Nest` 與數據庫無關，允許您輕松地與任何 `SQL` 或 `NoSQL` 數據庫集成。根據您的偏好，您有許多可用的選項。一般來說，將 `Nest` 連接到數據庫只需為數據庫加載一個適當的 `Node.js` 驅動程序，就像使用 [Express](https://expressjs.com/en/guide/database-integration.html) 或 `Fastify` 一樣。您還可以直接使用任何通用的 `Node.js` 數據庫集成庫或 `ORM` ，例如 [MikroORM](https://mikro-orm.io/)也可以在[這里查看](https://docs.nestjs.com/recipes/mikroorm)、[Sequelize](https://sequelize.org/)（導航到[Sequelize 集成](https://docs.nestjs.com/techniques/database#sequelize-integration)部分）、[Knex.js](https://knexjs.org/)（[教程](https://dev.to/nestjs/build-a-nestjs-module-for-knex-js-or-other-resource-based-libraries-in-5-minutes-12an)）、[TypeORM](https://github.com/typeorm/typeorm)和[Prisma](https://www.github.com/prisma/prisma)（[教程](https://docs.nestjs.com/recipes/prisma)），以在更高的抽象級別上進行操作。為了方便起見，`Nest` 還提供了與現成的 `TypeORM` 與 `@nestjs/typeorm` 的緊密集成，我們將在本章中對此進行介紹，而與 `@nestjs/mongoose` 的緊密集成將在[這一章](https://docs.nestjs.cn/8/techniques?id=mongo)中介紹。這些集成提供了附加的特定于 `nestjs` 的特性，比如模型/存儲庫注入、可測試性和異步配置，從而使訪問您選擇的數據庫更加容易。 ### TypeORM 集成為了與 `SQL`和 `NoSQL` 數據庫集成，`Nest` 提供了 `@nestjs/typeorm` 包。`Nest` 使用[TypeORM](https://github.com/typeorm/typeorm)是因為它是 `TypeScript` 中最成熟的對象關系映射器( `ORM` )。因為它是用 `TypeScript` 編寫的，所以可以很好地與 `Nest` 框架集成。為了開始使用它，我們首先安裝所需的依賴項。在本章中，我們將演示如何使用流行的 [Mysql](https://www.mysql.com/) ， `TypeORM` 提供了對許多關系數據庫的支持，比如 `PostgreSQL` 、`Oracle`、`Microsoft SQL Server`、`SQLite`，甚至像 `MongoDB`這樣的 `NoSQL` 數據庫。我們在本章中介紹的過程對于 `TypeORM` 支持的任何數據庫都是相同的。您只需為所選數據庫安裝相關的客戶端 `API` 庫。 ```bash $ npm install --save @nestjs/typeorm typeorm mysql2 ``` 安裝過程完成后，我們可以將 `TypeOrmModule` 導入`AppModule` 。 > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; @Module({ imports: [ TypeOrmModule.forRoot({ type: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', entities: [], synchronize: true, }), ], }) export class AppModule {} ``` `forRoot()` 方法支持所有`TypeORM`包中`createConnection()`函數暴露出的配置屬性。其他一些額外的配置參數描述如下： | 參數 | 說明 | | ------------------- | -------------------------------------------------------- | | retryAttempts | 重試連接數據庫的次數（默認：10） | | retryDelay | 兩次重試連接的間隔(ms)（默認：3000） | | autoLoadEntities | 如果為`true`,將自動加載實體(默認：false) | | keepConnectionAlive | 如果為`true`，在應用程序關閉后連接不會關閉（默認：false) | > 更多連接選項見[這里](https://typeorm.io/#/connection-options) 另外，我們可以創建 `ormconfig.json` ，而不是將配置對象傳遞給 `forRoot()`。 ```bash { "type": "mysql", "host": "localhost", "port": 3306, "username": "root", "password": "root", "database": "test", "entities": ["dist/**/*.entity{.ts,.js}"], "synchronize": true } ``` 然后，我們可以不帶任何選項地調用 `forRoot()` : > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; @Module({ imports: [TypeOrmModule.forRoot()], }) export class AppModule {} ``` > 靜態全局路徑(例如 `dist/**/*.entity{ .ts,.js}` )不適用于 Webpack 熱重載。 > 注意，`ormconfig.json` 文件由`typeorm`庫載入，因此，任何上述參數之外的屬性都不會被應用（例如由`forRoot()`方法內部支持的屬性--例如`autoLoadEntities`和`retryDelay()`) 一旦完成，`TypeORM` 的`Connection`和 `EntityManager` 對象就可以在整個項目中注入(不需要導入任何模塊)，例如: > app.module.ts ```typescript import { Connection } from 'typeorm'; @Module({ imports: [TypeOrmModule.forRoot(), PhotoModule], }) export class AppModule { constructor(private readonly connection: Connection) {} } ``` ### 存儲庫模式 `TypeORM` 支持存儲庫設計模式，因此每個實體都有自己的存儲庫。可以從數據庫連接獲得這些存儲庫。為了繼續這個示例，我們需要至少一個實體。我們來定義`User` 實體。 > user.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm'; @Entity() export class User { @PrimaryGeneratedColumn() id: number; @Column() firstName: string; @Column() lastName: string; @Column({ default: true }) isActive: boolean; } ``` > 關于實體的更多內容見[TypeORM 文檔](https://typeorm.io/#/entities)。該 `User` 實體在 `users` 目錄下。這個目錄包含了和 `UsersModule`模塊有關的所有文件。你可以決定在哪里保存模型文件，但我們推薦在他們的**域**中就近創建，即在相應的模塊目錄中。要開始使用 `user` 實體，我們需要在模塊的`forRoot()`方法的選項中（除非你使用一個靜態的全局路徑）將它插入`entities`數組中來讓 `TypeORM`知道它的存在。 > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from './users/user.entity'; @Module({ imports: [ TypeOrmModule.forRoot({ type: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', entities: [User], synchronize: true, }), ], }) export class AppModule {} ``` 現在讓我們看一下 `UsersModule`： > user.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { UsersService } from './users.service'; import { UsersController } from './users.controller'; import { User } from './user.entity'; @Module({ imports: [TypeOrmModule.forFeature([User])], providers: [UsersService], controllers: [UsersController], }) export class UsersModule {} ``` 此模塊使用 `forFeature()` 方法定義在當前范圍中注冊哪些存儲庫。這樣，我們就可以使用 `@InjectRepository()`裝飾器將 `UsersRepository` 注入到 `UsersService` 中: > users.service.ts ```typescript import { Injectable } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { User } from './user.entity'; @Injectable() export class UsersService { constructor( @InjectRepository(User) private usersRepository: Repository<User> ) {} findAll(): Promise<User[]> { return this.usersRepository.find(); } findOne(id: string): Promise<User> { return this.usersRepository.findOne(id); } async remove(id: string): Promise<void> { await this.usersRepository.delete(id); } } ``` > 不要忘記將 `UsersModule` 導入根 `AppModule`。如果要在導入`TypeOrmModule.forFeature` 的模塊之外使用存儲庫，則需要重新導出由其生成的提供程序。您可以通過導出整個模塊來做到這一點，如下所示： > users.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from './user.entity'; @Module({ imports: [TypeOrmModule.forFeature([User])], exports: [TypeOrmModule], }) export class UsersModule {} ``` 現在，如果我們在 `UserHttpModule` 中導入 `UsersModule` ，我們可以在后一個模塊的提供者中使用 `@InjectRepository(User)`。 > users-http.module.ts ```typescript import { Module } from '@nestjs/common'; import { UsersModule } from './user.module'; import { UsersService } from './users.service'; import { UsersController } from './users.controller'; @Module({ imports: [UsersModule], providers: [UsersService], controllers: [UsersController], }) export class UserHttpModule {} ``` ### 關系關系是指兩個或多個表之間的聯系。關系基于每個表中的常規字段，通常包含主鍵和外鍵。關系有三種： | 名稱 | 說明 | | ------------- | ------------------------------------------------------------------------------------------------------------------------- | | 一對一 | 主表中的每一行在外部表中有且僅有一個對應行。使用`@OneToOne()`裝飾器來定義這種類型的關系 | | 一對多/多對一 | 主表中的每一行在外部表中有一個或多的對應行。使用`@OneToMany()`和`@ManyToOne()`裝飾器來定義這種類型的關系 | | 多對多 | 主表中的每一行在外部表中有多個對應行，外部表中的每個記錄在主表中也有多個行。使用`@ManyToMany()`裝飾器來定義這種類型的關系 | 使用對應的裝飾器來定義實體的關系。例如，要定義每個`User`可以有多個`Photo`，可以使用`@OneToMany()`裝飾器。 > user.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm'; import { Photo } from '../photos/photo.entity'; @Entity() export class User { @PrimaryGeneratedColumn() id: number; @Column() firstName: string; @Column() lastName: string; @Column({ default: true }) isActive: boolean; @OneToMany((type) => Photo, (photo) => photo.user) photos: Photo[]; } ``` > 要了解 TypeORM 中關系的內容，可以查看[TypeORM 文檔](https://typeorm.io/#/relations)。 ### 自動載入實體手動將實體一一添加到連接選項的`entities`數組中的工作會很無聊。此外，在根模塊中涉及實體破壞了應用的域邊界，并可能將應用的細節泄露給應用的其他部分。針對這一情況，可以使用靜態全局路徑（例如, dist/\*_/_.entity{.ts,.js})。注意，`webpack`不支持全局路徑，因此如果你要在單一倉庫(Monorepo)中構建應用，可能不能使用全局路徑。針對這一問題，有另外一個可選的方案。在配置對象的屬性中(傳遞給`forRoot()`方法的)設置`autoLoadEntities`屬性為`true`來自動載入實體，示意如下： > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; @Module({ imports: [ TypeOrmModule.forRoot({ ... autoLoadEntities: true, }), ], }) export class AppModule {} ``` 通過配置這一選項，每個通過`forFeature()`注冊的實體都會自動添加到配置對象的`entities`數組中。 > 注意，那些沒有通過`forFeature()`方法注冊，而僅僅是在實體中被引用（通過關系）的實體不能通過`autoLoadEntities`配置被包含。 ### 分離實體定義[#](#separating-entity-definition) 您可以使用裝飾器在模型中定義實體及其列。[但是有些人更喜歡使用“實體模式”](https://typeorm.io/#/separating-entity-definition)在單獨的文件中定義實體及其列。 ~~~typescript import { EntitySchema } from 'typeorm'; import { User } from './user.entity'; export const UserSchema = new EntitySchema<User>({ name: 'User', target: User, columns: { id: { type: Number, primary: true, generated: true, }, firstName: { type: String, }, lastName: { type: String, }, isActive: { type: Boolean, default: true, }, }, relations: { photos: { type: 'one-to-many', target: 'Photo', // the name of the PhotoSchema }, }, }); ~~~ > **警告**：如果您提供`target`選項，則`name`選項值必須與目標類的名稱相同。如果您不提供，`target`您可以使用任何名稱。 Nest 允許您在`EntitySchema`任何需要的地方使用實例`Entity`，例如： ~~~typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { UserSchema } from './user.schema'; import { UsersController } from './users.controller'; import { UsersService } from './users.service'; @Module({ imports: [TypeOrmModule.forFeature([UserSchema])], providers: [UsersService], controllers: [UsersController], }) export class UsersModule {} ~~~ ### 事務數據庫事務代表在數據庫管理系統（DBMS）中針對數據庫的一組操作，這組操作是有關的、可靠的并且和其他事務相互獨立的。一個事務通常可以代表數據庫中的任何變更（[了解更多](https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E5%BA%93%E4%BA%8B%E5%8A%A1))。在[TypeORM 事務](https://typeorm.io/#/transactions)中有很多不同策略來處理事務，我們推薦使用`QueryRunner`類，因為它對事務是完全可控的。首先，我們需要將`Connection`對象以正常方式注入： ```typescript @Injectable() export class UsersService { constructor(private connection: Connection) {} } ``` > `Connection`類需要從`typeorm`包中導入現在，我們可以使用這個對象來創建一個事務。 ```typescript async createMany(users: User[]) { const queryRunner = this.connection.createQueryRunner(); await queryRunner.connect(); await queryRunner.startTransaction(); try { await queryRunner.manager.save(users[0]); await queryRunner.manager.save(users[1]); await queryRunner.commitTransaction(); } catch (err) { //如果遇到錯誤，可以回滾事務 await queryRunner.rollbackTransaction(); } finally { //你需要手動實例化并部署一個queryRunner await queryRunner.release(); } } ``` > 注意`connection`僅用于創建`QueryRunner`。然而，要測試這個類，就需要模擬整個`Connection`對象（它暴露出來的幾個方法），因此，我們推薦采用一個幫助工廠類（也就是`QueryRunnerFactory`)并且定義一個包含僅限于維持事務需要的方法的接口。這一技術讓模擬這些方法變得非常直接。可選地，你可以使用一個`Connection`對象的回調函數風格的`transaction`方法([閱讀更多](https://typeorm.io/#/transactions/creating-and-using-transactions))。 ```typescript async createMany(users: User[]) { await this.connection.transaction(async manager => { await manager.save(users[0]); await manager.save(users[1]); }); } ``` 不推薦使用裝飾器來控制事務(`@Transaction()`和`@TransactionManager()`)。 ### 訂閱者使用 TypeORM[訂閱者](https://typeorm.io/#/listeners-and-subscribers/what-is-a-subscriber)，你可以監聽特定的實體事件。 ```typescript import { Connection, EntitySubscriberInterface, EventSubscriber, InsertEvent } from 'typeorm'; import { User } from './user.entity'; @EventSubscriber() export class UserSubscriber implements EntitySubscriberInterface<User> { constructor(connection: Connection) { connection.subscribers.push(this); } listenTo() { return User; } beforeInsert(event: InsertEvent<User>) { console.log(`BEFORE USER INSERTED: `, event.entity); } } ``` > 事件訂閱者不能是[請求范圍](https://docs.nestjs.com/fundamentals/injection-scopes)的。現在，將`UserSubscriber`類添加到`providers`數組。 ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from './user.entity'; import { UsersController } from './users.controller'; import { UsersService } from './users.service'; import { UserSubscriber } from './user.subscriber'; @Module({ imports: [TypeOrmModule.forFeature([User])], providers: [UsersService, UserSubscriber], controllers: [UsersController], }) export class UsersModule {} ``` > 更多實體訂閱者內容見[這里](https://typeorm.io/#/listeners-and-subscribers/what-is-a-subscriber)。 ### 遷移 [遷移](https://typeorm.io/#/migrations)提供了一個在保存數據庫中現有數據的同時增量升級數據庫使其與應用中的數據模型保持同步的方法。TypeORM 提供了一個專用[CLI 命令行工具](https://typeorm.io/#/migrations/creating-a-new-migration)用于生成、運行以及回滾遷移。遷移類和`Nest`應用源碼是分開的。他們的生命周期由`TypeORM CLI`管理，因此，你不能在遷移中使用依賴注入和其他`Nest`專有特性。在[TypeORM 文檔](https://typeorm.io/#/migrations/creating-a-new-migration) 中查看更多關于遷移的內容。 ### 多個數據庫某些項目可能需要多個數據庫連接。這也可以通過本模塊實現。要使用多個連接，首先要做的是創建這些連接。在這種情況下，連接命名成為必填項。假設你有一個`Album` 實體存儲在他們自己的數據庫中。 ```typescript const defaultOptions = { type: 'postgres', port: 5432, username: 'user', password: 'password', database: 'db', synchronize: true, }; @Module({ imports: [ TypeOrmModule.forRoot({ ...defaultOptions, host: 'user_db_host', entities: [User], }), TypeOrmModule.forRoot({ ...defaultOptions, name: 'albumsConnection', host: 'album_db_host', entities: [Album], }), ], }) export class AppModule {} ``` > 如果未為連接設置任何 `name` ，則該連接的名稱將設置為 `default`。請注意，不應該有多個沒有名稱或同名的連接，否則它們會被覆蓋。此時，您的`User` 和 `Album` 實體中的每一個都已在各自的連接中注冊。通過此設置，您必須告訴 `TypeOrmModule.forFeature()` 方法和 `@InjectRepository()` 裝飾器應該使用哪種連接。如果不傳遞任何連接名稱，則使用 `default` 連接。 ```typescript @Module({ imports: [TypeOrmModule.forFeature([User]), TypeOrmModule.forFeature([Album], 'albumsConnection')], }) export class AppModule {} ``` 您也可以為給定的連接注入 `Connection` 或 `EntityManager`： ```typescript @Injectable() export class AlbumsService { constructor( @InjectConnection('albumsConnection') private connection: Connection, @InjectEntityManager('albumsConnection') private entityManager: EntityManager ) {} } ``` ### 測試在單元測試我們的應用程序時，我們通常希望避免任何數據庫連接，從而使我們的測試適合于獨立，并使它們的執行過程盡可能快。但是我們的類可能依賴于從連接實例中提取的存儲庫。那是什么？解決方案是創建假存儲庫。為了實現這一點，我們設置了[自定義提供者]。事實上，每個注冊的存儲庫都由 `entitynamereposition` 標記表示，其中 `EntityName` 是實體類的名稱。 `@nestjs/typeorm` 包提供了基于給定實體返回準備好 `token` 的 `getRepositoryToken()` 函數。 ```typescript @Module({ providers: [ UsersService, { provide: getRepositoryToken(User), useValue: mockRepository, }, ], }) export class UsersModule {} ``` 現在, 將使用`mockRepository` 作為 `UsersRepository`。每當任何提供程序使用 `@InjectRepository()` 裝飾器請求 `UsersRepository` 時, `Nest` 會使用注冊的 `mockRepository` 對象。 ### 自定義存儲庫 `TypeORM` 提供稱為自定義存儲庫的功能。要了解有關它的更多信息，請訪問此[頁面](https://typeorm.io/#/custom-repository)。基本上，自定義存儲庫允許您擴展基本存儲庫類，并使用幾種特殊方法對其進行豐富。要創建自定義存儲庫，請使用 `@EntityRepository()` 裝飾器和擴展 `Repository` 類。 ```typescript @EntityRepository(Author) export class AuthorRepository extends Repository<Author> {} ``` > `@EntityRepository()` 和 `Repository` 來自 `typeorm` 包。創建類后，下一步是將實例化責任移交給 `Nest`。為此，我們必須將 `AuthorRepository` 類傳遞給 `TypeOrm.forFeature()` 函數。 ```typescript @Module({ imports: [TypeOrmModule.forFeature([AuthorRepository])], controller: [AuthorController], providers: [AuthorService], }) export class AuthorModule {} ``` 之后，只需使用以下構造注入存儲庫： ```typescript @Injectable() export class AuthorService { constructor(private readonly authorRepository: AuthorRepository) {} } ``` ### 異步配置通常，您可能希望異步傳遞模塊選項，而不是事先傳遞它們。在這種情況下，使用 `forRootAsync()` 函數，提供了幾種處理異步數據的方法。第一種可能的方法是使用工廠函數： ```typescript TypeOrmModule.forRootAsync({ useFactory: () => ({ type: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', entities: [__dirname + '/**/*.entity{.ts,.js}'], synchronize: true, }), }); ``` 我們的工廠的行為與任何其他異步提供者一樣(例如，它可以是異步的，并且它能夠通過`inject`注入依賴)。 ```typescript TypeOrmModule.forRootAsync({ imports: [ConfigModule], useFactory: (configService: ConfigService) => ({ type: 'mysql', host: configService.get<string>('HOST'), port: configService.get<string>('PORT'), username: configService.get<string>('USERNAME'), password: configService.get<string>('PASSWORD'), database: configService.get<string>('DATABASE'), entities: [__dirname + '/**/*.entity{.ts,.js}'], synchronize: true, }), inject: [ConfigService], }); ``` 或者，您可以使用`useClass`語法。 ```typescript TypeOrmModule.forRootAsync({ useClass: TypeOrmConfigService, }); ``` 上面的構造將 `TypeOrmConfigService` 在內部進行實例化 `TypeOrmModule`，并將利用它來創建選項對象。在 `TypeOrmConfigService` 必須實現 `TypeOrmOptionsFactory` 的接口。上面的構造將在`TypeOrmModule`內部實例化`TypeOrmConfigService`，并通過調用`createTypeOrmOptions()` ```typescript @Injectable() class TypeOrmConfigService implements TypeOrmOptionsFactory { createTypeOrmOptions(): TypeOrmModuleOptions { return { type: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', entities: [__dirname + '/**/*.entity{.ts,.js}'], synchronize: true, }; } } ``` 為了防止在 `TypeOrmModule` 中創建 `TypeOrmConfigService` 并使用從不同模塊導入的提供程序，可以使用 `useExisting` 語法。 ```typescript TypeOrmModule.forRootAsync({ imports: [ConfigModule], useExisting: ConfigService, }); ``` 這個構造與 `useClass` 的工作原理相同，但有一個關鍵的區別 — `TypeOrmModule` 將查找導入的模塊來重用現有的 `ConfigService`，而不是實例化一個新的 `ConfigService`。 >**提示**：確保將 `name` 屬性定義在與 `useFactory`、`useClass` 或 `useValue` 屬性相同的級別。這將允許 Nest 在適當的注入令牌下正確注冊連接。 #### 自定義連接工廠[#](https://docs.nestjs.com/techniques/database#custom-connection-factory) 結合使用` useFactory`、`useClass` 或 `useExisting` 的異步配置，您可以選擇指定一個` connectionFactory` 函數，該函數將允許您提供自己的 `TypeORM `連接，而不是允許 `TypeOrmModule` 創建連接。 `connectionFactory` 接收在異步配置期間使用 `useFactory`、`useClass` 或 `useExisting `配置的 `TypeORM ConnectionOptions`，并返回解析 `TypeORM `連接的 `Promise`。 ~~~typescript TypeOrmModule.forRootAsync({ imports: [ConfigModule], inject: [ConfigService], // Use useFactory, useClass, or useExisting // to configure the ConnectionOptions. useFactory: (configService: ConfigService) => ({ type: 'mysql', host: configService.get('HOST'), port: +configService.get<number>('PORT'), username: configService.get('USERNAME'), password: configService.get('PASSWORD'), database: configService.get('DATABASE'), entities: [__dirname + '/**/*.entity{.ts,.js}'], synchronize: true, }), // connectionFactory receives the configured ConnectionOptions // and returns a Promise<Connection>. connectionFactory: async (options) => { const connection = await createConnection(options); return connection; }, }); ~~~ > **提示**：該`createConnection`函數是從`typeorm`包中導入的。 ### 示例 [這兒](https://github.com/nestjs/nest/tree/master/sample/05-sql-typeorm)有一個可用的例子。 ### Sequelize 集成另一個使用`TypeORM`的選擇是使用`@nestjs/sequelize`包中的`Sequelize ROM`。額外地，我們使用`sequelize-typescript`包來提供一系列額外的裝飾器以聲明實體。要開始使用它，我們首先安裝需要的依賴。在本章中，我們通過流行的`MySQL`關系數據庫來進行說明。`Sequelize`支持很多種關系數據庫，例如`PostgreSQL`,`MySQL`,`Microsoft SQL Server`,`SQLite`以及`MariaDB`。本章中的步驟也適合其他任何`Sequelize`支持的數據庫。你只要簡單地安裝所選數據庫相應的客戶端 API 庫就可以。 ```typescript $ npm install --save @nestjs/sequelize sequelize sequelize-typescript mysql2 $ npm install --save-dev @types/sequelize ``` 安裝完成后，就可以將`SequelizeModule`導入到根`AppModule`中。 > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { SequelizeModule } from '@nestjs/sequelize'; @Module({ imports: [ SequelizeModule.forRoot({ dialect: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', models: [], }), ], }) export class AppModule {} ``` `forRoot()`方法支持所有`Sequelize`構造器([了解更多](https://sequelize.org/v5/manual/getting-started.html#setting-up-a-connection))暴露的配置屬性。下面是一些額外的配置屬性。 | 名稱 | 說明 | | ------------------- | ----------------------------------------------------- | | retryAttempts | 嘗試連接數據庫的次數（默認：10） | | retryDelay | 兩次連接之間間隔時間(ms)(默認：3000) | | autoLoadModels | 如果為`true`，模型將自動載入（默認:false) | | keepConnectionAlive | 如果為`true`，在應用關閉后連接將不會關閉（默認:false) | | synchronize | 如果為`true`，自動載入的模型將同步（默認：false） | 一旦這些完成了，`Sequelize`對象就可以注入到整個項目中（不需要在任何模塊中再引入），例如： > app.service.ts ```typescript import { Injectable } from '@nestjs/common'; import { Sequelize } from 'sequelize-typescript'; @Injectable() export class AppService { constructor(private sequelize: Sequelize) {} } ``` ### 模型 `Sequelize`采用`活動記錄(Active Record)`模式，在這一模式下，你可以使用模型類直接和數據庫交互。要繼續該示例，我們至少需要一個模型，讓我們定義這個`User`模型： > user.model.ts ```typescript import { Column, Model, Table } from 'sequelize-typescript'; @Table export class User extends Model<User> { @Column firstName: string; @Column lastName: string; @Column({ defaultValue: true }) isActive: boolean; } ``` > 查看[更多](https://github.com/RobinBuschmann/sequelize-typescript#column)的可用裝飾器。 `User`模型文件在`users`目錄下。該目錄包含了和`UsersModule`有關的所有文件。你可以決定在哪里保存模型文件，但我們推薦在他們的**域**中就近創建，即在相應的模塊目錄中。要開始使用`User`模型，我們需要通過將其插入到`forRoot()`方法選項的`models`數組中來讓`Sequelize`知道它的存在。 > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { SequelizeModule } from '@nestjs/sequelize'; import { User } from './users/user.model'; @Module({ imports: [ SequelizeModule.forRoot({ dialect: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', models: [User], }), ], }) export class AppModule {} ``` 接下來我們看看`UsersModule`： > users.module.ts ```typescript import { Module } from '@nestjs/common'; import { SequelizeModule } from '@nestjs/sequelize'; import { User } from './user.model'; import { UsersController } from './users.controller'; import { UsersService } from './users.service'; @Module({ imports: [SequelizeModule.forFeature([User])], providers: [UsersService], controllers: [UsersController], }) export class UsersModule {} ``` 這個模塊使用`forFeature()`方法來定義哪個模型被注冊在當前范圍中。我們可以使用`@InjectModel()`裝飾器來把`UserModel`注入到`UsersService`中。 > users.service.ts ```typescript import { Injectable } from '@nestjs/common'; import { InjectModel } from '@nestjs/sequelize'; import { User } from './user.model'; @Injectable() export class UsersService { constructor( @InjectModel(User) private userModel: typeof User ) {} async findAll(): Promise<User[]> { return this.userModel.findAll(); } findOne(id: string): Promise<User> { return this.userModel.findOne({ where: { id, }, }); } async remove(id: string): Promise<void> { const user = await this.findOne(id); await user.destroy(); } } ``` > 不要忘記在根`AppModule`中導入`UsersModule`。如果你要在導入`SequelizeModule.forFreature`的模塊之外使用存儲庫，你需要重新導出其生成的提供者。你可以像這樣將整個模塊導出： > users.module.ts ```typescript import { Module } from '@nestjs/common'; import { SequelizeModule } from '@nestjs/sequelize'; import { User } from './user.entity'; @Module({ imports: [SequelizeModule.forFeature([User])], exports: [SequelizeModule], }) export class UsersModule {} ``` 現在如果我們在`UserHttpModule`中引入`UsersModule`，我們可以在后一個模塊的提供者中使用`@InjectModel(User)`。 > users-http.module.ts ```typescript import { Module } from '@nestjs/common'; import { UsersModule } from './user.module'; import { UsersService } from './users.service'; import { UsersController } from './users.controller'; @Module({ imports: [UsersModule], providers: [UsersService], controllers: [UsersController], }) export class UserHttpModule {} ``` ### 關系關系是指兩個或多個表之間的聯系。關系基于每個表中的常規字段，通常包含主鍵和外鍵。關系有三種： | 名稱 | 說明 | | ------------- | ------------------------------------------------------------------------------------------------------------------------- | | 一對一 | 主表中的每一行在外部表中有且僅有一個對應行。使用`@OneToOne()`裝飾器來定義這種類型的關系 | | 一對多/多對一 | 主表中的每一行在外部表中有一個或多的對應行。使用`@OneToMany()`和`@ManyToOne()`裝飾器來定義這種類型的關系 | | 多對多 | 主表中的每一行在外部表中有多個對應行，外部表中的每個記錄在主表中也有多個行。使用`@ManyToMany()`裝飾器來定義這種類型的關系 | 使用對應的裝飾器來定義實體的關系。例如，要定義每個`User`可以有多個`Photo`，可以使用`@HasMany()`裝飾器。 > user.entity.ts ```typescript import { Column, Model, Table, HasMany } from 'sequelize-typescript'; import { Photo } from '../photos/photo.model'; @Table export class User extends Model<User> { @Column firstName: string; @Column lastName: string; @Column({ defaultValue: true }) isActive: boolean; @HasMany(() => Photo) photos: Photo[]; } ``` > 閱讀[本章](https://github.com/RobinBuschmann/sequelize-typescript#model-association)了解更多關于`Sequelize`的內容。 ### 自動載入模型手動將模型一一添加到連接選項的`models`數組中的工作會很無聊。此外，在根模塊中涉及實體破壞了應用的域邊界，并可能將應用的細節泄露給應用的其他部分。針對這一情況，在配置對象的屬性中(傳遞給`forRoot()`方法的)設置`autoLoadModels`和`synchronize`屬性來自動載入模型，示意如下： > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { SequelizeModule } from '@nestjs/sequelize'; @Module({ imports: [ SequelizeModule.forRoot({ ... autoLoadModels: true, synchronize: true, }), ], }) export class AppModule {} ``` 通過配置這一選項，每個通過`forFeature()`注冊的實體都會自動添加到配置對象的`models`數組中。 > 注意，這不包含那些沒有通過`forFeature()`方法注冊，而僅僅是在實體中被引用（通過關系）的模型。 ### 事務數據庫事務代表在數據庫管理系統（DBMS）中針對數據庫的一組操作，這組操作是有關的、可靠的并且和其他事務相互獨立的。一個事務通常可以代表數據庫中的任何變更（[了解更多](https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E5%BA%93%E4%BA%8B%E5%8A%A1))。在[`Sequelize`事務](https://sequelize.org/v5/manual/transactions.html)中有很多不同策略來處理事務，下面是一個管理事務的示例（自動回調）。首先，我們需要將`Sequelize`對象以正常方式注入： ```typescript @Injectable() export class UsersService { constructor(private sequelize: Sequelize) {} } ``` > `Sequelize`類需要從`sequelize-typescript`包中導入現在，我們可以使用這個對象來創建一個事務。 ```typescript async createMany() { try { await this.sequelize.transaction(async t => { const transactionHost = { transaction: t }; await this.userModel.create( { firstName: 'Abraham', lastName: 'Lincoln' }, transactionHost, ); await this.userModel.create( { firstName: 'John', lastName: 'Boothe' }, transactionHost, ); }); } catch (err) { // 一旦發生錯誤，事務會回滾 } } ``` > 注意`Sequelize`僅用于開始一個事務。然而，要測試這個類，就需要模擬整個`Sequelize`對象（它暴露出來的幾個方法），因此，我們推薦采用一個幫助工廠類（也就是`TransactionRunner`)并且定義一個包含僅限于維持事務需要的方法的接口。這一技術讓模擬這些方法變得非常直接。可選地，你可以使用一個`Connection`對象的回調函數風格的`transaction`方法([閱讀更多](https://typeorm.io/#/transactions/creating-and-using-transactions))。 ```typescript async createMany(users: User[]) { await this.connection.transaction(async manager => { await manager.save(users[0]); await manager.save(users[1]); }); } ``` 不推薦使用裝飾器來控制事務(`@Transaction()`和`@TransactionManager()`)。 ### 遷移 [遷移](https://typeorm.io/#/migrations)提供了一個在保存數據庫中現有數據的同時增量升級數據庫使其與應用中的數據模型保持同步的方法。`Sequelize`提供了一個專用[CLI 命令行工具](https://sequelize.org/v5/manual/migrations.html#the-cli)用于生成、運行以及回滾遷移。遷移類和`Nest`應用源碼是分開的。他們的生命周期由`TypeORM CLI`管理，因此，你不能在遷移中使用依賴注入和其他`Nest`專有特性。在[`Sequelize`文檔](https://sequelize.org/v5/manual/migrations.html#the-cli) 中查看更多關于遷移的內容。 ### 多個數據庫某些項目可能需要多個數據庫連接。這也可以通過本模塊實現。要使用多個連接，首先要做的是創建這些連接。在這種情況下，連接命名成為必填項。假設你有一個`Album` 實體存儲在他們自己的數據庫中。 ```typescript const defaultOptions = { dialect: 'postgres', port: 5432, username: 'user', password: 'password', database: 'db', synchronize: true, }; @Module({ imports: [ SequelizeModule.forRoot({ ...defaultOptions, host: 'user_db_host', models: [User], }), SequelizeModule.forRoot({ ...defaultOptions, name: 'albumsConnection', host: 'album_db_host', models: [Album], }), ], }) export class AppModule {} ``` > 如果未為連接設置任何 `name` ，則該連接的名稱將設置為 `default`。請注意，不應該有多個沒有名稱或同名的連接，否則它們會被覆蓋。此時，您的`User` 和 `Album` 實體中的每一個都已在各自的連接中注冊。通過此設置，您必須告訴 `SequelizeModule.forFeature()` 方法和 `@InjectRepository()` 裝飾器應該使用哪種連接。如果不傳遞任何連接名稱，則使用 `default` 連接。 ```typescript @Module({ imports: [SequelizeModule.forFeature([User]), SequelizeModule.forFeature([Album], 'albumsConnection')], }) export class AppModule {} ``` 您也可以為給定的連接注入 `Sequelize`： ```typescript @Injectable() export class AlbumsService { constructor( @InjectConnection('albumsConnection') private sequelize: Sequelize ) {} } ``` ### 測試在單元測試我們的應用程序時，我們通常希望避免任何數據庫連接，從而使我們的測試適合于獨立，并使它們的執行過程盡可能快。但是我們的類可能依賴于從連接實例中提取的存儲庫。那是什么？解決方案是創建假模型。為了實現這一點，我們設置了[自定義提供者]。事實上，每個注冊的模型都由 `<ModelName>Model` 令牌自動表示，其中 `ModelName` 是模型類的名稱。 `@nestjs/sequelize` 包提供了基于給定模型返回準備好 `token` 的 `getModelToken()` 函數。 ```typescript @Module({ providers: [ UsersService, { provide: getModelToken(User), useValue: mockModel, }, ], }) export class UsersModule {} ``` 現在, 將使用`mockModel` 作為 `UsersModel`。每當任何提供程序使用 `@InjectModel()` 裝飾器請求 `UserModel` 時, `Nest` 會使用注冊的 `mockModel` 對象。 ### 異步配置通常，您可能希望異步傳遞`SequelizeModule`選項，而不是事先靜態傳遞它們。在這種情況下，使用 `forRootAsync()` 函數，提供了幾種處理異步數據的方法。第一種可能的方法是使用工廠函數： ```typescript SequelizeModule.forRootAsync({ useFactory: () => ({ dialect: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', models: [], }), }); ``` 我們的工廠的行為與任何其他[異步提供者](https://docs.nestjs.com/fundamentals/async-providers)一樣(例如，它可以是異步的，并且它能夠通過`inject`注入依賴)。 ```typescript SequelizeModule.forRootAsync({ imports: [ConfigModule], useFactory: (configService: ConfigService) => ({ dialect: 'mysql', host: configService.get<string>('HOST'), port: configService.get<string>('PORT'), username: configService.get<string>('USERNAME'), password: configService.get<string>('PASSWORD'), database: configService.get<string>('DATABASE'), models: [], }), inject: [ConfigService], }); ``` 或者，您可以使用`useClass`語法。 ```typescript SequelizeModule.forRootAsync({ useClass: SequelizeConfigService, }); ``` 上面的構造將 `SequelizeConfigService` 在`SequelizeModule`內部進行實例化 ,并通過調用`createSequelizeOptions()`來創建一個選項對象。注意，這意味著 `SequelizeConfigService` 必須實現 `SequelizeOptionsFactory` 的接口。如下所示： ```typescript @Injectable() class SequelizeConfigService implements SequelizeOptionsFactory { createSequelizeOptions(): SequelizeModuleOptions { return { dialect: 'mysql', host: 'localhost', port: 3306, username: 'root', password: 'root', database: 'test', models: [], }; } } ``` 為了防止在 `SequelizeModule` 中創建 `SequelizeConfigService` 并使用從不同模塊導入的提供程序，可以使用 `useExisting` 語法。 ```typescript SequelizeModule.forRootAsync({ imports: [ConfigModule], useExisting: ConfigService, }); ``` 這個構造與 `useClass` 的工作原理相同，但有一個關鍵的區別 — `SequelizeModule` 將查找導入的模塊來重用現有的 `ConfigService`，而不是實例化一個新的 `ConfigService`。 ### 示例 [這兒](https://github.com/nestjs/nest/tree/master/sample/07-sequelize)有一個可用的例子。