Merge pull request #19 from ccaaffee/feat/profile

Feat/profile: 유저 프로필 업로드 기능 추가

Author: Kimcheolhui

prisma/migrations/20250607174011_add_user_profile_image/migration.sql

@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE `User` ADD COLUMN `profileImage` VARCHAR(191) NULL;

prisma/schema.prisma

@@ -14,10 +14,11 @@ datasource db {
 }
 
 model User {
-  uuid      String   @id @default(uuid())
-  kakaoId   String   @unique
-  nickname  String?  @unique
-  createdAt DateTime @default(now())
+  uuid         String   @id @default(uuid())
+  kakaoId      String   @unique
+  nickname     String?  @unique
+  profileImage String?
+  createdAt    DateTime @default(now())
 
   userCafes UserCafe[]
 }

src/auth/strategy/jwt.strategy.ts

@@ -1,10 +1,10 @@
 import { Injectable, UnauthorizedException } from '@nestjs/common';
 import { ConfigService } from '@nestjs/config';
 import { PassportStrategy } from '@nestjs/passport';
+import { User } from '@prisma/client';
 
 import { ExtractJwt, Strategy } from 'passport-jwt';
 import { UserService } from 'src/user/user.service';
-import { UserInfo } from '../types/userInfo.type';
 
 @Injectable()
 export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
@@ -18,11 +18,12 @@ export class JwtStrategy extends PassportStrategy(Strategy, 'jwt') {
     });
   }
 
-  async validate(payload: any): Promise<UserInfo> {
+  async validate(payload: any): Promise<User> {
     const { sub: uuid } = payload;
-    const user = this.userService.findById(uuid).catch((error) => {
-      throw new UnauthorizedException(`User not found: ${error}`);
-    });
+    const user = await this.userService.findById(uuid);
+    if (!user) {
+      throw new UnauthorizedException(`User not found`);
+    }
 
     return user;
   }

src/auth/types/userInfo.type.ts

@@ -2,5 +2,6 @@ export type UserInfo = {
   uuid: string;
   kakaoId: string;
   nickname: string;
+  profileImageUrl?: string;
   createdAt: Date;
 };

src/image/image.service.ts

@@ -17,9 +17,15 @@ import { ConfigService } from '@nestjs/config';
 
 import sharp from 'sharp';
 
+export enum ImageType {
+  CAFE = 'cafe',
+  PROFILE = 'profile',
+}
+
 @Injectable()
 export class ImageService {
-  bucketName: string;
+  private readonly bucketName: string;
+  private readonly environment: string;
 
   constructor(
     private readonly configService: ConfigService,
@@ -35,28 +41,46 @@ export class ImageService {
       },
     });
     this.bucketName = this.configService.get<string>('AWS_S3_BUCKET_NAME');
+    this.environment =
+      this.configService.get<string>('NODE_ENV') || 'development';
   }
 
   /**
    * 이미지 파일을 여러 개 업로드
    * @param files Express.Multer.File[]
+   * @param type ImageType
    * @returns string[]
    */
