Feat: 헥사고날 아키텍쳐 기반 Auth 및 OAuth 로직 구현 (NEWZET 경험 기반 고도화)

.github/workflows/dev_deploy.yml

@@ -34,15 +34,6 @@ jobs:
 
       - name: 🏗️ Build with Gradle
         run: ./gradlew build
-        env:
-          REDIS_HOST: ${{ secrets.REDIS_HOST }}
-          REDIS_PORT: ${{ secrets.REDIS_PORT }}
-          REDIS_PASSWORD: ${{ secrets.REDIS_PASSWORD }}
-          MYSQL_HOST: ${{ secrets.MYSQL_HOST }}
-          MYSQL_PORT: ${{ secrets.MYSQL_PORT }}
-          MYSQL_USER: ${{ secrets.MYSQL_USER }}
-          MYSQL_PASSWORD: ${{ secrets.MYSQL_PASSWORD }}
-          MYSQL_DATABASE: ${{ secrets.MYSQL_DATABASE }}
 
       - name: Log in to Docker Hub
         uses: docker/login-action@v2

.github/workflows/pr_test.yml

@@ -9,22 +9,6 @@ jobs:
   test:
     runs-on: ubuntu-latest
 
-    services:
-      mysql:
-        image: mysql:8.0
-        env:
-          MYSQL_ROOT_PASSWORD: root
-          MYSQL_DATABASE: ddip_test
-          MYSQL_USER: user
-          MYSQL_PASSWORD: password
-        ports:
-          - 3306:3306
-        options: >-
-          --health-cmd="mysqladmin ping -h localhost"
-          --health-interval=5s
-          --health-timeout=5s
-          --health-retries=10
-
     steps:
       - name: Checkout code
         uses: actions/checkout@v4
@@ -37,15 +21,6 @@ jobs:
 
       - name: Run Gradle Tests
         run: ./gradlew test jacocoTestReport
-        env:
-          MYSQL_HOST: localhost
-          MYSQL_PORT: 3306
-          MYSQL_USER: user
-          MYSQL_PASSWORD: password
-          MYSQL_DATABASE: ddip_test
-          REDIS_HOST: ${{ secrets.REDIS_HOST }}
-          REDIS_PORT: ${{ secrets.REDIS_PORT }}
-          REDIS_PASSWORD: ${{ secrets.REDIS_PASSWORD }}
 
       - name: Write coverage comments on PR
         uses: madrapps/jacoco-report@v1.6.1

build.gradle

