Bài hướng dẫn này sẽ giới thiệu cách tích hợp TypeORM với Nest.js và thực hiện các thao tác CRUD (Create, Read, Update và Delete) cho RESTful API của bạn sử dụng cơ sở dữ liệu quan hệ như PostgreSQL hoặc MySQL.
I. Giới thiệu
Trong đó, Nest.js là một framework Node.js được phát triển để xây dựng các ứng dụng back-end hiệu quả, bảo mật và có thể mở rộng. TypeORM là một ORM (Object-Relational Mapping) cho TypeScript và JavaScript. Nó hỗ trợ các cơ sở dữ liệu quan hệ như PostgreSQL, MySQL và SQLite.
Với Nest.js và TypeORM, chúng ta có thể tạo ra một ứng dụng back-end mạnh mẽ với các tính năng CRUD cho cơ sở dữ liệu quan hệ.
II. Cài đặt
Để bắt đầu, chúng ta cần cài đặt Nest.js và TypeORM bằng các lệnh sau:
npm install --save @nestjs/core @nestjs/common @nestjs/platform-express @nestjs/microservices typeorm mysqlNgoài ra, chúng ta cũng cần cài đặt TypeScript, ts-node và @types/node:
npm install --save-dev typescript ts-node @types/nodeSau khi cài đặt thành công, chúng ta có thể bắt đầu tạo dự án Nest.js với TypeScript bằng cách chạy lệnh sau:
npx @nestjs/cli new project-name --language=tsIII. Kết nối cơ sở dữ liệu
Tiếp theo, chúng ta sẽ kết nối cơ sở dữ liệu với Nest.js và TypeORM. Chúng ta sẽ sử dụng MySQL như một ví dụ để kết nối.
1. Tạo file .env để lưu trữ thông tin kết nối cơ sở dữ liệu như sau:
DB_HOST = localhost
DB_PORT = 3306
DB_USERNAME = root
DB_PASSWORD = secret
DB_DATABASE = users2. Tạo file ormconfig.json để cấu hình TypeORM như sau:
{
"type": "mysql",
"host": process.env.DB_HOST,
"port": process.env.DB_PORT,
"username": process.env.DB_USERNAME,
"password": process.env.DB_PASSWORD,
"database": process.env.DB_DATABASE,
"synchronize": true,
"logging": false,
"entities": [
"dist/**/*.entity{.ts,.js}"
]
}Chúng ta đã cấu hình TypeORM cho phép đồng bộ hóa các thay đổi với cơ sở dữ liệu sử dụng “synchronize”: true. Đồng thời, chúng ta cũng đã chỉ định cho TypeORM sử dụng các file entity được tạo ra bởi Nest.js.
3. Tiếp theo, chúng ta sẽ tạo một file database.providers.ts để cung cấp kết nối cơ sở dữ liệu như sau:
import { createConnection } from 'typeorm';
export const databaseProviders = [
{
provide: 'DATABASE_CONNECTION',
useFactory: async () =>
await createConnection({
type: 'mysql',
host: process.env.DB_HOST,
port: Number(process.env.DB_PORT),
username: process.env.DB_USERNAME,
password: process.env.DB_PASSWORD,
database: process.env.DB_DATABASE,
entities: [__dirname + '/../**/*.entity{.ts,.js}'],
synchronize: true,
}),
},
];4. Cuối cùng, chúng ta sẽ import provider này vào file app.module.ts:
import { Module } from '@nestjs/common';
import { databaseProviders } from './database.providers';
@Module({
imports: [],
controllers: [],
providers: [...databaseProviders],
})
export class AppModule {}IV. Tạo model
Tiếp theo, chúng ta sẽ tạo một model cho bảng users trong cơ sở dữ liệu.
1. Tạo file user.entity.ts trong thư mục src/entities/ với nội dung như sau:
import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm';
@Entity()
export class User {
@PrimaryGeneratedColumn()
id: number;
@Column({ length: 50 })
lastName: string;
@Column({ length: 50 })
firstName: string;
@Column()
email: string;
@Column()
password: string;
}2. Sau đó, chúng ta sẽ tạo một file user.service.ts để xử lý các thao tác CRUD cho bảng users.
V. Tạo service
1. Tạo file user.service.ts trong thư mục src/ với nội dung như sau:
import { Injectable, Inject } from '@nestjs/common';
import { Repository } from 'typeorm';
import { User } from './entities/user.entity';
@Injectable()
export class UserService {
constructor(
@Inject('USER_REPOSITORY')
private userRepository: Repository,
) {}
async create(user: User): Promise {
await this.userRepository.save(user);
}
async findAll(): Promise<User[]> {
return await this.userRepository.find();
}
async findOne(id: number): Promise {
return await this.userRepository.findOne(id);
}
async update(id: number, user: User): Promise {
await this.userRepository.update(id, user);
}
async delete(id: number): Promise {
await this.userRepository.delete(id);
}
}Trong đó, chúng ta đã sử dụng Injectable để tiêm Repository cho bảng users vào UserService. Chúng ta cũng đã triển khai các hàm tương ứng để thực hiện các thao tác CRUD.
2. Tiếp theo, chúng ta sẽ tạo một Provider để cung cấp UserService cho ứng dụng Nest.js.
import { Provider } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './entities/user.entity';
export const userProviders: Provider[] = [
{
provide: 'USER_REPOSITORY',
useValue: User,
},
UserService,
];3. Cuối cùng, chúng ta sẽ import provider này vào file app.module.ts:
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { userProviders } from './user.providers';
@Module({
imports: [],
controllers: [AppController],
providers: [AppService, ...userProviders],
})
export class AppModule {}VI. Tạo controller
Cuối cùng, chúng ta sẽ tạo một RESTful API để truy cập các thao tác CRUD của UserService.
1. Tạo file user.controller.ts trong thư mục src/ với nội dung như sau:
import { Controller, Get, Post, Body, Put, Delete, Param } from '@nestjs/common';
import { UserService } from './user.service';
import { User } from './entities/user.entity';
@Controller('users')
export class UserController {
constructor(private readonly userService: UserService) {}
@Post()
async create(@Body() user: User) {
await this.userService.create(user);
}
@Get()
async findAll(): Promise<User[]> {
return this.userService.findAll();
}
@Get(':id')
async findOne(@Param('id') id: number): Promise {
return this.userService.findOne(id);
}
@Put(':id')
async update(@Param('id') id: number, @Body() user: User) {
await this.userService.update(id, user);
}
@Delete(':id')
async delete(@Param('id') id: number) {
await this.userService.delete(id);
}
}2. Cuối cùng, chúng ta sẽ import controller này vào file app.module.ts:
import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { userProviders } from './user.providers';
import { UserController } from './user.controller';
@Module({
imports: [],
controllers: [AppController, UserController],
providers: [AppService, ...userProviders],
})
export class AppModule {}VII. Kết luận
Với Nest.js và TypeORM, chúng ta đã tạo một RESTful API có các tính năng CRUD cho cơ sở dữ liệu quan hệ. Với các tính năng mở rộng của Nest.js và TypeORM, chúng ta có thể tùy chỉnh và mở rộng ứng dụng theo nhu cầu của mình.
Tóm lại, trong bài hướng dẫn này, chúng ta đã:
- Cài đặt Nest.js và TypeORM.
- Kết nối cơ sở dữ liệu.
- Tạo một model cho bảng users.
- Tạo một service để xử lý các thao tác CRUD cho bảng users.
- Tạo một controller để truy cập các thao tác CRUD của UserService.
Chúc các bạn thành công!