Feat/#462 닉네임 변경 API 구현

backend/src/main/java/shook/shook/auth/application/AuthService.java

@@ -1,9 +1,7 @@
 package shook.shook.auth.application;
 
-import io.jsonwebtoken.Claims;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
-import shook.shook.auth.application.dto.ReissueAccessTokenResponse;
 import shook.shook.auth.application.dto.TokenPair;
 import shook.shook.auth.repository.InMemoryTokenPairRepository;
 import shook.shook.member.application.MemberService;
@@ -34,16 +32,4 @@ public TokenPair oAuthLogin(final String oauthType, final String authorizationCo
         inMemoryTokenPairRepository.addOrUpdateTokenPair(refreshToken, accessToken);
         return new TokenPair(accessToken, refreshToken);
     }
-
-    public ReissueAccessTokenResponse reissueAccessTokenByRefreshToken(final String refreshToken,
-                                                                       final String accessToken) {
-        final Claims claims = tokenProvider.parseClaims(refreshToken);
-        final Long memberId = claims.get("memberId", Long.class);
-        final String nickname = claims.get("nickname", String.class);
-
-        inMemoryTokenPairRepository.validateTokenPair(refreshToken, accessToken);
-        final String reissuedAccessToken = tokenProvider.createAccessToken(memberId, nickname);
-        inMemoryTokenPairRepository.addOrUpdateTokenPair(refreshToken, reissuedAccessToken);
-        return new ReissueAccessTokenResponse(reissuedAccessToken);
-    }
 }

backend/src/main/java/shook/shook/auth/application/TokenProvider.java

@@ -50,6 +50,7 @@ private String createToken(final long memberId, final String nickname, final lon
         claims.put("memberId", memberId);
         claims.put("nickname", nickname);
         final Date now = new Date();
+
         return Jwts.builder()
             .setClaims(claims)
             .setIssuedAt(now)

backend/src/main/java/shook/shook/auth/application/TokenService.java

@@ -0,0 +1,44 @@
+package shook.shook.auth.application;
+
+import io.jsonwebtoken.Claims;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import shook.shook.auth.application.dto.ReissueAccessTokenResponse;
+import shook.shook.auth.exception.AuthorizationException;
+import shook.shook.auth.repository.InMemoryTokenPairRepository;
+
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+@Service
+public class TokenService {
+
+    public static final String EMPTY_REFRESH_TOKEN = "none";
+    public static final String TOKEN_PREFIX = "Bearer ";
+
+    private final TokenProvider tokenProvider;
+    private final InMemoryTokenPairRepository inMemoryTokenPairRepository;
+
+    public void validateRefreshToken(final String refreshToken) {
+        if (refreshToken.equals(EMPTY_REFRESH_TOKEN)) {
+            throw new AuthorizationException.RefreshTokenNotFoundException();
+        }
+    }
+
+    public String extractAccessToken(final String authorization) {
+        return authorization.substring(TOKEN_PREFIX.length());
+    }
+
+    public ReissueAccessTokenResponse reissueAccessTokenByRefreshToken(final String refreshToken,
+                                                                       final String accessToken) {
+        final Claims claims = tokenProvider.parseClaims(refreshToken);
+        final Long memberId = claims.get("memberId", Long.class);
+        final String nickname = claims.get("nickname", String.class);
+
+        inMemoryTokenPairRepository.validateTokenPair(refreshToken, accessToken);
+        final String reissuedAccessToken = tokenProvider.createAccessToken(memberId, nickname);
+        inMemoryTokenPairRepository.addOrUpdateTokenPair(refreshToken, reissuedAccessToken);
+
+        return new ReissueAccessTokenResponse(reissuedAccessToken);
+    }
+}

backend/src/main/java/shook/shook/auth/config/AuthConfig.java

@@ -45,7 +45,8 @@ private HandlerInterceptor tokenInterceptor() {
             .includePathPattern("/songs/*/parts/*/likes", PathMethod.PUT)
             .includePathPattern("/voting-songs/*/parts", PathMethod.POST)
             .includePathPattern("/songs/*/parts/*/comments", PathMethod.POST)
-            .includePathPattern("/members/*", PathMethod.DELETE);
+            .includePathPattern("/members/*", PathMethod.DELETE)
+            .includePathPattern("/members/*/nickname", PathMethod.PATCH);
     }
 
     @Override

backend/src/main/java/shook/shook/auth/ui/AccessTokenReissueController.java

@@ -7,9 +7,8 @@
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RestController;
-import shook.shook.auth.application.AuthService;
+import shook.shook.auth.application.TokenService;
 import shook.shook.auth.application.dto.ReissueAccessTokenResponse;
-import shook.shook.auth.exception.AuthorizationException;
 import shook.shook.auth.ui.openapi.AccessTokenReissueApi;
 
 @RequiredArgsConstructor
@@ -18,21 +17,18 @@ public class AccessTokenReissueController implements AccessTokenReissueApi {
 
     private static final String EMPTY_REFRESH_TOKEN = "none";
     private static final String REFRESH_TOKEN_KEY = "refreshToken";
-    private static final String TOKEN_PREFIX = "Bearer ";
 
-    private final AuthService authService;
+    private final TokenService tokenService;
 
     @PostMapping("/reissue")
     public ResponseEntity<ReissueAccessTokenResponse> reissueAccessToken(
         @CookieValue(value = REFRESH_TOKEN_KEY, defaultValue = EMPTY_REFRESH_TOKEN) final String refreshToken,
         @RequestHeader(HttpHeaders.AUTHORIZATION) final String authorization
     ) {
-        if (refreshToken.equals(EMPTY_REFRESH_TOKEN)) {
-            throw new AuthorizationException.RefreshTokenNotFoundException();
-        }
-        final String accessToken = authorization.split(TOKEN_PREFIX)[1];
-        final ReissueAccessTokenResponse response =
-            authService.reissueAccessTokenByRefreshToken(refreshToken, accessToken);
+        tokenService.validateRefreshToken(refreshToken);
+        final String accessToken = tokenService.extractAccessToken(authorization);
+        final ReissueAccessTokenResponse response = tokenService.reissueAccessTokenByRefreshToken(refreshToken,
+                                                                                                  accessToken);
 
         return ResponseEntity.ok(response);
     }

backend/src/main/java/shook/shook/auth/ui/AuthController.java

@@ -30,6 +30,7 @@ public ResponseEntity<LoginResponse> googleLogin(
         final Cookie cookie = cookieProvider.createRefreshTokenCookie(tokenPair.getRefreshToken());
         response.addCookie(cookie);
         final LoginResponse loginResponse = new LoginResponse(tokenPair.getAccessToken());
+
         return ResponseEntity.ok(loginResponse);
     }
 }

backend/src/main/java/shook/shook/auth/ui/CookieProvider.java

@@ -19,6 +19,7 @@ public Cookie createRefreshTokenCookie(final String refreshToken) {
         cookie.setPath("/api/reissue");
         cookie.setHttpOnly(true);
         cookie.setSecure(true);
+
         return cookie;
     }
 }

