refactor: authMember 이름 authCredentials 로 변경

src/main/kotlin/com/petqua/application/auth/AuthFacadeService.kt

@@ -22,17 +22,17 @@ class AuthFacadeService(
         val oauthTokenInfo = oauthService.requestOauthTokenInfo(oauthServerType, code)
         val oauthUserInfo = oauthService.requestOauthUserInfo(oauthServerType, oauthTokenInfo.accessToken)
 
-        val authMember = authService.findOrCreateAuthMemberBy(oauthServerType, oauthUserInfo.oauthId)
-        authService.updateOauthToken(authMember, oauthTokenInfo)
+        val authCredentials = authService.findOrCreateAuthCredentialsBy(oauthServerType, oauthUserInfo.oauthId)
+        authService.updateOauthToken(authCredentials, oauthTokenInfo)
 
-        return tokenService.createAuthOrSignUpToken(authMember.id)
+        return tokenService.createAuthOrSignUpToken(authCredentials.id)
     }
 
     fun extendLogin(accessToken: String, refreshToken: String): AuthTokenInfo {
-        val authMember = authService.findAuthMemberBy(accessToken = accessToken, refreshToken = refreshToken)
-        updateOauthTokenIfExpired(authMember)
+        val authCredentials = authService.findAuthCredentialsBy(accessToken = accessToken, refreshToken = refreshToken)
+        updateOauthTokenIfExpired(authCredentials)
 
-        return tokenService.createAuthOrSignUpToken(authMember.id)
+        return tokenService.createAuthOrSignUpToken(authCredentials.id)
     }
 
     private fun updateOauthTokenIfExpired(authCredentials: AuthCredentials) {
@@ -47,12 +47,12 @@ class AuthFacadeService(
 
     fun deleteBy(memberId: Long) {
         val member = authService.findMemberBy(memberId)
-        val authMember = authService.findAuthMemberBy(member.authMemberId)
-        updateOauthTokenIfExpired(authMember)
+        val authCredentials = authService.findAuthCredentialsBy(member.authCredentialsId)
+        updateOauthTokenIfExpired(authCredentials)
         oauthService.disconnectBy(
-            oauthServerType = authMember.oauthServerType,
-            oauthAccessToken = authMember.oauthAccessToken
+            oauthServerType = authCredentials.oauthServerType,
+            oauthAccessToken = authCredentials.oauthAccessToken
         )
-        authService.delete(member, authMember)
+        authService.delete(member, authCredentials)
     }
 }

src/main/kotlin/com/petqua/application/auth/AuthService.kt

@@ -2,7 +2,7 @@ package com.petqua.application.auth
 
 import com.petqua.common.domain.findActiveByIdOrThrow
 import com.petqua.domain.auth.AuthCredentials
-import com.petqua.domain.auth.AuthMemberRepository
+import com.petqua.domain.auth.AuthCredentialsRepository
 import com.petqua.domain.auth.oauth.OauthServerType
 import com.petqua.domain.auth.oauth.OauthTokenInfo
 import com.petqua.domain.auth.token.AuthTokenProvider
@@ -21,36 +21,36 @@ import org.springframework.transaction.annotation.Transactional
 @Transactional
 @Service
 class AuthService(
-    private val authMemberRepository: AuthMemberRepository,
+    private val authCredentialsRepository: AuthCredentialsRepository,
     private val authTokenProvider: AuthTokenProvider,
     private val cartProductRepository: CartProductRepository,
     private val refreshTokenRepository: RefreshTokenRepository,
     private val memberRepository: MemberRepository,
 ) {
 
-    fun findOrCreateAuthMemberBy(
+    fun findOrCreateAuthCredentialsBy(
         oauthServerType: OauthServerType,
         oauthId: Long,
     ): AuthCredentials {
-        return authMemberRepository.findByOauthIdAndOauthServerNumberAndIsDeletedFalse(
+        return authCredentialsRepository.findByOauthIdAndOauthServerNumberAndIsDeletedFalse(
             oauthId = oauthId,
             oauthServerNumber = oauthServerType.number
-        ) ?: authMemberRepository.save(
-            AuthCredentials.authMemberOf(
+        ) ?: authCredentialsRepository.save(
+            AuthCredentials.of(
                 oauthId = oauthId,
                 oauthServerNumber = oauthServerType.number,
             )
         )
     }
 
     @Transactional(readOnly = true)
-    fun findAuthMemberBy(accessToken: String, refreshToken: String): AuthCredentials {
+    fun findAuthCredentialsBy(accessToken: String, refreshToken: String): AuthCredentials {
         authTokenProvider.validateTokenExpiredStatusForExtendLogin(accessToken, refreshToken)
         val savedRefreshToken = refreshTokenRepository.findByTokenOrThrow(refreshToken) {
             AuthException(INVALID_REFRESH_TOKEN)
         }
         savedRefreshToken.validateTokenValue(refreshToken)
-        return authMemberRepository.findActiveByIdOrThrow(savedRefreshToken.memberId) {
+        return authCredentialsRepository.findActiveByIdOrThrow(savedRefreshToken.memberId) {
             MemberException(NOT_FOUND_MEMBER)
         }
     }
@@ -63,8 +63,8 @@ class AuthService(
     }
 
     @Transactional(readOnly = true)
-    fun findAuthMemberBy(authMemberId: Long): AuthCredentials {
-        return authMemberRepository.findActiveByIdOrThrow(authMemberId) {
+    fun findAuthCredentialsBy(authCredentialsId: Long): AuthCredentials {
+        return authCredentialsRepository.findActiveByIdOrThrow(authCredentialsId) {
             MemberException(NOT_FOUND_MEMBER)
         }
     }
@@ -75,14 +75,14 @@ class AuthService(
             expiresIn = oauthTokenInfo.expiresIn,
             refreshToken = oauthTokenInfo.refreshToken
         )
-        authMemberRepository.save(authCredentials)
+        authCredentialsRepository.save(authCredentials)
     }
 
     fun delete(member: Member, authCredentials: AuthCredentials) {
         member.delete()
         memberRepository.save(member)
         authCredentials.delete()
-        authMemberRepository.save(authCredentials)
+        authCredentialsRepository.save(authCredentials)
 
         cartProductRepository.deleteByMemberId(member.id)
         refreshTokenRepository.deleteByMemberId(member.id)

src/main/kotlin/com/petqua/application/auth/AuthTokenService.kt

@@ -19,14 +19,14 @@ class AuthTokenService(
     private val memberRepository: MemberRepository,
 ) : TokenService {
 
-    override fun createAuthOrSignUpToken(authMemberId: Long): AuthTokenInfo {
-        val member = memberRepository.findByAuthMemberId(authMemberId)
+    override fun createAuthOrSignUpToken(authCredentialsId: Long): AuthTokenInfo {
+        val member = memberRepository.findByAuthCredentialsId(authCredentialsId)
         return member?.let {
             createAuthToken(
                 memberId = member.id,
                 authority = member.authority
             )
-        } ?: createSignUpToken(authMemberId)
+        } ?: createSignUpToken(authCredentialsId)
     }
 
     override fun createAuthToken(memberId: Long, authority: Authority): AuthTokenInfo {
@@ -41,8 +41,8 @@ class AuthTokenService(
         return AuthTokenInfo.from(authToken)
     }
 
-    private fun createSignUpToken(authMemberId: Long): AuthTokenInfo {
-        val authToken = authTokenProvider.createSignUpAuthToken(authMemberId, Date())
+    private fun createSignUpToken(authCredentialsId: Long): AuthTokenInfo {
+        val authToken = authTokenProvider.createSignUpAuthToken(authCredentialsId, Date())
         return AuthTokenInfo.signUpTokenOf(authToken)
     }
 }

src/main/kotlin/com/petqua/application/member/MemberService.kt

@@ -39,22 +39,22 @@ class MemberService(
 ) {
 
     fun signUp(command: MemberSignUpCommand): AuthTokenInfo {
-        validateDuplicateSignUp(command.authMemberId)
+        validateDuplicateSignUp(command.authCredentialsId)
 
         val nicknameWords = nicknameWordRepository.findAll()
         val nickname = generateUniqueNickname(nicknameWords)
         val member = memberRepository.save(
             Member.emptyProfileMemberOf(
-                authMemberId = command.authMemberId,
+                authCredentialsId = command.authCredentialsId,
                 nickname = nickname,
                 hasAgreedToMarketingNotification = command.hasAgreedToMarketingNotification
             )
         )
         return tokenService.createAuthToken(member.id, member.authority)
     }
 
-    private fun validateDuplicateSignUp(authMemberId: Long) {
-        throwExceptionWhen(memberRepository.existsMemberByAuthMemberId(authMemberId)) {
+    private fun validateDuplicateSignUp(authCredentialsId: Long) {
+        throwExceptionWhen(memberRepository.existsMemberByAuthCredentialsId(authCredentialsId)) {
             MemberException(HAS_SIGNED_UP_MEMBER)
         }
     }

src/main/kotlin/com/petqua/application/member/dto/MemberDtos.kt

@@ -8,7 +8,7 @@ import com.petqua.domain.member.PetFishes
 import java.time.YearMonth
 
 data class MemberSignUpCommand(
-    val authMemberId: Long,
+    val authCredentialsId: Long,
     val hasAgreedToMarketingNotification: Boolean,
 )
 

src/main/kotlin/com/petqua/application/token/TokenService.kt

@@ -4,7 +4,7 @@ import com.petqua.domain.auth.Authority
 
 interface TokenService {
 
-    fun createAuthOrSignUpToken(authMemberId: Long): AuthTokenInfo
+    fun createAuthOrSignUpToken(authCredentialsId: Long): AuthTokenInfo
 
     fun createAuthToken(memberId: Long, authority: Authority): AuthTokenInfo
 }

src/main/kotlin/com/petqua/common/config/DataInitializer.kt

@@ -3,7 +3,7 @@ package com.petqua.common.config
 import com.petqua.domain.announcement.Announcement
 import com.petqua.domain.announcement.AnnouncementRepository
 import com.petqua.domain.auth.AuthCredentials
-import com.petqua.domain.auth.AuthMemberRepository
+import com.petqua.domain.auth.AuthCredentialsRepository
 import com.petqua.domain.auth.Authority.MEMBER
 import com.petqua.domain.banner.Banner
 import com.petqua.domain.banner.BannerRepository
@@ -75,7 +75,7 @@ class DataInitializer(
     private val productRepository: ProductRepository,
     private val recommendationRepository: ProductRecommendationRepository,
     private val storeRepository: StoreRepository,
-    private val authMemberRepository: AuthMemberRepository,
+    private val authCredentialsRepository: AuthCredentialsRepository,
     private val memberRepository: MemberRepository,
     private val categoryRepository: CategoryRepository,
     private val productReviewRepository: ProductReviewRepository,
@@ -96,8 +96,8 @@ class DataInitializer(
     @Transactional
     fun setUpData() {
         // member
-        val authMember = saveAuthMember()
-        saveMember(authMember.id)
+        val authCredentials = saveAuthCredentials()
+        saveMember(authCredentials.id)
 
         // fish
         saveFishes()
@@ -115,14 +115,14 @@ class DataInitializer(
         saveBanners()
 
         // shippingAddress
-        saveShippingAddress(authMember)
+        saveShippingAddress(authCredentials)
 
         // others
-        saveCommerceData(authMember.id)
+        saveCommerceData(authCredentials.id)
     }
 
-    private fun saveAuthMember(): AuthCredentials {
-        return authMemberRepository.save(
+    private fun saveAuthCredentials(): AuthCredentials {
+        return authCredentialsRepository.save(
             AuthCredentials(
                 oauthId = 1L,
                 oauthServerNumber = 1,
@@ -133,10 +133,10 @@ class DataInitializer(
         )
     }
 
-    private fun saveMember(authMemberId: Long) {
+    private fun saveMember(authCredentialsId: Long) {
         memberRepository.save(
             Member(
-                authMemberId = authMemberId,
+                authCredentialsId = authCredentialsId,
                 authority = MEMBER,
                 nickname = Nickname.from("홍길동"),
                 profileImageUrl = null,

src/main/kotlin/com/petqua/domain/auth/AuthCredentials.kt

@@ -74,7 +74,7 @@ class AuthCredentials(
     }
 
     companion object {
-        fun authMemberOf(
+        fun of(
             oauthId: Long,
             oauthServerNumber: Int,
         ): AuthCredentials {

src/main/kotlin/com/petqua/domain/auth/AuthMemberRepository.kt → src/main/kotlin/com/petqua/domain/auth/AuthCredentialsRepository.kt

@@ -2,7 +2,7 @@ package com.petqua.domain.auth
 
 import org.springframework.data.jpa.repository.JpaRepository
 
-interface AuthMemberRepository : JpaRepository<AuthCredentials, Long> {
+interface AuthCredentialsRepository : JpaRepository<AuthCredentials, Long> {
 
     fun findByOauthIdAndOauthServerNumberAndIsDeletedFalse(oauthId: Long, oauthServerNumber: Int): AuthCredentials?
 }

src/main/kotlin/com/petqua/domain/auth/SignUpGuest.kt

@@ -4,5 +4,5 @@ import io.swagger.v3.oas.annotations.Hidden
 
 @Hidden
 data class SignUpGuest(
-    val authMemberId: Long,
+    val authCredentialsId: Long,
 )

src/main/kotlin/com/petqua/domain/auth/token/AuthTokenProvider.kt

@@ -35,8 +35,8 @@ class AuthTokenProvider(
         )
     }
 
-    fun createSignUpAuthToken(authMemberId: Long, issuedDate: Date): AuthToken {
-        val signUpTokenClaims = SignUpTokenClaims(authMemberId = authMemberId)
+    fun createSignUpAuthToken(authCredentialsId: Long, issuedDate: Date): AuthToken {
+        val signUpTokenClaims = SignUpTokenClaims(authCredentialsId = authCredentialsId)
         val token = jwtProvider.createToken(
             claims = signUpTokenClaims.getClaims(),
             tokenLiveTime = properties.accessTokenLiveTime,

src/main/kotlin/com/petqua/domain/auth/token/SignUpTokenClaims.kt

@@ -3,23 +3,23 @@ package com.petqua.domain.auth.token
 import com.petqua.exception.auth.AuthException
 import com.petqua.exception.auth.AuthExceptionType.INVALID_ACCESS_TOKEN
 
-private const val AUTH_MEMBER_ID = "authMemberId"
+private const val AUTH_MEMBER_ID = "authCredentialsId"
 
 class SignUpTokenClaims(
-    val authMemberId: Long,
+    val authCredentialsId: Long,
 ) {
 
     fun getClaims(): Map<String, String> {
-        return mapOf(AUTH_MEMBER_ID to authMemberId.toString())
+        return mapOf(AUTH_MEMBER_ID to authCredentialsId.toString())
     }
 
     companion object {
         fun from(claims: Map<String, String>): SignUpTokenClaims {
-            val authMemberId = claims[AUTH_MEMBER_ID]
+            val authCredentialsId = claims[AUTH_MEMBER_ID]
                 ?: throw AuthException(INVALID_ACCESS_TOKEN)
 
             return SignUpTokenClaims(
-                authMemberId = authMemberId.toLong()
+                authCredentialsId = authCredentialsId.toLong()
             )
         }
     }

src/main/kotlin/com/petqua/domain/member/Member.kt

@@ -17,7 +17,7 @@ class Member(
     val id: Long = 0L,
 
     @Column(nullable = false)
-    val authMemberId: Long,
+    val authCredentialsId: Long,
 
     @Enumerated(EnumType.STRING)
     val authority: Authority,
@@ -64,13 +64,13 @@ class Member(
 
     companion object {
         fun emptyProfileMemberOf(
-            authMemberId: Long,
+            authCredentialsId: Long,
             nickname: Nickname,
             hasAgreedToMarketingNotification: Boolean,
         ): Member {
             return Member(
                 authority = MEMBER,
-                authMemberId = authMemberId,
+                authCredentialsId = authCredentialsId,
                 nickname = nickname,
                 profileImageUrl = null,
                 fishTankCount = 0,

src/main/kotlin/com/petqua/domain/member/MemberRepository.kt

@@ -3,19 +3,19 @@ package com.petqua.domain.member
 import com.petqua.domain.member.nickname.Nickname
 import org.springframework.data.jpa.repository.JpaRepository
 
-fun MemberRepository.findByAuthMemberIdOrThrow(
-    authMemberId: Long,
+fun MemberRepository.findByAuthCredentialsIdOrThrow(
+    authCredentialsId: Long,
     exceptionSupplier: () -> Exception = { IllegalArgumentException("${Member::class.java.name} entity 를 찾을 수 없습니다.") },
 ): Member {
-    return findByAuthMemberId(authMemberId) ?: throw exceptionSupplier()
+    return findByAuthCredentialsId(authCredentialsId) ?: throw exceptionSupplier()
 }
 
 
 interface MemberRepository : JpaRepository<Member, Long> {
 
-    fun findByAuthMemberId(authMemberId: Long): Member?
+    fun findByAuthCredentialsId(authCredentialsId: Long): Member?
 
     fun existsMemberByNickname(nickname: Nickname): Boolean
 
-    fun existsMemberByAuthMemberId(authMemberId: Long): Boolean
+    fun existsMemberByAuthCredentialsId(authCredentialsId: Long): Boolean
 }

src/main/kotlin/com/petqua/presentation/auth/AuthExtractor.kt

@@ -4,7 +4,7 @@ import com.petqua.common.domain.existActiveByIdOrThrow
 import com.petqua.common.util.getCookieValueOrThrow
 import com.petqua.common.util.getHeaderOrThrow
 import com.petqua.common.util.throwExceptionWhen
-import com.petqua.domain.auth.AuthMemberRepository
+import com.petqua.domain.auth.AuthCredentialsRepository
 import com.petqua.domain.auth.token.AccessTokenClaims
 import com.petqua.domain.auth.token.JwtProvider
 import com.petqua.domain.auth.token.SignUpTokenClaims
@@ -33,7 +33,7 @@ private const val SIGN_UP_AUTHORIZATION = "Sign-Up-Authorization"
 class AuthExtractor(
     private val jwtProvider: JwtProvider,
     private val memberRepository: MemberRepository,
-    private val authMemberRepository: AuthMemberRepository,
+    private val authCredentialsRepository: AuthCredentialsRepository,
 ) {
 
     fun hasAuthorizationHeader(request: HttpServletRequest): Boolean {
@@ -83,7 +83,7 @@ class AuthExtractor(
     fun getSignUpTokenClaimsOrThrow(token: String): SignUpTokenClaims {
         try {
             val signUpTokenClaims = SignUpTokenClaims.from(jwtProvider.getPayload(token))
-            authMemberRepository.existActiveByIdOrThrow(signUpTokenClaims.authMemberId) {
+            authCredentialsRepository.existActiveByIdOrThrow(signUpTokenClaims.authCredentialsId) {
                 AuthException(INVALID_SIGN_UP_TOKEN)
             }
             return signUpTokenClaims