Matarialize中文社区-Nest.js专栏

Nest.js 框架数据库操作

Nest.js,数据库操作

Nest.js 提供了与不同类型的数据库（如 SQL 和 NoSQL）集成的能力。最常用的数据库库是 TypeORM（用于 SQL 数据库）和 Mongoose（用于 MongoDB）。本文将详细介绍如何在 Nest.js 中使用这两个库进行数据库操作，涵盖数据库模型、迁移、基本 CRUD 操作以及其他模块的结合使用。

1. 使用 TypeORM 进行 SQL 数据库操作

1.1 安装 TypeORM 和相关依赖

首先，需要安装 TypeORM 和相应的数据库驱动。例如，我们将使用 PostgreSQL：

npm install @nestjs/typeorm typeorm pg

1.2 配置 TypeORM

在 app.module.ts 中配置 TypeORM：

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'your_username',
      password: 'your_password',
      database: 'your_database',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true, // 开发阶段可用，生产中建议设为 false
    }),
    UsersModule,
  ],
})
export class AppModule {}

1.3 创建数据库模型

创建一个用户实体模型 user.entity.ts：

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

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

  @Column()
  name: string;

  @Column()
  email: string;

  @Column()
  password: string;
}

1.4 创建用户模块

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { TypeOrmModule } from '@nestjs/typeorm';
import { User } from './user.entity';

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

1.5 创建用户服务

在 users.service.ts 中实现 CRUD 操作：

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>,
  ) {}

  create(user: User) {
    return this.usersRepository.save(user);
  }

  findAll(): Promise<User[]> {
    return this.usersRepository.find();
  }

  findOne(id: number): Promise<User> {
    return this.usersRepository.findOneBy({ id });
  }

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

1.6 创建用户控制器

在 users.controller.ts 中处理请求：

import { Controller, Get, Post, Body, Param, Delete } from '@nestjs/common';
import { UsersService } from './users.service';
import { User } from './user.entity';

@Controller('users')
export class UsersController {
  constructor(private readonly usersService: UsersService) {}

  @Post()
  create(@Body() user: User) {
    return this.usersService.create(user);
  }

  @Get()
  findAll() {
    return this.usersService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: number) {
    return this.usersService.findOne(id);
  }

  @Delete(':id')
  remove(@Param('id') id: number) {
    return this.usersService.remove(id);
  }
}

2. 数据库迁移

对于 TypeORM，可以使用 TypeORM CLI 进行数据库迁移。首先，安装 TypeORM CLI：

npm install typeorm -g

然后，添加配置文件 ormconfig.json：

{
  "type": "postgres",
  "host": "localhost",
  "port": 5432,
  "username": "your_username",
  "password": "your_password",
  "database": "your_database",
  "entities": ["src/**/*.entity{.ts,.js}"],
  "migrations": ["src/migration/**/*.ts"],
  "cli": {
    "entitiesDir": "src",
    "migrationsDir": "src/migration"
  }
}

创建迁移

创建迁移命令：

typeorm migration:create -n UserMigration

在生成的迁移文件中，可以定义数据库表结构：

import { MigrationInterface, QueryRunner, Table } from 'typeorm';

export class UserMigration1620000000000 implements MigrationInterface {
  public async up(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.createTable(
      new Table({
        name: 'user',
        columns: [
          {
            name: 'id',
            type: 'int',
            isPrimary: true,
            isGenerated: true,
          },
          {
            name: 'name',
            type: 'varchar',
          },
          {
            name: 'email',
            type: 'varchar',
          },
          {
            name: 'password',
            type: 'varchar',
          },
        ],
      }),
    );
  }

  public async down(queryRunner: QueryRunner): Promise<void> {
    await queryRunner.dropTable('user');
  }
}

执行迁移

运行迁移：

typeorm migration:run

3. 使用 Mongoose 进行 MongoDB 数据库操作

3.1 安装 Mongoose 和相关依赖

首先，安装 Mongoose：

npm install @nestjs/mongoose mongoose

3.2 配置 Mongoose

在 app.module.ts 中配置 Mongoose：

import { Module } from '@nestjs/common';
import { MongooseModule } from '@nestjs/mongoose';
import { UsersModule } from './users/users.module';

@Module({
  imports: [
    MongooseModule.forRoot('mongodb://localhost/nest'), // 连接到 MongoDB
    UsersModule,
  ],
})
export class AppModule {}

3.3 创建数据库模型

在 users 文件夹中创建 user.schema.ts：

import { Schema, Document } from 'mongoose';

export const UserSchema = new Schema({
  name: String,
  email: String,
  password: String,
});

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

3.4 创建用户模块

在 users.module.ts 中导入 Mongoose 模块：

import { Module } from '@nestjs/common';
import { UsersService } from './users.service';
import { UsersController } from './users.controller';
import { MongooseModule } from '@nestjs/mongoose';
import { UserSchema } from './user.schema';

@Module({
  imports: [
    MongooseModule.forFeature([{ name: 'User', schema: UserSchema }]),
  ],
  providers: [UsersService],
  controllers: [UsersController],
})
export class UsersModule {}

3.5 创建用户服务