使用 TypeORM + Nest.js 定义数据库模型-六虎

规划数据库模型是一个触及数据组织、结构化和存储的进程。这个进程保证了数据的完整性、削减了冗余，而且进步了查询功率。以下是规划数据库模型的进程：

1. 承认有哪些实体

实体是实际国际中能够区别的目标或事物，它们一般对应于数据库中的表。在承认实体时，你需求辨认出业务流程中的主要组件。例如，假如你正在规划一个电子商务数据库，实体或许包含“客户”、“产品”、“订单”等。

2. 承认有哪些相关的实体

实体之间往往存在相关，这些相关界说了实体怎么彼此相关。例如，在电子商务数据库中，“客户”或许与“订单”有相关，由于客户会下订单。同样，“订单”与“产品”有相关，由于订单包含一个或多个产品。

3. 承认相相联系

相相联系描绘了实体之间的交互办法，这些联系能够是1对1、一对多或多对多。例如，“客户”和“订单”之间一般是一对多的联系，由于一个客户能够有多个订单，但每个订单只能属于一个客户。承认相相联系是规划数据库模型中非常要害的一步，由于它影响了数据的整合和查询的杂乱性。

4. 承认实体特点

每个实体都会有一系列的特点，这些特点描绘了实体的特征。例如，关于“客户”实体，特点或许包含客户ID、姓名、地址和电子邮箱等。在承认特点时，重要的是要保证特点的原子性，即每个特点都是不可分割的根本单位。

5. 不断优化细节

数据库模型的规划是一个迭代进程，需求不断地优化。这包含正规化进程，以削减数据冗余和进步数据一致性。正规化一般触及到将一个大表分解成多个小表，并经过外键相关。此外，还需求考虑索引的运用以进步查询功率，以及怎么处理业务、并发和安全性问题。

示例场景：图书馆办理体系

在软件规划和数据库建模中，从用户角色动身来承认实体及其相关实体、相相联系和实体特点是一个常见的办法，这一般触及到用户故事或用例剖析。下面经过一个例子来说明这个进程：
假定咱们要规划一个图书馆办理体系，咱们的用户角色包含图书办理员和读者。

进程 1：界说用户故事或用例

首先，咱们需求界说用户故事或用例来描绘用户角色的需求。例如：

作为一个图书办理员，我想要增加新书本，以便扩充图书馆的藏书。
作为一个读者，我想要查找图书，以便借阅我感兴趣的书本。

进程 2：从用例中辨认实体

接下来，咱们从每个用户故事或用例中辨认出触及的实体。

图书办理员用例触及的实体或许有：
- 图书（Book）
读者用例触及的实体或许有：
- 图书（Book）
- 读者（Reader）

进程 3：承认相相联系

最后，咱们需求承认实体之间的相相联系。

**图书（Book）和读者（Reader）**之间的联系或许是：
- 读者能够借阅多本图书（一对多联系：一个 Reader 能够有多个 Book）
- 一本图书能够被多个读者借阅（多对一联系：一个 Book 能够被多个 Reader 借阅）

进程 4：界说实体特点

然后为每个实体界说特点。

**图书（Book）**的特点或许包含：
- 书名（Title）
- 作者（Author）
- ISBN 编号（ISBN）
- 出版日期（Publication Date）
- 类别（Genre）
**读者（Reader）**的特点或许包含：
- 姓名（Name）
- 读者编号（Reader ID）
- 借阅记载（Borrowing Record）

进程 5：制作实体联系图（ERD）

依据上述信息，咱们能够制作一个实体联系图（ERD），来可视化实体、特点和联系。

[Reader] --<借阅>-- [Book]
|         |
|         |-> 姓名（Name）
|         |-> 读者编号（Reader ID）
|         |-> 借阅记载（Borrowing Record）
|
|-> 书名（Title）
|-> 作者（Author）
|-> ISBN编号（ISBN）
|-> 出版日期（Publication Date）
|-> 类别（Genre）

经过这个进程，咱们从用户角色和运用路径动身，辨认了体系中的要害实体（图书和读者），实体之间的相相联系（如借阅联系）以及它们的特点（如书名、作者、读者编号等）。这样的剖析有助于咱们构建一个结构化的数据库模型，从而支撑图书馆办理体系的开发。

运用 TypeORM 生成实体和特点

TypeORM 是一个开源的目标联系映射（ORM）库，运用函数的操作映射数据库底层的 sql 履行。所以使得开发人员不必学习杂乱的 sql 语句，从而操作数据库。
TypeORM 支撑多种数据库，包含 MySQL, PostgreSQL, MariaDB, SQLite, MS SQL Server, Oracle, WebSQL 等。
在 Nest.js 中运用 TypeORM 界说 MySQL 数据库表结构并完结 CRUD（创立、读取、更新、删去）操作需求几个进程。下面是一个简化的流程：

1. 装置必要的包

首先，装置 Nest.js CLI（假如还没有装置的话）和必要的 npm 包：

