From c0dcfd8aa69e2c7e316fd19b2c35527541e59906 Mon Sep 17 00:00:00 2001
From: "hanyoung.park" <hanyoung.park@kurlycorp.com>
Date: Mon, 2 Feb 2026 01:26:59 +0900
Subject: [PATCH 1/8] remove: deprecated codeguide

---
 .codeguide/loopers-1-week.md | 45 ------------------------------------
 1 file changed, 45 deletions(-)
 delete mode 100644 .codeguide/loopers-1-week.md

diff --git a/.codeguide/loopers-1-week.md b/.codeguide/loopers-1-week.md
deleted file mode 100644
index a8ace53e..00000000
--- a/.codeguide/loopers-1-week.md
+++ /dev/null
@@ -1,45 +0,0 @@
-## 🧪 Implementation Quest
-
-> 지정된 **단위 테스트 / 통합 테스트 / E2E 테스트 케이스**를 필수로 구현하고, 모든 테스트를 통과시키는 것을 목표로 합니다.
-
-### 회원 가입
-
-**🧱 단위 테스트**
-
-- [ ]  ID 가 `영문 및 숫자 10자 이내` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  이메일이 `xx@yy.zz` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-- [ ]  생년월일이 `yyyy-MM-dd` 형식에 맞지 않으면, User 객체 생성에 실패한다.
-
-**🔗 통합 테스트**
-
-- [ ]  회원 가입시 User 저장이 수행된다. ( spy 검증 )
-- [ ]  이미 가입된 ID 로 회원가입 시도 시, 실패한다.
-
-**🌐 E2E 테스트**
-
-- [ ]  회원 가입이 성공할 경우, 생성된 유저 정보를 응답으로 반환한다.
-- [ ]  회원 가입 시에 성별이 없을 경우, `400 Bad Request` 응답을 반환한다.
-
-### 내 정보 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 회원 정보가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  내 정보 조회에 성공할 경우, 해당하는 유저 정보를 응답으로 반환한다.
-- [ ]  존재하지 않는 ID 로 조회할 경우, `404 Not Found` 응답을 반환한다.
-
-### 포인트 조회
-
-**🔗 통합 테스트**
-
-- [ ]  해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.
-- [ ]  해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.
-
-**🌐 E2E 테스트**
-
-- [ ]  포인트 조회에 성공할 경우, 보유 포인트를 응답으로 반환한다.
-- [ ]  `X-USER-ID` 헤더가 없을 경우, `400 Bad Request` 응답을 반환한다.

From 49e1d7232d6a4c62c38deb79e59d4e2176100850 Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Thu, 5 Feb 2026 01:01:34 +0900
Subject: [PATCH 2/8] =?UTF-8?q?feat:=20=ED=9A=8C=EC=9B=90=EA=B0=80?=
 =?UTF-8?q?=EC=9E=85=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../application/member/MemberFacade.java      | 31 ++++++
 .../application/member/MemberInfo.java        | 15 +++
 .../com/loopers/config/SecurityConfig.java    | 15 +++
 .../loopers/domain/member/MemberModel.java    | 99 +++++++++++++++++++
 .../domain/member/MemberRepository.java       |  9 ++
 .../loopers/domain/member/MemberService.java  | 39 ++++++++
 .../member/MemberJpaRepository.java           | 11 +++
 .../member/MemberRepositoryImpl.java          | 29 ++++++
 .../api/member/MemberV1ApiSpec.java           | 23 +++++
 .../api/member/MemberV1Controller.java        | 36 +++++++
 .../interfaces/api/member/MemberV1Dto.java    | 25 +++++
 .../member/MemberServiceIntegrationTest.java  | 91 +++++++++++++++++
 build.gradle.kts                              | 49 +++++----
 docker/infra-compose.yml                      |  2 +-
 modules/jpa/src/main/resources/jpa.yml        |  2 +-
 15 files changed, 455 insertions(+), 21 deletions(-)
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
 create mode 100644 apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java

diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
new file mode 100644
index 00000000..335399d2
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -0,0 +1,31 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.MemberModel;
+import com.loopers.domain.member.MemberService;
+import com.loopers.interfaces.api.member.MemberV1Dto;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberFacade {
+
+  private final MemberService memberService;
+
+  public MemberInfo signupMember(MemberV1Dto.SignUpRequest request) {
+    // 1. Request → MemberModel로 변환
+    MemberModel memberModel = new MemberModel(
+        request.loginId(),
+        request.password(),
+        request.name(),
+        request.birthDate(),
+        request.email()
+    );
+
+    // 2. Service 호출 (저장 + 중복 체크)
+    MemberModel saved = memberService.saveMember(memberModel);
+
+    // 3. MemberModel → MemberInfo로 변환해서 반환
+    return MemberInfo.from(saved);
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
new file mode 100644
index 00000000..2ae39624
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
@@ -0,0 +1,15 @@
+package com.loopers.application.member;
+
+import com.loopers.domain.member.MemberModel;
+
+// MemberInfo는 Facade → Controller로 전달되는 데이터
+public record MemberInfo(String loginId, String name, String birthDate, String email) {
+    public static MemberInfo from(MemberModel model) {
+        return new MemberInfo(
+            model.getLoginId(),
+            model.getName(),
+            model.getBirthDate(),
+            model.getEmail()
+          );
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java b/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java
new file mode 100644
index 00000000..7e23f737
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/config/SecurityConfig.java
@@ -0,0 +1,15 @@
+package com.loopers.config;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
+import org.springframework.security.crypto.password.PasswordEncoder;
+
+@Configuration
+public class SecurityConfig {
+
+  @Bean
+  public PasswordEncoder passwordEncoder() {
+    return new BCryptPasswordEncoder();
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
new file mode 100644
index 00000000..4ba20abd
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
@@ -0,0 +1,99 @@
+package com.loopers.domain.member;
+
+import com.loopers.domain.BaseEntity;
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Table;
+
+@Entity
+@Table(name = "member")
+public class MemberModel extends BaseEntity {
+
+    private String loginId;
+    private String password ;
+    private String name;
+    private String birthDate;
+    private String email;
+
+    protected MemberModel() {}
+
+    public MemberModel(String loginId, String password, String name, String birthDate, String email) {
+
+      // 모든 항목은 비어 있을 수 없다
+      if (loginId == null || loginId.isBlank()) {
+        throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
+      }
+      if (password == null || password.isBlank()) {
+        throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 비어있을 수 없습니다.");
+      }
+      if (name == null || name.isBlank()) {
+        throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
+      }
+      if (birthDate == null || birthDate.isBlank()) {
+          throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비어있을 수 없습니다.");
+      }
+      if (email == null || email.isBlank()) {
+        throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
+      }
+
+      // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
+      // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
+      // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
+      // 비밀번호 규칙 검증
+      validatePassword(password, birthDate);
+
+      this.loginId = loginId;
+      this.password = password;
+      this.name = name;
+      this.birthDate = birthDate;
+      this.email = email;
+    }
+
+    public String getLoginId() {
+      return loginId;
+    }
+
+    public String getPassword() {
+      return password;
+    }
+
+    public String getName() {
+      return name;
+    }
+
+    public String getBirthDate() {
+      return birthDate;
+    }
+
+    public String getEmail() {
+      return email;
+    }
+
+    private void validatePassword(String password, String birthDate) {
+        // 1. 8~16자 길이 체크
+        if (password.length() < 8 || password.length() > 16) {
+            throw new CoreException(ErrorType.BAD_REQUEST,
+                "비밀번호는 8~16자여야 합니다.");
+        }
+
+        // 2. 영문 대소문자, 숫자, 특수문자만 허용 (한글, 공백 등 불가)
+        if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
+            throw new CoreException(ErrorType.BAD_REQUEST,
+                "비밀번호는 영문 대소문자, 숫자, 특수문자만 가능합니다.");
+        }
+
+        // 3. 생년월일이 비밀번호에 포함되면 안됨
+        if (password.contains(birthDate)) {
+            throw new CoreException(ErrorType.BAD_REQUEST,
+                "비밀번호에 생년월일을 포함할 수 없습니다.");
+        }
+    }
+
+    // 암호화된 비밀번호를 엔티티에 넣어주기
+    public void encryptPassword(String encryptedPassword) {
+      this.password = encryptedPassword;
+    }
+
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
new file mode 100644
index 00000000..1d703f71
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -0,0 +1,9 @@
+package com.loopers.domain.member;
+
+import java.util.Optional;
+
+public interface MemberRepository {
+    MemberModel save(MemberModel memberModel);
+    Optional<MemberModel> update(MemberModel memberModel);
+    Optional<MemberModel> findByLoginId(String id);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
new file mode 100644
index 00000000..ec62150a
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -0,0 +1,39 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.security.crypto.password.PasswordEncoder;
+import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
+
+@RequiredArgsConstructor
+@Component
+public class MemberService {
+
+    private final MemberRepository memberRepository;
+    private final PasswordEncoder passwordEncoder;
+
+    @Transactional(readOnly = false)
+      public MemberModel saveMember(MemberModel memberModel) {
+        //저장하기 전에 이미 같은 loginId가 있는지 확인
+        Optional<MemberModel> existing = memberRepository.findByLoginId(memberModel.getLoginId());
+        if (existing.isPresent()) {
+          throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
+        }
+
+        // 비밀번호 암호화 후 저장
+        String encrypted = passwordEncoder.encode(memberModel.getPassword());
+        memberModel.encryptPassword(encrypted);
+        memberRepository.save(memberModel);
+
+        return getMember(memberModel.getLoginId());
+      }
+
+    @Transactional(readOnly = true)
+    public MemberModel getMember(String id) {
+        return memberRepository.findByLoginId(id)
+            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + id + "] 회원을 찾을 수 없습니다."));
+    }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
new file mode 100644
index 00000000..0bcc2c78
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberJpaRepository.java
@@ -0,0 +1,11 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.MemberModel;
+import java.util.Optional;
+import org.springframework.data.jpa.repository.JpaRepository;
+
+public interface MemberJpaRepository extends JpaRepository<MemberModel, Long> {
+
+  Optional<MemberModel> findByLoginId(String loginId);
+  MemberModel save(MemberModel memberModel);
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
new file mode 100644
index 00000000..17e86c5d
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/infrastructure/member/MemberRepositoryImpl.java
@@ -0,0 +1,29 @@
+package com.loopers.infrastructure.member;
+
+import com.loopers.domain.member.MemberModel;
+import com.loopers.domain.member.MemberRepository;
+import java.util.Optional;
+import lombok.RequiredArgsConstructor;
+import org.springframework.stereotype.Component;
+
+@RequiredArgsConstructor
+@Component
+public class MemberRepositoryImpl implements MemberRepository {
+
+  private final MemberJpaRepository memberJpaRepository;
+
+  @Override
+  public MemberModel save(MemberModel memberModel) {
+    return memberJpaRepository.save(memberModel);
+  }
+
+  @Override
+  public Optional<MemberModel> update(MemberModel memberModel) {
+    return Optional.empty();
+  }
+
+  @Override
+  public Optional<MemberModel> findByLoginId(String id) {
+    return memberJpaRepository.findByLoginId(id);
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
new file mode 100644
index 00000000..c312ab9f
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -0,0 +1,23 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
+import io.swagger.v3.oas.annotations.Operation;
+import io.swagger.v3.oas.annotations.media.Schema;
+import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.PostMapping;
+
+@Tag(name = "Member V1 API", description = "회원 API")
+public interface MemberV1ApiSpec {
+
+  @Operation(
+      summary = "회원 가입 요청",
+      description = "주어진 정보를 가지고 회원 가입을 실행한다"
+  )
+    // @Schema는 Swagger API 문서에서 파라미터 설명을 보여주는 용도
+    // 예제에서는 Long exampleId 같은 단일 파라미터에 붙였는데, 지금은 SignUpRequest로 통째로 받으니까 여기엔 필요 없음
+  ApiResponse<MemberV1Dto.SignUpResponse> signUp(
+      MemberV1Dto.SignUpRequest request
+  );
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
new file mode 100644
index 00000000..744937a7
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -0,0 +1,36 @@
+package com.loopers.interfaces.api.member;
+
+import com.loopers.application.member.MemberFacade;
+import com.loopers.application.member.MemberInfo;
+import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.SignUpRequest;
+import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
+import lombok.RequiredArgsConstructor;
+import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.PostMapping;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.ResponseStatus;
+import org.springframework.web.bind.annotation.RestController;
+
+@RequiredArgsConstructor
+@RestController
+@RequestMapping("/api/v1/members")
+public class MemberV1Controller implements MemberV1ApiSpec {
+
+  //  클라이언트 → [SignUpRequest (record)] → Controller → Facade → Service → [MemberModel (entity)] → DB
+  //                   요청 데이터 전달용                                           DB에 저장되는 객체
+  //  DB → [MemberModel (entity)] → Facade → [SignUpResponse (record)] → Controller → 클라이언트
+  //            DB에서 꺼낸 객체                     응답 데이터 전달용
+  private final MemberFacade memberFacade;
+
+  @PostMapping
+  @ResponseStatus(HttpStatus.CREATED)
+  @Override
+  public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
+    MemberInfo info = memberFacade.signupMember(request);
+    MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
+    return ApiResponse.success(response);
+  }
+
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
new file mode 100644
index 00000000..e1545299
--- /dev/null
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -0,0 +1,25 @@
+package com.loopers.interfaces.api.member;
+
+
+import com.loopers.application.member.MemberInfo;
+
+public class MemberV1Dto {
+
+    // Request: POST방식으로 보낼때 데이터를 담는 그릇 (from 필요 없음)
+    public record SignUpRequest(
+        String loginId,
+        String password,
+        String name,
+        String birthDate,
+        String email
+    ) {}
+
+    // Response: 변환 메서드(from)가 여기에!
+    public record SignUpResponse(String loginId) {
+      public static SignUpResponse from(MemberInfo info) {
+        return new SignUpResponse(info.loginId());
+      }
+    }
+
+
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
new file mode 100644
index 00000000..7cb23df8
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
@@ -0,0 +1,91 @@
+package com.loopers.domain.member;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@SpringBootTest
+class MemberServiceIntegrationTest {
+
+  @Autowired
+  private MemberService memberService;
+
+  @Autowired
+  private DatabaseCleanUp databaseCleanUp;
+
+  @AfterEach
+  void tearDown() {
+    databaseCleanUp.truncateAllTables();
+  }
+
+  @DisplayName("회원가입을 성공한다")
+  @Nested
+  class SaveMember {
+
+    @DisplayName("회원가입에 필요한 정보가 들어오면 디비에 저장하고 저장한 아이디를 조회한다")
+    @Test
+    void returnsMemberInfo_whenValidMemberInfoIsProvided() {
+      // arrange
+      MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
+
+      // act
+      memberService.saveMember(memberModel);
+      MemberModel result = memberService.getMember(memberModel.getLoginId());
+
+      // assert
+      assertAll(
+          () -> assertThat(result).isNotNull(),
+          () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()),
+          () -> assertThat(result.getName()).isEqualTo(memberModel.getName()),
+          () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()),
+          () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail())
+      );
+    }
+
+    @DisplayName("중복 ID로 가입 시도하면 예외가 발생한다")
+    @Test
+    void throwsException_whenExistIdIsTryToSaveMember() {
+      // arrange - 먼저 한 명 가입시키기
+      memberService.saveMember(new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com"));
+
+      // act - 같은 ID로 또 가입 시도
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.saveMember(new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com"));
+      });
+
+      // assert
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.CONFLICT);
+    }
+
+  }
+
+  @DisplayName("회원을 조회할 때, ")
+  @Nested
+  class GetMember {
+
+    @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
+    @Test
+    void throwsException_whenMemberNotFound() {
+      // arrange
+      String loginId = "testuser"; // Assuming this ID does not exist
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.getMember(loginId);
+      });
+
+      // assert
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.NOT_FOUND);
+    }
+  }
+}
diff --git a/build.gradle.kts b/build.gradle.kts
index 9c8490b8..6f9ce28b 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -34,10 +34,16 @@ allprojects {
 }
 
 subprojects {
+    val containerProjects = setOf("apps", "modules", "supports")
+
     apply(plugin = "java")
     apply(plugin = "org.springframework.boot")
     apply(plugin = "io.spring.dependency-management")
-    apply(plugin = "jacoco")
+
+    // TODO: JDK 24 환경에서 JacocoReport 태스크 생성 오류 발생 - JDK 21로 전환 후 활성화 필요
+    // if (name !in containerProjects) {
+    //     apply(plugin = "jacoco")
+    // }
 
     dependencyManagement {
         imports {
@@ -55,6 +61,8 @@ subprojects {
         // Lombok
         implementation("org.projectlombok:lombok")
         annotationProcessor("org.projectlombok:lombok")
+        // 암호화
+        implementation ("org.springframework.security:spring-security-crypto")
         // Test
         testRuntimeOnly("org.junit.platform:junit-platform-launcher")
         // testcontainers:mysql 이 jdbc 사용함
@@ -85,24 +93,27 @@ subprojects {
         jvmArgs("-Xshare:off")
     }
 
-    tasks.withType<JacocoReport> {
-        mustRunAfter("test")
-        executionData(fileTree(layout.buildDirectory.asFile).include("jacoco/*.exec"))
-        reports {
-            xml.required = true
-            csv.required = false
-            html.required = false
-        }
-        afterEvaluate {
-            classDirectories.setFrom(
-                files(
-                    classDirectories.files.map {
-                        fileTree(it)
-                    },
-                ),
-            )
-        }
-    }
+    // TODO: JDK 24 환경에서 JacocoReport 태스크 생성 오류 발생 - JDK 21로 전환 후 활성화 필요
+    // if (name !in containerProjects) {
+    //     tasks.withType<JacocoReport> {
+    //         mustRunAfter("test")
+    //         executionData(fileTree(layout.buildDirectory.asFile).include("jacoco/*.exec"))
+    //         reports {
+    //             xml.required = true
+    //             csv.required = false
+    //             html.required = false
+    //         }
+    //         afterEvaluate {
+    //             classDirectories.setFrom(
+    //                 files(
+    //                     classDirectories.files.map {
+    //                         fileTree(it)
+    //                     },
+    //                 ),
+    //             )
+    //         }
+    //     }
+    // }
 }
 
 // module-container 는 task 를 실행하지 않도록 한다.
diff --git a/docker/infra-compose.yml b/docker/infra-compose.yml
index 18e5fcf5..6921cb39 100644
--- a/docker/infra-compose.yml
+++ b/docker/infra-compose.yml
@@ -3,7 +3,7 @@ services:
   mysql:
     image: mysql:8.0
     ports:
-      - "3306:3306"
+      - "3307:3306"
     environment:
       - MYSQL_ROOT_PASSWORD=root
       - MYSQL_USER=application
diff --git a/modules/jpa/src/main/resources/jpa.yml b/modules/jpa/src/main/resources/jpa.yml
index 37f4fb1b..8b90b1c7 100644
--- a/modules/jpa/src/main/resources/jpa.yml
+++ b/modules/jpa/src/main/resources/jpa.yml
@@ -42,7 +42,7 @@ spring:
 datasource:
   mysql-jpa:
     main:
-      jdbc-url: jdbc:mysql://localhost:3306/loopers
+      jdbc-url: jdbc:mysql://localhost:3307/loopers
       username: application
       password: application
 

From d4a67a77a40a4e51ffef11e0bed1ee9d90c4ade8 Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Thu, 5 Feb 2026 01:02:14 +0900
Subject: [PATCH 3/8] =?UTF-8?q?feat:=20=ED=9A=8C=EC=9B=90=EA=B0=80?=
 =?UTF-8?q?=EC=9E=85=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 CLAUDE.md                                     | 166 ++++++++++++++++++
 .../domain/member/MemberModelTest.java        | 118 +++++++++++++
 .../interfaces/api/MemberV1ApiE2ETest.java    | 100 +++++++++++
 3 files changed, 384 insertions(+)
 create mode 100644 CLAUDE.md
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
 create mode 100644 apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java

diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..e57d39ca
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1,166 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Tech Stack & Versions
+
+| Category | Technology | Version |
+|----------|------------|---------|
+| Language | Java | 21 |
+| Framework | Spring Boot | 3.4.4 |
+| Dependency Management | Spring Dependency Management | 1.1.7 |
+| Cloud | Spring Cloud | 2024.0.1 |
+| Build Tool | Gradle (Kotlin DSL) | 8.13+ |
+| API Documentation | SpringDoc OpenAPI | 2.7.0 |
+| ORM | Spring Data JPA + QueryDSL | (managed by Spring Boot) |
+| Database | MySQL | 8.0 |
+| Cache | Redis (Master-Replica) | - |
+| Messaging | Kafka | 3.5.1 |
+| Monitoring | Micrometer + Prometheus | (managed by Spring Boot) |
+| Logging | Logback + Slack Appender | 1.6.1 |
+| Testing | JUnit 5, Mockito 5.14.0, SpringMockk 4.0.2, Instancio 5.0.2 | - |
+| Containers | TestContainers | (managed by Spring Boot) |
+
+## Build & Run Commands
+
+```bash
+# Build all modules
+./gradlew build
+
+# Run tests (profile: test, timezone: Asia/Seoul)
+./gradlew test
+
+# Run specific app
+./gradlew :apps:commerce-api:bootRun
+./gradlew :apps:commerce-batch:bootRun --args='--job.name=jobName'
+./gradlew :apps:commerce-streamer:bootRun
+
+# Build specific module
+./gradlew :apps:commerce-api:build
+
+# Run single test class
+./gradlew test --tests "com.loopers.ExampleServiceIntegrationTest"
+
+# Run single test method
+./gradlew test --tests "com.loopers.ExampleServiceIntegrationTest.testMethodName"
+
+# Test with coverage report
+./gradlew test jacocoTestReport
+```
+
+**Java version**: 21 (configured via Gradle toolchain)
+
+## Local Infrastructure
+
+```bash
+# Start MySQL, Redis (master+replica), Kafka
+docker-compose -f docker/infra-compose.yml up
+
+# Start Prometheus + Grafana monitoring
+docker-compose -f docker/monitoring-compose.yml up
+```
+
+- MySQL: localhost:3307 (root/root, application/application)
+- Redis Master: localhost:6379, Replica: localhost:6380
+- Kafka: localhost:19092, Kafka UI: localhost:9099
+- Grafana: localhost:3000 (admin/admin)
+
+## Architecture
+
+### Multi-Module Structure
+
+```
+loopers-java-spring-template/
+├── apps/                          # Executable Spring Boot applications
+│   ├── commerce-api              # REST API (web, actuator, springdoc-openapi)
+│   ├── commerce-batch            # Batch jobs (spring-batch)
+│   └── commerce-streamer         # Event streaming (web, kafka)
+├── modules/                       # Reusable infrastructure configurations
+│   ├── jpa                       # JPA, QueryDSL, MySQL connector
+│   ├── redis                     # Spring Data Redis (master-replica)
+│   └── kafka                     # Spring Kafka
+└── supports/                      # Cross-cutting add-on modules
+    ├── jackson                   # Jackson serialization (Kotlin module, JSR310)
+    ├── logging                   # Logback, Slack appender
+    └── monitoring                # Micrometer, Prometheus registry
+```
+
+### Module Dependencies
+
+| App | modules | supports |
+|-----|---------|----------|
+| commerce-api | jpa, redis | jackson, logging, monitoring |
+| commerce-batch | jpa, redis | jackson, logging, monitoring |
+| commerce-streamer | jpa, redis, kafka | jackson, logging, monitoring |
+
+### Layer Architecture (commerce-api)
+```
+interfaces/api/     → Controllers, DTOs, OpenAPI specs
+application/        → Facades (use case orchestration)
+domain/             → Entities, Services, Repository interfaces
+infrastructure/     → Repository implementations, adapters
+```
+
+### Key Patterns
+- **Controllers**: Implement `*ApiSpec` interfaces for OpenAPI documentation
+- **Facades**: Orchestrate domain services, convert domain models to DTOs
+- **Services**: `@Component` with `@Transactional`, contain business logic
+- **Repositories**: Interface in `domain/`, implementation in `infrastructure/`
+- **Entities**: Extend `BaseEntity` (provides id, createdAt, updatedAt, deletedAt)
+- **Response wrapper**: All APIs return `ApiResponse<T>`
+- **Error handling**: `CoreException` with `ErrorType` enum, caught by `ApiControllerAdvice`
+
+### Soft Delete
+Entities use `deletedAt` field via `BaseEntity`:
+```java
+entity.delete();   // marks as deleted
+entity.restore();  // restores
+```
+
+## Configuration
+
+- Profile-based: local, test, dev, qa, prd
+- Config imports in application.yml: jpa.yml, redis.yml, logging.yml, monitoring.yml
+- Management endpoints on port 8081 (/health, /prometheus)
+
+## Testing
+
+- Framework: JUnit 5 + AssertJ + Mockito + SpringMockk + Instancio
+- `DatabaseCleanUp` utility truncates tables between tests (from jpa test fixtures)
+- `RedisCleanUp` available from redis test fixtures
+- TestContainers support for MySQL, Redis, Kafka
+
+## 개발 규칙
+
+### 진행 Workflow - 증강 코딩
+- **대원칙**: 방향성 및 주요 의사 결정은 개발자에게 제안만 할 수 있으며, 최종 승인된 사항을 기반으로 작업 수행
+- **중간 결과 보고**: AI가 반복적인 동작을 하거나, 요청하지 않은 기능을 구현, 테스트 삭제를 임의로 진행할 경우 개발자가 개입
+- **설계 주도권 유지**: AI가 임의판단을 하지 않고, 방향성에 대한 제안 등을 진행할 수 있으나 개발자의 승인을 받은 후 수행
+
+### 개발 Workflow - TDD (Red → Green → Refactor)
+- 모든 테스트는 3A 원칙으로 작성 (Arrange - Act - Assert)
+
+| Phase | 설명 |
+|-------|------|
+| **Red** | 요구사항을 만족하는 실패하는 테스트 케이스 먼저 작성 |
+| **Green** | Red Phase의 테스트가 모두 통과할 수 있는 최소한의 코드 작성 (오버엔지니어링 금지) |
+| **Refactor** | 불필요한 private 함수 지양, 객체지향적 코드 작성, unused import 제거, 성능 최적화. 모든 테스트 통과 필수 |
+
+### 주의사항
+
+**Never Do:**
+- 실제 동작하지 않는 코드, 불필요한 Mock 데이터를 이용한 구현 금지
+- null-safety 하지 않은 코드 작성 금지 (Java의 경우 Optional 활용)
+- println 코드 남기지 말 것
+
+**Recommendation:**
+- 실제 API를 호출해 확인하는 E2E 테스트 코드 작성
+- 재사용 가능한 객체 설계
+- 성능 최적화에 대한 대안 및 제안
+- 개발 완료된 API는 `http/*.http` 파일에 분류해 작성
+
+**Priority:**
+1. 실제 동작하는 해결책만 고려
+2. null-safety, thread-safety 고려
+3. 테스트 가능한 구조로 설계
+4. 기존 코드 패턴 분석 후 일관성 유지
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
new file mode 100644
index 00000000..0d0cfd1f
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
@@ -0,0 +1,118 @@
+package com.loopers.domain.member;
+
+import com.loopers.support.error.CoreException;
+import com.loopers.support.error.ErrorType;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+class MemberModelTest {
+
+    @DisplayName("회원 모델을 생성할 때, ")
+    @Nested
+    class Create {
+
+        @DisplayName("(성공케이스) 필수 정보가 모두 주어지면, 정상적으로 생성된다.")
+        @Test
+        void createsMemberModel_whenAllFieldsAreProvided() {
+            // arrange
+            String loginId = "testuser";
+            String rawPassword = "Test1234!";
+            String name = "홍길동";
+            String birthDate = "19900101";
+            String email = "test@example.com";
+
+            // act
+            MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+            // assert
+            assertThat(member.getLoginId()).isEqualTo(loginId);
+            assertThat(member.getPassword()).isNotEqualTo(rawPassword);
+            assertThat(member.getName()).isEqualTo(name);
+            assertThat(member.getBirthDate()).isEqualTo(birthDate);
+            assertThat(member.getEmail()).isEqualTo(email);
+            // 비밀번호는 암호화되어 저장되므로 원본과 다를 수 있음 - 나중에 검증 방식 결정
+        }
+
+
+        @DisplayName("(실패케이스) 비밀번호가 7자일때, 예외발생.")
+        @Test
+        void throwsBadRequestException_whenPwIsOutOfRange() {
+          // arrange
+          String loginId = "testuser";
+          String password = "Test12!";
+          String name = "홍길동";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          CoreException result = assertThrows(CoreException.class, () -> {
+            new MemberModel(loginId, password, name, birthDate, email);
+          });
+
+          // assert
+          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+
+        @DisplayName("비밀번호가 17자일 때 → 예외 발생")
+        @Test
+        void throwsBadRequestException_whenPwIsOutOfRange2() {
+          // arrange
+          String loginId = "testuser";
+          String password = "Test123456789012!";
+          String name = "홍길동";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          CoreException result = assertThrows(CoreException.class, () -> {
+            new MemberModel(loginId, password, name, birthDate, email);
+          });
+
+          // assert
+          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("비밀번호에 한글이 있을 때 → 예외 발생")
+        @Test
+        void throwsBadRequestException_whenPwIsKorean() {
+          // arrange
+          String loginId = "testuser";
+          String password = "Test홍길동890123!";
+          String name = "홍길동";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          CoreException result = assertThrows(CoreException.class, () -> {
+            new MemberModel(loginId, password, name, birthDate, email);
+          });
+
+          // assert
+          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+
+        @DisplayName("비밀번호에 생년월일이 포함될 때 → 예외 발생")
+        @Test
+        void throwsBadRequestException_whenPwContainsBirthDate() {
+          // arrange
+          String loginId = "testuser";
+          String password = "Test19900101!";
+          String name = "홍길동";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          CoreException result = assertThrows(CoreException.class, () -> {
+            new MemberModel(loginId, password, name, birthDate, email);
+          });
+
+          // assert
+          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+        }
+    }
+}
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
new file mode 100644
index 00000000..8e2f27f1
--- /dev/null
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -0,0 +1,100 @@
+package com.loopers.interfaces.api;
+
+import com.loopers.utils.DatabaseCleanUp;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.test.web.client.TestRestTemplate;
+import org.springframework.core.ParameterizedTypeReference;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
+class MemberV1ApiE2ETest {
+
+    private static final String ENDPOINT = "/api/v1/members";
+
+    private final TestRestTemplate testRestTemplate;
+    private final DatabaseCleanUp databaseCleanUp;
+
+    @Autowired
+    public MemberV1ApiE2ETest(
+        TestRestTemplate testRestTemplate,
+        DatabaseCleanUp databaseCleanUp
+    ) {
+        this.testRestTemplate = testRestTemplate;
+        this.databaseCleanUp = databaseCleanUp;
+    }
+
+    @AfterEach
+    void tearDown() {
+        databaseCleanUp.truncateAllTables();
+    }
+
+    @DisplayName("POST /api/v1/members (회원가입)")
+    @Nested
+    class SignUp {
+
+        @DisplayName("유효한 회원 정보를 보내면, 201 Created와 생성된 ID를 반환한다.")
+        @Test
+        void returnsCreated_whenValidMemberInfoIsProvided() {
+            // arrange
+            Map<String, String> request = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@example.com"
+            );
+
+            // act
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
+                () -> assertThat(response.getBody().data().get("loginId")).isNotNull()
+            );
+        }
+
+        @DisplayName("중복된 loginId로 가입하면, 409 Conflict를 반환한다.")
+        @Test
+        void returnsConflict_whenDuplicateLoginIdIsProvided() {
+            // arrange - 먼저 한 명 가입
+            Map<String, String> request = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@example.com"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(request), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 같은 ID로 다시 가입
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT,
+                HttpMethod.POST,
+                new HttpEntity<>(request),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
+        }
+    }
+}

From 5860d3398d0f1859732dd116d490ef12e0d1e996 Mon Sep 17 00:00:00 2001
From: ksonepick-dev <ks_developer@myonepick.com>
Date: Thu, 5 Feb 2026 18:57:17 +0900
Subject: [PATCH 4/8] =?UTF-8?q?feat:=20=EB=82=B4=20=EC=A0=95=EB=B3=B4=20?=
 =?UTF-8?q?=EC=A1=B0=ED=9A=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../application/member/MemberFacade.java      | 11 +++--
 .../application/member/MemberInfo.java        |  2 +-
 .../loopers/domain/member/MemberModel.java    | 46 +++++++++++++++++--
 .../domain/member/MemberRepository.java       |  2 +-
 .../loopers/domain/member/MemberService.java  |  7 +--
 .../api/member/MemberV1ApiSpec.java           |  4 ++
 .../api/member/MemberV1Controller.java        | 26 +++++++----
 .../domain/member/MemberModelTest.java        |  2 +-
 .../member/MemberServiceIntegrationTest.java  | 30 ++++++++++--
 9 files changed, 103 insertions(+), 27 deletions(-)

diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
index 335399d2..12272ab3 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -25,7 +25,12 @@ public MemberInfo signupMember(MemberV1Dto.SignUpRequest request) {
     // 2. Service 호출 (저장 + 중복 체크)
     MemberModel saved = memberService.saveMember(memberModel);
 
-    // 3. MemberModel → MemberInfo로 변환해서 반환
-    return MemberInfo.from(saved);
-  }
+        // 3. MemberModel → MemberInfo로 변환해서 반환
+        return MemberInfo.from(saved);
+    }
+
+    public MemberInfo getMyInfo(String loginId) {
+        MemberModel member = memberService.getMember(loginId);
+        return MemberInfo.from(member);
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
index 2ae39624..38b99890 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberInfo.java
@@ -7,7 +7,7 @@ public record MemberInfo(String loginId, String name, String birthDate, String e
     public static MemberInfo from(MemberModel model) {
         return new MemberInfo(
             model.getLoginId(),
-            model.getName(),
+            model.getMaskedName(),
             model.getBirthDate(),
             model.getEmail()
           );
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
index 4ba20abd..bb3b422f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
@@ -37,11 +37,14 @@ public MemberModel(String loginId, String password, String name, String birthDat
         throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
       }
 
-      // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
-      // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
-      // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
-      // 비밀번호 규칙 검증
-      validatePassword(password, birthDate);
+        // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
+        // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+        validateLoginId(loginId);
+
+        // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
+        // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
+        // 비밀번호 규칙 검증
+        validatePassword(password, birthDate);
 
       this.loginId = loginId;
       this.password = password;
@@ -50,6 +53,11 @@ public MemberModel(String loginId, String password, String name, String birthDat
       this.email = email;
     }
 
+    public MemberModel(String loginId) {
+        // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+        validateLoginId(loginId);
+    }
+
     public String getLoginId() {
       return loginId;
     }
@@ -70,6 +78,16 @@ public String getEmail() {
       return email;
     }
 
+    private void validateLoginId(String loginId) {
+        // 로그인 ID 는 영문과 숫자만 허용
+        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+            throw new CoreException(
+                    ErrorType.BAD_REQUEST,
+                    "로그인 아이디는 영문자와 숫자만 사용할 수 있습니다."
+            );
+        }
+    }
+
     private void validatePassword(String password, String birthDate) {
         // 1. 8~16자 길이 체크
         if (password.length() < 8 || password.length() > 16) {
@@ -95,5 +113,23 @@ public void encryptPassword(String encryptedPassword) {
       this.password = encryptedPassword;
     }
 
+    // 이름 마지막 글자에 마스킹 추가
+    public String maskLastChar(String name) {
+        if (name == null || name.isBlank()) {
+            throw new IllegalArgumentException("이름은 비어 있을 수 없습니다.");
+        }
+
+        if (name.length() == 1) {
+            return "*";
+        }
+
+        return name.substring(0, name.length() - 1) + "*";
+    }
+
+    // 마스킹된 이름 가져오기
+    public String getMaskedName(){
+        return maskLastChar(this.name);
+    }
+
 
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
index 1d703f71..b86afc71 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -4,6 +4,6 @@
 
 public interface MemberRepository {
     MemberModel save(MemberModel memberModel);
-    Optional<MemberModel> update(MemberModel memberModel);
     Optional<MemberModel> findByLoginId(String id);
+    Optional<MemberModel> update(MemberModel memberModel);
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
index ec62150a..bb6cca4a 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -32,8 +32,9 @@ public MemberModel saveMember(MemberModel memberModel) {
       }
 
     @Transactional(readOnly = true)
-    public MemberModel getMember(String id) {
-        return memberRepository.findByLoginId(id)
-            .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + id + "] 회원을 찾을 수 없습니다."));
+    public MemberModel getMember(String loginId) {
+        MemberModel model = new MemberModel(loginId);  // 객체 먼저 생성해야 함
+        return memberRepository.findByLoginId(model.getLoginId())
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + loginId + "] 회원을 찾을 수 없습니다."));
     }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
index c312ab9f..c58dffe2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -20,4 +20,8 @@ ApiResponse<MemberV1Dto.SignUpResponse> signUp(
       MemberV1Dto.SignUpRequest request
   );
 
+  ApiResponse<MemberV1Dto.SignUpResponse> getMyInfo(
+          String loginId
+  );
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
index 744937a7..6ca5f25c 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -24,13 +24,23 @@ public class MemberV1Controller implements MemberV1ApiSpec {
   //            DB에서 꺼낸 객체                     응답 데이터 전달용
   private final MemberFacade memberFacade;
 
-  @PostMapping
-  @ResponseStatus(HttpStatus.CREATED)
-  @Override
-  public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
-    MemberInfo info = memberFacade.signupMember(request);
-    MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
-    return ApiResponse.success(response);
-  }
+    @PostMapping
+    @ResponseStatus(HttpStatus.CREATED)
+    @Override
+    public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
+        MemberInfo info = memberFacade.signupMember(request);
+        MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
+        return ApiResponse.success(response);
+    }
+
+    @GetMapping("/{loginId}")
+    @Override
+    public ApiResponse<SignUpResponse> getMyInfo(
+            @PathVariable(value = "loginId") String loginId
+    ) {
+        MemberInfo info = memberFacade.getMyInfo(loginId);
+        MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
+        return ApiResponse.success(response);
+    }
 
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
index 0d0cfd1f..b827bbdd 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
@@ -30,7 +30,7 @@ void createsMemberModel_whenAllFieldsAreProvided() {
 
             // assert
             assertThat(member.getLoginId()).isEqualTo(loginId);
-            assertThat(member.getPassword()).isNotEqualTo(rawPassword);
+            assertThat(member.getPassword()).isEqualTo(rawPassword);
             assertThat(member.getName()).isEqualTo(name);
             assertThat(member.getBirthDate()).isEqualTo(birthDate);
             assertThat(member.getEmail()).isEqualTo(email);
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
index 7cb23df8..d7b296cb 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
@@ -73,11 +73,31 @@ void throwsException_whenExistIdIsTryToSaveMember() {
   @Nested
   class GetMember {
 
-    @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
-    @Test
-    void throwsException_whenMemberNotFound() {
-      // arrange
-      String loginId = "testuser"; // Assuming this ID does not exist
+      @DisplayName("존재하는 ID를 주면, 해당 유저 정보를 반환한다.")
+      @Test
+      void returnsExampleInfo_whenValidIdIsProvided() {
+          // arrange  // 정보저장
+          MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
+          memberService.saveMember(memberModel);
+
+          // act
+          MemberModel result = memberService.getMember(memberModel.getLoginId());
+
+          // assert
+          assertAll(
+                  () -> assertThat(result).isNotNull(),
+                  () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()),
+                  () -> assertThat(result.getName()).isEqualTo(memberModel.getName()),
+                  () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()),
+                  () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail())
+          );
+      }
+
+      @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
+      @Test
+      void throwsException_whenMemberNotFound() {
+        // arrange
+        String loginId = "testuser"; // Assuming this ID does not exist
 
       // act
       CoreException exception = assertThrows(CoreException.class, () -> {

From fd56b5e9874f993b77c60ac419dedc54c416a106 Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Thu, 5 Feb 2026 21:30:57 +0900
Subject: [PATCH 5/8] =?UTF-8?q?feat:=20=EB=82=B4=20=EC=A0=95=EB=B3=B4=20?=
 =?UTF-8?q?=EC=A1=B0=ED=9A=8C=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../loopers/domain/member/MemberModel.java    |  1 +
 .../loopers/domain/member/MemberService.java  |  8 ++-
 .../api/member/MemberV1ApiSpec.java           |  9 +--
 .../api/member/MemberV1Controller.java        |  7 ++-
 .../interfaces/api/member/MemberV1Dto.java    | 16 ++++++
 .../domain/member/MemberModelTest.java        | 54 ++++++++++++++++++
 .../interfaces/api/MemberV1ApiE2ETest.java    | 55 +++++++++++++++++++
 build.gradle.kts                              |  7 +--
 8 files changed, 145 insertions(+), 12 deletions(-)

diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
index bb3b422f..70b6bcf2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
@@ -56,6 +56,7 @@ public MemberModel(String loginId, String password, String name, String birthDat
     public MemberModel(String loginId) {
         // 가입하는 로그인 ID는 영문과 숫자만 허용한다
         validateLoginId(loginId);
+        this.loginId = loginId;
     }
 
     public String getLoginId() {
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
index bb6cca4a..b8593099 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -4,6 +4,7 @@
 import com.loopers.support.error.ErrorType;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
+import org.springframework.dao.DataIntegrityViolationException;
 import org.springframework.security.crypto.password.PasswordEncoder;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -26,9 +27,12 @@ public MemberModel saveMember(MemberModel memberModel) {
         // 비밀번호 암호화 후 저장
         String encrypted = passwordEncoder.encode(memberModel.getPassword());
         memberModel.encryptPassword(encrypted);
-        memberRepository.save(memberModel);
 
-        return getMember(memberModel.getLoginId());
+        try {
+          return memberRepository.save(memberModel);
+        } catch (DataIntegrityViolationException e) {
+          throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
+        }
       }
 
     @Transactional(readOnly = true)
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
index c58dffe2..b1a6b2a1 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -1,11 +1,8 @@
 package com.loopers.interfaces.api.member;
 
 import com.loopers.interfaces.api.ApiResponse;
-import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
 import io.swagger.v3.oas.annotations.Operation;
-import io.swagger.v3.oas.annotations.media.Schema;
 import io.swagger.v3.oas.annotations.tags.Tag;
-import org.springframework.web.bind.annotation.PostMapping;
 
 @Tag(name = "Member V1 API", description = "회원 API")
 public interface MemberV1ApiSpec {
@@ -20,7 +17,11 @@ ApiResponse<MemberV1Dto.SignUpResponse> signUp(
       MemberV1Dto.SignUpRequest request
   );
 
-  ApiResponse<MemberV1Dto.SignUpResponse> getMyInfo(
+  @Operation(
+      summary = "내 정보 조회",
+      description = "로그인 ID로 내 회원 정보를 조회한다"
+  )
+  ApiResponse<MemberV1Dto.MemberInfoResponse> getMyInfo(
           String loginId
   );
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
index 6ca5f25c..f375fdf2 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -3,10 +3,13 @@
 import com.loopers.application.member.MemberFacade;
 import com.loopers.application.member.MemberInfo;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.MemberInfoResponse;
 import com.loopers.interfaces.api.member.MemberV1Dto.SignUpRequest;
 import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
 import org.springframework.web.bind.annotation.RequestMapping;
@@ -35,11 +38,11 @@ public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
 
     @GetMapping("/{loginId}")
     @Override
-    public ApiResponse<SignUpResponse> getMyInfo(
+    public ApiResponse<MemberInfoResponse> getMyInfo(
             @PathVariable(value = "loginId") String loginId
     ) {
         MemberInfo info = memberFacade.getMyInfo(loginId);
-        MemberV1Dto.SignUpResponse response = MemberV1Dto.SignUpResponse.from(info);
+        MemberInfoResponse response = MemberInfoResponse.from(info);
         return ApiResponse.success(response);
     }
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
index e1545299..bd29ed0f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -21,5 +21,21 @@ public static SignUpResponse from(MemberInfo info) {
       }
     }
 
+    public record MemberInfoResponse(
+        String loginId,
+        String name,
+        String birthDate,
+        String email
+    ) {
+      public static MemberInfoResponse from(MemberInfo info) {
+        return new MemberInfoResponse(
+            info.loginId(),
+            info.name(),
+            info.birthDate(),
+            info.email()
+        );
+      }
+    }
+
 
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
index b827bbdd..654ad034 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
@@ -37,6 +37,22 @@ void createsMemberModel_whenAllFieldsAreProvided() {
             // 비밀번호는 암호화되어 저장되므로 원본과 다를 수 있음 - 나중에 검증 방식 결정
         }
 
+        @DisplayName("아이디로 회원 모델을 생성할 때, 영문과 숫자가 아닌 문자가 포함되면 예외가 발생한다.")
+        @Test
+        void throwsBadRequestException_whenLoginIdContainsInvalidChars() {
+          // arrange
+          String loginId = "testuser!@#";
+
+          // act
+          CoreException result = assertThrows(CoreException.class, () -> {
+            new MemberModel(loginId);
+          });
+          // assert
+          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST
+          );
+
+        }
+
 
         @DisplayName("(실패케이스) 비밀번호가 7자일때, 예외발생.")
         @Test
@@ -115,4 +131,42 @@ void throwsBadRequestException_whenPwContainsBirthDate() {
           assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
         }
     }
+
+    @DisplayName("회원정보조회할 때,")
+    @Nested
+    class GetMemberInfo {
+
+        @DisplayName("이름 마지막 글자를 마스킹한다")
+        @Test
+        void mask_last_character() {
+          //arrange
+          String loginId = "testuser";
+          String rawPassword = "Test1234!";
+          String name = "홍길동";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+          assertThat(member.getMaskedName()).isEqualTo("홍길*");
+        }
+
+        @DisplayName("이름 마지막 글자를 마스킹한다")
+        @Test
+        void single_character_name_is_fully_masked() {
+          //arrange
+          String loginId = "testuser";
+          String rawPassword = "Test1234!";
+          String name = "홍";
+          String birthDate = "19900101";
+          String email = "test@example.com";
+
+          // act
+          MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+          assertThat(member.getMaskedName()).isEqualTo("*");
+        }
+
+    }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
index 8e2f27f1..837a4dd1 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -68,6 +68,8 @@ void returnsCreated_whenValidMemberInfoIsProvided() {
             // assert
             assertAll(
                 () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> assertThat(response.getBody().data()).isNotNull(),
                 () -> assertThat(response.getBody().data().get("loginId")).isNotNull()
             );
         }
@@ -97,4 +99,57 @@ void returnsConflict_whenDuplicateLoginIdIsProvided() {
             assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
         }
     }
+
+    @DisplayName("GET /api/v1/members/{loginId} (회원정보조회)")
+    @Nested
+    class GetMemberInfo {
+
+        @DisplayName("존재하는 회원의 ID로 조회하면, 200 OK와 마스킹된 이름을 반환한다.")
+        @Test
+        void returnsMemberInfo_whenExistingLoginIdIsProvided() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - GET 요청으로 회원 정보 조회
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/testuser",
+                HttpMethod.GET,
+                null,
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> assertThat(response.getBody().data()).isNotNull(),
+                () -> assertThat(response.getBody().data().get("loginId")).isEqualTo("testuser"),
+                () -> assertThat(response.getBody().data().get("name")).isEqualTo("홍길*")
+            );
+        }
+
+        @DisplayName("존재하지 않는 회원의 ID로 조회하면, 404 Not Found를 반환한다.")
+        @Test
+        void returnsNotFound_whenNonExistingLoginIdIsProvided() {
+            // arrange - 아무 데이터 없음
+
+            // act
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/nonexistent",
+                HttpMethod.GET,
+                null,
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
+        }
+    }
 }
diff --git a/build.gradle.kts b/build.gradle.kts
index 6f9ce28b..b7f02279 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -40,10 +40,9 @@ subprojects {
     apply(plugin = "org.springframework.boot")
     apply(plugin = "io.spring.dependency-management")
 
-    // TODO: JDK 24 환경에서 JacocoReport 태스크 생성 오류 발생 - JDK 21로 전환 후 활성화 필요
-    // if (name !in containerProjects) {
-    //     apply(plugin = "jacoco")
-    // }
+     if (name !in containerProjects) {
+         apply(plugin = "jacoco")
+     }
 
     dependencyManagement {
         imports {

From e6e5d94848f0dcda92960d1503332a171e6eb757 Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Fri, 6 Feb 2026 00:36:51 +0900
Subject: [PATCH 6/8] =?UTF-8?q?feat:=20=EB=B9=84=EB=B0=80=EB=B2=88?=
 =?UTF-8?q?=ED=98=B8=20=EA=B5=AC=ED=98=84?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .claude/settings.local.json                   |   8 +
 .../application/member/MemberFacade.java      |  25 +-
 .../loopers/domain/member/MemberModel.java    | 212 +++++-----
 .../domain/member/MemberRepository.java       |   1 +
 .../loopers/domain/member/MemberService.java  |  25 ++
 .../api/member/MemberV1ApiSpec.java           |   9 +
 .../api/member/MemberV1Controller.java        |  12 +
 .../interfaces/api/member/MemberV1Dto.java    |   7 +
 .../com/loopers/support/error/ErrorType.java  |   3 +-
 .../domain/member/MemberModelTest.java        | 362 ++++++++++--------
 .../member/MemberServiceIntegrationTest.java  | 141 +++++--
 .../interfaces/api/MemberV1ApiE2ETest.java    |  96 +++++
 12 files changed, 603 insertions(+), 298 deletions(-)
 create mode 100644 .claude/settings.local.json

diff --git a/.claude/settings.local.json b/.claude/settings.local.json
new file mode 100644
index 00000000..4cd83877
--- /dev/null
+++ b/.claude/settings.local.json
@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(./gradlew test:*)",
+      "Bash(./gradlew :apps:commerce-api:test:*)"
+    ]
+  }
+}
diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
index 12272ab3..1e9cd02b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -25,12 +25,21 @@ public MemberInfo signupMember(MemberV1Dto.SignUpRequest request) {
     // 2. Service 호출 (저장 + 중복 체크)
     MemberModel saved = memberService.saveMember(memberModel);
 
-        // 3. MemberModel → MemberInfo로 변환해서 반환
-        return MemberInfo.from(saved);
-    }
-
-    public MemberInfo getMyInfo(String loginId) {
-        MemberModel member = memberService.getMember(loginId);
-        return MemberInfo.from(member);
-    }
+    // 3. MemberModel → MemberInfo로 변환해서 반환
+    return MemberInfo.from(saved);
+  }
+
+  public MemberInfo getMyInfo(String loginId) {
+    MemberModel member = memberService.getMember(loginId);
+    return MemberInfo.from(member);
+  }
+
+  public void changePassword(String loginId, String prevPassword, String newPassword) {
+    // Request → MemberModel로 변환
+    MemberModel memberModel = new MemberModel(loginId, prevPassword);
+
+    // Service 호출
+    memberService.changePassword(memberModel, newPassword);
+
+  }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
index 70b6bcf2..58e72de9 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberModel.java
@@ -10,127 +10,139 @@
 @Table(name = "member")
 public class MemberModel extends BaseEntity {
 
-    private String loginId;
-    private String password ;
-    private String name;
-    private String birthDate;
-    private String email;
-
-    protected MemberModel() {}
-
-    public MemberModel(String loginId, String password, String name, String birthDate, String email) {
-
-      // 모든 항목은 비어 있을 수 없다
-      if (loginId == null || loginId.isBlank()) {
-        throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
-      }
-      if (password == null || password.isBlank()) {
-        throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 비어있을 수 없습니다.");
-      }
-      if (name == null || name.isBlank()) {
-        throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
-      }
-      if (birthDate == null || birthDate.isBlank()) {
-          throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비어있을 수 없습니다.");
-      }
-      if (email == null || email.isBlank()) {
-        throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
-      }
-
-        // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
-        // 가입하는 로그인 ID는 영문과 숫자만 허용한다
-        validateLoginId(loginId);
-
-        // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
-        // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
-        // 비밀번호 규칙 검증
-        validatePassword(password, birthDate);
-
-      this.loginId = loginId;
-      this.password = password;
-      this.name = name;
-      this.birthDate = birthDate;
-      this.email = email;
-    }
+  private String loginId;
+  private String password;
+  private String name;
+  private String birthDate;
+  private String email;
 
-    public MemberModel(String loginId) {
-        // 가입하는 로그인 ID는 영문과 숫자만 허용한다
-        validateLoginId(loginId);
-        this.loginId = loginId;
-    }
+  protected MemberModel() {
+  }
+
+  public MemberModel(String loginId, String password, String name, String birthDate, String email) {
 
-    public String getLoginId() {
-      return loginId;
+    // 모든 항목은 비어 있을 수 없다
+    if (loginId == null || loginId.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
+    }
+    if (password == null || password.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 비어있을 수 없습니다.");
+    }
+    if (name == null || name.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "이름은 비어있을 수 없습니다.");
+    }
+    if (birthDate == null || birthDate.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "생년월일은 비어있을 수 없습니다.");
+    }
+    if (email == null || email.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "이메일은 비어있을 수 없습니다.");
     }
 
-    public String getPassword() {
-      return password;
+    // 가입된 아이디로는 가입이 불가능하다 -> 디비에서 검증. 서비스에서 하기
+    // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+    validateLoginId(loginId);
+
+    // 비밀번호 8~16자의 영문 대소문자, 숫자, 특수문자만 가능합니다.
+    // 비밀번호 생년월일은 비밀번호 내에 포함될 수 없습니다.
+    // 비밀번호 규칙 검증
+    validatePassword(password, birthDate);
+
+    this.loginId = loginId;
+    this.password = password;
+    this.name = name;
+    this.birthDate = birthDate;
+    this.email = email;
+  }
+
+  public MemberModel(String loginId) {
+    // 모든 항목은 비어 있을 수 없다
+    if (loginId == null || loginId.isBlank()) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "아이디는 비어있을 수 없습니다.");
     }
 
-    public String getName() {
-      return name;
+    // 가입하는 로그인 ID는 영문과 숫자만 허용한다
+    validateLoginId(loginId);
+    this.loginId = loginId;
+  }
+
+  public MemberModel(String loginId, String prevPassword) {
+    this.loginId = loginId;
+    this.password = prevPassword;
+  }
+
+  public String getLoginId() {
+    return loginId;
+  }
+
+  public String getPassword() {
+    return password;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public String getBirthDate() {
+    return birthDate;
+  }
+
+  public String getEmail() {
+    return email;
+  }
+
+  private void validateLoginId(String loginId) {
+    // 로그인 ID 는 영문과 숫자만 허용
+    if (!loginId.matches("^[a-zA-Z0-9]+$")) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "로그인 아이디는 영문자와 숫자만 사용할 수 있습니다.");
     }
+  }
 
-    public String getBirthDate() {
-      return birthDate;
+  private void validatePassword(String password, String birthDate) {
+    // 1. 8~16자 길이 체크
+    if (password.length() < 8 || password.length() > 16) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 8~16자여야 합니다.");
     }
 
-    public String getEmail() {
-      return email;
+    // 2. 영문 대소문자, 숫자, 특수문자만 허용 (한글, 공백 등 불가)
+    if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호는 영문 대소문자, 숫자, 특수문자만 가능합니다.");
     }
 
-    private void validateLoginId(String loginId) {
-        // 로그인 ID 는 영문과 숫자만 허용
-        if (!loginId.matches("^[a-zA-Z0-9]+$")) {
-            throw new CoreException(
-                    ErrorType.BAD_REQUEST,
-                    "로그인 아이디는 영문자와 숫자만 사용할 수 있습니다."
-            );
-        }
+    // 3. 생년월일이 비밀번호에 포함되면 안됨
+    if (password.contains(birthDate)) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "비밀번호에 생년월일을 포함할 수 없습니다.");
     }
+  }
+
+  // 암호화된 비밀번호를 엔티티에 넣어주기
+  public void encryptPassword(String encryptedPassword) {
+    this.password = encryptedPassword;
+  }
 
-    private void validatePassword(String password, String birthDate) {
-        // 1. 8~16자 길이 체크
-        if (password.length() < 8 || password.length() > 16) {
-            throw new CoreException(ErrorType.BAD_REQUEST,
-                "비밀번호는 8~16자여야 합니다.");
-        }
-
-        // 2. 영문 대소문자, 숫자, 특수문자만 허용 (한글, 공백 등 불가)
-        if (!password.matches("^[a-zA-Z0-9!@#$%^&*()_+\\-=\\[\\]{};':\"\\\\|,.<>/?]+$")) {
-            throw new CoreException(ErrorType.BAD_REQUEST,
-                "비밀번호는 영문 대소문자, 숫자, 특수문자만 가능합니다.");
-        }
-
-        // 3. 생년월일이 비밀번호에 포함되면 안됨
-        if (password.contains(birthDate)) {
-            throw new CoreException(ErrorType.BAD_REQUEST,
-                "비밀번호에 생년월일을 포함할 수 없습니다.");
-        }
+  // 이름 마지막 글자에 마스킹 추가
+  public String maskLastChar(String name) {
+    if (name == null || name.isBlank()) {
+      throw new IllegalArgumentException("이름은 비어 있을 수 없습니다.");
     }
 
-    // 암호화된 비밀번호를 엔티티에 넣어주기
-    public void encryptPassword(String encryptedPassword) {
-      this.password = encryptedPassword;
+    if (name.length() == 1) {
+      return "*";
     }
 
-    // 이름 마지막 글자에 마스킹 추가
-    public String maskLastChar(String name) {
-        if (name == null || name.isBlank()) {
-            throw new IllegalArgumentException("이름은 비어 있을 수 없습니다.");
-        }
+    return name.substring(0, name.length() - 1) + "*";
+  }
 
-        if (name.length() == 1) {
-            return "*";
-        }
+  // 마스킹된 이름 가져오기
+  public String getMaskedName() {
+    return maskLastChar(this.name);
+  }
 
-        return name.substring(0, name.length() - 1) + "*";
-    }
 
-    // 마스킹된 이름 가져오기
-    public String getMaskedName(){
-        return maskLastChar(this.name);
-    }
+  // 비밀번호 변경하기
+  public void changePassword(String newPassword, String birthDate) {
+    validatePassword(newPassword, birthDate);
+    this.password = newPassword;
+  }
 
 
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
index b86afc71..ca1e3cd8 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberRepository.java
@@ -6,4 +6,5 @@ public interface MemberRepository {
     MemberModel save(MemberModel memberModel);
     Optional<MemberModel> findByLoginId(String id);
     Optional<MemberModel> update(MemberModel memberModel);
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
index b8593099..f6ee186b 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -41,4 +41,29 @@ public MemberModel getMember(String loginId) {
         return memberRepository.findByLoginId(model.getLoginId())
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + loginId + "] 회원을 찾을 수 없습니다."));
     }
+
+    @Transactional(readOnly = false)
+    public void changePassword(MemberModel memberModel, String newPassword) {
+
+        // 기존 회원 정보 조회
+        MemberModel member = getMember(memberModel.getLoginId());
+
+        // 암호화된 DB 비밀번호와 입력한 기존 비밀번호 비교
+        if (!passwordEncoder.matches(memberModel.getPassword(), member.getPassword())) {
+          throw new CoreException(ErrorType.UNAUTHORIZED, "기존 비밀번호가 일치하지 않습니다.");
+        }
+
+        // 암호화된 DB 기존 비밀번호와 입력한 새로운 비밀번호 비교
+        if (passwordEncoder.matches(newPassword, member.getPassword())) {
+          throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 기존 비밀번호와 달라야 합니다.");
+        }
+
+        // 새 비밀번호 규칙 검증 + 암호화 + 저장 (Dirty Checking)
+        member.changePassword(newPassword, member.getBirthDate());
+
+        // 암호화 후 저장 (Dirty Checking)
+        String encryptedPassword = passwordEncoder.encode(newPassword);
+        member.encryptPassword(encryptedPassword);
+
+    }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
index b1a6b2a1..41128ac7 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -25,4 +25,13 @@ ApiResponse<MemberV1Dto.MemberInfoResponse> getMyInfo(
           String loginId
   );
 
+  @Operation(
+      summary = "비밀번호 변경",
+      description = "기존 비밀번호와 새 비밀번호를 받아 비밀번호를 변경한다"
+  )
+  ApiResponse<String> changePassword(
+      String loginId,
+      MemberV1Dto.ChangePasswordRequest request
+  );
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
index f375fdf2..a7a3928e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -3,12 +3,14 @@
 import com.loopers.application.member.MemberFacade;
 import com.loopers.application.member.MemberInfo;
 import com.loopers.interfaces.api.ApiResponse;
+import com.loopers.interfaces.api.member.MemberV1Dto.ChangePasswordRequest;
 import com.loopers.interfaces.api.member.MemberV1Dto.MemberInfoResponse;
 import com.loopers.interfaces.api.member.MemberV1Dto.SignUpRequest;
 import com.loopers.interfaces.api.member.MemberV1Dto.SignUpResponse;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.PatchMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
@@ -46,4 +48,14 @@ public ApiResponse<MemberInfoResponse> getMyInfo(
         return ApiResponse.success(response);
     }
 
+    @PatchMapping("/{loginId}/password")
+    public ApiResponse<String> changePassword(
+        @PathVariable String loginId,
+        @RequestBody ChangePasswordRequest request
+    ) {
+      memberFacade.changePassword(loginId, request.oldPassword(), request.newPassword());
+      return ApiResponse.success("비밀번호가 변경되었습니다.");
+    }
+
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
index bd29ed0f..e4e6f046 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Dto.java
@@ -38,4 +38,11 @@ public static MemberInfoResponse from(MemberInfo info) {
     }
 
 
+    // Request: 비밀번호 변경 요청
+    public record ChangePasswordRequest(
+      String oldPassword,
+      String newPassword
+    ) {}
+
+
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
index 5d142efb..96c81c9f 100644
--- a/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
+++ b/apps/commerce-api/src/main/java/com/loopers/support/error/ErrorType.java
@@ -11,7 +11,8 @@ public enum ErrorType {
     INTERNAL_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase(), "일시적인 오류가 발생했습니다."),
     BAD_REQUEST(HttpStatus.BAD_REQUEST, HttpStatus.BAD_REQUEST.getReasonPhrase(), "잘못된 요청입니다."),
     NOT_FOUND(HttpStatus.NOT_FOUND, HttpStatus.NOT_FOUND.getReasonPhrase(), "존재하지 않는 요청입니다."),
-    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다.");
+    CONFLICT(HttpStatus.CONFLICT, HttpStatus.CONFLICT.getReasonPhrase(), "이미 존재하는 리소스입니다."),
+    UNAUTHORIZED(HttpStatus.UNAUTHORIZED, HttpStatus.UNAUTHORIZED.getReasonPhrase(), "유효하지 않은 인증 정보입니다.");
 
     private final HttpStatus status;
     private final String code;
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
index 654ad034..e28f0cda 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberModelTest.java
@@ -1,172 +1,220 @@
 package com.loopers.domain.member;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
 
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertThrows;
-
 class MemberModelTest {
 
-    @DisplayName("회원 모델을 생성할 때, ")
-    @Nested
-    class Create {
-
-        @DisplayName("(성공케이스) 필수 정보가 모두 주어지면, 정상적으로 생성된다.")
-        @Test
-        void createsMemberModel_whenAllFieldsAreProvided() {
-            // arrange
-            String loginId = "testuser";
-            String rawPassword = "Test1234!";
-            String name = "홍길동";
-            String birthDate = "19900101";
-            String email = "test@example.com";
-
-            // act
-            MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
-
-            // assert
-            assertThat(member.getLoginId()).isEqualTo(loginId);
-            assertThat(member.getPassword()).isEqualTo(rawPassword);
-            assertThat(member.getName()).isEqualTo(name);
-            assertThat(member.getBirthDate()).isEqualTo(birthDate);
-            assertThat(member.getEmail()).isEqualTo(email);
-            // 비밀번호는 암호화되어 저장되므로 원본과 다를 수 있음 - 나중에 검증 방식 결정
-        }
-
-        @DisplayName("아이디로 회원 모델을 생성할 때, 영문과 숫자가 아닌 문자가 포함되면 예외가 발생한다.")
-        @Test
-        void throwsBadRequestException_whenLoginIdContainsInvalidChars() {
-          // arrange
-          String loginId = "testuser!@#";
-
-          // act
-          CoreException result = assertThrows(CoreException.class, () -> {
-            new MemberModel(loginId);
-          });
-          // assert
-          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST
-          );
-
-        }
-
-
-        @DisplayName("(실패케이스) 비밀번호가 7자일때, 예외발생.")
-        @Test
-        void throwsBadRequestException_whenPwIsOutOfRange() {
-          // arrange
-          String loginId = "testuser";
-          String password = "Test12!";
-          String name = "홍길동";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          CoreException result = assertThrows(CoreException.class, () -> {
-            new MemberModel(loginId, password, name, birthDate, email);
-          });
-
-          // assert
-          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
-        }
-
-
-        @DisplayName("비밀번호가 17자일 때 → 예외 발생")
-        @Test
-        void throwsBadRequestException_whenPwIsOutOfRange2() {
-          // arrange
-          String loginId = "testuser";
-          String password = "Test123456789012!";
-          String name = "홍길동";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          CoreException result = assertThrows(CoreException.class, () -> {
-            new MemberModel(loginId, password, name, birthDate, email);
-          });
-
-          // assert
-          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
-        }
-
-        @DisplayName("비밀번호에 한글이 있을 때 → 예외 발생")
-        @Test
-        void throwsBadRequestException_whenPwIsKorean() {
-          // arrange
-          String loginId = "testuser";
-          String password = "Test홍길동890123!";
-          String name = "홍길동";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          CoreException result = assertThrows(CoreException.class, () -> {
-            new MemberModel(loginId, password, name, birthDate, email);
-          });
-
-          // assert
-          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
-        }
-
-        @DisplayName("비밀번호에 생년월일이 포함될 때 → 예외 발생")
-        @Test
-        void throwsBadRequestException_whenPwContainsBirthDate() {
-          // arrange
-          String loginId = "testuser";
-          String password = "Test19900101!";
-          String name = "홍길동";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          CoreException result = assertThrows(CoreException.class, () -> {
-            new MemberModel(loginId, password, name, birthDate, email);
-          });
-
-          // assert
-          assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
-        }
+  @DisplayName("회원 모델을 생성할 때, ")
+  @Nested
+  class Create {
+
+    @DisplayName("(성공케이스) 필수 정보가 모두 주어지면, 정상적으로 생성된다.")
+    @Test
+    void createsMemberModel_whenAllFieldsAreProvided() {
+      // arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      // assert
+      assertThat(member.getLoginId()).isEqualTo(loginId);
+      assertThat(member.getPassword()).isEqualTo(rawPassword);
+      assertThat(member.getName()).isEqualTo(name);
+      assertThat(member.getBirthDate()).isEqualTo(birthDate);
+      assertThat(member.getEmail()).isEqualTo(email);
+      // 비밀번호는 암호화되어 저장되므로 원본과 다를 수 있음 - 나중에 검증 방식 결정
+    }
+
+    @DisplayName("아이디로 회원 모델을 생성할 때, 영문과 숫자가 아닌 문자가 포함되면 예외가 발생한다.")
+    @Test
+    void throwsBadRequestException_whenLoginIdContainsInvalidChars() {
+      // arrange
+      String loginId = "testuser!@#";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId);
+      });
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+
+    @DisplayName("(실패케이스) 비밀번호가 7자일때, 예외발생.")
+    @Test
+    void throwsBadRequestException_whenPwIsOutOfRange() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test12!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+
+    @DisplayName("비밀번호가 17자일 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwIsOutOfRange2() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test123456789012!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("비밀번호에 한글이 있을 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwIsKorean() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test홍길동890123!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+
+    @DisplayName("비밀번호에 생년월일이 포함될 때 → 예외 발생")
+    @Test
+    void throwsBadRequestException_whenPwContainsBirthDate() {
+      // arrange
+      String loginId = "testuser";
+      String password = "Test19900101!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        new MemberModel(loginId, password, name, birthDate, email);
+      });
+
+      // assert
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
     }
+  }
+
+  @DisplayName("회원정보조회할 때,")
+  @Nested
+  class GetMemberInfo {
+
+    @DisplayName("이름 마지막 글자를 마스킹한다")
+    @Test
+    void mask_last_character() {
+      //arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      assertThat(member.getMaskedName()).isEqualTo("홍길*");
+    }
+
+    @DisplayName("이름 마지막 글자를 마스킹한다")
+    @Test
+    void single_character_name_is_fully_masked() {
+      //arrange
+      String loginId = "testuser";
+      String rawPassword = "Test1234!";
+      String name = "홍";
+      String birthDate = "19900101";
+      String email = "test@example.com";
+
+      // act
+      MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
+
+      assertThat(member.getMaskedName()).isEqualTo("*");
+    }
+
+  }
+
+  @DisplayName("비밀번호 수정 할 때,")
+  @Nested
+  class ChangePassword {
+
+    @DisplayName("새 비밀번호가 규칙을 만족하면, 비밀번호가 변경된다.")
+    @Test
+    void changesPassword_whenOldPasswordMatchesAndNewPasswordIsValid() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      String newPassword = "Newpass123!";
+      member.changePassword(newPassword, birthDate);
+
+      // assert
+      assertThat(member.getPassword()).isEqualTo(newPassword);
+    }
+
+
+    @DisplayName("새 비밀번호에 생년월일이 포함되면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenNewPasswordContainsBirthDate() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      String newPassword = "Test19900101!";
+
+      // act
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+
+      // act
+      CoreException result = assertThrows(CoreException.class, () -> {
+        member.changePassword(newPassword, birthDate);
+      });
 
-    @DisplayName("회원정보조회할 때,")
-    @Nested
-    class GetMemberInfo {
-
-        @DisplayName("이름 마지막 글자를 마스킹한다")
-        @Test
-        void mask_last_character() {
-          //arrange
-          String loginId = "testuser";
-          String rawPassword = "Test1234!";
-          String name = "홍길동";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
-
-          assertThat(member.getMaskedName()).isEqualTo("홍길*");
-        }
-
-        @DisplayName("이름 마지막 글자를 마스킹한다")
-        @Test
-        void single_character_name_is_fully_masked() {
-          //arrange
-          String loginId = "testuser";
-          String rawPassword = "Test1234!";
-          String name = "홍";
-          String birthDate = "19900101";
-          String email = "test@example.com";
-
-          // act
-          MemberModel member = new MemberModel(loginId, rawPassword, name, birthDate, email);
-
-          assertThat(member.getMaskedName()).isEqualTo("*");
-        }
+      // assert - ErrorType.BAD_REQUEST
+      assertThat(result.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
 
     }
+  }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
index d7b296cb..90820170 100644
--- a/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/domain/member/MemberServiceIntegrationTest.java
@@ -43,13 +43,7 @@ void returnsMemberInfo_whenValidMemberInfoIsProvided() {
       MemberModel result = memberService.getMember(memberModel.getLoginId());
 
       // assert
-      assertAll(
-          () -> assertThat(result).isNotNull(),
-          () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()),
-          () -> assertThat(result.getName()).isEqualTo(memberModel.getName()),
-          () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()),
-          () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail())
-      );
+      assertAll(() -> assertThat(result).isNotNull(), () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()), () -> assertThat(result.getName()).isEqualTo(memberModel.getName()), () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()), () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail()));
     }
 
     @DisplayName("중복 ID로 가입 시도하면 예외가 발생한다")
