장소 저장할 때 ES에도 저장

backend/package.json

@@ -23,6 +23,7 @@
     "@nestjs/platform-express": "^10.0.0",
     "@nestjs/typeorm": "^10.0.0",
     "@nestjs/throttler": "^6.2.1",
+    "@nestjs/schedule": "^4.1.1",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
     "google-auth-library": "^9.14.2",
@@ -34,6 +35,7 @@
     "pino-socket": "^7.4.0",
     "rxjs": "^7.8.1",
     "typeorm": "^0.3.20",
+    "typeorm-transactional": "^0.5.0",
     "@nestjs/elasticsearch": "^10.0.2",
     "@elastic/elasticsearch": "^8.16.0"
   },

backend/src/admin/admin.module.ts

@@ -22,5 +22,7 @@ import { AuthModule } from '@src/auth/auth.module';
       },
     ]),
   ],
+  providers: [AdminGuard],
+  exports: [AdminGuard],
 })
 export class AdminModule {}

backend/src/admin/guard/AdminGuard.ts

@@ -11,14 +11,17 @@ export class AdminGuard extends JwtAuthGuard {
     if (!isAuthenticated) {
       return false;
     }
-
-    const request = context.switchToHttp().getRequest();
-    const user = request.user;
-
-    if (!user || user.role !== UserRole.ADMIN) {
+    if (!this.isAdmin(context)) {
       throw new AuthorizationException('관리자 권한이 없습니다.');
     }
 
     return true;
   }
+
+  isAdmin(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const user = request.user;
+
+    return user?.role === UserRole.ADMIN;
+  }
 }

backend/src/app.module.ts

@@ -18,20 +18,30 @@ import { StorageModule } from './storage/storage.module';
 import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
 import { CustomLoggerModule } from './common/log/CustomLoggerModule';
 import { SearchModule } from './search/search.module';
