♻️ refactor: response DTO 사용하도록 변경

Author: Jo-Minseok

server/src/activity/service/activity.service.ts

@@ -1,26 +1,23 @@
-import { Injectable, NotFoundException } from '@nestjs/common';
+import { Injectable } from '@nestjs/common';
 import { ActivityRepository } from '../repository/activity.repository';
-import { UserRepository } from '../../user/repository/user.repository';
 import {
   ActivityReadResponseDto,
   DailyActivityDto,
 } from '../dto/response/activity-read.dto';
+import { UserService } from '../../user/service/user.service';
 
 @Injectable()
 export class ActivityService {
   constructor(
     private readonly activityRepository: ActivityRepository,
-    private readonly userRepository: UserRepository,
+    private readonly userService: UserService,
   ) {}
 
   async readActivities(
     userId: number,
     year: number,
   ): Promise<ActivityReadResponseDto> {
-    const user = await this.userRepository.findOneBy({ id: userId });
-    if (!user) {
-      throw new NotFoundException('존재하지 않는 사용자입니다.');
-    }
+    const user = await this.userService.getUser(userId);
 
     const activities =
       await this.activityRepository.findActivitiesByUserIdAndYear(userId, year);
@@ -33,12 +30,7 @@ export class ActivityService {
         }),
     );
 