@@ -73,31 +67,25 @@ void throwsException_whenExistIdIsTryToSaveMember() {
   @Nested
   class GetMember {
 
-      @DisplayName("존재하는 ID를 주면, 해당 유저 정보를 반환한다.")
-      @Test
-      void returnsExampleInfo_whenValidIdIsProvided() {
-          // arrange  // 정보저장
-          MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
-          memberService.saveMember(memberModel);
-
-          // act
-          MemberModel result = memberService.getMember(memberModel.getLoginId());
-
-          // assert
-          assertAll(
-                  () -> assertThat(result).isNotNull(),
-                  () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()),
-                  () -> assertThat(result.getName()).isEqualTo(memberModel.getName()),
-                  () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()),
-                  () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail())
-          );
-      }
-
-      @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
-      @Test
-      void throwsException_whenMemberNotFound() {
-        // arrange
-        String loginId = "testuser"; // Assuming this ID does not exist
+    @DisplayName("존재하는 ID를 주면, 해당 유저 정보를 반환한다.")
+    @Test
+    void returnsExampleInfo_whenValidIdIsProvided() {
+      // arrange  // 정보저장
+      MemberModel memberModel = new MemberModel("testuser", "Test1234!", "홍길동", "19900101", "test@example.com");
+      memberService.saveMember(memberModel);
+
+      // act
+      MemberModel result = memberService.getMember(memberModel.getLoginId());
+
+      // assert
+      assertAll(() -> assertThat(result).isNotNull(), () -> assertThat(result.getLoginId()).isEqualTo(memberModel.getLoginId()), () -> assertThat(result.getName()).isEqualTo(memberModel.getName()), () -> assertThat(result.getBirthDate()).isEqualTo(memberModel.getBirthDate()), () -> assertThat(result.getEmail()).isEqualTo(memberModel.getEmail()));
+    }
+
+    @DisplayName("존재하지 않는 ID로 조회하면 예외가 발생한다")
+    @Test
+    void throwsException_whenMemberNotFound() {
+      // arrange
+      String loginId = "testuser"; // Assuming this ID does not exist
 
       // act
       CoreException exception = assertThrows(CoreException.class, () -> {
@@ -108,4 +96,93 @@ void throwsException_whenMemberNotFound() {
       assertThat(exception.getErrorType()).isEqualTo(ErrorType.NOT_FOUND);
     }
   }
+
+
+  @DisplayName("비밀번호 변경을 할 때, ")
+  @Nested
+  class ChangePassword {
+
+    @DisplayName("기존 비밀번호와 새 비밀번호가 유효하면, 비밀번호가 변경된다.")
+    @Test
+    void changesPassword_whenOldAndNewPasswordsAreValid() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      // 기존 등록된 디비 설정
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      MemberModel insertedMember = new MemberModel(loginId, prevPassword);
+      String newPassword = "NewPass123!";
+
+      // act
+      memberService.changePassword(insertedMember, newPassword);
+
+      // assert
+      MemberModel updatedMember = memberService.getMember("testuser");
+      // 비밀번호가 변경되었는지 확인 (암호화된 비밀번호 비교)
+      assertThat(updatedMember.getPassword()).isNotEqualTo(insertedMember.getPassword());
+    }
+
+    @DisplayName("기존 비밀번호가 일치하지 않으면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenOldPasswordDoesNotMatch() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      // act
+      // 기존 등록된 디비 설정
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      String wrongPrevPassword = "WrongPass!";
+      MemberModel insertedMember = new MemberModel(loginId, wrongPrevPassword);
+      String newPassword = "NewPass123!";
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.changePassword(insertedMember, newPassword);
+      });
+
+      // assert - ErrorType.UNAUTHORIZED
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.UNAUTHORIZED);
+    }
+
+    @DisplayName("새 비밀번호가 기존 비밀번호와 같으면, 예외가 발생한다.")
+    @Test
+    void throwsException_whenNewPasswordIsSameAsOld() {
+      // arrange
+      String loginId = "testuser";
+      String prevPassword = "Test1234!";
+      String name = "홍길동";
+      String birthDate = "19900101";
+      String email = "test@test.co.kr";
+
+      MemberModel member = new MemberModel(loginId, prevPassword, name, birthDate, email);
+      memberService.saveMember(member);
+
+      // 클라에서 입력한 아이디와 기존 비밀번호, 새로운 비밀번호
+      MemberModel insertedMember = new MemberModel(loginId, prevPassword);
+      String newPassword = "Test1234!";
+
+      // act
+      CoreException exception = assertThrows(CoreException.class, () -> {
+        memberService.changePassword(insertedMember, newPassword);
+      });
+
+      // assert - ErrorType.UNAUTHORIZED 또는 BAD_REQUEST
+      assertThat(exception.getErrorType()).isEqualTo(ErrorType.BAD_REQUEST);
+    }
+  }
 }
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
index 837a4dd1..a31933ee 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -152,4 +152,100 @@ void returnsNotFound_whenNonExistingLoginIdIsProvided() {
             assertThat(response.getStatusCode()).isEqualTo(HttpStatus.NOT_FOUND);
         }
     }