@@ -40,7 +40,6 @@ dependencies {
 	// Database & Redis
 	runtimeOnly 'com.mysql:mysql-connector-j'
 	implementation 'org.springframework.boot:spring-boot-starter-data-redis'
-	implementation 'org.redisson:redisson-spring-boot-starter:3.23.1'
 	implementation 'org.springframework.session:spring-session-data-redis'
 
 	// Lombok
@@ -51,6 +50,8 @@ dependencies {
 
 	// Test Dependencies
 	testImplementation 'org.springframework.boot:spring-boot-starter-test'
+	testImplementation 'org.testcontainers:testcontainers:1.20.5'
+	testImplementation 'org.testcontainers:junit-jupiter:1.20.5'
 
 	// monitoring
 	implementation 'io.micrometer:micrometer-registry-prometheus'

src/main/java/com/knu/ddip/DdipApplication.java

@@ -6,8 +6,8 @@
 @SpringBootApplication
 public class DdipApplication {
 
-	public static void main(String[] args) {
-		SpringApplication.run(DdipApplication.class, args);
-	}
+    public static void main(String[] args) {
+        SpringApplication.run(DdipApplication.class, args);
+    }
 
 }

src/main/java/com/knu/ddip/auth/business/dto/JwtRefreshRequest.java

@@ -0,0 +1,7 @@
+package com.knu.ddip.auth.business.dto;
+
+public record JwtRefreshRequest(
+        String refreshToken,
+        String deviceType
+) {
+}

src/main/java/com/knu/ddip/auth/business/dto/JwtResponse.java

@@ -0,0 +1,7 @@
+package com.knu.ddip.auth.business.dto;
+
+public record JwtResponse(
+        String accessToken,
+        String refreshToken
+) {
+}

src/main/java/com/knu/ddip/auth/business/dto/OAuthContext.java

@@ -0,0 +1,16 @@
+package com.knu.ddip.auth.business.dto;
+
+import com.knu.ddip.auth.domain.DeviceType;
+import com.knu.ddip.auth.domain.OAuthProvider;
+import lombok.AccessLevel;
+import lombok.Builder;
+
+@Builder(access = AccessLevel.PRIVATE)
+public record OAuthContext(OAuthProvider oAuthProvider, DeviceType deviceType) {
+    public static OAuthContext of(OAuthProvider oAuthProvider, DeviceType deviceType) {
+        return OAuthContext.builder()
+                .oAuthProvider(oAuthProvider)
+                .deviceType(deviceType)
+                .build();
+    }
+}

src/main/java/com/knu/ddip/auth/business/dto/OAuthLoginResponse.java

@@ -0,0 +1,29 @@
+package com.knu.ddip.auth.business.dto;
+
+import lombok.AccessLevel;
+import lombok.Builder;
+
+import java.util.UUID;
+
+@Builder(access = AccessLevel.PROTECTED)
+public record OAuthLoginResponse(
+        String accessToken,
+        String refreshToken,
+        UUID OAuthMappingEntityId,
+        boolean needRegister
+) {
+    public static OAuthLoginResponse toJwt(String accessToken, String refreshToken) {
+        return OAuthLoginResponse.builder()
+                .accessToken(accessToken)
+                .refreshToken(refreshToken)
+                .needRegister(false)
+                .build();
+    }
+
+    public static OAuthLoginResponse toSignUp(UUID OAuthMappingEntityId) {
+        return OAuthLoginResponse.builder()
+                .OAuthMappingEntityId(OAuthMappingEntityId)
+                .needRegister(true)
+                .build();
+    }
+}

src/main/java/com/knu/ddip/auth/business/dto/OAuthMappingEntityDto.java

@@ -0,0 +1,37 @@
+package com.knu.ddip.auth.business.dto;
+
+import com.knu.ddip.auth.domain.OAuthProvider;
+import com.knu.ddip.auth.domain.OAuthToken;
+import lombok.AccessLevel;
+import lombok.Builder;
+import lombok.Getter;
+
+import java.util.UUID;
+
+@Getter
+@Builder(access = AccessLevel.PROTECTED)
+public class OAuthMappingEntityDto {
+    private final UUID id;
+    private final String socialUserId;
+    private final String socialUserEmail;
+    private final String socialUserName;
+    private final OAuthProvider provider;
+    private final UUID userId;
+    private final OAuthToken oauthToken;
+    private final boolean temporary;
+
+    public static OAuthMappingEntityDto create(UUID id, String providerId, String providerEmail,
+                                               String providerName, OAuthProvider provider,
+                                               UUID userId, OAuthToken oauthToken, boolean temporary) {
+        return OAuthMappingEntityDto.builder()
+                .id(id)
+                .socialUserId(providerId)
+                .socialUserEmail(providerEmail)
+                .socialUserName(providerName)
+                .provider(provider)
+                .userId(userId)
+                .oauthToken(oauthToken)
+                .temporary(temporary)
+                .build();
+    }
+}

src/main/java/com/knu/ddip/auth/business/dto/OAuthTokenDto.java

@@ -0,0 +1,20 @@
+package com.knu.ddip.auth.business.dto;
+
+import com.knu.ddip.auth.domain.OAuthToken;
+import lombok.AccessLevel;
+import lombok.Builder;
+
+@Builder(access = AccessLevel.PRIVATE)
+public record OAuthTokenDto(
+        String accessToken,
+        String refreshToken,
+        long expiresIn) {
+
+    public static OAuthTokenDto from(OAuthToken oAuthToken) {
+        return OAuthTokenDto.builder()
+                .accessToken(oAuthToken.getAccessToken())
+                .refreshToken(oAuthToken.getRefreshToken())
+                .expiresIn(oAuthToken.getExpiresIn())
+                .build();
+    }
+}

src/main/java/com/knu/ddip/auth/business/dto/TokenDTO.java

@@ -0,0 +1,13 @@
+package com.knu.ddip.auth.business.dto;
+
+import lombok.AccessLevel;
+import lombok.Builder;
+
+@Builder(access = AccessLevel.PRIVATE)
+public record TokenDTO(
+        String value
+) {
+    public static TokenDTO from(String value) {
+        return TokenDTO.builder().value(value).build();
+    }
+}

src/main/java/com/knu/ddip/auth/business/service/JwtFactory.java

@@ -0,0 +1,72 @@
+package com.knu.ddip.auth.business.service;
+
+import com.knu.ddip.auth.domain.Token;
+import com.knu.ddip.auth.domain.TokenType;
+import io.jsonwebtoken.Claims;
+import io.jsonwebtoken.Jwts;
+import io.jsonwebtoken.security.Keys;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.stereotype.Component;
+
+import javax.crypto.SecretKey;
+import java.util.Date;
+import java.util.Optional;
+import java.util.UUID;
+
+@Component
+public class JwtFactory {
+    public static final long REFRESH_TOKEN_VALIDITY_MILLISECONDS = 14 * 24 * 60 * 60 * 1000;
+    private static final long ACCESS_TOKEN_VALIDITY_MILLISECONDS = 30 * 60 * 1000;
+    private final SecretKey secretKey;
+
+    public JwtFactory(@Value("${SECRET_KEY}") String secret) {
+        this.secretKey = Keys.hmacShaKeyFor(secret.getBytes());
+    }
+
+    public Token createAccessToken(UUID userId) {
+        return createToken(userId, TokenType.ACCESS, ACCESS_TOKEN_VALIDITY_MILLISECONDS);
+    }
+
+    public Token createRefreshToken(UUID userId) {
+        return createToken(userId, TokenType.REFRESH, REFRESH_TOKEN_VALIDITY_MILLISECONDS);
+    }
+
+    private Token createToken(UUID userId, TokenType tokenType, long validityInMilliseconds) {
+        Date now = new Date();
+        Date validity = new Date(now.getTime() + validityInMilliseconds);
+
+        String tokenValue = Jwts.builder()
+                .subject(String.valueOf(userId))
+                .issuedAt(now)
+                .expiration(validity)
+                .claim("type", tokenType.name())
+                .signWith(secretKey)
+                .compact();
+
+        return Token.of(tokenType, tokenValue, String.valueOf(userId), now, validity);
+    }
+
+    public Optional<Token> parseToken(String tokenValue) {
+        if (tokenValue == null || tokenValue.isEmpty()) {
+            return Optional.empty();
+        }
+
+        try {
+            Claims claims = Jwts.parser()
+                    .verifyWith(secretKey)
+                    .build()
+                    .parseSignedClaims(tokenValue)
+                    .getPayload();
+
+            String subject = claims.getSubject();
+            Date issuedAt = claims.getIssuedAt();
+            Date expiration = claims.getExpiration();
+            String tokenTypeStr = claims.get("type", String.class);
+            TokenType tokenType = TokenType.valueOf(tokenTypeStr);
+
+            return Optional.of(Token.of(tokenType, tokenValue, subject, issuedAt, expiration));
+        } catch (Exception e) {
+            return Optional.empty();
+        }
+    }
+}

src/main/java/com/knu/ddip/auth/business/service/JwtService.java

@@ -0,0 +1,46 @@
+package com.knu.ddip.auth.business.service;
+
+import com.knu.ddip.auth.business.dto.JwtRefreshRequest;
+import com.knu.ddip.auth.business.dto.JwtResponse;
+import com.knu.ddip.auth.business.dto.TokenDTO;
+import com.knu.ddip.auth.business.validator.JwtValidator;
+import com.knu.ddip.auth.domain.Token;
+import com.knu.ddip.auth.exception.TokenBadRequestException;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+import java.util.UUID;
+
+@Service
+@RequiredArgsConstructor
+public class JwtService {
+    private final JwtFactory jwtFactory;
+    private final TokenRepository tokenRepository;
+    private final JwtValidator JWTValidator;
+
+    public JwtResponse refreshAccessToken(JwtRefreshRequest request) {
+        String refreshTokenValue = request.refreshToken();
+        String deviceType = request.deviceType();
+
+        Token refreshToken = jwtFactory.parseToken(refreshTokenValue)
+                .orElseThrow(() -> new TokenBadRequestException("유효하지 않은 토큰입니다."));
+
+        UUID userId = UUID.fromString(refreshToken.getSubject());
+
+        JWTValidator.validateRefreshToken(refreshToken, userId, deviceType);
+
+        Token newAccessToken = jwtFactory.createAccessToken(userId);
+        Token newRefreshToken = jwtFactory.createRefreshToken(userId);
+
+        TokenDTO newRefreshTokenDTO = newRefreshToken.toTokenDTO();
+
+        tokenRepository.saveToken(userId, deviceType, newRefreshTokenDTO);
+        tokenRepository.updateLastRefreshTime(userId, deviceType);
+
+        return new JwtResponse(newAccessToken.getValue(), newRefreshToken.getValue());
+    }
+
+    public void logout(UUID userId, String deviceType) {
+        tokenRepository.removeToken(userId, deviceType);
+    }
+}