Xây dựng CRUD API đầu tiên

Hãy cài đặt các thư viện cần thiết để tích hợp TypeORM với SQLite, đồng thời cài đặt các thư viện 'class-validator' và 'class-transformer' để hỗ trợ validate dữ liệu đầu vào.

npm install @nestjs/typeorm typeorm sqlite3 class-validator class-transformer
npm install --save-dev @types/sqlite3

Hãy cấu hình kết nối cơ sở dữ liệu SQLite trong file 'src/app.module.ts'. 
- Đặt tên file database lưu trữ là 'database.sqlite'.
- Cấu hình tự động tải các thực thể (entities).
- Bật chế độ 'synchronize: true' để tự động đồng bộ bảng dữ liệu trong môi trường phát triển.

import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { ProductsModule } from './products/products.module';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'sqlite',
      database: 'database.sqlite',
      entities: [__dirname + '/**/*.entity{.ts,.js}'],
      synchronize: true,
    }),
    ProductsModule,
  ],
})
export class AppModule {}

Hãy sử dụng Nest CLI để sinh cấu trúc thư mục hoàn chỉnh (gồm Module, Service, Controller) cho đối tượng 'products'.

nest g module products
nest g service products
nest g controller products

Hãy thiết kế một Entity 'Product' trong file 'src/products/entities/product.entity.ts' đại diện cho bảng 'products' trong SQLite:
- id: Khóa chính tự tăng (auto-increment integer).
- name: string, bắt buộc.
- price: decimal (chữ số thập phân), bắt buộc.
- description: string, nullable (cho phép trống).
- isAvailable: boolean, mặc định true.
- createdAt: timestamp, tự động sinh thời gian.
Đồng thời, hãy nhớ đăng ký thực thể này vào đối tượng 'TypeOrmModule.forFeature' trong file 'products.module.ts'.

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

@Entity('products')
export class Product {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @Column({ type: 'decimal', precision: 10, scale: 2 })
  price: number;

  @Column({ nullable: true })
  description: string;

  @Column({ default: true })
  isAvailable: boolean;

  @CreateDateColumn()
  createdAt: Date;
}

Hãy tạo CreateProductDto và UpdateProductDto trong thư mục 'src/products/dto' sử dụng 'class-validator' để xác thực dữ liệu đầu vào:
- name: phải là string, độ dài tối thiểu 3 ký tự.
- price: phải là số nguyên hoặc số thập phân hợp lệ.
- description: tùy chọn.
- isAvailable: tùy chọn, kiểm tra kiểu boolean.

Hãy viết UpdateProductDto kế thừa từ CreateProductDto bằng cách sử dụng 'PartialType' từ '@nestjs/mapped-types'.

Đồng thời, kích hoạt 'ValidationPipe' toàn cục trong file 'src/main.ts' để cơ chế validate tự động hoạt động.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common';

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  
  // Kích hoạt xác thực dữ liệu tự động cho mọi request
  app.useGlobalPipes(new ValidationPipe());
  
  await app.listen(3000);
}
bootstrap();

Hãy hoàn thiện mã nguồn 'src/products/products.service.ts':
- Inject Product Repository thông qua Constructor.
- Hàm 'create': Tạo mới và lưu sản phẩm.
- Hàm 'findAll': Lấy toàn bộ danh sách sản phẩm.
- Hàm 'findOne': Tìm kiếm sản phẩm theo ID. Nếu không tìm thấy, hãy ném ra 'NotFoundException' kèm thông báo lỗi phù hợp.
- Hàm 'update': Tìm sản phẩm theo ID, sử dụng hàm 'merge' của TypeORM để cập nhật các trường được thay đổi, sau đó lưu lại.
- Hàm 'remove': Tìm sản phẩm theo ID và xóa khỏi CSDL.

import { Injectable, NotFoundException } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Product } from './entities/product.entity';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';

@Injectable()
export class ProductsService {
  constructor(
    @InjectRepository(Product)
    private readonly productRepository: Repository<Product>,
  ) {}

  async create(createProductDto: CreateProductDto): Promise<Product> {
    const newProduct = this.productRepository.create(createProductDto);
    return await this.productRepository.save(newProduct);
  }

  async findAll(): Promise<Product[]> {
    return await this.productRepository.find();
  }

  async findOne(id: number): Promise<Product> {
    const product = await this.productRepository.findOneBy({ id });
    if (!product) {
      throw new NotFoundException(`Không tìm thấy sản phẩm có ID #${id}`);
    }
    return product;
  }

  async update(id: number, updateProductDto: UpdateProductDto): Promise<Product> {
    const product = await this.findOne(id);
    const updatedProduct = this.productRepository.merge(product, updateProductDto);
    return await this.productRepository.save(updatedProduct);
  }

  async remove(id: number): Promise<void> {
    const product = await this.findOne(id);
    await this.productRepository.remove(product);
  }
}

Hãy hoàn thiện file 'src/products/products.controller.ts' để định nghĩa các endpoint HTTP kết nối tới ProductsService:
- POST /products: Tạo sản phẩm mới (Body là CreateProductDto).
- GET /products: Lấy danh sách sản phẩm.
- GET /products/:id: Lấy chi tiết sản phẩm (sử dụng ParseIntPipe cho tham số id).
- PATCH /products/:id: Cập nhật sản phẩm (sử dụng ParseIntPipe cho id, Body là UpdateProductDto).
- DELETE /products/:id: Xóa sản phẩm (sử dụng ParseIntPipe cho id).

import { Controller, Get, Post, Body, Patch, Param, Delete, ParseIntPipe } from '@nestjs/common';
import { ProductsService } from './products.service';
import { CreateProductDto } from './dto/create-product.dto';
import { UpdateProductDto } from './dto/update-product.dto';

@Controller('products')
export class ProductsController {
  constructor(private readonly productsService: ProductsService) {}

  @Post()
  create(@Body() createProductDto: CreateProductDto) {
    return this.productsService.create(createProductDto);
  }

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

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

  @Patch(':id')
  update(@Param('id', ParseIntPipe) id: number, @Body() updateProductDto: UpdateProductDto) {
    return this.productsService.update(id, updateProductDto);
  }

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