# Type ORM ## 1. TypeORM là gì? `TypeORM` là một ORM (Object-Relational Mapping) framework giúp chúng ta tương tác với database thông qua các object và class. TypeORM hỗ trợ nhiều loại database như MySQL, PostgreSQL, SQLite, SQL Server, Oracle, MariaDB, CockroachDB, và MongoDB. Với `TypeORM`, chúng ta có thể tạo các entity, tạo các relationship giữa các entity, thực hiện các truy vấn, và thực hiện các migration để cập nhật cấu trúc database. ## 2. Cài đặt TypeORM Để cài đặt TypeORM, chúng ta chạy lệnh sau: ```bash npm install @nestjs/typeorm typeorm {database-driver} ``` - Trong đó, `{database-driver}` là driver của database mà chúng ta muốn sử dụng. + MySQL: `mysql` + PostgreSQL: `pg` + SQLite: `sqlite3` + SQL Server: `mssql` + Oracle: `oracle` ## 3. Sử dụng TypeORM với SQLite ### 3.1. Tạo entity Đầu tiên, chúng ta cần tạo một entity để tương ứng với một bảng trong database. Entity là một class với các property tương ứng với các cột trong bảng. >Ví dụ, chúng ta tạo một entity `User` với các property `id`, `name`, `email`: > user.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn } from 'typeorm'; // Import các decorator từ typeorm @Entity() // Đánh dấu class này là một entity export class User { @PrimaryGeneratedColumn() // Đánh dấu property này là primary key và tự động tăng id: number; @Column() name: string; @Column() email: string; } ``` ### 3.2. Tạo module và service Tiếp theo, chúng ta tạo một module và một service để thực hiện các thao tác với entity `User`. > user.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from './user.entity'; // Import entity @Module({ imports: [TypeOrmModule.forFeature([User])], // Import entity vào module }) export class UserModule {} ``` > user.service.ts ```typescript import { Injectable } from '@nestjs/common'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { User } from './user.entity'; // Import entity @Injectable() export class UserService { constructor( @InjectRepository(User) // Inject repository của entity User private userRepository: Repository // Inject repository vào service để thực hiện các thao tác với database ) {} } ``` ### 3.3. Kết nối với database Để kết nối với database, chúng ta cần cấu hình trong file `app.module.ts`. > app.module.ts ```typescript import { Module } from '@nestjs/common'; import { TypeOrmModule } from '@nestjs/typeorm'; import { UserModule } from './user/user.module'; // Import module import { User } from './user/user.entity'; // Import entity @Module({ imports: [ TypeOrmModule.forRoot({ type: 'sqlite', // Loại database database: 'database.sqlite', // Tên database entities: [User], // Những entity sẽ được sử dụng synchronize: true, // Tự động tạo bảng nếu chưa tồn tại }), UserModule, // Import module ], }) ``` ### 3.4. Thực hiện các thao tác với database thông qua Repository Sau khi đã cấu hình xong, chúng ta có thể thực hiện các thao tác với database thông qua repository. > user.service.ts ```typescript import { Injectable } from '@nestjs/common'; // Nhâp Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { InjectRepository } from '@nestjs/typeorm'; // Nhập InjectRepository decorator từ @nestjs/typeorm để inject repository vào service import { Repository } from 'typeorm'; // Nhập Repository từ typeorm để thực hiện các thao tác với database import { User } from './user.entity'; // Nhập entity User @Injectable() // Đánh dấu class này là một service export class UserService { constructor( @InjectRepository(User) // Inject repository của entity User private userRepository: Repository // Inject repository vào service để thực hiện các thao tác với database ) {} async findAll(): Promise { return this.userRepository.find(); // Lấy tất cả user từ database } async findOne(id: number): Promise { return this.userRepository.findOne({where: {id: id}}); // Lấy một user từ database theo id, nếu không có By thì phải thêm where } async findOneBy(name: string): Promise { return this.userRepository.findOneBy({ name: name }); // Tim kiếm một user theo name trong database } async find(name: string): Promise { return this.userRepository.find({ where: { name } }); // Tim kiếm tất cả user theo name trong database, nếu không có By thì phải thêm where } async create(user: User): Promise { return this.userRepository.save(user); // Tạo một user mới trong database } async update(id: number, user: User): Promise { await this.userRepository.update(id, user); // Cập nhật một user trong database return this.userRepository.findOne({where: {id}}); // Lấy user sau khi cập nhật } async remove(id: number): Promise { await this.userRepository.delete(id); // Xóa một user trong database theo id, sẽ không gọi hook /* const user = await this.userRepository.findOne({where: {id}}); // Lấy user trước khi xóa await this.userRepository.remove(user); // Xóa một user trong database, sẽ gọi hook */ } } ``` ### 3.5. Lưu ý về hook trong việc sử dụng các method của Repository Khi sử dụng các method của Repository, chúng ta có thể sử dụng các hook để thực hiện các thao tác trước hoặc sau khi thực hiện các method đó. Ví dụ, chúng ta có thể sử dụng các hook `@BeforeInsert()`, `@BeforeUpdate()`, `@BeforeRemove()`, `@AfterInsert()`, `@AfterUpdate()`, `@AfterRemove()` để thực hiện các thao tác trước hoặc sau khi thực hiện các method thêm, sửa, xóa của Repository. Để các hook hoạt động thì chúng ta phải tạo 1 instance của entity và gọi method `save()` hoặc `remove()` của Repository. Nếu gọi trực tiếp các method `insert()`, `update()`, `delete()` thì các hook sẽ không hoạt động. >Ví dụ, chúng ta tạo một hook `@BeforeInsert()` để hash password trước khi tạo một user mới: > user.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn, BeforeInsert } from 'typeorm'; // Import các decorator từ typeorm import * as bcrypt from 'bcrypt'; // Import bcrypt để hash password @Entity() // Đánh dấu class này là một entity export class User { @PrimaryGeneratedColumn() // Đánh dấu property này là primary key và tự động tăng id: number; @Column() name: string; @Column() email: string; @Column() password: string; @BeforeInsert() // Đánh dấu method này sẽ được thực hiện trước khi insert async hashPassword() { this.password = await bcrypt.hash(this.password, 10); // Hash password } } ``` > user.service.ts ```typescript import { Injectable } from '@nestjs/common'; // Nhâp Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { InjectRepository } from '@nestjs/typeorm'; // Nhập InjectRepository decorator từ @nestjs/typeorm để inject repository vào service import { Repository } from 'typeorm'; // Nhập Repository từ typeorm để thực hiện các thao tác với database import { User } from './user.entity'; // Nhập entity User @Injectable() // Đánh dấu class này là một service export class UserService { constructor( @InjectRepository(User) // Inject repository của entity User private userRepository: Repository // Inject repository vào service để thực hiện các thao tác với database ) {} async create(user: User): Promise { const newUser = this.userRepository.create(user); // Tạo một instance của entity User return this.userRepository.save(newUser); // Tạo một user mới trong database, như này thì hook @BeforeInsert() sẽ hoạt động, nếu gọi this.userRepository.insert(user) thì hook sẽ không hoạt động hoặc gọi trực tiếp user.save(user) thì hook cũng không hoạt động } } ``` ## 4. Các relationship giữa các entity TypeORM hỗ trợ nhiều loại relationship giữa các entity như `OneToOne`, `OneToMany`, `ManyToOne`, `ManyToMany`. Để tạo relationship giữa các entity, chúng ta sử dụng các decorator `@OneToOne()`, `@OneToMany()`, `@ManyToOne()`, `@ManyToMany()`. >Ví dụ, chúng ta tạo một relationship `OneToMany` giữa entity `User` và entity `Post`: > user.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn, OneToMany } from 'typeorm'; // Import các decorator từ typeorm import { Post } from './post.entity'; // Import entity Post @Entity() // Đánh dấu class này là một entity export class User { @PrimaryGeneratedColumn() // Đánh dấu property này là primary key và tự động tăng id: number; @Column() name: string; @Column() email: string; @OneToMany(() => Post, post => post.user) // Tạo relationship OneToMany giữa entity User và entity Post // () => Post: Entity mà User sẽ tương tác // post => post.user: Property mà Post sẽ tương tác, user sẽ là thuộc tính được tạo trong entity Post posts: Post[]; // Một user có nhiều post } ``` > post.entity.ts ```typescript import { Entity, Column, PrimaryGeneratedColumn, ManyToOne } from 'typeorm'; // Import các decorator từ typeorm import { User } from './user.entity'; // Import entity User @Entity() // Đánh dấu class này là một entity export class Post { @PrimaryGeneratedColumn() // Đánh dấu property này là primary key và tự động tăng id: number; @Column() title: string; @Column() content: string; @ManyToOne(() => User, user => user.posts) // Tạo relationship ManyToOne giữa entity Post và entity User // () => User: Entity mà Post sẽ tương tác // user => user.posts: Property mà User sẽ tương tác, posts sẽ là thuộc tính được tạo trong entity User user: User; // Một post thuộc về một user } ``` > NOTE: Các thuộc tính liên kết giữa các entity sẽ không được tự động fetch khi lấy entity từ database. Mà phải tìm nạp cụ thể cho từng thuộc tính đó. VD, khi lấy 1 user từ database, thì chỉ có thông tin của user được lấy, còn thông tin của các post của user sẽ không được lấy, lúc này post sẽ là một mảng rỗng. Tạo một post mới cho user: > post.service.ts ```typescript import { Injectable } from '@nestjs/common'; // Nhâp Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { InjectRepository } from '@nestjs/typeorm'; // Nhập InjectRepository decorator từ @nestjs/typeorm để inject repository vào service import { Repository } from 'typeorm'; // Nhập Repository từ typeorm để thực hiện các thao tác với database import { Post } from './post.entity'; // Nhập entity Post import { User } from './user.entity'; // Nhập entity User @Injectable() // Đánh dấu class này là một service export class PostService { constructor( @InjectRepository(Post) // Inject repository của entity Post private postRepository: Repository, // Inject repository vào service để thực hiện các thao tác với database @InjectRepository(User) // Inject repository của entity User private userRepository: Repository // Inject repository vào service để thực hiện các thao tác với database ) {} async createPost(userId: number, post: Post): Promise { const newPost = this.postRepository.create(post); // Tạo một instance của entity Post const user = await this.userRepository.findOne(userId); // Lấy user từ database theo id newPost.user = user; // Gán user cho post return this.postRepository.save(newPost); // Tạo một post mới trong database } } ``` ## 5. Sử dụng createQueryBuilder Để thực hiện các truy vấn phức tạp, chúng ta có thể sử dụng `createQueryBuilder` của TypeORM. >Ví dụ, chúng ta thực hiện truy vấn lấy tất cả user có email chứa từ khóa `@gmail.com`: > user.service.ts ```typescript import { Injectable } from '@nestjs/common'; // Nhâp Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { InjectRepository } from '@nestjs/typeorm'; // Nhập InjectRepository decorator từ @nestjs/typeorm để inject repository vào service import { Repository } from 'typeorm'; // Nhập Repository từ typeorm để thực hiện các thao tác với database import { User } from './user.entity'; // Nhập entity User @Injectable() // Đánh dấu class này là một service export class UserService { constructor( @InjectRepository(User) // Inject repository của entity User private userRepository: Repository // Inject repository vào service để thực hiện các thao tác với database ) {} async findUserByEmail(email: string): Promise { return userRepository .createQueryBuilder('user') // Tạo một query builder với entity User .where('user.email LIKE :email', { email: `%${email}%` }) // Thêm điều kiện cho truy vấn .getMany(); // Lấy tất cả user thỏa mãn điều kiện } } // NOTE find({where: [ {name: "Alice", name: "Bob"}, {age: 18} ]}) // WHERE (name = 'Alice' AND name = 'Bob') OR age = 18 ``` ## 6. Query với Raw SQL Đôi khi chúng ta cần thực hiện các truy vấn phức tạp mà không thể thực hiện được với `createQueryBuilder`. Trong trường hợp này, chúng ta có thể sử dụng `query` để thực hiện truy vấn với raw SQL. Trước đó cần inject `DataSource` vào service: > user.service.ts ```typescript import { Injectable } from '@nestjs/common'; // Nhâp Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { DataSource, Repository } from 'typeorm'; // Nhập DataSource từ typeorm để tạo kết nối với database import { InjectRepository, InjectableDataSource } from '@nestjs/typeorm'; // Nhập InjectRepository decorator từ @nestjs/typeorm để inject repository vào service import { User } from './user.entity'; // Nhập entity User @Injectable() // Đánh dấu class này là một service export class UserService { constructor( @InjectRepository(User) // Inject repository của entity User private userRepository: Repository, // Inject repository vào service để thực hiện các thao tác với database @InjectableDataSource() // Inject DataSource private dataSource: DataSource // Inject DataSource vào service để thực hiện truy vấn với raw SQL ) {} async findUserByEmail(email: string): Promise { return this.dataSource.query(`SELECT * FROM user WHERE email LIKE '%${email}%'`); // Thực hiện truy vấn với raw SQL } } ``` ## 7. Migration Migration là quá trình cập nhật cấu trúc database thông qua các file migration. Khi chúng ta thay đổi cấu trúc database, chúng ta cần tạo một file migration để cập nhật cấu trúc database. ### 7.1. Tạo migration **B1**: Tạo file `typeorm.config.ts` để cấu hình kết nối với database: >src/config/typeorm.config.ts ```typescript import { Injectable } from '@nestjs/common'; // Import Injectable decorator từ @nestjs/common để đánh dấu class này là một service import { ConfigService } from '@nestjs/config'; // Import ConfigService từ @nestjs/config để đọc các biến môi trường import { TypeOrmModuleOptions, TypeOrmOptionsFactory } from '@nestjs/typeorm'; // Import TypeOrmModuleOptions, TypeOrmOptionsFactory từ @nestjs/typeorm để cấu hình kết nối với database @Injectable() export class TypeOrmConfigService implements TypeOrmOptionsFactory { // Implement TypeOrmOptionsFactory để tạo cấu hình kết nối với database constructor(private configService: ConfigService) {} // Inject ConfigService để đọc các biến môi trường createTypeOrmOptions(): TypeOrmModuleOptions { // Tạo cấu hình kết nối với database return { type: 'sqlite', // Loại database synchronize: false, // Tự động tạo bảng nếu chưa tồn tại (false: không tạo, true: tạo) (Tránh sử dụng synchronize trong production, chỉ sử dụng trong development) database: this.configService.get('DB_NAME'), // Tên database autoLoadEntities: true, // Tự động load các entity từ thư mục entities }; } } ``` **B2**: Tạo file data-source.ts để tạo một instance của DataSource hỗ trợ migration: > src/data-source.ts ```typescript import { DataSource, DataSourceOptions } from 'typeorm'; // Import DataSource, DataSourceOptions từ typeorm để tạo kết nối với database export const appDataSource = new DataSource({ type: 'sqlite', database: 'db.sqlite', entities: ['**/*.entity.ts'], // Load tất cả các entity từ thư mục entities migrations: [__dirname + '/migrations/*.ts'], // Load tất cả các file migration từ thư mục migrations } as DataSourceOptions); ``` **B3**: Thêm script để chạy file migration trong `package.json`: > package.json ```json { "scripts": { "typeorm": "typeorm-ts-node-commonjs -d src/data-source.ts" } } ``` **B4**: Chạy lệnh sau để tạo file migration: ```bash npm run typeorm migration:generate src/migrations/initial-schema ``` **B5**: Sau đó chạy file migration: ```bash npm run typeorm migration:run ``` > Để rollback file migration, chúng ta chạy lệnh sau: ```bash npx typeorm migration:revert ```

NestJS: Sử dụng TypeORM