[NestJS] 10. 프로젝트 문제 인식과 컨벤션 리팩토링, 트러블 슈팅

import { PrimaryGeneratedColumn, CreateDateColumn, UpdateDateColumn } from 'typeorm'; export abstract class CommonEntity { @PrimaryGeneratedColumn() id: number; @CreateDateColumn({ type: 'timestamp' }) createdAt: Date; @UpdateDateColumn({ type: 'timestamp' }) updatedAt: Date; }

export class ApiResponseDto<T> { success: boolean; statusCode?: number; message?: string; data?: T; error?: string; constructor(success: boolean, statusCode?: number, message?: string, data?: T, error?: string) { this.success = success; this.statusCode = statusCode; this.message = message; this.data = data; this.error = error; } }

import { UserRole } from "src/user/user-role.enum"; import { User } from "src/user/user.entity"; export class UserResponseDto { id: number; username: string; email: string; role: UserRole; createdAt: Date; updatedAt: Date; constructor(user: User){ this.id = user.id; this.username = user.username; this.email = user.email; this.role = user.role; this.createdAt = user.createdAt; this.updatedAt = user.updatedAt; } }

import { Body, Controller, HttpStatus, Logger, Post, Res } from '@nestjs/common'; import { AuthService } from './auth.service'; import { SignInRequestDto } from './dto/sign-in-request.dto'; import { Response } from 'express'; import { ApiResponseDto } from 'src/common/api-response-dto/api-response.dto'; @Controller('api/auth') export class AuthController { private readonly logger = new Logger(AuthController.name); constructor(private authService: AuthService){} // Sign-In @Post('/signin') async signIn(@Body() signInRequestDto: SignInRequestDto, @Res() res:Response): Promise<void> { this.logger.verbose(`User with email: ${signInRequestDto.email} is try to signing in`); const accessToken = await this.authService.signIn(signInRequestDto); this.logger.verbose(`User with email: ${signInRequestDto.email} issued JWT ${accessToken}`); // [2] JWT를 헤더에 저장 후 ApiResponse를 바디에 담아서 전송 res.setHeader('Authorization', accessToken); const response = new ApiResponseDto(true, HttpStatus.OK, 'User logged in successfully', { accessToken }); res.send(response); } }

import { Injectable, Logger, NotFoundException, UnauthorizedException } from '@nestjs/common'; import { User } from '../user/entities/user.entity'; import * as bcrypt from 'bcryptjs' import { SignInRequestDto } from './dto/sign-in-request.dto'; import { JwtService } from '@nestjs/jwt'; import { UserService } from 'src/user/user.service'; @Injectable() export class AuthService { private readonly logger = new Logger(AuthService.name); constructor( private jwtService: JwtService, private userService: UserService, ){} // Sign-In async signIn(signInRequestDto : SignInRequestDto): Promise<string> { this.logger.verbose(`User with email: ${signInRequestDto.email} is signing in`); const { email, password } = signInRequestDto; try{ const existingUser = await this.userService.findUserByEmail(email); if(!existingUser || !(await bcrypt.compare(password, existingUser.password))) { throw new UnauthorizedException('Invalid credentials'); } // [1] JWT 토큰 생성 const payload = { id: existingUser.id, email: existingUser.email, username: existingUser.username, role: existingUser.role }; const accessToken = await this.jwtService.sign(payload); this.logger.verbose(`User with email: ${signInRequestDto.email} issued JWT ${accessToken}`); return accessToken; } catch (error) { this.logger.error(`Invalid credentials or Internal Server error`); throw error; } } }

import { User } from "src/user/user.entity"; import { ArticleStatus } from "../article-status.enum"; import { Article } from "../article.entity"; import { UserResponseDto } from "src/auth/dto/user-response.dto"; export class ArticleResponseDto { id: number; author: string; title: string; contents: string; status: ArticleStatus; createdAt: Date; updatedAt: Date; user: UserResponseDto; constructor(article: Article) { this.id = article.id; this.author = article.author; this.title = article.title; this.contents = article.contents; this.status = article.status; this.createdAt = article.createdAt; this.updatedAt = article.updatedAt; this.user = article.user ? new UserResponseDto(article.user) : null; } }

import { Body, Controller, Delete, Get, HttpStatus, Logger, Param, Patch, Post, Put, Query, UseGuards } from '@nestjs/common'; import { ArticleService } from './article.service'; import { Article } from './entities/article.entity'; import { CreateArticleRequestDto } from './dto/create-article-request.dto'; import { ArticleResponseDto } from './dto/article-response.dto'; import { SearchArticleResponseDto } from './dto/search-article-response.dto'; import { UpdateArticleRequestDto } from './dto/update-article-request.dto'; import { ArticleStatusValidationPipe } from '../common/pipes/article-status-validation.pipe'; import { ArticleStatus } from './entities/article-status.enum'; import { AuthGuard } from '@nestjs/passport'; import { RolesGuard } from 'src/auth/custom-guards-decorators/custom-role.guard'; import { UserRole } from 'src/user/entities/user-role.enum'; import { User } from 'src/user/entities/user.entity'; import { ApiResponseDto } from 'src/common/api-response-dto/api-response.dto'; import { GetUser } from 'src/auth/custom-guards-decorators/get-user.decorator'; import { Roles } from 'src/auth/custom-guards-decorators/roles.decorator'; @Controller('api/articles') @UseGuards(AuthGuard(), RolesGuard) export class ArticleController { private readonly logger = new Logger(ArticleController.name); constructor(private articleService: ArticleService){} // CREATE @Post('/') async createArticle( @Body() createArticleRequestDto: CreateArticleRequestDto, @GetUser() logginedUser: User): Promise<ApiResponseDto<void>> { this.logger.verbose(`User: ${logginedUser.username} is try to creating a new article with title: ${createArticleRequestDto.title}`); await this.articleService.createArticle(createArticleRequestDto, logginedUser) this.logger.verbose(`Article created Successfully`); return new ApiResponseDto(true, HttpStatus.CREATED, 'Article created Successfully'); } // READ - all @Get('/') @Roles(UserRole.USER) async getAllArticles(): Promise<ApiResponseDto<ArticleResponseDto[]>> { this.logger.verbose(`Try to Retrieving all Articles`); const articles: Article[] = await this.articleService.getAllArticles(); const articlesResponseDto = articles.map(article => new ArticleResponseDto(article)); this.logger.verbose(`Retrieved all articles list Successfully`); return new ApiResponseDto(true, HttpStatus.OK, 'Article list retrive Successfully', articlesResponseDto); } // READ - by Loggined User @Get('/myarticles') async getMyAllArticles(@GetUser() logginedUser: User): Promise<ApiResponseDto<ArticleResponseDto[]>> { this.logger.verbose(`Try to Retrieving ${logginedUser.username}'s all Articles`); const articles: Article[] = await this.articleService.getMyAllArticles(logginedUser); const articlesResponseDto = articles.map(article => new ArticleResponseDto(article)); this.logger.verbose(`Retrieved ${logginedUser.username}'s all Articles list Successfully`); return new ApiResponseDto(true, HttpStatus.OK, 'Article list retrive Successfully', articlesResponseDto); } // READ - by id @Get('/:id') async getArticleDetailById(@Param('id') id: number): Promise<ApiResponseDto<ArticleResponseDto>> { this.logger.verbose(`Try to Retrieving a article by id: ${id}`); const articleResponseDto = new ArticleResponseDto(await this.articleService.getArticleDetailById(id)); this.logger.verbose(`Retrieved a article by ${id} details Successfully`); return new ApiResponseDto(true, HttpStatus.OK, 'Article retrive Successfully', articleResponseDto); } // READ - by keyword @Get('/search/:keyword') async getArticlesByKeyword(@Query('author') author: string): Promise<ApiResponseDto<SearchArticleResponseDto[]>> { this.logger.verbose(`Try to Retrieving a article by author: ${author}`); const articles: Article[] = await this.articleService.getArticlesByKeyword(author); const articlesResponseDto = articles.map(article => new SearchArticleResponseDto(article)); this.logger.verbose(`Retrieved articles list by ${author} Successfully`); return new ApiResponseDto(true, HttpStatus.OK, 'Article list retrive Successfully', articlesResponseDto); } // UPDATE - by id @Put('/:id') async updateArticleById( @Param('id') id: number, @Body() updateArticleRequestDto: UpdateArticleRequestDto): Promise<ApiResponseDto<void>> { this.logger.verbose(`Try to Updating a article by id: ${id} with updateArticleRequestDto`); await this.articleService.updateArticleById(id, updateArticleRequestDto) this.logger.verbose(`Updated a article by ${id} Successfully`); return new ApiResponseDto(true, HttpStatus.NO_CONTENT, 'Article update Successfully'); } // UPDATE - status <ADMIN> @Patch('/:id') @Roles(UserRole.ADMIN) async updateArticleStatusById( @Param('id') id: number, @Body('status', ArticleStatusValidationPipe) status: ArticleStatus): Promise<ApiResponseDto<void>> { this.logger.verbose(`ADMIN is trying to Updating a article by id: ${id} with status: ${status}`); await this.articleService.updateArticleStatusById(id, status); this.logger.verbose(`ADMIN Updated a article's by ${id} status to ${status} Successfully`); return new ApiResponseDto(true, HttpStatus.NO_CONTENT, 'Article status changed Successfully'); } // DELETE - by id @Delete('/:id') @Roles(UserRole.USER, UserRole.ADMIN) async deleteArticleById(@Param('id') id: number, @GetUser() logginedUser: User): Promise<ApiResponseDto<void>> { this.logger.verbose(`User: ${logginedUser.username} is trying to Deleting a article by id: ${id}`); await this.articleService.deleteArticleById(id, logginedUser); this.logger.verbose(`Deleted a article by id: ${id} Successfully`); return new ApiResponseDto(true, HttpStatus.NO_CONTENT, 'Article delete Successfully'); } }

import { BadRequestException, Injectable, Logger, NotFoundException, UnauthorizedException } from '@nestjs/common'; import { Article } from './entities/article.entity'; import { ArticleStatus } from './entities/article-status.enum'; import { CreateArticleRequestDto } from './dto/create-article-request.dto'; import { InjectRepository } from '@nestjs/typeorm'; import { Repository } from 'typeorm'; import { UpdateArticleRequestDto } from './dto/update-article-request.dto'; import { User } from 'src/user/entities/user.entity'; @Injectable() export class ArticleService { private readonly logger = new Logger(ArticleService.name); constructor( @InjectRepository(Article) private articleRepository : Repository<Article> ){} // CREATE async createArticle(createArticleRequestDto: CreateArticleRequestDto, logginedUser: User): Promise<void> { this.logger.verbose(`User: ${logginedUser.username} is creating a new article with title: ${createArticleRequestDto.title}`); const { title, contents } = createArticleRequestDto; if (!title || !contents) { throw new BadRequestException('Title, and contents must be provided'); } const newArticle = this.articleRepository.create({ author: logginedUser.username, title, contents, status: ArticleStatus.PUBLIC, user: logginedUser }); await this.articleRepository.save(newArticle); this.logger.verbose(`Article title with ${newArticle.title} created Successfully`); } // READ - all async getAllArticles(): Promise<Article[]> { this.logger.verbose(`Retrieving all Articles`); const foundArticles = await this.articleRepository.find(); this.logger.verbose(`Retrieved all articles list Successfully`); return foundArticles; } // READ - by Loggined User async getMyAllArticles(logginedUser: User): Promise<Article[]> { this.logger.verbose(`Retrieving ${logginedUser.username}'s all Articles`); const foundArticles = await this.articleRepository.createQueryBuilder('article') .leftJoinAndSelect('article.user', 'user') .where('article.userId = :userId', { userId : logginedUser.id }) .getMany(); this.logger.verbose(`Retrieved ${logginedUser.username}'s all Articles list Successfully`); return foundArticles; } // READ - by id async getArticleDetailById(id: number): Promise<Article> { this.logger.verbose(`Retrieving a article by id: ${id}`); const foundArticle = await this.articleRepository.createQueryBuilder('article') .leftJoinAndSelect('article.user', 'user') .where('article.id = :id', { id }) .getOne(); if (!foundArticle) { throw new NotFoundException(`Article with ID ${id} not found`); } this.logger.verbose(`Retrieved a article by ${id} details Successfully`); return foundArticle; } // READ - by keyword async getArticlesByKeyword(author: string): Promise<Article[]> { this.logger.verbose(`Retrieving a article by author: ${author}`); if (!author) { throw new BadRequestException('Author keyword must be provided'); } const foundArticles = await this.articleRepository.findBy({ author: author }) if (foundArticles.length === 0) { throw new NotFoundException(`No articles found for author: ${author}`); } this.logger.verbose(`Retrieved articles list by ${author} Successfully`); return foundArticles; } // UPDATE - by id async updateArticleById(id: number, updateArticleRequestDto: UpdateArticleRequestDto): Promise<void> { this.logger.verbose(`Updating a article by id: ${id} with updateArticleRequestDto`); const foundArticle = await this.getArticleDetailById(id); const { title, contents } = updateArticleRequestDto; if (!title || !contents) { throw new BadRequestException('Title and contents must be provided'); } foundArticle.title = title; foundArticle.contents = contents; await this.articleRepository.save(foundArticle) this.logger.verbose(`Updated a article by ${id} Successfully`); } // UPDATE - status <ADMIN> async updateArticleStatusById(id: number, status: ArticleStatus): Promise<void> { this.logger.verbose(`ADMIN is Updating a article by id: ${id} with status: ${status}`); const result = await this.articleRepository.update(id, { status }); if (result.affected === 0) { throw new NotFoundException(`Article with ID ${id} not found`); } this.logger.verbose(`ADMIN Updated a article's by ${id} status to ${status} Successfully`); } // DELETE - by id async deleteArticleById(id: number, logginedUser: User): Promise<void> { this.logger.verbose(`User: ${logginedUser.username} is Deleting a article by id: ${id}`); const foundArticle = await this.getArticleDetailById(id); if (foundArticle.user.id !== logginedUser.id) { throw new UnauthorizedException('Do not have permission to delete this article') } await this.articleRepository.delete(foundArticle); this.logger.verbose(`Deleted a article by id: ${id} Successfully`); } }

import { Module } from '@nestjs/common'; import { AuthController } from './auth.controller'; import { AuthService } from './auth.service'; import { TypeOrmModule } from '@nestjs/typeorm'; import { User } from "src/user/user.entity"; import { JwtModule } from '@nestjs/jwt'; import { PassportModule } from '@nestjs/passport'; import * as dotenv from 'dotenv'; import { JwtStrategy } from './jwt.strategy'; dotenv.config(); @Module({ imports: [ PassportModule.register({ defaultStrategy: 'jwt' }), JwtModule.register({ secret: process.env.JWT_SECRET, signOptions:{ expiresIn: parseInt(process.env.JWT_EXPIRATION, 10) } }), TypeOrmModule.forFeature([User]) ], controllers: [AuthController], providers: [AuthService, JwtStrategy], exports: [JwtModule, PassportModule], }) export class AuthModule {}