Tiếp tục với series, ở bài trước chúng ta đã tạo project TaskFlow API với một module duy nhất là AppModule. Bài này mình sẽ giới thiệu với mọi người về module trong NestJS, cách NestJS chia ứng dụng thành từng phần, và tạo ProjectsModule, TasksModule cho TaskFlow API.
1. Module là gì?
Module là một class được gắn decorator
@Module(), dùng để gom nhóm các thành phần liên quan đến cùng một chức năng của ứng dụng.
Mỗi ứng dụng NestJS có ít nhất một module là module gốc (root module), chính là AppModule được truyền vào NestFactory.create() trong main.ts. Từ module gốc, NestJS đi theo các module được import để dựng ra toàn bộ ứng dụng.
@Module() nhận một object với các thuộc tính:
controllers: các controller của module, nơi nhận request (Bài 5).providers: các provider (VD service) mà NestJS sẽ khởi tạo, dùng được trong module này (Bài 6).imports: các module khác mà module này cần dùng provider của chúng.exports: những provider của module này cho phép module khác dùng khi import nó.
Điểm quan trọng nhất: module đóng gói (encapsulate) provider của nó. Một provider chỉ dùng được ở module khai báo nó, hoặc ở module đã import một module có export provider đó. Các bạn có thể coi exports là "API công khai" của module.
2. Tạo feature module cho TaskFlow API.
Feature module là module gom code của một chức năng cụ thể. TaskFlow API quản lý project và task nên mình tạo hai module tương ứng bằng Nest CLI (Bài 3):
nest g module projects
# CREATE src/projects/projects.module.ts (85 bytes)
# UPDATE src/app.module.ts (339 bytes)
nest g module tasks
# CREATE src/tasks/tasks.module.ts (82 bytes)
# UPDATE src/app.module.ts (407 bytes)
npm run format
Mỗi module nằm trong thư mục riêng, sau này controller, service, DTO của chức năng nào sẽ nằm trong thư mục đó:
- src/projects/projects.module.ts
import { Module } from '@nestjs/common';
@Module({})
export class ProjectsModule {}
src/tasks/tasks.module.ts cũng tương tự với class TasksModule. CLI đã tự thêm hai module vào imports của module gốc:
- src/app.module.ts
import { Module } from '@nestjs/common';
import { AppController } from './app.controller.js';
import { AppService } from './app.service.js';
import { ProjectsModule } from './projects/projects.module.js';
import { TasksModule } from './tasks/tasks.module.js';
@Module({
imports: [ProjectsModule, TasksModule],
controllers: [AppController],
providers: [AppService],
})
export class AppModule {}
Chạy npm run start, log cho thấy NestJS đã khởi tạo cả ba module:
[Nest] 34 - 11/15/2026, 5:37:57 AM LOG [NestFactory] Starting Nest application...
[Nest] 34 - 11/15/2026, 5:37:57 AM LOG [InstanceLoader] ProjectsModule dependencies initialized +24ms
[Nest] 34 - 11/15/2026, 5:37:57 AM LOG [InstanceLoader] TasksModule dependencies initialized +0ms
[Nest] 34 - 11/15/2026, 5:37:57 AM LOG [InstanceLoader] AppModule dependencies initialized +0ms
...
Hai module hiện vẫn trống, ở các bài sau chúng ta sẽ thêm controller và service vào. Nếu quên import một feature module vào AppModule (hoặc vào module khác đã được import), NestJS sẽ không biết đến module đó và route của nó cũng không tồn tại.
3. Shared module: exports và imports.
Trong NestJS, mọi module đều có thể là shared module: provider được export ra sẽ dùng chung được ở các module import nó. Để thấy rõ cơ chế đóng gói, mình làm một ví dụ thử (sẽ xoá ở cuối bài).
VD: Tạo CommonModule chứa SlugService chuyển tên thành slug, rồi dùng nó trong TasksModule. Chạy nest g module common (lệnh này cũng thêm CommonModule vào AppModule) và tạo thêm file service:
- src/common/slug.service.ts
import { Injectable } from '@nestjs/common';
@Injectable()
export class SlugService {
toSlug(text: string): string {
return text.trim().toLowerCase().replace(/\s+/g, '-');
}
}
- src/common/common.module.ts
import { Module } from '@nestjs/common';
import { SlugService } from './slug.service.js';
@Module({
providers: [SlugService],
})
export class CommonModule {}
TasksModule import CommonModule và nhận SlugService qua constructor (class module cũng được NestJS inject provider như controller hay service, chi tiết về inject mình sẽ nói ở Bài 6):
- src/tasks/tasks.module.ts
import { Module } from '@nestjs/common';
import { CommonModule } from '../common/common.module.js';
import { SlugService } from '../common/slug.service.js';
@Module({
imports: [CommonModule],
})
export class TasksModule {
constructor(slugService: SlugService) {
console.log(slugService.toSlug('TaskFlow API'));
}
}
Chạy npm run start, ứng dụng không khởi động được:
[Nest] 34 - 11/15/2026, 5:38:38 AM ERROR [ExceptionHandler] UnknownDependenciesException [Error]: Nest can't resolve dependencies of the TasksModule (?). Please make sure that the argument SlugService at index [0] is available in the TasksModule module.
Dù đã import CommonModule, TasksModule vẫn không thấy SlugService vì service này chưa được export. Các bạn thêm exports:
- src/common/common.module.ts
import { Module } from '@nestjs/common';
import { SlugService } from './slug.service.js';
@Module({
providers: [SlugService],
exports: [SlugService],
})
export class CommonModule {}
Chạy lại, log in ra taskflow-api và ứng dụng khởi động bình thường.
Module trong NestJS là singleton: mọi module import CommonModule đều dùng chung một instance của SlugService. Nếu mỗi module tự khai báo SlugService trong providers thì mỗi module có một instance riêng, tốn bộ nhớ và dễ sai khi service giữ dữ liệu. Module cũng có thể export lại module mà nó import (re-export): imports: [CommonModule], exports: [CommonModule].
4. Global module.
Với những thứ cần ở khắp nơi (helper, kết nối database...), import đi import lại ở mọi module khá mệt. Lúc này các bạn có thể biến module thành global module bằng decorator @Global():
- src/common/common.module.ts
import { Global, Module } from '@nestjs/common';
import { SlugService } from './slug.service.js';
@Global()
@Module({
providers: [SlugService],
exports: [SlugService],
})
export class CommonModule {}
Global module chỉ cần đăng ký một lần, thường là ở module gốc (AppModule đã import CommonModule ở phần 3). Provider nó export dùng được ở mọi module mà không cần import, nên TasksModule bỏ được imports:
- src/tasks/tasks.module.ts
import { Module } from '@nestjs/common';
import { SlugService } from '../common/slug.service.js';
@Module({})
export class TasksModule {
constructor(slugService: SlugService) {
console.log(slugService.toSlug('TaskFlow API'));
}
}
Lưu ý: Đừng biến mọi module thành global. Danh sách imports cho biết rõ module nào phụ thuộc vào module nào; global quá nhiều thì mất đi điều đó. Chỉ nên dùng cho những thứ thật sự dùng chung như config (Bài 14) hay database (Bài 15).
5. Dynamic module.
Các module ở trên là module tĩnh: cấu hình viết cố định trong @Module(). Dynamic module là module được tạo lúc chạy, nhận cấu hình từ module import nó. Cách làm là viết một method static (theo quy ước tên là forRoot(), register() hoặc forFeature()) trả về object kiểu DynamicModule.
VD: Cho CommonModule tự chọn có global hay không qua forRoot().
- src/common/common.module.ts
import { DynamicModule, Module } from '@nestjs/common';
import { SlugService } from './slug.service.js';
@Module({
providers: [SlugService],
exports: [SlugService],
})
export class CommonModule {
static forRoot(options: { isGlobal?: boolean } = {}): DynamicModule {
return {
module: CommonModule,
global: options.isGlobal ?? false,
};
}
}
Trong đó:
modulelà class module, bắt buộc phải có.global: truecó tác dụng giống@Global().- Object trả về còn có thể có
providers,imports,exports... Chúng được cộng thêm vào cấu hình trong@Module()chứ không thay thế.
Trong src/app.module.ts, các bạn đổi CommonModule trong mảng imports thành CommonModule.forRoot({ isGlobal: true }). Chạy lại, TasksModule vẫn nhận được SlugService mà không cần import.
Ở phạm vi bài này các bạn chỉ cần hiểu khái niệm, vì phần lớn thời gian chúng ta sẽ dùng dynamic module do package có sẵn cung cấp, VD ConfigModule.forRoot({ isGlobal: true }) ở Bài 14. Muốn tìm hiểu thêm, các bạn xem tại đây.
Lưu ý: CommonModule chỉ để thử. Các bạn xoá thư mục src/common, trả src/tasks/tasks.module.ts và src/app.module.ts về như ở phần 2 để project giống với bài sau.
6. Lời kết.
Như vậy mình đã giới thiệu với mọi người về module trong NestJS: các thuộc tính của @Module(), feature module, shared module với exports, global module và khái niệm dynamic module. TaskFlow API giờ đã có ProjectsModule và TasksModule. Bài sau mình sẽ giới thiệu về controller và route trong NestJS, và viết ProjectsController đầu tiên.
Đăng ký nhận tin.
Chúng tôi chỉ gửi tối đa 2 lần trên 1 tháng. Tuyên bố không spam mail!





0 Comments