backend/src/main/java/shook/shook/globalexception/ErrorCode.java

@@ -60,22 +60,24 @@ public enum ErrorCode {
     VOTING_PART_END_OVER_SONG_LENGTH(4003, "파트의 끝 초는 노래 길이를 초과할 수 없습니다."),
     INVALID_VOTING_PART_LENGTH(4004, "파트의 길이는 5, 10, 15초 중 하나여야합니다."),
     VOTING_PART_DUPLICATE_START_AND_LENGTH_EXCEPTION(4005,
-        "한 노래에 동일한 파트를 두 개 이상 등록할 수 없습니다."),
+                                                     "한 노래에 동일한 파트를 두 개 이상 등록할 수 없습니다."),
     VOTING_SONG_PART_NOT_EXIST(4006, "투표 대상 파트가 존재하지 않습니다."),
 
     VOTING_SONG_PART_FOR_OTHER_SONG(4007, "해당 파트는 다른 노래의 파트입니다."),
     VOTING_SONG_NOT_EXIST(4008, "존재하지 않는 투표 노래입니다."),
     VOTE_FOR_OTHER_PART(4009, "해당 투표는 다른 파트에 대한 투표입니다."),
     DUPLICATE_VOTE_EXIST(4010, "중복된 투표입니다."),
-    // 5000: 사용자
 
+    // 5000: 사용자
     EMPTY_EMAIL(5001, "이메일은 비어있을 수 없습니다."),
     TOO_LONG_EMAIL(5002, "이메일은 100자를 초과할 수 없습니다."),
     INVALID_EMAIL_FORM(5003, "이메일 형식에 맞지 않습니다."),
     EMPTY_NICKNAME(5004, "닉네임은 비어있을 수 없습니다."),
