♻️ refactor: 예약 오픈 스케줄링 방식 개선

- 기존의 방식은 매 시 정각에만 예약이 오픈될 수 있었음.
- 부팅 시 및 매 정각마다 스케줄에 등록하고, 비동기로 스케줄을 수행해 유연성을 확보함.

Issue Resolved: #

Author: kyu4583

back/package-lock.json

@@ -38,6 +38,7 @@
     "class-validator": "^0.14.1",
     "connect-redis": "^7.1.1",
     "cookie-parser": "^1.4.7",
+    "cron": "^3.1.7",
     "dotenv": "^16.4.5",
     "express-session": "^1.18.1",
     "ioredis": "^5.4.1",

back/package.json

@@ -0,0 +1 @@
+export const ONE_MINUTE_BEFORE_THE_HOUR = '0 59 * * * *';

back/src/domains/booking/const/cronExpressions.const.ts

@@ -193,6 +193,6 @@ export class BookingController {
   @ApiOkResponse({ description: '확인 및 오픈 완료' })
   @ApiUnauthorizedResponse({ description: '인증 실패' })
   async reloadOpenTarget() {
-    await this.openBookingService.checkAndOpenReservations();
+    await this.openBookingService.scheduleUpcomingReservations();
   }
 }

back/src/domains/booking/controller/booking.controller.ts

@@ -1,11 +1,13 @@
 import { RedisService } from '@liaoliaots/nestjs-redis';
 import { Injectable, OnApplicationBootstrap } from '@nestjs/common';
-import { Cron, CronExpression } from '@nestjs/schedule';
+import { Cron, SchedulerRegistry } from '@nestjs/schedule';
+import { CronJob } from 'cron';
 import Redis from 'ioredis';
 
 import { Event } from '../../event/entity/event.entity';
 import { EventRepository } from '../../event/repository/event.reposiotry';
 import { SectionRepository } from '../../place/repository/section.repository';
+import { ONE_MINUTE_BEFORE_THE_HOUR } from '../const/cronExpressions.const';
 import { IN_BOOKING_DEFAULT_MAX_SIZE } from '../const/inBookingDefaultMaxSize.const';
 
 import { BookingSeatsService } from './booking-seats.service';
@@ -23,24 +25,47 @@ export class OpenBookingService implements OnApplicationBootstrap {
     private inBookingService: InBookingService,
     private seatsUpdateService: BookingSeatsService,
     private enterBookingService: EnterBookingService,
+    private schedulerRegistry: SchedulerRegistry,
   ) {
     this.redis = this.redisService.getOrThrow();
   }
 
   async onApplicationBootstrap() {
     await this.inBookingService.setInBookingSessionsDefaultMaxSize(IN_BOOKING_DEFAULT_MAX_SIZE);
-    await this.checkAndOpenReservations();
+    await this.scheduleUpcomingReservations();
   }
 
-  @Cron(CronExpression.EVERY_HOUR)
-  async checkAndOpenReservations() {
-    const events = await this.eventRepository.selectEvents();
+  @Cron(ONE_MINUTE_BEFORE_THE_HOUR)
+  async scheduleUpcomingReservations() {
+    const comingEvents = await this.eventRepository.selectUpcomingEvents();
     const openedEventIds = new Set(await this.getOpenedEventIds());
-    const eventsToOpen = events.filter((event) => {
-      const now = new Date();
-      return event.reservationOpenDate <= now && !openedEventIds.has(event.id);
+    const now = new Date();
+    const eventToOpen = comingEvents.filter((event) => event.reservationOpenDate <= now);
+    const eventsToSchedule = comingEvents.filter(
+      (event) => !openedEventIds.has(event.id) && event.reservationOpenDate > now,
+    );
+
+    for (const event of eventToOpen) {
+      await this.openReservation(event);
+    }
+    for (const event of eventsToSchedule) {
+      this.scheduleReservationOpen(event);
+    }
+  }
+
+  private scheduleReservationOpen(event: Event) {
+    const jobName = `reservation-open-${event.id}`;
+
+    if (this.schedulerRegistry.doesExist('cron', jobName)) {
+      this.schedulerRegistry.deleteCronJob(jobName);
+    }
+
+    const job = new CronJob(event.reservationOpenDate, async () => {
+      await this.openReservationById(event.id);
     });
-    await Promise.all(eventsToOpen.map((event) => this.openReservation(event)));
+
+    this.schedulerRegistry.addCronJob(jobName, job);
+    job.start();
   }
 
   async isEventOpened(eventId: number) {
@@ -53,7 +78,14 @@ export class OpenBookingService implements OnApplicationBootstrap {
     return eventIds;
   }
 
+  private async openReservationById(eventId: number) {
+    const event = await this.eventRepository.selectEvent(eventId);
+    await this.openReservation(event);
+  }
+
   private async openReservation(event: Event) {
+    this.validateOpeningEvent(event);
+
     const eventId = event.id;
     const place = await event.place;
     const sections = await Promise.all(
@@ -71,6 +103,25 @@ export class OpenBookingService implements OnApplicationBootstrap {
     await this.registerOpenedEvent(eventId);
   }
 
+  private validateOpeningEvent(event: Event) {
+    if (!event) {
+      return false;
+    }
+
+    const openTime = event.reservationOpenDate;
+    if (openTime > new Date()) {
+      const jobName = `reservation-open-${event.id}`;
+      const job = new CronJob(openTime, async () => {
+        await this.openReservationById(event.id);
+      });
+      this.schedulerRegistry.addCronJob(jobName, job);
+      job.start();
+      return false;
+    }
+
+    return true;
+  }
+
   private async registerOpenedEvent(eventId: number) {
     await this.redis.set(`open-booking:${eventId}:opened`, 'true');
   }

back/src/domains/booking/service/open-booking.service.ts

@@ -1,6 +1,6 @@
 import { ConflictException, Injectable } from '@nestjs/common';
 import { InjectRepository } from '@nestjs/typeorm';
-import { Repository } from 'typeorm';
+import { MoreThan, Repository } from 'typeorm';
 
 import { Event } from '../entity/event.entity';
 
@@ -30,6 +30,20 @@ export class EventRepository {
     });
   }
 
+  async selectUpcomingEvents(): Promise<Event[]> {
+    const now = new Date();
+
+    return await this.EventRepository.find({
+      where: {
+        reservationCloseDate: MoreThan(now),
+      },
+      relations: ['place'],
+      order: {
+        reservationOpenDate: 'ASC',
+      },
+    });
+  }
+
   async storeEvent(data: any) {
     const event = this.EventRepository.create(data);
     return await this.EventRepository.save(event);