-    return new ActivityReadResponseDto({
-      dailyActivities,
-      maxStreak: user.maxStreak,
-      currentStreak: user.currentStreak,
-      totalViews: user.totalViews,
-    });
+    return ActivityReadResponseDto.toResponseDto(dailyActivities, user);
   }
 
   async upsertActivity(userId: number) {

server/src/comment/service/comment.service.ts

@@ -6,18 +6,21 @@ import {
 import { CommentRepository } from '../repository/comment.repository';
 import { CreateCommentRequestDto } from '../dto/request/create-comment.dto';
 import { FeedRepository } from '../../feed/repository/feed.repository';
-import { UserRepository } from '../../user/repository/user.repository';
 import { Payload } from '../../common/guard/jwt.guard';
 import { DeleteCommentRequestDto } from '../dto/request/delete-comment.dto';
 import { UpdateCommentRequestDto } from '../dto/request/update-comment.dto';
 import { GetCommentRequestDto } from '../dto/request/get-comment.dto';
+import { GetCommentResponseDto } from '../dto/response/get-comment.dto';
+import { FeedService } from '../../feed/service/feed.service';
+import { UserService } from '../../user/service/user.service';
 
 @Injectable()
 export class CommentService {
   constructor(
     private readonly commentRepository: CommentRepository,
     private readonly feedRepository: FeedRepository,
-    private readonly userRepository: UserRepository,
+    private readonly userService: UserService,
+    private readonly feedService: FeedService,
   ) {}
 
   private async commentCheck(userInformation: Payload, commentId: number) {
@@ -38,41 +41,17 @@ export class CommentService {
   }
 
   async get(commentDto: GetCommentRequestDto) {
-    const feed = await this.feedRepository.findOneBy({
-      id: commentDto.feedId,
-    });
-
-    if (!feed) {
-      throw new NotFoundException('게시글을 찾을 수 없습니다.');
-    }
+    await this.feedService.getFeed(commentDto.feedId);
 
     const comments = await this.commentRepository.getCommentInformation(
       commentDto.feedId,
     );
-    return comments.map((row) => ({
-      id: row.id,
-      comment: row.comment,
-      date: row.date,
-      user: {
-        id: row.user.id,
-        userName: row.user.userName,
-        profileImage: row.user.profileImage,
-      },
-    }));
+    return GetCommentResponseDto.toResponseDtoArray(comments);
   }
 
   async create(userInformation: Payload, commentDto: CreateCommentRequestDto) {
-    const feed = await this.feedRepository.findOneBy({ id: commentDto.feedId });
-    if (!feed) {
-      throw new NotFoundException('존재하지 않는 게시글입니다.');
-    }
-
-    const user = await this.userRepository.findOneBy({
-      id: userInformation.id,
-    });
-    if (!user) {
-      throw new NotFoundException('존재하지 않는 유저입니다.');
-    }
+    const feed = await this.feedService.getFeed(commentDto.feedId);
+    const user = await this.userService.getUser(userInformation.id);
 
     await this.commentRepository.save({
       comment: commentDto.comment,

server/src/feed/service/feed.service.ts

@@ -42,6 +42,24 @@ export class FeedService {
     private readonly redisService: RedisService,
   ) {}
 
+  async getFeed(feedId: number) {
+    const feed = await this.feedRepository.findOneBy({ id: feedId });
+    if (!feed) {
+      throw new NotFoundException('존재하지 않는 게시글입니다.');
+    }
+
+    return feed;
+  }
+
+  async getFeedByView(feedId: number) {
+    const feed = await this.feedViewRepository.findOneBy({ feedId });
+    if (!feed) {
+      throw new NotFoundException('존재하지 않는 게시글입니다.');
+    }
+
+    return feed;
+  }
+
   async readFeedPagination(feedPaginationQueryDto: FeedPaginationRequestDto) {
     const feedList = await this.feedViewRepository.findFeedPagination(
       feedPaginationQueryDto,
@@ -103,10 +121,6 @@ export class FeedService {
     const { find, page, limit, type } = searchFeedQueryDto;
     const offset = (page - 1) * limit;
 
-    if (!this.validateSearchType(type)) {
-      throw new BadRequestException('검색 타입이 잘못되었습니다.');
-    }
-
     const [searchResult, totalCount] = await this.feedRepository.searchFeedList(
       find,
       limit,
@@ -125,16 +139,6 @@ export class FeedService {
     );
   }
 
-  private validateSearchType(type: string) {
-    const searchType = {
-      title: 'title',
-      blogName: 'blogName',
-      all: 'all',
-    };
-
-    return searchType.hasOwnProperty(type);
-  }
-
   async updateFeedViewCount(
     viewUpdateParamDto: FeedViewUpdateRequestDto,
     request: Request,
@@ -144,18 +148,12 @@ export class FeedService {
     const ip = this.getIp(request);
     const feedId = viewUpdateParamDto.feedId;
     if (ip && this.isString(ip)) {
-      const [feed, hasCookie, hasIpFlag] = await Promise.all([
-        this.feedRepository.findOne({
-          where: { id: feedId },
-        }),
+      const [_, hasCookie, hasIpFlag] = await Promise.all([
+        this.getFeed(feedId),
         Boolean(cookie?.includes(`View_count_${feedId}=${feedId}`)),
         this.redisService.sismember(`feed:${feedId}:ip`, ip),
       ]);
 
-      if (!feed) {
-        throw new NotFoundException(`${feedId}번 피드를 찾을 수 없습니다.`);
-      }
-
       if (!hasCookie) {
         this.createCookie(response, feedId);
       }
@@ -241,28 +239,12 @@ export class FeedService {
   }
 
   async readFeedDetail(feedDetailRequestDto: FeedDetailRequestDto) {
-    const feed = await this.feedViewRepository.findOneBy({
-      feedId: feedDetailRequestDto.feedId,
-    });
-    if (!feed) {
-      throw new NotFoundException(
-        `${feedDetailRequestDto.feedId}번 피드는 존재하지 않습니다.`,
-      );
-    }
-
+    const feed = await this.getFeedByView(feedDetailRequestDto.feedId);
     return FeedDetailResponseDto.toResponseDto(feed);
   }
 
   async deleteCheckFeed(feedDeleteCheckDto: FeedDeleteCheckDto) {
-    const feed = await this.feedRepository.findOneBy({
-      id: feedDeleteCheckDto.feedId,
-    });
-    if (!feed) {
-      throw new NotFoundException(
-        `${feedDeleteCheckDto.feedId}번 피드는 존재하지 않습니다.`,
-      );
-    }
-
+    const feed = await this.getFeed(feedDeleteCheckDto.feedId);
     const response = await fetch(feed.path);
 
     if (response.status === HttpStatus.NOT_FOUND) {

server/src/like/service/like.service.ts

@@ -7,26 +7,20 @@ import {
 } from '@nestjs/common';
 import { LikeRepository } from '../repository/like.repository';
 import { Payload } from '../../common/guard/jwt.guard';
-import { FeedRepository } from '../../feed/repository/feed.repository';
 import { FeedLikeRequestDto } from '../dto/request/like.dto';
+import { GetLikeResponseDto } from '../dto/response/like.dto';
+import { FeedService } from '../../feed/service/feed.service';
 
 @Injectable()
 export class LikeService {
   constructor(
     private readonly likeRepository: LikeRepository,
-    private readonly feedRepository: FeedRepository,
+    private readonly feedService: FeedService,
     private readonly dataSource: DataSource,
   ) {}
 
   async get(userInformation: Payload, feedLikeGetDto: FeedLikeRequestDto) {
-    const feed = await this.feedRepository.findOneBy({
-      id: feedLikeGetDto.feedId,
-    });
-
-    if (!feed) {
-      throw new NotFoundException('해당 피드를 찾을 수 없습니다.');
-    }
-
+    await this.feedService.getFeed(feedLikeGetDto.feedId);
     let isLike = false;
 
     if (userInformation) {
@@ -37,9 +31,7 @@ export class LikeService {
       isLike = !!like;
     }
 
-    return {
-      isLike,
-    };
+    return GetLikeResponseDto.toResponseDto(isLike);
   }
 
   async create(
@@ -51,13 +43,7 @@ export class LikeService {
     await queryRunner.startTransaction();
 
     try {
-      const feed = await this.feedRepository.findOneBy({
-        id: feedLikeCreateDto.feedId,
-      });
-      if (!feed) {
-        throw new NotFoundException('해당 피드를 찾을 수 없습니다.');
-      }
-
+      const feed = await this.feedService.getFeed(feedLikeCreateDto.feedId);
       const existing = await this.likeRepository.findOneBy({
         user: { id: userInformation.id },
         feed: { id: feedLikeCreateDto.feedId },
@@ -91,13 +77,7 @@ export class LikeService {
     await queryRunner.startTransaction();
 
     try {
-      const feed = await this.feedRepository.findOneBy({
-        id: feedLikeDeleteDto.feedId,
-      });
-      if (!feed) {
-        throw new NotFoundException('해당 피드를 찾을 수 없습니다.');
-      }
-
+      const feed = await this.feedService.getFeed(feedLikeDeleteDto.feedId);
       const existing = await this.likeRepository.findOneBy({
         user: { id: userInformation.id },
         feed: { id: feedLikeDeleteDto.feedId },

server/src/user/service/user.service.ts

@@ -18,6 +18,7 @@ import { ConfigService } from '@nestjs/config';
 import { cookieConfig } from '../../common/cookie/cookie.config';
 import { Payload } from '../../common/guard/jwt.guard';
 import { UpdateUserDto } from '../dto/request/update-user.dto';
+import { CheckEmailDuplicationResponseDto } from '../dto/response/checkEmailDuplication.dto';
 
 @Injectable()
 export class UserService {
@@ -29,12 +30,22 @@ export class UserService {
     private readonly configService: ConfigService,
   ) {}
 
-  async checkEmailDuplication(email: string): Promise<boolean> {
+  async getUser(userId: number) {
+    const user = await this.userRepository.findOneBy({
+      id: userId,
+    });
+    if (!user) {
+      throw new NotFoundException('존재하지 않는 유저입니다.');
+    }
+    return user;
+  }
+
+  async checkEmailDuplication(email: string) {
     const user = await this.userRepository.findOne({
       where: { email },
     });
 
-    return !!user;
+    return CheckEmailDuplicationResponseDto.toResponseDto(!!user);
   }
 
   async registerUser(registerDto: RegisterDto): Promise<void> {
@@ -121,10 +132,7 @@ export class UserService {
   }
 
   async updateUserActivity(userId: number) {
-    const user = await this.userRepository.findOneBy({ id: userId });
-    if (!user) {
-      throw new NotFoundException(`존재하지 않는 사용자 입니다.`);
-    }
+    const user = await this.getUser(userId);
 
     const today = new Date();
     today.setHours(0, 0, 0, 0);
@@ -158,20 +166,15 @@ export class UserService {
     userId: number,
     updateData: Partial<UpdateUserDto>,
   ): Promise<void> {
-    const user = await this.userRepository.findOneBy({ id: userId });
-    if (!user) {
-      throw new NotFoundException('존재하지 않는 사용자입니다.');
-    }
-
-    if (updateData.userName !== undefined) {
-      user.userName = updateData.userName;
-    }
-    if (updateData.profileImage !== undefined) {
-      user.profileImage = updateData.profileImage;
-    }
-    if (updateData.introduction !== undefined) {
-      user.introduction = updateData.introduction;
-    }
+    const user = await this.getUser(userId);
+
+    user.userName = updateData.userName ? updateData.userName : user.userName;
+    user.profileImage = updateData.profileImage
+      ? updateData.profileImage
+      : user.profileImage;
+    user.introduction = updateData.introduction
+      ? updateData.introduction
+      : user.introduction;
 
     await this.userRepository.save(user);
   }