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

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

@@ -1,11 +1,8 @@
 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;
 import shook.shook.member.domain.Member;
 
@@ -15,8 +12,7 @@ public class AuthService {
 
     private final MemberService memberService;
     private final OAuthProviderFinder oauthProviderFinder;
-    private final TokenProvider tokenProvider;
-    private final InMemoryTokenPairRepository inMemoryTokenPairRepository;
+    private final TokenService tokenService;
 
     public TokenPair oAuthLogin(final String oauthType, final String authorizationCode) {
         final OAuthInfoProvider oAuthInfoProvider = oauthProviderFinder.getOAuthInfoProvider(oauthType);
@@ -26,24 +22,9 @@ public TokenPair oAuthLogin(final String oauthType, final String authorizationCo
 
         final Member member = memberService.findByEmail(memberInfo)
             .orElseGet(() -> memberService.register(memberInfo));
-
         final Long memberId = member.getId();
         final String nickname = member.getNickname();
-        final String accessToken = tokenProvider.createAccessToken(memberId, nickname);
-        final String refreshToken = tokenProvider.createRefreshToken(memberId, nickname);
-        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);
+        return tokenService.updateWithNewTokenPair(memberId, nickname);
     }
 }

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,49 @@
+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.application.dto.TokenPair;
+import shook.shook.auth.repository.InMemoryTokenPairRepository;
+
+@Transactional(readOnly = true)
+@RequiredArgsConstructor
+@Service
+public class TokenService {
+
+    public static final String TOKEN_PREFIX = "Bearer ";
+
+    private final TokenProvider tokenProvider;
+    private final InMemoryTokenPairRepository inMemoryTokenPairRepository;
+
+    public String createAccessToken(final Long memberId, final String nickname) {
+        return tokenProvider.createAccessToken(memberId, nickname);
+    }
+
+    public String createRefreshToken(final Long memberId, final String nickname) {
+        return tokenProvider.createRefreshToken(memberId, nickname);
+    }
+
+    public ReissueAccessTokenResponse reissueAccessTokenByRefreshToken(final String refreshToken,
+                                                                       final String accessToken) {
+        inMemoryTokenPairRepository.validateTokenPair(refreshToken, accessToken);
+        final Claims claims = tokenProvider.parseClaims(refreshToken);
+        final Long memberId = claims.get("memberId", Long.class);
+        final String nickname = claims.get("nickname", String.class);
+
+        final String reissuedAccessToken = tokenProvider.createAccessToken(memberId, nickname);
+        inMemoryTokenPairRepository.addOrUpdateTokenPair(refreshToken, reissuedAccessToken);
+
+        return new ReissueAccessTokenResponse(reissuedAccessToken);
+    }
+
+    public TokenPair updateWithNewTokenPair(final Long memberId, final String nickname) {
+        final String accessToken = createAccessToken(memberId, nickname);
+        final String refreshToken = createRefreshToken(memberId, nickname);
+        inMemoryTokenPairRepository.addOrUpdateTokenPair(refreshToken, accessToken);
+
+        return new TokenPair(refreshToken, accessToken);
+    }
+}

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

@@ -1,13 +1,15 @@
 package shook.shook.auth.ui;
 
+import static shook.shook.auth.application.TokenService.TOKEN_PREFIX;
+
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.bind.annotation.CookieValue;
 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;
@@ -18,22 +20,29 @@ 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
     ) {
+        validateRefreshToken(refreshToken);
+        final String accessToken = extractAccessToken(authorization);
+        final ReissueAccessTokenResponse response = tokenService.reissueAccessTokenByRefreshToken(refreshToken,
+                                                                                                  accessToken);
+
+        return ResponseEntity.ok(response);
+    }
+
+    private void validateRefreshToken(final String refreshToken) {
         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);
+    }
 
-        return ResponseEntity.ok(response);
+    private String extractAccessToken(final String authorization) {
+        return authorization.substring(TOKEN_PREFIX.length());
     }
 }

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

@@ -2,12 +2,15 @@
 
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 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.ui.argumentresolver.MemberInfo;
+import shook.shook.auth.repository.InMemoryTokenPairRepository;
+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;
     }
 
@@ -54,20 +60,27 @@ 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 List<KillingPartLike> membersExistLikes = likeRepository.findAllByMemberAndIsDeleted(
-            targetMember,
-            false
-        );
+    public void deleteById(final Long id, final Long requestMemberId) {
+        final Member member = getMemberIfValidRequest(id, requestMemberId);
+
+        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 getMemberIfValidRequest(final Long memberId, final Long requestMemberId) {
+        if (Objects.equals(memberId, requestMemberId)) {
+            return findById(memberId);
+        }
+
+        throw new AuthorizationException.UnauthenticatedException(
+            Map.of(
+                "tokenMemberId", String.valueOf(requestMemberId),
+                "pathMemberId", String.valueOf(memberId)
+            )
+        );
     }
 
     private Member findById(final Long id) {
@@ -77,14 +90,27 @@ private Member findById(final Long id) {
             ));
     }
 
-    private void validateMemberAuthentication(final Member requestMember,
-                                              final Member targetMember) {
-        if (!requestMember.equals(targetMember)) {
-            throw new AuthorizationException.UnauthenticatedException(
-                Map.of(
-                    "tokenMemberId", String.valueOf(requestMember.getId()),
-                    "pathMemberId", String.valueOf(targetMember.getId())
-                )
+    @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());
+
+        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/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);
 }