feat: User API 구현 (회원가입, 내 정보 조회, 비밀번호 변경)

apps/commerce-api/build.gradle.kts

@@ -6,6 +6,9 @@ dependencies {
     implementation(project(":supports:logging"))
     implementation(project(":supports:monitoring"))
 
+    // security (for password encoding)
+    implementation("org.springframework.security:spring-security-crypto")
+
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
     implementation("org.springframework.boot:spring-boot-starter-actuator")

apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java

@@ -0,0 +1,30 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserService;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class UserFacade {
+
+    private final UserService userService;
+
+    public UserInfo register(String loginId, String rawPassword, String name, LocalDate birthDate, String email) {
+        User user = userService.register(loginId, rawPassword, name, birthDate, email);
+        return UserInfo.from(user);
+    }
+
+    public UserInfo getMe(String loginId, String rawPassword) {
+        User user = userService.authenticate(loginId, rawPassword);
+        return UserInfo.from(user);
+    }
+
+    public void changePassword(String loginId, String currentRawPassword, String newRawPassword) {
+        User user = userService.authenticate(loginId, currentRawPassword);
+        userService.changePassword(user.getId(), currentRawPassword, newRawPassword);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/application/user/UserInfo.java

@@ -0,0 +1,25 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.User;
+
+import java.time.LocalDate;
+
+public record UserInfo(
+    Long id,
+    String loginId,
+    String name,
+    String maskedName,
+    LocalDate birthDate,
+    String email
+) {
+    public static UserInfo from(User user) {
+        return new UserInfo(
+            user.getId(),
+            user.getLoginId(),
+            user.getName(),
+            user.getMaskedName(),
+            user.getBirthDate(),
+            user.getEmail()
+        );
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/User.java

@@ -0,0 +1,143 @@
+package com.loopers.domain.user;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+@Entity
+@Table(name = "users")
+public class User extends BaseEntity {
+
+    private static final String PASSWORD_PATTERN = "^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$";
+    private static final String LOGIN_ID_PATTERN = "^[a-zA-Z0-9]+$";
+
+    @Column(name = "login_id", nullable = false, unique = true, length = 50)
+    private String loginId;
+
+    @Column(name = "password", nullable = false, length = 255)
+    private String password;
+
+    @Column(name = "name", nullable = false, length = 100)
+    private String name;
+
+    @Column(name = "birth_date", nullable = false)
+    private LocalDate birthDate;
+
+    @Column(name = "email", nullable = false, length = 255)
+    private String email;
+
+    protected User() {}
+
+    public User(String loginId, String encodedPassword, String name, LocalDate birthDate, String email) {
+        validateLoginId(loginId);
+        validateName(name);
+        validateBirthDate(birthDate);
+        validateEmail(email);
+
+        this.loginId = loginId;
+        this.password = encodedPassword;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    public static void validateRawPassword(String rawPassword, LocalDate birthDate) {
+        if (rawPassword == null || rawPassword.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 비어있을 수 없습니다.");
+        }
+        if (rawPassword.length() < 8 || rawPassword.length() > 16) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자여야 합니다.");
+        }
+        if (!rawPassword.matches(PASSWORD_PATTERN)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문 대소문자, 숫자, 특수문자만 사용 가능합니다.");
+        }
+        if (birthDate != null && containsBirthDate(rawPassword, birthDate)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+
+    private static boolean containsBirthDate(String password, LocalDate birthDate) {
+        String yyyyMMdd = birthDate.format(DateTimeFormatter.ofPattern("yyyyMMdd"));
+        String yyMMdd = birthDate.format(DateTimeFormatter.ofPattern("yyMMdd"));
+        String yyyy_MM_dd = birthDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
+        String yy_MM_dd = birthDate.format(DateTimeFormatter.ofPattern("yy-MM-dd"));
+
+        return password.contains(yyyyMMdd) ||
+               password.contains(yyMMdd) ||
+               password.contains(yyyy_MM_dd) ||
+               password.contains(yy_MM_dd);
+    }
+
+    private void validateLoginId(String loginId) {
+        if (loginId == null || loginId.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 비어있을 수 없습니다.");
+        }
+        if (!loginId.matches(LOGIN_ID_PATTERN)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 영문과 숫자만 사용 가능합니다.");
+        }
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
+        }
+    }
+
+    private void validateBirthDate(LocalDate birthDate) {
+        if (birthDate == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비어있을 수 없습니다.");
+        }
+        if (birthDate.isAfter(LocalDate.now())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 미래일 수 없습니다.");
+        }
+    }
+
+    private void validateEmail(String email) {
+        if (email == null || email.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
+        }
+        if (!email.matches("^[^@]+@[^@]+\\.[^@]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+
+    public void changePassword(String newEncodedPassword) {
+        this.password = newEncodedPassword;
+    }
+
+    public String getMaskedName() {
+        if (name == null || name.isEmpty()) {
+            return name;
+        }
+        if (name.length() == 1) {
+            return "*";
+        }
+        return name.substring(0, name.length() - 1) + "*";
+    }
+
+    public String getLoginId() {
+        return loginId;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public LocalDate getBirthDate() {
+        return birthDate;
+    }
+
+    public String getEmail() {
+        return email;
+    }
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserRepository.java

@@ -0,0 +1,10 @@
+package com.loopers.domain.user;
+
+import java.util.Optional;
+
+public interface UserRepository {
+    User save(User user);
+    Optional<User> findById(Long id);
+    Optional<User> findByLoginId(String loginId);
+    boolean existsByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java

@@ -0,0 +1,70 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+
+@RequiredArgsConstructor
+@Component
+public class UserService {
+
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
+
+    @Transactional
+    public User register(String loginId, String rawPassword, String name, LocalDate birthDate, String email) {
+        if (userRepository.existsByLoginId(loginId)) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 로그인 ID입니다.");
+        }
+
+        User.validateRawPassword(rawPassword, birthDate);
+        String encodedPassword = passwordEncoder.encode(rawPassword);
+
+        User user = new User(loginId, encodedPassword, name, birthDate, email);
+        return userRepository.save(user);
+    }
+
+    @Transactional(readOnly = true)
+    public User getUser(Long id) {
+        return userRepository.findById(id)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+    }
+
+    @Transactional(readOnly = true)
+    public User getUserByLoginId(String loginId) {
+        return userRepository.findByLoginId(loginId)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+    }
+
+    @Transactional(readOnly = true)
+    public User authenticate(String loginId, String rawPassword) {
+        User user = getUserByLoginId(loginId);
+        if (!passwordEncoder.matches(rawPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호가 일치하지 않습니다.");
+        }
+        return user;
+    }
+
+    @Transactional
+    public void changePassword(Long userId, String currentRawPassword, String newRawPassword) {
+        User user = getUser(userId);
+
+        if (!passwordEncoder.matches(currentRawPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        if (passwordEncoder.matches(newRawPassword, user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호와 동일한 비밀번호는 사용할 수 없습니다.");
+        }
+
+        User.validateRawPassword(newRawPassword, user.getBirthDate());
+        String newEncodedPassword = passwordEncoder.encode(newRawPassword);
+        user.changePassword(newEncodedPassword);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserJpaRepository.java

@@ -0,0 +1,11 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.User;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+import java.util.Optional;
+
+public interface UserJpaRepository extends JpaRepository<User, Long> {
+    Optional<User> findByLoginId(String loginId);
+    boolean existsByLoginId(String loginId);
+}

apps/commerce-api/src/main/java/com/loopers/infrastructure/user/UserRepositoryImpl.java

@@ -0,0 +1,35 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserRepository;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.util.Optional;
+
+@RequiredArgsConstructor
+@Component
+public class UserRepositoryImpl implements UserRepository {
+
+    private final UserJpaRepository userJpaRepository;
+
+    @Override
+    public User save(User user) {
+        return userJpaRepository.save(user);
+    }
+
+    @Override
+    public Optional<User> findById(Long id) {
+        return userJpaRepository.findById(id);
+    }
+
+    @Override
+    public Optional<User> findByLoginId(String loginId) {
+        return userJpaRepository.findByLoginId(loginId);
+    }
+
+    @Override
+    public boolean existsByLoginId(String loginId) {
+        return userJpaRepository.existsByLoginId(loginId);
+    }
+}

apps/commerce-api/src/main/java/com/loopers/interfaces/api/user/UserV1ApiSpec.java

@@ -0,0 +1,26 @@
+package com.loopers.interfaces.api.user;
+
+import com.loopers.interfaces.api.ApiResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.Parameter;
+import io.swagger.v3.oas.annotations.tags.Tag;
+
+@Tag(name = "User", description = "사용자 API")
+public interface UserV1ApiSpec {
+
+    @Operation(summary = "회원가입", description = "새로운 사용자를 등록합니다.")
+    ApiResponse<UserV1Dto.RegisterResponse> register(UserV1Dto.RegisterRequest request);
+
+    @Operation(summary = "내 정보 조회", description = "로그인한 사용자의 정보를 조회합니다. 이름은 마스킹 처리됩니다.")
+    ApiResponse<UserV1Dto.UserResponse> getMe(
+        @Parameter(description = "로그인 ID", required = true) String loginId,
+        @Parameter(description = "비밀번호", required = true) String password
+    );
+
+    @Operation(summary = "비밀번호 변경", description = "비밀번호를 변경합니다.")
+    ApiResponse<Void> changePassword(
+        @Parameter(description = "로그인 ID", required = true) String loginId,
+        @Parameter(description = "비밀번호", required = true) String password,
+        UserV1Dto.ChangePasswordRequest request
+    );
+}