+
+    @DisplayName("PATCH /api/v1/members/{loginId}/password (비밀번호 변경)")
+    @Nested
+    class ChangePassword {
+
+        @DisplayName("기존 비밀번호가 일치하고 새 비밀번호가 유효하면, 200 OK를 반환한다.")
+        @Test
+        void returnsOk_whenOldPasswordMatchesAndNewPasswordIsValid() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 비밀번호 변경 요청
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/testuser/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertAll(
+                () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
+                () -> assertThat(response.getBody()).isNotNull(),
+                () -> assertThat(response.getBody().data()).isEqualTo("비밀번호가 변경되었습니다.")
+            );
+        }
+
+        @DisplayName("기존 비밀번호가 일치하지 않으면, 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenOldPasswordDoesNotMatch() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 틀린 기존 비밀번호로 변경 요청
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "WrongPass1!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/testuser/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("새 비밀번호가 기존 비밀번호와 같으면, 400 Bad Request를 반환한다.")
+        @Test
+        void returnsBadRequest_whenNewPasswordIsSameAsOld() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 기존과 동일한 비밀번호로 변경 요청
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "Test1234!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/testuser/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
+        }
+    }
 }

From df0e33003002447ebdffc71a6f7a644af38eddad Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Fri, 6 Feb 2026 01:18:27 +0900
Subject: [PATCH 7/8] =?UTF-8?q?feat:=20=ED=97=A4=EB=8D=94=EC=9D=B8?=
 =?UTF-8?q?=EC=A6=9D=20=EC=B6=94=EA=B0=80(=ED=85=8C=EC=8A=A4=ED=8A=B8?=
 =?UTF-8?q?=EC=97=90=EB=8F=84=20=EC=B6=94=EA=B0=80)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../application/member/MemberFacade.java      |  14 +-
 .../loopers/domain/member/MemberService.java  | 101 ++++++-----
 .../api/member/MemberV1ApiSpec.java           |   7 +-
 .../api/member/MemberV1Controller.java        |  16 +-
 .../interfaces/api/MemberV1ApiE2ETest.java    | 170 ++++++++++++++----
 5 files changed, 217 insertions(+), 91 deletions(-)