npm i -g @nestjs/cli
npm i @nestjs/typeorm typeorm mysql2

这儿 mysql2 是 MySQL 的 Node.js 驱动。

2. 创立数据库衔接

在 app.module.ts 或相关的模块文件中装备 TypeORM：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'mysql',
      host: 'localhost',
      port: 3306,
      username: 'your_username',
      password: 'your_password',
      database: 'your_database',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true, // 注意：在出产环境中不主张运用此选项，由于它或许会导致数据丢掉
    }),
    // ... other modules
  ],
  // ... controllers, providers
})
export class AppModule {}

3. 界说实体

创立一个 TypeScript 类作为实体，并运用装修器界说表结构：

import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;
  @Column({ length: 500 })
  name: string;
  @Column('text')
  description: string;
  // 其他列...
}

4. 创立服务

创立一个服务来处理 CRUD 操作：

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './user.entity';
@Injectable()
export class UserService {
  constructor(
    @InjectRepository(User)
    private userRepository: Repository<User>,
  ) {}
  findAll(): Promise<User[]> {
    return this.userRepository.find();
  }
  findOne(id: string): Promise<User> {
    return this.userRepository.findOne(id);
  }
  async create(user: User): Promise<User> {
    return this.userRepository.save(user);
  }
  async update(id: string, user: User): Promise<void> {
    await this.userRepository.update(id, user);
  }
  async delete(id: string): Promise<void> {
    await this.userRepository.delete(id);
  }
}

5. 创立控制器

创立一个控制器来处理 HTTP 请求：

import { Controller, Get, Post, Put, Delete, Body, Param } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './user.entity';
@Controller('users')
export class UserController {
  constructor(private readonly userService: UserService) {}
  @Get()
  getAll(): Promise<User[]> {
    return this.userService.findAll();
  }
  @Get(':id')
  getOne(@Param('id') id: string): Promise<User> {
    return this.userService.findOne(id);
  }
  @Post()
  create(@Body() user: User): Promise<User> {
    return this.userService.create(user);
  }
  @Put(':id')
  update(@Param('id') id: string, @Body() user: User): Promise<void> {
    return this.userService.update(id, user);
  }
  @Delete(':id')
  delete(@Param('id') id: string): Promise<void> {
    return this.userService.delete(id);
  }
}

6. 注册模块

在你的模块（例如 app.module.ts）中注册 TypeOrmModule.forFeature 和控制器：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UserController } from './user.controller';
import { UserService } from './user.service';
import { User } from './user.entity';
@Module({
  imports: [TypeOrmModule.forFeature([User])],
  controllers: [UserController],
  providers: [UserService],
})
export class UserModule {}

这些进程概述了在 Nest.js 应用程序中运用 TypeORM 完结 CRUD 操作的根本流程。
具体完成或许会依据具体需求有所不同。

在运用 TypeORM 结合 Nest.js 界说表结构时，会用到一系列的装修器（decorators）来界说实体（Entity）和表之间的映射联系。以下是一些常用的 TypeORM 装修器：

@Entity()
用于界说一个类作为数据库表的映射。
@PrimaryGeneratedColumn()
将某个字段符号为主键，而且值会主动生成。一般用于自增的ID字段。
@Column()
界说表中的一个列。能够指定列的类型、长度、是否仅有等特点。
@CreateDateColumn()
主动设置列的值为刺进数据的时刻。
@UpdateDateColumn()
主动设置列的值为数据更新的时刻。
@DeleteDateColumn()
用于软删去功能，主动设置列的值为数据被软删去的时刻。
@VersionColumn()
用于达观锁，每次实体更新时，该列的值会主动增加。
@ManyToOne(), @OneToMany(), @OneToOne(), @ManyToMany()
这些装修器用于界说不同类型的相相联系。
@JoinColumn()
用于@OneToOne()和@ManyToOne()联系，指定外键列。
@JoinTable()
用于@ManyToMany()联系，指定衔接表的信息。
@Index()
用于为实体的某个或某些列创立数据库索引。
@Unique()
用于界说表等级的仅有束缚。
@Check()
用于界说表等级的检查束缚。
@Generated()
用于界说一个生成的列，如主动创立的UUID。
@EntityRepository()
用于自界说库房类，尽管不直接界说表结构，但与表操作严密相关。

在依赖注入 TypeORM 后，TypeORM 提供了一系列的办法来操作数据库，这些办法一般经过 Repository 目标来调用。Repository 是 TypeORM 的抽象，它答应你履行常见的持久层操作。以下是一些常用的 Repository 办法：
这些办法能够大致分为以下几类：

