Tiếp tục với series, TaskFlow cần gửi mail nhắc việc mỗi sáng và báo khi task hoàn thành. Bài này mình sẽ giới thiệu với mọi người về Task Scheduling và Event trong NestJS.
1. Task scheduling và event là gì?
Task scheduling là chạy code theo lịch, giống cron của Linux nhưng chạy trong ứng dụng: package @nestjs/schedule (12.0.4).
Event: một phần của ứng dụng báo "việc này vừa xảy ra", các listener tự lắng nghe: package @nestjs/event-emitter (12.0.3).
npm install @nestjs/schedule @nestjs/event-emitter
- src/app.module.ts (đoạn trích trong imports, sau BullModule)
// Chạy các @Cron, @Interval, @Timeout (chỉ gọi forRoot() một lần)
ScheduleModule.forRoot(),
// EventEmitter2 dùng chung (global) và đăng ký các @OnEvent
EventEmitterModule.forRoot(),
2. Lập lịch với @Cron, @Interval và @Timeout.
Các bạn gắn decorator lên method của một provider: @Cron(pattern, { name, timeZone }), @Interval(ms) hoặc @Timeout(ms).
Trong đó:
- Cron pattern:
giây (tuỳ chọn) phút giờ ngày tháng thứ, VD'0 8 * * *'là 8:00 mỗi ngày. Không cótimeZonethì theo giờ server (container thường là UTC). @Interval()lặp lại theo mili giây,@Timeout()chạy một lần sau khi khởi động.- Lỗi trong method chỉ được ghi log (context
Scheduler).
Lưu ý: ScheduleModule.forRoot() gọi ở 3 module thì job chạy 3 lần.
3. Nhắc việc hằng ngày qua queue mail.
Mỗi sáng, ai có task chưa xong sắp hoặc đã quá hạn nhận một mail. Cron chỉ đưa job vào queue mail của Bài 29; MailProcessor lo gửi và thử lại.
- src/tasks/due-soon.ts (điều kiện dùng chung cho cron và processor)
import type { Prisma } from '../generated/prisma/client.js';
// Task chưa xong, hạn trong 24 giờ tới hoặc đã quá hạn
export function dueSoon(now = new Date()): Prisma.TaskWhereInput {
return {
status: { not: 'done' },
dueDate: { lte: new Date(now.getTime() + 24 * 60 * 60 * 1000) },
};
}
Tạo service bằng nest g service tasks/task-reminders --flat --no-spec --format (tự thêm vào providers của TasksModule):
- src/tasks/task-reminders.service.ts (rút gọn phần import)
// import Injectable, Logger, Cron (@nestjs/schedule), NotificationsService,
// PrismaService và dueSoon
@Injectable()
export class TaskRemindersService {
private readonly logger = new Logger(TaskRemindersService.name);
constructor(
private readonly prisma: PrismaService,
private readonly notifications: NotificationsService,
) {}
// 8 giờ sáng mỗi ngày theo giờ Việt Nam
@Cron('0 8 * * *', { name: 'due-reminders', timeZone: 'Asia/Ho_Chi_Minh' })
async sendDueReminders(): Promise<void> {
// Mỗi người được giao có task sắp đến hạn chỉ nhận một mail
const groups = await this.prisma.task.groupBy({
by: ['assigneeId'],
where: { ...dueSoon(), assigneeId: { not: null } },
});
const userIds = groups
.map((group) => group.assigneeId)
.filter((id) => id !== null);
// Ngày theo giờ Việt Nam, dạng 2026-11-15
const day = new Date().toLocaleDateString('en-CA', {
timeZone: 'Asia/Ho_Chi_Minh',
});
await this.notifications.sendDueReminders(userIds, day);
this.logger.log(`Đã lên lịch nhắc việc cho ${userIds.length} người`);
}
}
- src/notifications/notifications.service.ts (method mới; mail-jobs.ts thêm DueReminderJob là { userId: number })
// Gọi từ cron (không nằm trong request) nên await để lỗi được ghi log.
// jobId theo ngày và user: thêm lại cùng jobId thì BullMQ bỏ qua
async sendDueReminders(userIds: number[], day: string): Promise<void> {
await this.mailQueue.addBulk(
userIds.map((userId) => ({
name: 'due-reminder',
data: { userId } satisfies DueReminderJob,
opts: { jobId: `due-reminder-${day}-${userId}` },
})),
);
}
- src/notifications/mail.processor.ts (đoạn trích: method mới; process() thêm case 'due-reminder' gọi this.dueReminder(job.data as DueReminderJob))
private async dueReminder({ userId }: DueReminderJob): Promise<string> {
const user = ...; // user.findUnique theo userId, select name, email
// Đọc lại lúc gửi: task đã xong trong lúc chờ thì không nhắc nữa
const tasks = await this.prisma.task.findMany({
where: { ...dueSoon(), assigneeId: userId },
select: {
title: true,
dueDate: true,
project: { select: { name: true } },
},
orderBy: { dueDate: 'asc' },
});
if (!user || tasks.length === 0) {
return 'skipped';
}
// Gửi như taskAssigned(): data là { name, tasks } với
// tasks: { title, projectName: task.project.name, dueDate }[]
await this.mailer.send(DueReminderMail, { to: ..., data: ... });
return 'sent';
}
- src/notifications/due-reminder.mail.ts: mail class như WelcomeMail của Bài 28 (thêm vào providers của NotificationsModule), nhận { name, tasks }, subject là `Nhắc việc: ${tasks.length} task sắp đến hạn`, template: 'due-reminder'; mỗi task trong context giữ title, projectName và dueDate: task.dueDate?.toLocaleString('vi-VN', { timeZone: 'Asia/Ho_Chi_Minh', day: '2-digit', month: '2-digit', year: 'numeric', hour: '2-digit', minute: '2-digit' }).
- src/notifications/templates/due-reminder.html
<p>Chào {{ name }},</p>
<p>Các task sau sắp đến hạn hoặc đã quá hạn:</p>
<ul>
{{#each tasks}}
<li><strong>{{ title }}</strong> ({{ projectName }}), hạn {{ dueDate }}</li>
{{/each}}
</ul>
Để thử, reset dữ liệu như Bài 29, đăng ký An, giao cho An một task có dueDate trong 24 giờ tới, rồi tạm đổi pattern thành '*/20 * * * * *':
# Log: {"level":"log",...,"context":"TaskRemindersService","message":"Đã lên lịch nhắc việc cho 1 người"}
docker exec taskflow-redis redis-cli hget bull:mail:due-reminder-2026-11-15-2 returnvalue
# "sent"
Mailpit nhận mail "Nhắc việc: 1 task sắp đến hạn"; các lần sau trùng jobId nên không có mail mới. Thử xong trả pattern về '0 8 * * *'.
Lưu ý: Chạy nhiều instance thì instance nào cũng chạy cron; ở đây trùng jobId nên chỉ có một job. Việc khác thì dùng queue.upsertJobScheduler() của BullMQ hoặc chỉ bật cron ở một instance.
4. Event với @OnEvent.
Khi task chuyển sang done, TasksService ghi completedAt rồi phát event task.completed.
- src/tasks/events/task-completed.event.ts
export const TASK_COMPLETED = 'task.completed';
// Dữ liệu đi kèm event: chỉ những gì listener cần
export class TaskCompletedEvent {
constructor(
readonly taskId: number,
readonly title: string,
readonly userId: number, // người đánh dấu hoàn thành
readonly completedAt: Date,
) {}
}
completedAt tính từ status cũ, nên update() đọc task cũ cả khi chỉ gửi status (thiếu thì gửi done hai lần ra hai event):
- src/tasks/tasks.service.ts (đoạn trích; constructor thêm private readonly events: EventEmitter2, import thêm TaskStatus; create() ghi completedAt: new Date() nếu tạo task done)
// Dữ liệu cũ: ..., status để biết task vừa chuyển sang done
const old =
dto.projectId !== undefined ||
dto.assigneeId != null ||
dto.status !== undefined
? await this.findOne(id, userId)
: undefined;
const completedAt = this.completedAt(dto.status, old?.status);
// ... prisma.task.update() thêm completedAt vào data, rồi cuối update():
if (completedAt) {
// Ghi xong mới phát event; TasksService không cần biết ai lắng nghe
this.events.emit(
TASK_COMPLETED,
new TaskCompletedEvent(id, task.title, userId, completedAt),
);
}
// Vừa chuyển sang done: thời điểm hoàn thành; rời done: null; không đổi: undefined
private completedAt(
status: TaskStatus | undefined,
oldStatus: TaskStatus | undefined,
): Date | null | undefined {
if (status === undefined || status === oldStatus) {
return undefined;
}
return status === 'done' ? new Date() : null;
}
- src/activities/task-completed.listener.ts (rút gọn phần import; thêm vào providers của ActivitiesModule; ACTIVITY_ACTIONS thêm 'completed')
// import Injectable, Logger (@nestjs/common), OnEvent (@nestjs/event-emitter),
// TASK_COMPLETED, TaskCompletedEvent và ActivitiesService
@Injectable()
export class TaskCompletedListener {
private readonly logger = new Logger(TaskCompletedListener.name);
constructor(private readonly activities: ActivitiesService) {}
// async: true chạy listener ở lượt sau của event loop, emit() trả về ngay
@OnEvent(TASK_COMPLETED, { async: true })
handle(event: TaskCompletedEvent): void {
this.logger.log(`Task #${event.taskId} đã hoàn thành`);
this.activities.log({
userId: event.userId,
entity: 'task',
entityId: event.taskId,
action: 'completed',
data: { title: event.title, completedAt: event.completedAt },
});
}
}
curl -X PATCH http://localhost:3000/api/v1/tasks/1 -H "$A" \
-H "Content-Type: application/json" -d '{"status":"done"}'
# {"data":{"id":1,...,"status":"done",...,"completedAt":"2026-11-15T12:15:51.781Z",...}}
# Log: {...,"context":"TaskCompletedListener","message":"Task #1 đã hoàn thành"}
Listener ném lỗi thì chỉ có log lỗi context Event (suppressErrors mặc định true), request vẫn 200. Không có async: true, listener chậm thì request chậm theo.
Chú ý: Đừng đặt suppressErrors: false cho listener async: lỗi không còn ai bắt và làm sập cả ứng dụng.
5. Khi nào dùng event, khi nào dùng queue?
- Event nằm trong bộ nhớ của process: nhanh, nhưng process sập là mất, không thử lại. Hợp với việc mất cũng không sao: ghi log, xoá cache.
- Queue lưu job trong Redis: có retry, nhiều instance chia nhau xử lý. Hợp với việc chậm hoặc bắt buộc phải xong: gửi mail, gọi API ngoài.
- Kết hợp: listener nhận event rồi đưa job vào queue.
6. Lời kết.
Như vậy mình đã giới thiệu xong về Task Scheduling và Event trong NestJS: @Cron, nhắc việc qua queue, @OnEvent và cách chọn giữa event với queue. Bài sau mình sẽ giới thiệu về WebSocket trong NestJS để báo realtime khi task đổi trạng thái.
Đă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