-  async uploadImages(files: Express.Multer.File[]): Promise<string[]> {
-    return Promise.all(files.map((file) => this.uploadImage(file)));
+  async uploadImages(
+    files: Express.Multer.File[],
+    type: ImageType = ImageType.CAFE,
+  ): Promise<string[]> {
+    return Promise.all(files.map((file) => this.uploadImage(file, type)));
+  }
+
+  /**
+   * 프로필 이미지 업로드 (1:1 비율로 크롭)
+   * @param file Express.Multer.File
+   * @returns string
+   */
+  async uploadProfileImage(file: Express.Multer.File): Promise<string> {
+    const processedFile = await this.processProfileImage(file);
+    return this.uploadImage(processedFile, ImageType.PROFILE);
   }
 
   /**
    * S3에 단일 이미지 업로드
    * @param file Express.Multer.File
+   * @param type ImageType
    * @returns string
    */
-  private async uploadImage(file: Express.Multer.File): Promise<string> {
-    const key = `staging/${Date.now()}-${Math.random().toString(36).substring(2)}${file.originalname}`;
+  private async uploadImage(
+    file: Express.Multer.File,
+    type: ImageType,
+  ): Promise<string> {
+    const key = `${this.environment}/${type}/${Date.now()}-${Math.random().toString(36).substring(2)}${file.originalname}`;
 
-    const webpFile = await this.convertToWebp({
-      ...file,
-    });
+    const webpFile = await this.convertToWebp(file);
 
     const command = new PutObjectCommand({
       Bucket: this.bucketName,
@@ -77,6 +101,35 @@ export class ImageService {
     }
   }
 
+  /**
+   * 프로필 이미지 처리 (1:1 비율로 크롭)
+   * @param file Express.Multer.File
+   * @returns Express.Multer.File
+   */
+  private async processProfileImage(
+    file: Express.Multer.File,
+  ): Promise<Express.Multer.File> {
+    try {
+      const metadata = await sharp(file.buffer).metadata();
+      const size = Math.min(metadata.width, metadata.height);
+
+      file.buffer = await sharp(file.buffer)
+        .resize(size, size, {
+          fit: 'cover',
+          position: 'center',
+        })
+        .toBuffer();
+
+      return file;
+    } catch (error) {
+      console.log(error);
+      if (error.message.includes('unsupported image format')) {
+        throw new BadRequestException('Unsupported image format');
+      }
+      throw new InternalServerErrorException('Failed to process profile image');
+    }
+  }
+
   /**
    * S3에서 단일 이미지 삭제
    * @param key string

src/user/dto/res/userInfo.dto.ts

@@ -22,6 +22,15 @@ export class UserInfoDto {
   })
   nickname: string;
 
+  @ApiProperty({
+    type: String,
+    description: "User's profile image signed URL",
+    example:
+      'https://your-bucket.s3.region.amazonaws.com/production/profile/1234567890-abcdef.webp?signed-params',
+    required: false,
+  })
+  profileImageUrl?: string;
+
   @ApiProperty({
     type: Date,
     description: 'Account created Date',

src/user/user.controller.ts

@@ -1,20 +1,35 @@
-import { Controller, Get, UseGuards, Body, Patch, Query } from '@nestjs/common';
+import {
+  Controller,
+  Get,
+  UseGuards,
+  Body,
+  Patch,
+  Query,
+  Post,
+  UseInterceptors,
+  UploadedFile,
+  BadRequestException,
+} from '@nestjs/common';
 import { UserService } from './user.service';
 import { JwtAuthGuard } from 'src/auth/jwt.auth.strategy';
 import { GetUser } from './decorator/get-user.decorator';
 import { UserInfo } from 'src/auth/types/userInfo.type';
 import {
   ApiBearerAuth,
+  ApiConsumes,
   ApiInternalServerErrorResponse,
   ApiOkResponse,
   ApiOperation,
   ApiQuery,
   ApiTags,
   ApiUnauthorizedResponse,
+  ApiBody,
 } from '@nestjs/swagger';
 import { UserInfoDto } from './dto/res/userInfo.dto';
 import { UpdateNicknameDto } from './dto/req/updateNickname.dto';
 import { NicknameDuplicateCheckDto } from './dto/res/nicknameDuplicateCheck.dto';
+import { FileInterceptor } from '@nestjs/platform-express';
+import { User } from '@prisma/client';
 
 @ApiTags('User')
 @Controller('user')
@@ -35,8 +50,8 @@ export class UserController {
   @ApiBearerAuth('JWT')
   @Get('profile')
   @UseGuards(JwtAuthGuard)
-  async getProfile(@GetUser() user: UserInfo): Promise<UserInfo> {
-    return user;
+  async getProfile(@GetUser() user: User): Promise<UserInfo> {
+    return this.userService.formatUserForResponse(user);
   }
 
   @ApiOperation({
@@ -75,12 +90,67 @@ export class UserController {
   @Patch('nickname')
   @UseGuards(JwtAuthGuard)
   async updateNickname(
-    @GetUser() user: UserInfo,
+    @GetUser() user: User,
     @Body() updateNicknameDto: UpdateNicknameDto,
   ): Promise<UserInfo> {
-    return this.userService.updateNickname(
+    const updatedUser = await this.userService.updateNickname(
       user.uuid,
       updateNicknameDto.nickname,
     );
+    return this.userService.formatUserForResponse(updatedUser);
+  }
+
+  @ApiOperation({
+    summary: 'upload profile image',
+    description:
+      '프로필 이미지를 업로드합니다. 이미지는 1:1 비율로 자동 크롭됩니다.',
+  })
+  @ApiConsumes('multipart/form-data')
+  @ApiBody({
+    schema: {
+      type: 'object',
+      properties: {
+        image: {
+          type: 'string',
+          format: 'binary',
+          description: '프로필 이미지 파일 (jpg, jpeg, png만 가능)',
+        },
+      },
+    },
+  })
+  @ApiOkResponse({
+    type: UserInfoDto,
+    description: 'Return updated profile',
+  })
+  @ApiUnauthorizedResponse({ description: 'Unauthorized' })
+  @ApiInternalServerErrorResponse({
+    description: 'Internal Server Error',
+  })
+  @ApiBearerAuth('JWT')
+  @Post('profile-image')
+  @UseGuards(JwtAuthGuard)
+  @UseInterceptors(
+    FileInterceptor('image', {
+      fileFilter: (req, file, cb) => {
+        if (!file.mimetype.match(/^image\/(jpg|jpeg|png)$/)) {
+          cb(new BadRequestException('Only image files are allowed'), false);
+        }
+        cb(null, true);
+      },
+    }),
+  )
+  async uploadProfileImage(
+    @GetUser() user: User,
+    @UploadedFile() file: Express.Multer.File,
+  ): Promise<UserInfo> {
+    if (!file) {
+      throw new BadRequestException('No file uploaded');
+    }
+
+    const updatedUser = await this.userService.updateProfileImage(
+      user.uuid,
+      file,
+    );
+    return this.userService.formatUserForResponse(updatedUser);
   }
 }

src/user/user.module.ts

@@ -3,9 +3,10 @@ import { UserController } from './user.controller';
 import { UserService } from './user.service';
 import { PrismaModule } from 'src/prisma/prisma.module';
 import { UserRepository } from './user.repository';
+import { ImageModule } from 'src/image/image.module';
 
 @Module({
-  imports: [PrismaModule],
+  imports: [PrismaModule, ImageModule],
   controllers: [UserController],
   providers: [UserService, UserRepository],
   exports: [UserService],

src/user/user.repository.ts

@@ -49,4 +49,12 @@ export class UserRepository {
       data: { nickname },
     });
   }
+
+  // 프로필 이미지 업데이트
+  async updateProfileImage(uuid: string, profileImage: string) {
+    return this.prismaService.user.update({
+      where: { uuid },
+      data: { profileImage },
+    });
+  }
 }

src/user/user.service.ts

@@ -1,30 +1,52 @@
 import { ConflictException, Injectable } from '@nestjs/common';
 import { UserRepository } from './user.repository';
+import { ImageService } from 'src/image/image.service';
+import { UserInfo } from 'src/auth/types/userInfo.type';
+import { User } from '@prisma/client';
 
 @Injectable()
 export class UserService {
-  constructor(private readonly userRepository: UserRepository) {}
+  constructor(
+    private readonly userRepository: UserRepository,
+    private readonly imageService: ImageService,
+  ) {}
 
-  async createUser(kakaoId: string) {
+  async createUser(kakaoId: string): Promise<User> {
     return this.userRepository.createUser(kakaoId);
   }
 
-  async findByKakaoId(kakaoId: string) {
+  async findByKakaoId(kakaoId: string): Promise<User | null> {
     return this.userRepository.findByKakaoId(kakaoId);
   }
 
-  async findById(uuid: string) {
+  async findById(uuid: string): Promise<User | null> {
     return this.userRepository.findByUuid(uuid);
   }
 
+  async formatUserForResponse(user: User): Promise<UserInfo> {
+    if (!user) {
+      return null;
+    }
+
+    const { profileImage, ...userWithoutProfileImage } = user;
+    const responseUser: UserInfo = userWithoutProfileImage;
+
+    if (profileImage) {
+      responseUser.profileImageUrl =
+        await this.imageService.generateSignedUrl(profileImage);
+    }
+
+    return responseUser;
+  }
+
   // 닉네임 중복 확인
   async checkNicknameDuplicate(nickname: string): Promise<boolean> {
     const existingUser = await this.userRepository.findByNickname(nickname);
     return !!existingUser;
   }
 
   // 닉네임 업데이트
-  async updateNickname(uuid: string, nickname: string) {
+  async updateNickname(uuid: string, nickname: string): Promise<User> {
     // 닉네임 중복 확인
     const isDuplicate = await this.checkNicknameDuplicate(nickname);
     if (isDuplicate) {
@@ -33,4 +55,13 @@ export class UserService {
 
     return this.userRepository.updateNickname(uuid, nickname);
   }
+
+  // 프로필 이미지 업데이트
+  async updateProfileImage(
+    uuid: string,
+    file: Express.Multer.File,
+  ): Promise<User> {
+    const imageKey = await this.imageService.uploadProfileImage(file);
+    return this.userRepository.updateProfileImage(uuid, imageKey);
+  }
 }