Repository 办法 – 用于对单个数据库实体进行操作的办法，包含：
- find：查找多个实体。
- findOne：查找单个实体。
- create：依据提供的目标创立一个新的实体实例，但不保存它。
- save：保存给定的实体或实体数组。
- remove：从数据库中移除给定的实体。
- update：更新数据库中的实体。
- insert：向数据库中刺进新的实体。
- delete：删去数据库中的记载。
- count：回来满足条件的实体数量。
- increment：增加实体的某个列的值。
- decrement：削减实体的某个列的值。
QueryBuilder – 用于构建更杂乱查询的接口，例如：
- createQueryBuilder：创立一个新的查询构建器。
- select：挑选特定的列。
- where：增加查询条件。
- orderBy：增加排序条件。
- leftJoinAndSelect：增加左衔接并挑选相关实体。
- getMany：履行查询并回来多个成果。
- getOne：履行查询并回来单个成果。
Entity Manager – 提供了一些更底层的数据库操作办法，例如：
- transaction：履行业务操作。
- createQueryRunner：创立一个能够用来办理单个数据库衔接的查询运转器。
- getCustomRepository：获取自界说的 repository。
Migration 办法 – 用于数据库搬迁，例如：
- createMigration：创立新的搬迁文件。
- runMigration：履行搬迁。
- revertMigration：回滚搬迁。
Subscriber 和 Listener – 答应你监听和订阅特定的数据库事件，例如：
- beforeInsert：在刺进之前触发。
- afterInsert：在刺进之后触发。
- beforeUpdate：在更新之前触发。
- afterUpdate：在更新之后触发。
- beforeRemove：在删去之前触发。
- afterRemove：在删去之后触发。

以下是运用 TypeORM 进行数据库操作的一些代码示例，基于 Nest.js 框架：

查找记载

async findAllUsers(): Promise<User[]> {
  return await this.userRepository.find();
}
async findOneUser(id: number): Promise<User> {
  return await this.userRepository.findOne(id);
}

创立和保存记载

async createUser(userData: Partial<User>): Promise<User> {
  const user = this.userRepository.create(userData);
  return await this.userRepository.save(user);
}

更新记载

async updateUser(id: number, updateData: Partial<User>): Promise<void> {
  await this.userRepository.update(id, updateData);
}

删去记载

async deleteUser(id: number): Promise<void> {
  await this.userRepository.delete(id);
}

运用 QueryBuilder 进行杂乱查询

async findUsersWithPosts(): Promise<User[]> {
  return this.userRepository
    .createQueryBuilder('user') // 'user' 是给 User 实体起的别名
    .leftJoinAndSelect('user.posts', 'post') // 假定 User 实体有一个 posts 相关
    .where('user.isActive = :isActive', { isActive: true })
    .andWhere('post.published = :published', { published: true })
    .orderBy('user.createdAt', 'DESC')
    .getMany();
}
// 关于更杂乱的查询，你能够运用子查询和多种不同的条件。例如：
async findUsersWithRecentPosts(): Promise<User[]> {
  return this.userRepository
    .createQueryBuilder('user')
    .leftJoinAndSelect('user.posts', 'post')
    .where('user.isActive = :isActive', { isActive: true })
    .andWhere(new Brackets(qb => {
      qb.where('post.createdAt > :date', { date: new Date(/* 一些日期 */) })
        .orWhere('post.title LIKE :title', { title: '%特定标题%' });
    }))
    .getMany();
}
// 咱们运用了 Brackets 来创立一个嵌套的条件块，这答应咱们在一个子查询中组合多个条件。

运用 Entity Manager 进行业务操作

import { EntityManager } from 'typeorm';
async updateUserAndLogTransaction(user: User, logMessage: string): Promise<void> {
  await this.userRepository.manager.transaction(async (entityManager: EntityManager) => {
    await entityManager.save(user);
    await entityManager.insert(Log, { message: logMessage });
  });
}

使用 TypeORM + Nest.js 定义数据库模型

1. 承认有哪些实体

2. 承认有哪些相关的实体

3. 承认相相联系

4. 承认实体特点

5. 不断优化细节

示例场景：图书馆办理体系

进程 1：界说用户故事或用例

进程 2：从用例中辨认实体

进程 3：承认相相联系

进程 4：界说实体特点

进程 5：制作实体联系图（ERD）

运用 TypeORM 生成实体和特点

1. 装置必要的包

2. 创立数据库衔接

3. 界说实体

4. 创立服务

5. 创立控制器

6. 注册模块

作者信息

推广

使用 TypeORM + Nest.js 定义数据库模型

1. 承认有哪些实体

2. 承认有哪些相关的实体

3. 承认相相联系

4. 承认实体特点

5. 不断优化细节

示例场景：图书馆办理体系

进程 1：界说用户故事或用例

进程 2：从用例中辨认实体

进程 3：承认相相联系

进程 4：界说实体特点

进程 5：制作实体联系图（ERD）

运用 TypeORM 生成实体和特点

1. 装置必要的包

2. 创立数据库衔接

3. 界说实体

4. 创立服务

5. 创立控制器

6. 注册模块

相关文章

手把手教你做一个天猫精灵（一）

从零开发一个vscode插件

一个全新的 Android 组件化通信工具

Android-create-pinned-shortcut创建桌面快捷方式

作者信息

推广