diff --git a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
index 1e9cd02b..781bacce 100644
--- a/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
+++ b/apps/commerce-api/src/main/java/com/loopers/application/member/MemberFacade.java
@@ -29,14 +29,18 @@ public MemberInfo signupMember(MemberV1Dto.SignUpRequest request) {
     return MemberInfo.from(saved);
   }
 
-  public MemberInfo getMyInfo(String loginId) {
-    MemberModel member = memberService.getMember(loginId);
+
+  public MemberInfo getMyInfo(String loginId, String password) {
+    MemberModel member = memberService.authenticate(loginId, password);
     return MemberInfo.from(member);
   }
 
-  public void changePassword(String loginId, String prevPassword, String newPassword) {
-    // Request → MemberModel로 변환
-    MemberModel memberModel = new MemberModel(loginId, prevPassword);
+
+  public void changePassword(String loginId, String password, String prevPassword, String newPassword) {
+    // 헤더 인증
+    memberService.authenticate(loginId, password);
+
+    MemberModel memberModel = new MemberModel(loginId, prevPassword);  // raw prevPassword
 
     // Service 호출
     memberService.changePassword(memberModel, newPassword);
diff --git a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
index f6ee186b..0ab66665 100644
--- a/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
+++ b/apps/commerce-api/src/main/java/com/loopers/domain/member/MemberService.java
@@ -13,57 +13,70 @@
 @Component
 public class MemberService {
 
-    private final MemberRepository memberRepository;
-    private final PasswordEncoder passwordEncoder;
-
-    @Transactional(readOnly = false)
-      public MemberModel saveMember(MemberModel memberModel) {
-        //저장하기 전에 이미 같은 loginId가 있는지 확인
-        Optional<MemberModel> existing = memberRepository.findByLoginId(memberModel.getLoginId());
-        if (existing.isPresent()) {
-          throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
-        }
-
-        // 비밀번호 암호화 후 저장
-        String encrypted = passwordEncoder.encode(memberModel.getPassword());
-        memberModel.encryptPassword(encrypted);
-
-        try {
-          return memberRepository.save(memberModel);
-        } catch (DataIntegrityViolationException e) {
-          throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
-        }
-      }
-
-    @Transactional(readOnly = true)
-    public MemberModel getMember(String loginId) {
-        MemberModel model = new MemberModel(loginId);  // 객체 먼저 생성해야 함
-        return memberRepository.findByLoginId(model.getLoginId())
-                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + loginId + "] 회원을 찾을 수 없습니다."));
+  private final MemberRepository memberRepository;
+  private final PasswordEncoder passwordEncoder;
+
+  @Transactional(readOnly = false)
+  public MemberModel saveMember(MemberModel memberModel) {
+    //저장하기 전에 이미 같은 loginId가 있는지 확인
+    Optional<MemberModel> existing = memberRepository.findByLoginId(memberModel.getLoginId());
+    if (existing.isPresent()) {
+      throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
     }
 
-    @Transactional(readOnly = false)
-    public void changePassword(MemberModel memberModel, String newPassword) {
+    // 비밀번호 암호화 후 저장
+    String encrypted = passwordEncoder.encode(memberModel.getPassword());
+    memberModel.encryptPassword(encrypted);
+
+    try {
+      return memberRepository.save(memberModel);
+    } catch (DataIntegrityViolationException e) {
+      throw new CoreException(ErrorType.CONFLICT, "이미 존재하는 아이디입니다.");
+    }
+  }
+
+  public MemberModel authenticate(String loginId, String password) {
+    // 1. 회원 조회
+    MemberModel member = getMember(loginId);  // 없으면 NOT_FOUND
+
+    // 2. 비밀번호 일치 여부 확인
+    if (!passwordEncoder.matches(password, member.getPassword())) {
+      // 3. 불일치 시 UNAUTHORIZED 예외
+      throw new CoreException(ErrorType.UNAUTHORIZED, "인증 실패");
+    }
 
-        // 기존 회원 정보 조회
-        MemberModel member = getMember(memberModel.getLoginId());
+    return member;
+  }
 
-        // 암호화된 DB 비밀번호와 입력한 기존 비밀번호 비교
-        if (!passwordEncoder.matches(memberModel.getPassword(), member.getPassword())) {
-          throw new CoreException(ErrorType.UNAUTHORIZED, "기존 비밀번호가 일치하지 않습니다.");
-        }
+  @Transactional(readOnly = true)
+  public MemberModel getMember(String loginId) {
+    MemberModel model = new MemberModel(loginId);  // 객체 먼저 생성해야 함
+    return memberRepository.findByLoginId(model.getLoginId())
+        .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "[id = " + loginId + "] 회원을 찾을 수 없습니다."));
+  }
 
-        // 암호화된 DB 기존 비밀번호와 입력한 새로운 비밀번호 비교
-        if (passwordEncoder.matches(newPassword, member.getPassword())) {
-          throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 기존 비밀번호와 달라야 합니다.");
-        }
+  @Transactional(readOnly = false)
+  public void changePassword(MemberModel memberModel, String newPassword) {
 
-        // 새 비밀번호 규칙 검증 + 암호화 + 저장 (Dirty Checking)
-        member.changePassword(newPassword, member.getBirthDate());
+    // 기존 회원 정보 조회
+    MemberModel member = getMember(memberModel.getLoginId());
 
-        // 암호화 후 저장 (Dirty Checking)
-        String encryptedPassword = passwordEncoder.encode(newPassword);
-        member.encryptPassword(encryptedPassword);
+    // 암호화된 DB 비밀번호와 입력한 기존 비밀번호 비교
+    if (!passwordEncoder.matches(memberModel.getPassword(), member.getPassword())) {
+      throw new CoreException(ErrorType.UNAUTHORIZED, "기존 비밀번호가 일치하지 않습니다.");
+    }
 
+    // 암호화된 DB 기존 비밀번호와 입력한 새로운 비밀번호 비교
+    if (passwordEncoder.matches(newPassword, member.getPassword())) {
+      throw new CoreException(ErrorType.BAD_REQUEST, "새 비밀번호는 기존 비밀번호와 달라야 합니다.");
     }
+
+    // 새 비밀번호 규칙 검증 + 암호화 + 저장 (Dirty Checking)
+    member.changePassword(newPassword, member.getBirthDate());
+
+    // 암호화 후 저장 (Dirty Checking)
+    String encryptedPassword = passwordEncoder.encode(newPassword);
+    member.encryptPassword(encryptedPassword);
+
+  }
 }
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
index 41128ac7..52cb6480 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1ApiSpec.java
@@ -3,6 +3,7 @@
 import com.loopers.interfaces.api.ApiResponse;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
+import org.springframework.web.bind.annotation.RequestHeader;
 
 @Tag(name = "Member V1 API", description = "회원 API")
 public interface MemberV1ApiSpec {
@@ -22,7 +23,8 @@ ApiResponse<MemberV1Dto.SignUpResponse> signUp(
       description = "로그인 ID로 내 회원 정보를 조회한다"
   )
   ApiResponse<MemberV1Dto.MemberInfoResponse> getMyInfo(
-          String loginId
+      @RequestHeader("X-Loopers-LoginId") String loginId,
+      @RequestHeader("X-Loopers-LoginPw") String password
   );
 
   @Operation(
@@ -30,7 +32,8 @@ ApiResponse<MemberV1Dto.MemberInfoResponse> getMyInfo(
       description = "기존 비밀번호와 새 비밀번호를 받아 비밀번호를 변경한다"
   )
   ApiResponse<String> changePassword(
-      String loginId,
+      @RequestHeader("X-Loopers-LoginId") String loginId,
+      @RequestHeader("X-Loopers-LoginPw") String password,
       MemberV1Dto.ChangePasswordRequest request
   );
 
diff --git a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
index a7a3928e..07bf218e 100644
--- a/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
+++ b/apps/commerce-api/src/main/java/com/loopers/interfaces/api/member/MemberV1Controller.java
@@ -11,9 +11,9 @@
 import org.springframework.http.HttpStatus;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PatchMapping;
-import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.PostMapping;
 import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseStatus;
 import org.springframework.web.bind.annotation.RestController;
@@ -38,22 +38,24 @@ public ApiResponse<SignUpResponse> signUp(@RequestBody SignUpRequest request) {
         return ApiResponse.success(response);
     }
 
-    @GetMapping("/{loginId}")
+    @GetMapping("/me")
     @Override
     public ApiResponse<MemberInfoResponse> getMyInfo(
-            @PathVariable(value = "loginId") String loginId
+        @RequestHeader("X-Loopers-LoginId") String loginId,
+        @RequestHeader("X-Loopers-LoginPw") String password
     ) {
-        MemberInfo info = memberFacade.getMyInfo(loginId);
+        MemberInfo info = memberFacade.getMyInfo(loginId, password);
         MemberInfoResponse response = MemberInfoResponse.from(info);
         return ApiResponse.success(response);
     }
 
-    @PatchMapping("/{loginId}/password")
+  @PatchMapping("/me/password")
     public ApiResponse<String> changePassword(
-        @PathVariable String loginId,
+        @RequestHeader("X-Loopers-LoginId") String loginId,
+        @RequestHeader("X-Loopers-LoginPw") String password,
         @RequestBody ChangePasswordRequest request
     ) {
-      memberFacade.changePassword(loginId, request.oldPassword(), request.newPassword());
+      memberFacade.changePassword(loginId, password, request.oldPassword(), request.newPassword());
       return ApiResponse.success("비밀번호가 변경되었습니다.");
     }
 
diff --git a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
index a31933ee..b9fb6e26 100644
--- a/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
+++ b/apps/commerce-api/src/test/java/com/loopers/interfaces/api/MemberV1ApiE2ETest.java
@@ -1,7 +1,12 @@
 package com.loopers.interfaces.api;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
 import com.loopers.utils.DatabaseCleanUp;
+import java.util.Map;
 import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
 import org.junit.jupiter.api.Test;
@@ -10,15 +15,11 @@
 import org.springframework.boot.test.web.client.TestRestTemplate;
 import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 
-import java.util.Map;
-
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.junit.jupiter.api.Assertions.assertAll;
-
 @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
 class MemberV1ApiE2ETest {
 
@@ -69,8 +70,14 @@ void returnsCreated_whenValidMemberInfoIsProvided() {
             assertAll(
                 () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED),
                 () -> assertThat(response.getBody()).isNotNull(),
-                () -> assertThat(response.getBody().data()).isNotNull(),
-                () -> assertThat(response.getBody().data().get("loginId")).isNotNull()
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isNotNull();
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("loginId")).isNotNull();
+                }
             );
         }
 
@@ -100,13 +107,13 @@ void returnsConflict_whenDuplicateLoginIdIsProvided() {
         }
     }
 