-    TOO_LONG_NICKNAME(5005, "닉네임은 100자를 초과할 수 없습니다."),
+    TOO_LONG_NICKNAME(5005, "닉네임은 20자를 초과할 수 없습니다."),
     EXIST_MEMBER(5006, "이미 회원가입 된 멤버입니다."),
     MEMBER_NOT_EXIST(5007, "존재하지 않는 멤버입니다."),
+    DUPLICATE_NICKNAME(5008, "중복되는 닉네임입니다."),
+    TOO_SHORT_NICKNAME(5009, "닉네임은 2자 이상이어야 합니다."),
 
     REQUEST_BODY_VALIDATION_FAIL(10001, ""),
     WRONG_REQUEST_URL(10002, "URL의 pathVariable 은 비어있을 수 없습니다."),

backend/src/main/java/shook/shook/member/application/MemberService.java

@@ -6,8 +6,11 @@
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
+import shook.shook.auth.application.TokenProvider;
 import shook.shook.auth.exception.AuthorizationException;
+import shook.shook.auth.repository.InMemoryTokenPairRepository;
 import shook.shook.auth.ui.argumentresolver.MemberInfo;
+import shook.shook.member.application.dto.NicknameUpdateRequest;
 import shook.shook.member.domain.Email;
 import shook.shook.member.domain.Member;
 import shook.shook.member.domain.Nickname;
