[volume-1] 회원가입, 내 정보 조회, 비밀번호 변경 기능 구현

apps/commerce-api/build.gradle.kts

@@ -8,6 +8,7 @@ dependencies {
 
     // web
     implementation("org.springframework.boot:spring-boot-starter-web")
+    implementation("org.springframework.security:spring-security-crypto")
     implementation("org.springframework.boot:spring-boot-starter-actuator")
     implementation("org.springdoc:springdoc-openapi-starter-webmvc-ui:${project.properties["springDocOpenApiVersion"]}")
 

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

@@ -0,0 +1,23 @@
+package com.loopers.application.user;
+
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+
+import java.time.LocalDate;
+
+public record SignUpCommand(
+        String loginId,
+        String password,
+        String name,
+        LocalDate birthDate,
+        String email
+) {
+    public static SignUpCommand from(UserV1Dto.CreateRequest request) {
+        return new SignUpCommand(
+                request.loginId(),
+                request.password(),
+                request.name(),
+                request.birthDate(),
+                request.email()
+        );
+    }
+}

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

@@ -0,0 +1,13 @@
+package com.loopers.application.user;
+
+import com.loopers.interfaces.api.user.dto.UserV1Dto;
+
+public record UpdatePasswordCommand(
+    String loginId,
+    String currentPassword,
+    String newPassword
+) {
+    public static UpdatePasswordCommand from(String loginId, String currentPassword, UserV1Dto.UpdatePasswordRequest request) {
+        return new UpdatePasswordCommand(loginId, currentPassword, request.newPassword());
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.loopers.application.user;
+
+import com.loopers.domain.user.User;
+
+import java.time.LocalDate;
+
+public record UserInfo(String loginId, String name, LocalDate birthDate, String email) {
+    public static UserInfo from(User user) {
+        return new UserInfo(
+            user.getLoginId(),
+            maskLastChar(user.getName()),
+            user.getBirthDate(),
+            user.getEmail()
+        );
+    }
+
+    private static String maskLastChar(String name) {
+        if (name == null || name.isBlank()) return name;
+        if (name.length() == 1) return "*";
+
+        return name.substring(0, name.length() - 1) + "*";
+    }
+}

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

@@ -0,0 +1,6 @@
+package com.loopers.domain.user;
+
+public interface PasswordEncoder {
+    String encode(String rawPassword);
+    boolean matches(String rawPassword, String encodedPassword);
+}

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

@@ -0,0 +1,25 @@
+package com.loopers.domain.user;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+
+public class PasswordPolicyValidator {
+
+    private static final DateTimeFormatter BIRTH_DATE_FORMAT_FOR_PASSWORD_CHECK = DateTimeFormatter.ofPattern("yyyyMMdd");
+    private static final String PASSWORD_PATTERN = "^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?~`]{8,16}$";
+
+    private PasswordPolicyValidator() {}
+
+    public static void validate(String password, LocalDate birthDate) {
+        if (!password.matches(PASSWORD_PATTERN)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자의 영문/숫자/특수문자만 가능합니다.");
+        }
+
+        String birthDateString = birthDate.format(BIRTH_DATE_FORMAT_FOR_PASSWORD_CHECK);
+        if (password.contains(birthDateString)) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import jakarta.transaction.Transactional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+
+@Service
+@Transactional
+@RequiredArgsConstructor
+public class SignUpService {
+    private final SignUpValidator signUpValidator;
+    private final PasswordEncoder passwordEncoder;
+    private final UserRepository userRepository;
+
+    public void signUp(SignUpCommand command) {
+        signUpValidator.validate(command);
+        String encodedPassword = passwordEncoder.encode(command.password());
+        User user = User.create(command, encodedPassword);
+
+        userRepository.save(user);
+    }
+}

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

@@ -0,0 +1,27 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+import java.time.LocalDate;
+
+@Component
+@RequiredArgsConstructor
+public class SignUpValidator {
+    private final UserRepository userRepository;
+
+    public void validate(SignUpCommand command) {
+        if (userRepository.findByLoginId(command.loginId()).isPresent()) {
+            throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 로그인 ID입니다.");
+        }
+
+        if (command.birthDate().isAfter(LocalDate.now())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 미래일 수 없습니다.");
+        }
+
+        PasswordPolicyValidator.validate(command.password(), command.birthDate());
+    }
+}

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

@@ -0,0 +1,95 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.SignUpCommand;
+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 lombok.Getter;
+
+import java.time.LocalDate;
+
+@Getter
+@Entity
+@Table(name = "users")
+public class User extends BaseEntity {
+    @Column(unique = true)
+    private String loginId;
+    private String password; // encoded
+    private String name;
+    private LocalDate birthDate;
+    private String email;
+
+    protected User() {}
+
+    private User(String loginId, String encodedPassword, String name, LocalDate birthDate, String email) {
+        validateLoginId(loginId);
+        validateEncodedPassword(encodedPassword);
+        validateName(name);
+        validateBirthDate(birthDate);
+        validateEmail(email);
+
+        this.loginId = loginId;
+        this.password = encodedPassword;
+        this.name = name;
+        this.birthDate = birthDate;
+        this.email = email;
+    }
+
+    public static User create(String loginId, String encodedPassword, String name, LocalDate birthDate, String email) {
+        return new User(loginId, encodedPassword, name, birthDate, email);
+    }
+
+    public static User create(SignUpCommand command, String encodedPassword) {
+        return new User(command.loginId(), encodedPassword, command.name(), command.birthDate(), command.email());
+
+    }
+
+    private void validateLoginId(String loginId) {
+        if (loginId == null || loginId.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 필수값입니다.");
+        }
+
+        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "로그인 ID는 영문/숫자만 가능합니다.");
+        }
+    }
+
+    private void validateEncodedPassword(String encodedPassword) {
+        if (encodedPassword == null || encodedPassword.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 필수값입니다.");
+        }
+    }
+
+    private void validateName(String name) {
+        if (name == null || name.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 필수값입니다.");
+        }
+
+        if (name.length() < 2) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이름은 최소 두글자 이상이어야 합니다.");
+        }
+    }
+
+    private void validateBirthDate(LocalDate birthDate) {
+        if (birthDate == null) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 필수값입니다.");
+        }
+    }
+
+    private void validateEmail(String email) {
+        if (email == null || email.isBlank()) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 필수값입니다.");
+        }
+
+        if (!email.contains("@") || !email.matches("^[\\w\\.]+@[\\w\\.]+\\.[a-zA-Z]{2,}$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "이메일 형식이 올바르지 않습니다.");
+        }
+    }
+
+    public void updatePassword(String newEncodedPassword) {
+        this.password = newEncodedPassword;
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.loopers.domain.user;
+
+import java.util.Optional;
+
+public interface UserRepository {
+    void save(User user);
+    Optional<User> findByLoginId(String loginId);
+}

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

@@ -0,0 +1,45 @@
+package com.loopers.domain.user;
+
+import com.loopers.application.user.UpdatePasswordCommand;
+import com.loopers.application.user.UserInfo;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Service
+public class UserService {
+    private final UserRepository userRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional
+    public void updatePassword(UpdatePasswordCommand command) {
+        User user = getUser(command.loginId());
+
+        if (!passwordEncoder.matches(command.currentPassword(), user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호가 일치하지 않습니다.");
+        }
+
+        if (passwordEncoder.matches(command.newPassword(), user.getPassword())) {
+            throw new CoreException(ErrorType.BAD_REQUEST, "현재 비밀번호와 동일한 비밀번호로 변경할 수 없습니다.");
+        }
+
+        PasswordPolicyValidator.validate(command.newPassword(), user.getBirthDate());
+        String encoded = passwordEncoder.encode(command.newPassword());
+        user.updatePassword(encoded);
+    }
+
+    @Transactional(readOnly = true)
+    public UserInfo getMyInfo(String loginId) {
+        User user = getUser(loginId);
+        return UserInfo.from(user);
+    }
+
+    private User getUser(String loginId) {
+        return userRepository.findByLoginId(loginId)
+                             .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND,
+                                                                  "[loginId = " + loginId + "] 를 찾을 수 없습니다."));
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.loopers.infrastructure.user;
+
+import com.loopers.domain.user.PasswordEncoder;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.stereotype.Component;
+
+@Component
+public class BcryptPasswordEncoder implements PasswordEncoder {
+    private final BCryptPasswordEncoder encoder = new BCryptPasswordEncoder();
+
+    @Override
+    public String encode(String rawPassword) {
+        return encoder.encode(rawPassword);
+    }
+
+    @Override
+    public boolean matches(String rawPassword, String encodedPassword) {
+        return encoder.matches(rawPassword, encodedPassword);
+    }
+}

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

@@ -0,0 +1,10 @@
+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);
+}