-    @DisplayName("GET /api/v1/members/{loginId} (회원정보조회)")
+    @DisplayName("GET /api/v1/members/me (회원정보조회)")
     @Nested
     class GetMemberInfo {
 
-        @DisplayName("존재하는 회원의 ID로 조회하면, 200 OK와 마스킹된 이름을 반환한다.")
+        @DisplayName("헤더 인증 성공 시, 200 OK와 마스킹된 이름을 반환한다.")
         @Test
-        void returnsMemberInfo_whenExistingLoginIdIsProvided() {
+        void returnsMemberInfo_whenHeaderAuthIsValid() {
             // arrange - 먼저 회원 가입
             Map<String, String> signUpRequest = Map.of(
                 "loginId", "testuser",
@@ -117,11 +124,15 @@ void returnsMemberInfo_whenExistingLoginIdIsProvided() {
             );
             testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
 
-            // act - GET 요청으로 회원 정보 조회
+            // act - 헤더에 인증 정보 포함하여 조회
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+
             ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
-                ENDPOINT + "/testuser",
+                ENDPOINT + "/me",
                 HttpMethod.GET,
-                null,
+                new HttpEntity<>(headers),
                 new ParameterizedTypeReference<>() {}
             );
 
@@ -129,22 +140,63 @@ void returnsMemberInfo_whenExistingLoginIdIsProvided() {
             assertAll(
                 () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
                 () -> assertThat(response.getBody()).isNotNull(),
-                () -> assertThat(response.getBody().data()).isNotNull(),
-                () -> assertThat(response.getBody().data().get("loginId")).isEqualTo("testuser"),
-                () -> assertThat(response.getBody().data().get("name")).isEqualTo("홍길*")
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isNotNull();
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("loginId")).isEqualTo("testuser");
+                },
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data().get("name")).isEqualTo("홍길*");
+                }
             );
         }
 