@@ -27,6 +30,8 @@ public class MemberService {
     private final MemberRepository memberRepository;
     private final KillingPartCommentRepository commentRepository;
     private final KillingPartLikeRepository likeRepository;
+    private final TokenProvider tokenProvider;
+    private final InMemoryTokenPairRepository inMemoryTokenPairRepository;
 
     @Transactional
     public Member register(final String email) {
@@ -37,6 +42,7 @@ public Member register(final String email) {
         final Member newMember = new Member(email, BASIC_NICKNAME);
         final Member savedMember = memberRepository.save(newMember);
         savedMember.updateNickname(savedMember.getNickname() + savedMember.getId());
+
         return savedMember;
     }
 
@@ -55,30 +61,24 @@ public Member findByIdAndNicknameThrowIfNotExist(final Long id, final Nickname n
 
     @Transactional
     public void deleteById(final Long id, final MemberInfo memberInfo) {
-        final long requestMemberId = memberInfo.getMemberId();
-        final Member requestMember = findById(requestMemberId);
-        final Member targetMember = findById(id);
-        validateMemberAuthentication(requestMember, targetMember);
+        final Member member = getMemberIfValidRequest(id, memberInfo.getMemberId());
 
-        final List<KillingPartLike> membersExistLikes = likeRepository.findAllByMemberAndIsDeleted(
-            targetMember,
-            false
-        );
+        final List<KillingPartLike> membersExistLikes = likeRepository.findAllByMemberAndIsDeleted(member, false);
 
         membersExistLikes.forEach(KillingPartLike::updateDeletion);
-        commentRepository.deleteAllByMember(targetMember);
-        memberRepository.delete(targetMember);
+        commentRepository.deleteAllByMember(member);
+        memberRepository.delete(member);
     }
 
-    private Member findById(final Long id) {
-        return memberRepository.findById(id)
-            .orElseThrow(() -> new MemberException.MemberNotExistException(
-                Map.of("Id", String.valueOf(id))
-            ));
+    private Member getMemberIfValidRequest(final Long memberId, final Long requestMemberId) {
+        final Member requestMember = findById(requestMemberId);
+        final Member targetMember = findById(memberId);
+        validateMemberAuthentication(requestMember, targetMember);
+
+        return targetMember;
     }
 
-    private void validateMemberAuthentication(final Member requestMember,
-                                              final Member targetMember) {
+    private void validateMemberAuthentication(final Member requestMember, final Member targetMember) {
         if (!requestMember.equals(targetMember)) {
             throw new AuthorizationException.UnauthenticatedException(
                 Map.of(
@@ -88,4 +88,37 @@ private void validateMemberAuthentication(final Member requestMember,
             );
         }
     }
+
+    private Member findById(final Long id) {
+        return memberRepository.findById(id)
+            .orElseThrow(() -> new MemberException.MemberNotExistException(
+                Map.of("Id", String.valueOf(id))
+            ));
+    }
+
+    @Transactional
+    public boolean updateNickname(final Long memberId, final Long requestMemberId,
+                                  final NicknameUpdateRequest request) {
+        final Member member = getMemberIfValidRequest(memberId, requestMemberId);
+        final Nickname nickname = new Nickname(request.getNickname());
+
+        if (member.hasSameNickname(nickname)) {
+            return false;
+        }
+
+        validateDuplicateNickname(nickname);
+        member.updateNickname(nickname.getValue());
+        memberRepository.save(member);
+
+        return true;
+    }
+
+    private void validateDuplicateNickname(final Nickname nickname) {
+        final boolean isDuplicated = memberRepository.existsMemberByNickname(nickname);
+        if (isDuplicated) {
+            throw new MemberException.ExistNicknameException(
+                Map.of("Nickname", nickname.getValue())
+            );
+        }
+    }
 }

backend/src/main/java/shook/shook/member/application/dto/NicknameUpdateRequest.java

@@ -0,0 +1,18 @@
+package shook.shook.member.application.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import jakarta.validation.constraints.NotBlank;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Schema(description = "닉네임 변경 요청")
+@NoArgsConstructor(access = lombok.AccessLevel.PRIVATE)
+@AllArgsConstructor
+@Getter
+public class NicknameUpdateRequest {
+
+    @Schema(description = "닉네임", example = "shookshook")
+    @NotBlank
+    private String nickname;
+}

backend/src/main/java/shook/shook/member/application/dto/NicknameUpdateResponse.java

@@ -0,0 +1,20 @@
+package shook.shook.member.application.dto;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+import lombok.NoArgsConstructor;
+
+@Schema(description = "닉네임 변경 응답")
+@AllArgsConstructor
+@NoArgsConstructor(access = AccessLevel.PRIVATE)
+@Getter
+public class NicknameUpdateResponse {
+
+    @Schema(description = "액세스 토큰", example = "lfahrg;aoiehflksejflakwjeglk")
+    private String accessToken;
+
+    @Schema(description = "변경된 닉네임", example = "shook")
+    private String nickname;
+}

backend/src/main/java/shook/shook/member/domain/Member.java

@@ -49,6 +49,14 @@ public void updateNickname(final String newNickName) {
         this.nickname = new Nickname(newNickName);
     }
 
+    public void updateNickname(final Nickname newNickname) {
+        this.nickname = newNickname;
+    }
+
+    public boolean hasSameNickname(final Nickname nickname) {
+        return nickname.equals(this.nickname);
+    }
+
     public String getEmail() {
         return email.getValue();
     }

backend/src/main/java/shook/shook/member/domain/Nickname.java

@@ -16,7 +16,8 @@
 @Embeddable
 public class Nickname {
 
-    private static final int NICKNAME_MAXIMUM_LENGTH = 100;
+    private static final int NICKNAME_MAXIMUM_LENGTH = 20;
+    private static final int NICKNAME_MINIMUM_LENGTH = 2;
 
     @Column(name = "nickname", length = NICKNAME_MAXIMUM_LENGTH, nullable = false)
     private String value;
@@ -35,5 +36,10 @@ private void validateNickname(final String value) {
                 Map.of("Nickname", value)
             );
         }
+        if (value.length() < NICKNAME_MINIMUM_LENGTH) {
+            throw new MemberException.TooShortNicknameException(
+                Map.of("Nickname", value)
+            );
+        }
     }
 }

backend/src/main/java/shook/shook/member/domain/repository/MemberRepository.java

@@ -13,4 +13,6 @@ public interface MemberRepository extends JpaRepository<Member, Long> {
     Optional<Member> findByEmail(final Email email);
 
     Optional<Member> findByIdAndNickname(final Long id, final Nickname nickname);
+
+    boolean existsMemberByNickname(final Nickname nickname);
 }

backend/src/main/java/shook/shook/member/exception/MemberException.java

@@ -93,4 +93,26 @@ public MemberNotExistException(final Map<String, String> inputValuesByProperty)
             super(ErrorCode.MEMBER_NOT_EXIST, inputValuesByProperty);
         }
     }
+
+    public static class ExistNicknameException extends MemberException {
+
+        public ExistNicknameException() {
+            super(ErrorCode.DUPLICATE_NICKNAME);
+        }
+
+        public ExistNicknameException(final Map<String, String> inputValuesByProperty) {
+            super(ErrorCode.DUPLICATE_NICKNAME, inputValuesByProperty);
+        }
+    }
+
+    public static class TooShortNicknameException extends MemberException {
+
+        public TooShortNicknameException() {
+            super(ErrorCode.TOO_SHORT_NICKNAME);
+        }
+
+        public TooShortNicknameException(final Map<String, String> inputValuesByProperty) {
+            super(ErrorCode.TOO_SHORT_NICKNAME, inputValuesByProperty);
+        }
+    }
 }