+import { addTransactionalDataSource } from 'typeorm-transactional';
+import { DataSource } from 'typeorm';
+import { BatchModule } from './batch/batch.module';
+import { ScheduleModule } from '@nestjs/schedule';
 
 @Module({
   imports: [
     ConfigModule.forRoot({ isGlobal: true }),
     CustomLoggerModule,
     TypeOrmModule.forRootAsync({
       useClass: TypeOrmConfigService,
+      async dataSourceFactory(options) {
+        const dataSource = new DataSource(options);
+        await dataSource.initialize();
+        return addTransactionalDataSource(dataSource);
+      },
     }),
     ThrottlerModule.forRoot([
       {
         ttl: 60000,
         limit: 500,
       },
     ]),
+    ScheduleModule.forRoot(),
     AuthModule,
     UserModule,
     PlaceModule,
@@ -41,6 +51,7 @@ import { SearchModule } from './search/search.module';
     AdminModule,
     StorageModule,
     SearchModule,
+    BatchModule,
   ],
   controllers: [AppController],
   providers: [

backend/src/batch/batch.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { BatchService } from '@src/batch/batch.service';
+import { PinoLogger } from 'nestjs-pino';
+import { PlaceRepository } from '@src/place/place.repository';
+import { SearchModule } from '@src/search/search.module';
+
+@Module({
+  imports: [SearchModule],
+  providers: [BatchService, PlaceRepository, PinoLogger],
+})
+export class BatchModule {}

backend/src/batch/batch.service.ts

@@ -0,0 +1,31 @@
+import { Injectable } from '@nestjs/common';
+import { PinoLogger } from 'nestjs-pino';
+import { Cron, CronExpression } from '@nestjs/schedule';
+import { PlaceRepository } from '@src/place/place.repository';
+import { SearchService } from '@src/search/search.service';
+
+@Injectable()
+export class BatchService {
+  constructor(
+    private readonly searchService: SearchService,
+    private readonly placeRepository: PlaceRepository,
+    private readonly logger: PinoLogger,
+  ) {}
+
+  @Cron(CronExpression.EVERY_HOUR)
+  async syncPlacesToElastic() {
+    this.logger.debug(`syncPlacesToElastic() 배치 시작`);
+    try {
+      this.logger.debug(`동기화 작업을 시작합니다.`);
+      const places = await this.placeRepository.findUpdatedPlacesForTwoHours();
+      this.logger.debug(`동기화 할 장소의 갯수: ${places.length}`);
+
+      await this.searchService.syncPlaceToElasticSearch(places);
+      this.logger.debug(`동기화 작업이 완료되었습니다.`);
+    } catch (error) {
+      this.logger.error(`동기화 작업 중 에러가 발생했습니다: ${error}`);
+    } finally {
+      this.logger.debug(`syncPlacesToElastic() 배치 종료`);
+    }
+  }
+}

backend/src/course/course.module.ts

@@ -6,10 +6,24 @@ import { CourseRepository } from './course.repository';
 import { PlaceModule } from '../place/place.module';
 import { TypeOrmModule } from '@nestjs/typeorm';
 import { CoursePlace } from '@src/course/entity/course-place.entity';
+import { AdminGuard } from '@src/admin/guard/AdminGuard';
+import { CoursePermissionGuard } from '@src/course/guards/CoursePermissionGuard';
+import { AdminModule } from '@src/admin/admin.module';
 
 @Module({
-  imports: [UserModule, PlaceModule, TypeOrmModule.forFeature([CoursePlace])],
+  imports: [
+    UserModule,
+    PlaceModule,
+    AdminModule,
+    TypeOrmModule.forFeature([CoursePlace]),
+  ],
   controllers: [CourseController],
-  providers: [CourseService, CourseRepository],
+  providers: [
+    CourseService,
+    CourseRepository,
+    CoursePermissionGuard,
+    AdminGuard,
+  ],
+  exports: [CoursePermissionGuard],
 })
 export class CourseModule {}

backend/src/course/guards/CoursePermissionGuard.ts

@@ -1,18 +1,26 @@
 import { CanActivate, ExecutionContext, Injectable } from '@nestjs/common';
 import { CourseService } from '../course.service';
 import { CoursePermissionException } from '../exception/CoursePermissionException';
+import { AdminGuard } from '@src/admin/guard/AdminGuard';
 
 @Injectable()
 export class CoursePermissionGuard implements CanActivate {
-  constructor(private readonly courseService: CourseService) {}
+  constructor(
+    private readonly adminGuard: AdminGuard,
+    private readonly courseService: CourseService,
+  ) {}
 
   async canActivate(context: ExecutionContext): Promise<boolean> {
+    const isAdmin = this.adminGuard.isAdmin(context);
+    if (isAdmin) {
+      return true;
+    }
+
     const request = context.switchToHttp().getRequest();
     const courseId = Number(request.params.id);
     const userId = Number(request.user.userId);
-
-    const course = await this.courseService.getCourseOwnerId(courseId);
-    if (course !== userId) {
+    const courseOwnerId = await this.courseService.getCourseOwnerId(courseId);
+    if (courseOwnerId !== userId) {
       throw new CoursePermissionException(courseId);
     }
     return true;

backend/src/main.ts

@@ -8,13 +8,16 @@
   HttpExceptionFilter,
   BaseExceptionFilter,
 } from './common/exception/filter/GlobalExceptionFilter';
+import { initializeTransactionalContext } from 'typeorm-transactional';
 
 process.env.NODE_ENV =
   process.env.NODE_ENV && process.env.NODE_ENV.trim().toLowerCase() === 'prod'
     ? 'prod'
     : 'develop';
 
 async function bootstrap() {
+  initializeTransactionalContext();
+
   const app = await NestFactory.create(AppModule, { bufferLogs: true });
   const logger = app.get(Logger);
 
@@ -30,12 +33,12 @@
 
   process.on('unhandledRejection', (reason, promise) => {
     // 버그 원인 파악시까지 컨테이너 로그에도 남기기 위해 console.error 사용
     console.error('Unhandled Rejection at:', { promise, reason });
     logger.error('Unhandled Rejection at:', { promise, reason });
   });
 
   process.on('uncaughtException', (err) => {
     console.error('Uncaught Exception:', err);
     logger.error('Uncaught Exception:', err);
   });
 

backend/src/place/place.module.ts

@@ -1,13 +1,16 @@
-import { Module } from '@nestjs/common';
+import { forwardRef, Module } from '@nestjs/common';
 import { PlaceController } from './place.controller';
 import { PlaceService } from './place.service';
 import { PlaceRepository } from './place.repository';
 import { ConfigModule } from '@nestjs/config';
+import { SearchModule } from '@src/search/search.module';
+import { SearchService } from '@src/search/search.service';
+import { PinoLogger } from 'nestjs-pino';
 
 @Module({
-  imports: [ConfigModule],
+  imports: [ConfigModule, forwardRef(() => SearchModule)],
   controllers: [PlaceController],
-  providers: [PlaceService, PlaceRepository],
+  providers: [PlaceService, PlaceRepository, SearchService, PinoLogger],
   exports: [PlaceRepository],
 })
 export class PlaceModule {}

backend/src/place/place.repository.ts

@@ -1,5 +1,5 @@
 import { Injectable, BadRequestException } from '@nestjs/common';
-import { DataSource, ILike } from 'typeorm';
+import { DataSource, ILike, MoreThan } from 'typeorm';
 import { Place } from './entity/place.entity';
 import { SoftDeleteRepository } from '../common/SoftDeleteRepository';
 
@@ -39,6 +39,19 @@ export class PlaceRepository extends SoftDeleteRepository<Place, number> {
     });
   }
 
+  public async findUpdatedPlacesForTwoHours(): Promise<Place[]> {
+    const twoHoursAgo = new Date();
+    twoHoursAgo.setHours(twoHoursAgo.getHours() - 2);
+
+    return this.find({
+      where: [
+        { createdAt: MoreThan(twoHoursAgo) },
+        { updatedAt: MoreThan(twoHoursAgo) },
+        { deletedAt: MoreThan(twoHoursAgo) },
+      ],
+    });
+  }
+
   private validatePageAndPageSize(page: number, pageSize: number) {
     if (page <= 0) {
       throw new BadRequestException('페이지는 1 이상이어야 합니다.');

backend/src/place/place.service.ts

@@ -1,10 +1,13 @@
-import { Injectable, BadGatewayException } from '@nestjs/common';
-import { PlaceRepository } from './place.repository';
-import { CreatePlaceRequest } from './dto/CreatePlaceRequest';
-import { PlaceNotFoundException } from './exception/PlaceNotFoundException';
-import { PlaceAlreadyExistsException } from './exception/PlaceAlreadyExistsException';
-import { PlaceSearchResponse } from './dto/PlaceSearchResponse';
+import { BadGatewayException, Injectable } from '@nestjs/common';
+import { PlaceRepository } from '@src/place/place.repository';
+import { CreatePlaceRequest } from '@src/place/dto/CreatePlaceRequest';
+import { PlaceNotFoundException } from '@src/place/exception/PlaceNotFoundException';
+import { PlaceAlreadyExistsException } from '@src/place/exception/PlaceAlreadyExistsException';
+import { PlaceSearchResponse } from '@src/place/dto/PlaceSearchResponse';
 import { ConfigService } from '@nestjs/config';
+import { Transactional } from 'typeorm-transactional';
+import { SearchService } from '@src/search/search.service';
+import { PinoLogger } from 'nestjs-pino';
 
 @Injectable()
 export class PlaceService {
@@ -17,10 +20,13 @@ export class PlaceService {
   constructor(
     private readonly placeRepository: PlaceRepository,
     private readonly configService: ConfigService,
+    private readonly searchService: SearchService,
+    private readonly logger: PinoLogger,
   ) {
     this.GOOGLE_API_KEY = this.configService.get(<string>'GOOGLE_MAPS_API_KEY');
   }
 
+  @Transactional()
   async addPlace(createPlaceRequest: CreatePlaceRequest) {
     const { googlePlaceId } = createPlaceRequest;
     if (await this.placeRepository.findByGooglePlaceId(googlePlaceId)) {
@@ -33,6 +39,11 @@ export class PlaceService {
     );
 
     const savedPlace = await this.placeRepository.save(place);
+    this.searchService.savePlace(place).catch((error) => {
+      this.logger.error(
+        `ElasticSearch에 장소 정보를 저장하는 중 오류가 발생했습니다. ${error}`,
+      );
+    });
     return { id: savedPlace.id };
   }
 
@@ -85,8 +96,8 @@ export class PlaceService {
       name: name,
       rating: rating || null,
       location: {
-        longitude: geometry.location.lng,
-        latitude: geometry.location.lat,
+        longitude: geometry.location.longitude,
+        latitude: geometry.location.latitude,
       },
       formattedAddress: formatted_address || null,
       category: types?.[0] || null,

backend/src/search/dto/ESPlaceSaveDTO.ts

@@ -0,0 +1,43 @@
+import { Place } from '@src/place/entity/place.entity';
+
+export class ESPlaceSaveDTO {
+  constructor(
+    readonly id: number,
+    readonly googlePlaceId: string,
+    readonly name: string,
+    readonly thumbnailUrl: string,
+    readonly rating: number,
+    readonly location: {
+      latitude: number;
+      longitude: number;
+    },
+    readonly formattedAddress: string,
+    readonly category: string,
+    readonly description: string,
+    readonly detailPageUrl: string,
+    readonly createdAt: Date,
+    readonly updatedAt: Date,
+    readonly deletedAt: Date,
+  ) {}
+
+  static from(place: Place) {
+    return new ESPlaceSaveDTO(
+      place.id,
+      place.googlePlaceId,
+      place.name,
+      place.thumbnailUrl,
+      place.rating,
+      {
+        latitude: place.latitude,
+        longitude: place.longitude,
+      },
+      place.formattedAddress,
+      place.category,
+      place.description,
+      place.detailPageUrl,
+      place.createdAt,
+      place.updatedAt,
+      place.deletedAt,
+    );
+  }
+}

backend/src/search/exception/ElasticSearchException.ts

@@ -0,0 +1,15 @@
+import { BaseException } from '@src/common/exception/BaseException';
+import { HttpStatus } from '@nestjs/common';
+
+export class ElasticSearchException extends BaseException {
+  constructor(id?: number) {
+    const message = id
+      ? `id:${id} ElasticSearch에 데이터를 저장하는데 실패했습니다.`
+      : 'ElasticSearch에 데이터를 저장하는데 실패했습니다.';
+    super({
+      code: 1003,
+      message,
+      status: HttpStatus.INTERNAL_SERVER_ERROR,
+    });
+  }
+}