+        @DisplayName("헤더 인증 실패 시 (비밀번호 불일치), 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenHeaderPasswordIsWrong() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 틀린 비밀번호로 조회
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "WrongPass1!");
+
+            ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me",
+                HttpMethod.GET,
+                new HttpEntity<>(headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
         @DisplayName("존재하지 않는 회원의 ID로 조회하면, 404 Not Found를 반환한다.")
         @Test
-        void returnsNotFound_whenNonExistingLoginIdIsProvided() {
+        void returnsNotFound_whenMemberDoesNotExist() {
             // arrange - 아무 데이터 없음
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "nonexistent");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
 
             // act
             ResponseEntity<ApiResponse<Map<String, String>>> response = testRestTemplate.exchange(
-                ENDPOINT + "/nonexistent",
+                ENDPOINT + "/me",
                 HttpMethod.GET,
-                null,
+                new HttpEntity<>(headers),
                 new ParameterizedTypeReference<>() {}
             );
 
@@ -153,13 +205,13 @@ void returnsNotFound_whenNonExistingLoginIdIsProvided() {
         }
     }
 
-    @DisplayName("PATCH /api/v1/members/{loginId}/password (비밀번호 변경)")
+    @DisplayName("PATCH /api/v1/members/me/password (비밀번호 변경)")
     @Nested
     class ChangePassword {
 
-        @DisplayName("기존 비밀번호가 일치하고 새 비밀번호가 유효하면, 200 OK를 반환한다.")
+        @DisplayName("헤더 인증 성공 + 유효한 비밀번호 변경 요청이면, 200 OK를 반환한다.")
         @Test
-        void returnsOk_whenOldPasswordMatchesAndNewPasswordIsValid() {
+        void returnsOk_whenHeaderAuthAndPasswordChangeAreValid() {
             // arrange - 먼저 회원 가입
             Map<String, String> signUpRequest = Map.of(
                 "loginId", "testuser",
@@ -170,15 +222,20 @@ void returnsOk_whenOldPasswordMatchesAndNewPasswordIsValid() {
             );
             testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
 
-            // act - 비밀번호 변경 요청
+            // act - 헤더 인증 + 비밀번호 변경 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
             Map<String, String> changePasswordRequest = Map.of(
                 "oldPassword", "Test1234!",
                 "newPassword", "NewPass123!"
             );
             ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
-                ENDPOINT + "/testuser/password",
+                ENDPOINT + "/me/password",
                 HttpMethod.PATCH,
-                new HttpEntity<>(changePasswordRequest),
+                new HttpEntity<>(changePasswordRequest, headers),
                 new ParameterizedTypeReference<>() {}
             );
 
@@ -186,13 +243,16 @@ void returnsOk_whenOldPasswordMatchesAndNewPasswordIsValid() {
             assertAll(
                 () -> assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK),
                 () -> assertThat(response.getBody()).isNotNull(),
-                () -> assertThat(response.getBody().data()).isEqualTo("비밀번호가 변경되었습니다.")
+                () -> {
+                  Assertions.assertNotNull(response.getBody());
+                  assertThat(response.getBody().data()).isEqualTo("비밀번호가 변경되었습니다.");
+                }
             );
         }
 
-        @DisplayName("기존 비밀번호가 일치하지 않으면, 401 Unauthorized를 반환한다.")
+        @DisplayName("헤더 인증 실패 시 (비밀번호 불일치), 401 Unauthorized를 반환한다.")
         @Test
-        void returnsUnauthorized_whenOldPasswordDoesNotMatch() {
+        void returnsUnauthorized_whenHeaderPasswordIsWrong() {
             // arrange - 먼저 회원 가입
             Map<String, String> signUpRequest = Map.of(
                 "loginId", "testuser",
@@ -203,15 +263,54 @@ void returnsUnauthorized_whenOldPasswordDoesNotMatch() {
             );
             testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
 
-            // act - 틀린 기존 비밀번호로 변경 요청
+            // act - 틀린 헤더 비밀번호로 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "WrongPass1!");
+            headers.set("Content-Type", "application/json");
+
+            Map<String, String> changePasswordRequest = Map.of(
+                "oldPassword", "Test1234!",
+                "newPassword", "NewPass123!"
+            );
+            ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
+                ENDPOINT + "/me/password",
+                HttpMethod.PATCH,
+                new HttpEntity<>(changePasswordRequest, headers),
+                new ParameterizedTypeReference<>() {}
+            );
+
+            // assert
+            assertThat(response.getStatusCode()).isEqualTo(HttpStatus.UNAUTHORIZED);
+        }
+
+        @DisplayName("Body의 기존 비밀번호가 일치하지 않으면, 401 Unauthorized를 반환한다.")
+        @Test
+        void returnsUnauthorized_whenOldPasswordInBodyDoesNotMatch() {
+            // arrange - 먼저 회원 가입
+            Map<String, String> signUpRequest = Map.of(
+                "loginId", "testuser",
+                "password", "Test1234!",
+                "name", "홍길동",
+                "birthDate", "19900101",
+                "email", "test@test.co.kr"
+            );
+            testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
+
+            // act - 헤더는 맞지만 Body의 oldPassword가 틀림
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
             Map<String, String> changePasswordRequest = Map.of(
                 "oldPassword", "WrongPass1!",
                 "newPassword", "NewPass123!"
             );
             ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
-                ENDPOINT + "/testuser/password",
+                ENDPOINT + "/me/password",
                 HttpMethod.PATCH,
-                new HttpEntity<>(changePasswordRequest),
+                new HttpEntity<>(changePasswordRequest, headers),
                 new ParameterizedTypeReference<>() {}
             );
 
@@ -233,14 +332,19 @@ void returnsBadRequest_whenNewPasswordIsSameAsOld() {
             testRestTemplate.exchange(ENDPOINT, HttpMethod.POST, new HttpEntity<>(signUpRequest), new ParameterizedTypeReference<ApiResponse<Map<String, String>>>() {});
 
             // act - 기존과 동일한 비밀번호로 변경 요청
+            HttpHeaders headers = new HttpHeaders();
+            headers.set("X-Loopers-LoginId", "testuser");
+            headers.set("X-Loopers-LoginPw", "Test1234!");
+            headers.set("Content-Type", "application/json");
+
             Map<String, String> changePasswordRequest = Map.of(
                 "oldPassword", "Test1234!",
                 "newPassword", "Test1234!"
             );
             ResponseEntity<ApiResponse<String>> response = testRestTemplate.exchange(
-                ENDPOINT + "/testuser/password",
+                ENDPOINT + "/me/password",
                 HttpMethod.PATCH,
-                new HttpEntity<>(changePasswordRequest),
+                new HttpEntity<>(changePasswordRequest, headers),
                 new ParameterizedTypeReference<>() {}
             );
 

From 2f40dc76da2be94955326c43520eac84c782df6c Mon Sep 17 00:00:00 2001
From: katiekim17 <pyeongsuk.kim88@gmail.com>
Date: Fri, 6 Feb 2026 01:37:18 +0900
Subject: [PATCH 8/8] =?UTF-8?q?docs:=20=ED=9A=8C=EC=9B=90=20=EB=8F=84?=
 =?UTF-8?q?=EB=A9=94=EC=9D=B8=20=ED=94=8C=EB=A1=9C=EC=9A=B0=20=EB=8B=A4?=
 =?UTF-8?q?=EC=9D=B4=EC=96=B4=EA=B7=B8=EB=9E=A8=20=EC=B6=94=EA=B0=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

- 회원가입 시퀀스 다이어그램 (핵심 + 예외 플로우)
- 내 정보 조회 시퀀스 다이어그램 (헤더 인증 포함)
- 비밀번호 변경 시퀀스 다이어그램 (핵심 + 예외 플로우)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
---
 MERMAID.md | 167 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 167 insertions(+)
 create mode 100644 MERMAID.md

diff --git a/MERMAID.md b/MERMAID.md
new file mode 100644
index 00000000..09f77cf3
--- /dev/null
+++ b/MERMAID.md
@@ -0,0 +1,167 @@
+# Flow Diagrams
+
+## 1. 회원가입 (POST /api/v1/members)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: POST /api/v1/members (SignUpRequest)
+    Controller->>Facade: signupMember(request)
+    Facade->>Facade: Request to MemberModel 변환
+    Facade->>Service: saveMember(memberModel)
+    Service->>DB: findByLoginId (중복 체크)
+    DB-->>Service: Optional.empty()
+    Service->>Service: passwordEncoder.encode()
+    Service->>DB: save(memberModel)
+    DB-->>Service: savedMember
+    Service-->>Facade: MemberModel
+    Facade->>Facade: MemberModel to MemberInfo 변환
+    Facade-->>Controller: MemberInfo
+    Controller-->>Client: 201 Created (SignUpResponse)
+```
+
+### 예외 흐름
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: POST /api/v1/members (중복 ID)
+    Controller->>Facade: signupMember(request)
+    Facade->>Service: saveMember(memberModel)
+    Service->>DB: findByLoginId
+    DB-->>Service: Optional.of(existingMember)
+    Service-->>Controller: CoreException (CONFLICT)
+    Controller-->>Client: 409 Conflict
+```
+
+---
+
+## 2. 내 정보 조회 (GET /api/v1/members/me)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: GET /api/v1/members/me
+    Note over Client,Controller: Headers: X-Loopers-LoginId, X-Loopers-LoginPw
+    Controller->>Facade: getMyInfo(loginId, password)
+    Facade->>Service: authenticate(loginId, password)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches()
+    Service-->>Facade: MemberModel (인증 성공)
+    Facade->>Facade: MemberModel to MemberInfo 변환 (이름 마스킹)
+    Facade-->>Controller: MemberInfo
+    Controller-->>Client: 200 OK (MemberInfoResponse)
+```
+
+### 예외 흐름 - 인증 실패
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: GET /api/v1/members/me (틀린 비밀번호)
+    Controller->>Facade: getMyInfo(loginId, wrongPassword)
+    Facade->>Service: authenticate(loginId, wrongPassword)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches() = false
+    Service-->>Controller: CoreException (UNAUTHORIZED)
+    Controller-->>Client: 401 Unauthorized
+```
+
+---
+
+## 3. 비밀번호 변경 (PATCH /api/v1/members/me/password)
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+    participant DB
+
+    Client->>Controller: PATCH /api/v1/members/me/password
+    Note over Client,Controller: Headers: X-Loopers-LoginId, X-Loopers-LoginPw
+    Note over Client,Controller: Body: oldPassword, newPassword
+    Controller->>Facade: changePassword(loginId, headerPw, oldPw, newPw)
+    Facade->>Service: authenticate(loginId, headerPw)
+    Service->>DB: findByLoginId
+    DB-->>Service: MemberModel
+    Service->>Service: passwordEncoder.matches(headerPw)
+    Service-->>Facade: 인증 성공
+    Facade->>Facade: new MemberModel(loginId, oldPw)
+    Facade->>Service: changePassword(memberModel, newPw)
+    Service->>Service: passwordEncoder.matches(oldPw) 검증
+    Service->>Service: newPw != oldPw 검증
+    Service->>Service: validatePassword(newPw) 규칙 검증
+    Service->>Service: passwordEncoder.encode(newPw)
+    Service->>DB: Dirty Checking (자동 저장)
+    Service-->>Facade: void
+    Facade-->>Controller: void
+    Controller-->>Client: 200 OK
+```
+
+### 예외 흐름 - Body의 기존 비밀번호 불일치
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+
+    Client->>Controller: PATCH (헤더 인증 OK, Body oldPw 틀림)
+    Controller->>Facade: changePassword(...)
+    Facade->>Service: authenticate() 성공
+    Facade->>Service: changePassword(wrongOldPw, newPw)
+    Service->>Service: passwordEncoder.matches(wrongOldPw) = false
+    Service-->>Controller: CoreException (UNAUTHORIZED)
+    Controller-->>Client: 401 Unauthorized
+```
+
+### 예외 흐름 - 새 비밀번호가 기존과 동일
+
+```mermaid
+sequenceDiagram
+    autonumber
+    participant Client
+    participant Controller
+    participant Facade
+    participant Service
+
+    Client->>Controller: PATCH (newPw == oldPw)
+    Controller->>Facade: changePassword(...)
+    Facade->>Service: authenticate() 성공
+    Facade->>Service: changePassword(oldPw, samePassword)
+    Service->>Service: oldPw 검증 성공
+    Service->>Service: newPw == oldPw 체크
+    Service-->>Controller: CoreException (BAD_REQUEST)
+    Controller-->>Client: 400 Bad Request
+```
\ No newline at end of file