diff --git "a/keyword/chapter05/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png" "b/keyword/chapter05/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png"
new file mode 100644
index 0000000..501cb97
Binary files /dev/null and "b/keyword/chapter05/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png" differ
diff --git "a/keyword/chapter05/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220_\353\223\261\353\241\235.png" "b/keyword/chapter05/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..98573b5
Binary files /dev/null and "b/keyword/chapter05/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220_\353\223\261\353\241\235.png" differ
diff --git a/keyword/chapter05/keyword.md b/keyword/chapter05/keyword.md
new file mode 100644
index 0000000..0ed6af2
--- /dev/null
+++ b/keyword/chapter05/keyword.md
@@ -0,0 +1,383 @@
+### **📦 실습**
+---
+1. 회원가입 API
+    - Repository 함수
+        ```javascript
+        // 회원 데이터 삽입 (회원 등록) & 회원 ID 반환
+        export const addMember = async(data) => {
+            const conn = await pool.getConnection(); // 데이터베이스 연결
+            try{
+                // 해당 이메일(중복된 이메일)의 사용자가 있는지 확인
+                const [confirm] = await pool.query( // 쿼리 실행
+                    `SELECT EXISTS(SELECT 1 FROM member WHERE email = ?) as isExistEmail;`, 
+                    data.email
+                );
+                if (confirm[0].isExistEmail) { // 이미 등록된 이메일일 경우
+                    return null;
+                }
+                // 중복된 이메일이 아닐 경우, 회원 정보 member 테이블에 삽입
+                const [result] = await pool.query(
+                    `INSERT INTO member (member_name, nickname, gender, birth, location_address, email, phone_number) VALUES (?, ?, ?, ?, ?, ?, ?);`,
+                    [
+                        data.name,
+                        data.nickname,
+                        data.gender,
+                        data.birth,
+                        data.location,
+                        data.email,
+                        data.phoneNumber, 
+                    ] // 정보 삽입, 다른 속성들은 default 값을 지정해주었다. 
+                );
+                return result.insertId; // 생성된 회원의 ID 반환
+                // insertId - DB에 새로운 레코드 삽입
+                // 새 레코드가 삽입될 때 해당 레코드의 자동 증가 ID 값을 반환한다.
+            } catch(err) { // 오류 처리
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            } finally {
+                conn.release(); // DB 연결 해지
+            }
+        };
+
+        // 회원 정보 조회
+        export const getMember = async (memberId) => {
+            const conn = await pool.getConnection();
+            try{
+                // 회원 ID로 조회해서 해당 회원 정보를 모두 조회한다.   
+                const [member] = await pool.query(
+                    `SELECT * FROM member WHERE id = ?;`,
+                    memberId
+                )
+                console.log(member);
+                if (member.length == 0){ // 조회된 회원이 없을 경우
+                    return null;
+                }
+                return member;
+            }catch (err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        };
+
+        // 음식 - 선호_음식_종류 매핑
+        export const setFavoriteFoodKind = async(memberId, favoriteFoodKindId) => {
+            const conn = await pool.getConnection();
+            try{
+                await pool.query( // 회원-음식_종류 매핑 테이블에 회원 ID, 음식_종류 ID를 삽입함으로써 두 관계를 이어준다. 
+                        `INSERT INTO member_food_kind (food_kind_id, member_id) VALUES (?, ?);`,
+                        [favoriteFoodKindId, memberId]
+                );
+                return;
+            } catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            } finally{
+                conn.release();
+            }
+        };
+
+        // 회원 - 선호_음식_종류 반환
+        export const getMemberFavoriteFoodKindByMemberId = async (memberId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [favoriteFoodKinds] = await pool.query(`
+                    SELECT mfk.id, mfk.food_kind_id, mfk.member_id, fk.kind
+                    FROM member_food_kind mfk JOIN food_kind fk ON mfk.food_kind_id = fk.id
+                    WHERE mfk.member_id = ?
+                    ORDER BY mfk.food_kind_id ASC`,
+                    memberId
+                ); // member 테이블과 food_kind 테이블을 join해 해당 회원의 선호 음식 종류에 대한 정보를 가져온다. 
+                return favoriteFoodKinds;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+        ```
+    - 테스트 결과<br/>
+        ![실습-1-회원등록](images/실습-1-회원_등록.png)
+    - 동일한 이메일로 회원가입하는 경우<br/>
+        ![images/실습-1-중복된_회원](images/실습-1-중복된_회원.png)
+        - 회원 이메일로 조회했을 때 이미 데이터가 존재할 경우 에러를 발생시켰다.  
+### 🎯 핵심 키워드
+---
+- 환경 변수 (Environment Variables)
+    - 운영체제나 실행 환경에서 설정된 변수
+    - 소프트퉤어 애플리케이션 동작에 영향을 미치는 중요한 정보를 저장하는 데 사용된다. 즉, 중요한 정보를 소스코드에 직접 포함하지 않아 보안을 강화한다.
+    - 민감하거나 자주 변경될 수 있는 설정 값을 코드에 하드코딩하지 않고 외부에서 관리할 수 있도록 한다.
+        - ex. 데이터베이스 연결 정보, API 키, 서버 포트 번호 등
+    - ex. Node.js 프로젝트에서의 .env 파일
+        - dotenv 라이브러리를 사용해 .env 파일에 환경변수를 정의하고 로드할 수 있다.
+        ```javascript
+        DB_HOST=localhost
+        DB_POST=3306
+        DB_USER=root
+        DB_PASSWORD=mypassword
+        PORT=3000
+        ```
+        - Node.js에서 process.env를 통해 환경변수에 접근할 수 있다.
+        ```javascript
+        const dbHost = process.env.DB_HOST
+        const dbPort = process.env.DB_PORT
+        ```     
+- CORS (Cross-Origin Resource Sharing)
+    - 웹 브라우저에서 실행되는 웹 애플리케이션이 다른 도메인, 프로토콜, 포트에서 실행되는 리소스에 접근할 수 있도록 허용하는 보안 기능
+    - 기본적으로 브라우저는 보안상의 이유로 동일한 출처 정책(Same-Origin Policy)을 적용해 한 출처에서 로드된 웹 페이지가 다른 출처의 리소스에 접근하는 것을 제한한다.
+        - ex. http://umc.com에서 로드된 웹 애플리케이션은 기본적으로 http://api.umc.com과 같은 다른 도메인에 있는 API에 접근할 수 없다. → Cors는 이러한 제한을 완화한다.
+        - 웹 애플리케이션이 외부 API를 통해 데이터를 가져오거나 다른 도메인에 있는 서버와 상호작용해야 할 때 CORS 설정으로 이러한 요청을 허용할 수 있다.
+    1. 간단한 요청 (Simple Request)
+        - 브라우저는 GET, POST, HEAD 메서드를 사용하는 단순한 HTTP 요청에 대해 origin 헤더를 추가한다. 서버는 이 요청을 받고 응답 헤더에 Access-Control-Allow-Origin을 포함시켜 요청을 허용할 지를 결정한다.
+        - ex.<br/>
+            요청 헤더: Origin: http://umc.com <br/>
+            응답 헤더: Access-Control-Allow-Origin: http://umc.com 
+    2. 예비 요청 (Preflight Request)
+        - 보안상의 이유로 브라우저는 단순하지 않은 요청(ex. PUT, DELETE 메서드, 사용자 지정 헤더가 포함된 요청)을 실행하기 전에 서버에 예비 요청(OPTIONS 메서드)을 보낸다. 이는 실제 요청을 보내기 전에 서버가 해당 요청을 허용할지를 확인하는 과정이다.
+    - CORS 관련 헤더
+        1. Access-Control-Allow-Origin
+            - 클라이언트가 리소스에 접근할 수 있도록 허용된 출처(Origin)를 정의한다.
+            - ex. Access-Control-Allow-Origin: * →  모든 출처를 허용한다.
+        2. Access-Control-Allow-Methods
+            - 허용된 HTTP 메서드를 지정한다.
+            - ex. Access-Control-Allow-Methods: GET, POST, PUT, DELETE
+        3. Access-Control-Allow-Headers
+            - 클라이언트가 요청할 때 사용할 수 있는 헤더를 명시한다.
+            - ex. Access-Control-Allow-Headers: Content-Type, Authorization
+        4. Access-Control-Allow-Credentials
+            - 클라이언트에서 쿠키와 같은 자격 증명을 포함한 요청을 할 수 있도록 허용할 지에 대한 여부를 설정한다.
+            - ex. Access-Control-Allow-Credentials: true
+    - ex. CORS 설정 (Node.js/Express)
+        ```javascript
+        import express from 'express'; 
+        import cors from 'cors';;
+        const app = express();
+        
+        app.use(cors()); // 모든 출처에 대해 cors 허용
+        
+        // 특정 출처만 허용하는 경우
+        app.use(cors({ // cors 미들웨어 추가
+          origin: 'http://umc.com', // 허용된 출처(Cross-Origin) 지정
+          methods: 'GET, POST', // 허용된 HTTP 지정
+          credentials: true // 클라이언트가 서버에 쿠키, 인증 헤더 등 자격 증명(credentials)을 포함할 수 있다.
+        }));
+        
+        app.listen(3000, () => {
+          console.log('Server is running on port 3000');
+        });
+        ```
+        - http://umc.com에서 오는 요청만 CORS 규칙에 의해 허용된다.
+        - Cross-Origin: 동일 출처 정책을 우회할 출처를 지정한다.
+            - 위의 예시에선 웹 브라우저가 http://umc.com에서 실행되는 애플리케이션이 서버에 요청을 보내는 것을 허용한다.
+        - 서버는 GET과 POST 메서드로만 요청을 받을 수 있다.
+        - Credential 옵션이 true로 설정될 경우 Access-Control-Allow-Origin을 *로 설정할 수 없고 특정 출처를 지정해야 한다.
+- DB Connection, DB Connection Pool
+    1. DB Connection (데이터베이스 연결)
+        - 애플리케이션이 데이터를 읽거나 쓰기 위해 데이터베이스에 접근할 때 필요한 데이터베이스 연결을 해준다.
+        - 각 연결은 네트워크를 통해 데이터베이스와 상호작용하고 쿼리를 실행하며 결과를 가져오는 데 사용된다.
+        - 기본 흐름
+            1. 애플리케이션이 데이터베이스 연결을 설정한다.
+            2. 쿼리를 보내고 응답을 받는다. 
+            3. 작업이 끝나면 연결을 종료한다.
+    2. DB Connection Pool (데이터베이스 연결 풀)
+        - 여러 데이터베이스 연결을 미리 생성해두고 이를 애플리케이션에서 재사용(성능, 효율 ↑)할 수 있도록 관리하는 메키니즘
+        - 작동 원리
+            1. 초기화: 애플리케이션이 시작될 때 일정한 수(과부하 방지)의 데이터베이스 연결을 미리 생성해놓는다. 
+            2. 재사용: 애플리케이션이 데이터베이스 작업을 요청할 때 연결 풀에서 사용 가능한 연결을 가져다 사용한다. (시간 및 리소스 절약)
+            3. 반환: 작업이 끝나면 연결이 닫히는 것이 아니라 풀로 반환되어 다른 요청이 재사용할 수 있다.
+            4. 확장/축소: 연결 풀이 필요한 경우 더 많은 연결을 생성하거나 사용되지 않는 연결을 종료하여 리소스를 관리할 수 있다. 
+    - Node.js에선 mysql2 라이브러리를 사용해 데이터베이스 연결 풀을 생성할 수 있다.
+        ```javascript
+        import mysql from 'mysql2/promise'; // MySQL 데이터베이스와 연결
+        
+        export const pool = mysql.createPool({ // 데이터베이스 연결 풀(connection pool) 생성
+            host: process.env.DB_HOST || 'localhost', // mysql의 hostname
+            user: process.env.DB_USER || 'root', // 사용자 이름
+            port: process.env.DB_PORT || 3306, // 포트 번호
+            database: process.env.DB_TABLE || 'restaurant_service', // 데이터베이스 이름
+            password: process.env.DB_PASSWORD || 'mypassword', // 비밀번호
+            waitForConnections: true, 
+            // Pool에 획득할 수 있는 connection이 없을 때 
+            // true면 요청을 queue에 넣고 connection을 사용할 수 있게 되면 요청을 실행한다.
+            // false면 즉시 오류를 내보내고 다시 요청한다. 
+            connectionLimit: 10, // 몇 개의 커넥션을 가지게끔 할 것인지 
+            queueLimit: 0, // getConnection에서 오류가 발생하기 전에 Pool에 대기할 요청의 개수 한도
+        });
+        
+        // 연결 사용
+        pool.query('SELECT * FROM users', (error, results) => { // sql 쿼리 실행
+          if (error) throw error;
+          console.log(results);
+        });
+        ```
+        
+- 비동기 (async, await)
+    - **동기 프로그래밍 (Synchronous Programming)**
+        - 작업들이 순서대로 실행되어 이전 작업이 끝나야만 다음 작업을 시작한다.
+        - 시간이 오래 걸리는 작업이 있으면 그동안 프로그램이 멈춘 상태로 대기한다.
+            ```javascript
+            console.log("Start");
+            const result = fetchData();  // 오래 걸리는 작업
+            console.log(result);
+            console.log("End");
+            ```
+            1. fetchData()가 완료될 때까지 기다린 후
+            2. ”End”가 출력된다. 
+            - “Start” → fetchData() → “End”
+    - **비동기 프로그래밍 (Asynchronous Programming)**
+        - 작업을 동시에 실행되도록 하여 하나의 작업이 끝날 때까지 기다리지 않고 다음 작업을 수행하는 방식
+        - 오래 걸리는 작업을 처리하는 동안 애플리케이션이 다른 작업을 계속 수행할 수 있도록 도와준다. (각 작업이 병렬적으로 진행된다)
+        - 완료된 작업은 나중에 콜백, Promise 또는 async/await을 통해 처리된다. 
+            ```javascript
+            console.log("Start");
+            setTimeout(() => {
+            	console.log("Fetching data... (completed)");
+            }, 2000); // 2초 후 실행
+            console.log("End");	
+            ```
+            - setTimeout 함수에서 2초 기다리는 동안 다음 코드(”End” 출력)를 먼저 실행한다.
+            - “Start” → setTimeout() 실행 → “End” → (2초 후) ”Fetching data... (completed)"
+    - **비동기 프로그래밍의 주요 패턴**
+        1. **콜백 함수 (Callback Function)**
+            - 작업이 완료된 후 특정 함수를 호출한다.
+            ```javascript
+            function fetchData(callback){
+            	setTimeout(() => {
+            		**callback("Data loaded")**;
+            	}, 1000);
+            }
+            console.log("Start");
+            fetchData(**(data) => console.log(data)**);
+            console.log("End");
+            ```
+            - “Start” → setTimeout() 실행 → “End” → (1초 후) “Data loaded”
+            - 문제점: 콜백 함수(Callback Hell)가 중첩되면 콜백 지옥이라는 복잡한 코드가 발생할 수 있다.
+        2. **Promise**
+            - 작업의 성공/실패를 표현하며 then과 catch로 결과를 처리한다.
+            ```javascript
+            const fetchData = new **Promise**((resolve, reject) => {
+            	setTimeout(() => **resolve**("Data loaded"), 1000);
+            });
+            console.log("Start");
+            fetchData.**then**((data) => console.log(data));
+            console.log("End");
+            ```
+            > resolve: 작업이 성공적으로 완료되었을 때 호출된다.
+            > reject: 작업이 실패했을 때 호출된다. 
+            - setTimeout으로 1초 후에 resolve 함수를 호출한다. 이 작업 성공 시 Promise가 해결(resolved)된다.
+            - fetchData는 Promise이므로 then 메서드를 사용해 비동기 작업이 완료되었을 때 결과(data)를 처리한다.
+                - 1초 후 resolve 함수가 호출되면 값("Data loaded")이 then에 전달되어 data가 출력된다.
+            - “Start” → setTimeout() 실행 → “End” → (1초 후) “Data loaded”
+        3. **async/await**
+            - 자바스크립트의 비동기 프로그래밍을 직관적이고 간결하게 처리할 수 있도록 도와주는 문법
+            - 비동기 작업 순서와 흐름을 동기적 코드처럼 작성할 수 있다.
+            - async 키워드를 함수 앞에 붙여 해당 함수를 비동기 함수로 만든다.
+                ```javascript
+                async function example() {
+                	return "Hello, Wenty!";
+                }
+                example().then((result) => console.log(result)); // 호출 시 Promise로 반환된다. 
+                ```
+                - 비동기 함수는 항상 Promise 객체를 반환한다.
+                - 반환 값이 일반 값이면 자동으로 Promise.resolve(…)으로 감싸서 반환된다.
+            - await는 비동기 함수 내에서만 사용할 수 있다.
+                ```javascript
+                async function fetchData() {
+                	let data = await **new Promise**((resolve) => 
+                		setTimeout(() => resolve("Data loaded"), 1000)
+                	);
+                	console.log(data); // 1초 후 출력
+                }
+                fetchData();
+                ```
+                - Promise가 해결될 때까지 기다렸다가 해당 결과를 반환 받아 다음 코드를 실행한다.
+                - await 뒤에는 Promise가 반환되는 비동기 작업이 와야 한다.
+            - ex.
+                ```javascript
+                **async** function loadData(){
+                	console.log("Start");
+                	let data = **await** new **Promise**(
+                		(resolve) => setTimeout(() => resolve("Data loaded"), 1000));
+                	);
+                	console.log(data);
+                	condole.log("End");
+                }
+                loadData();
+                ```
+                - await는 Promise가 해결될 때까지 대기하므로 이후의 코드는 실행되지 않는다.
+                - 1초 후 Promise가 해결된 후에 resolve()가 호출되면서 await가 해제되고 “Data loaded”가 data 변수에 저장된다.
+                - “Start” → (1초 후) “Data loaded” → “End”
+        4. async/await + Promise.all
+            - 여러 개의 비동기 작업을 병렬로 실행하려면 Promise.all과 함께 사용한다.
+            - async/await만 사용하면 비동기 작업들이 순차적으로 실행되어 시간이 더 오래 걸린다. 그러나 Promise.all과 async/await을 함께 사용하면 작업들을 동시에 실행할 수 있어 더 효율적이다.
+                - 이 경우 전체 실행 시간은 가장 오래 걸리는 작업의 시간만큼만 필요합니다.
+            - async/await만 사용할 경우
+                ```javascript
+                async function getStudent1() {
+                	return new Promise((resolve) => setTimeout(() => resolve("Wenty", 1000));
+                }
+                async function getStudent2() {
+                	return new Promise((resolve) => setTimeout(() => resolve("Bongoo"), 2000));
+                }
+                async function loadData() {
+                	console.log("Start"); // 1
+                	let student1 = await getStudent1();
+                	console.log(`Student 1: ${student1}`); // 2
+                	let student2 = await getStudent2();
+                	console.log(`Student 2: ${student2}`); // 3
+                	console.log("End"); // 4
+                }
+                loadData();
+                ```
+                - getStudent1()를 기다렸다가 getStudent2()를 기다린다.
+                    - 총 1 + 2 = 3초 소요된다.
+            - async/await + Promise.all을 사용할 경우
+                ```javascript
+                async function getStudent1() {
+                	return new Promise((resolve) => setTimeout(() => resolve("Wenty", 1000));
+                }
+                async function getStudent2() {
+                	return new Promise((resolve) => setTimeout(() => resolve("Bongoo"), 2000));
+                }
+                async function loadData() {
+                	console.log("Start"); // 1
+                	let [student1, student2] = await Promise.all([getStudent1(), getStuent2()]); // 병렬로 실행되며 가장 오래 걸리는 작업 시간(2초)만 기다린다. 
+                	console.log(`Student 1: ${student1}`); // 2
+                	console.log(`Student 2: ${student2}`); // 3
+                	console.log("End"); // 4
+                }
+                loadData();
+                ```
+                - Promise.all을 사용해 student1과 student2 정보를 동시에 가져온다.
+                - 두 작업이 병렬로 진행되어 가장 오래 걸리는 작업 시간만 소요된다.
+                    - getStudent1()과 getStudent2() 중 작업 시간이 더 긴 시간 즉, 2초 소요된다.
+- try/catch/finally
+    - 코드에서 발생할 수 있는 오류를 처리하고 오류가 발생했을 때 어떻게 동작할 지를 제어하는 데 사용된다.
+    - 예외 처리(Exception Handling)을 통해 코드 실행 중 오류를 탐지하고 이를 적절히 처리할 수 있도록 한다.
+    ```javascript
+    function riskyFunction() { // 오류가 날 수도 있는 코드
+      throw new Error("Error"); 
+    }
+    
+    try { // try 블록 - 실행할 코드
+      let result = riskyFunction(); // 오류 발생 시
+      console.log("Result:", result); // 이 코드는 실행되지 않는다.
+    } catch (error) { // 오류 발생 시 이 코드로 이동
+      console.error("Error:", error.message); // 오류 처리
+    } finally {
+      console.log("End"); // 항상 실행
+    }
+    ```
+    - 오류가 발생할 가능성이 있는 코드를 try에 넣어 예외 처리에 대비한다.
+    - catch의 매개변수: 일반적으로 error로 사용되며 발생한 오류에 대한 정보가 포함된다.
+    - finally: 오류 발생 여부와 상관없이 항상 실행된다. try 블록과 catch 블록이 끝난 후에 실행된다.
\ No newline at end of file
diff --git "a/keyword/chapter06/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png" "b/keyword/chapter06/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png"
new file mode 100644
index 0000000..94164f6
Binary files /dev/null and "b/keyword/chapter06/images/\354\213\244\354\212\265-1-\354\244\221\353\263\265\353\220\234_\355\232\214\354\233\220.png" differ
diff --git "a/keyword/chapter06/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220\353\223\261\353\241\235.png" "b/keyword/chapter06/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..13aedcb
Binary files /dev/null and "b/keyword/chapter06/images/\354\213\244\354\212\265-1-\355\232\214\354\233\220\353\223\261\353\241\235.png" differ
diff --git "a/keyword/chapter06/images/\354\213\244\354\212\265-2-\355\212\271\354\240\225\352\260\200\352\262\214_\353\246\254\353\267\260\353\252\251\353\241\235.png" "b/keyword/chapter06/images/\354\213\244\354\212\265-2-\355\212\271\354\240\225\352\260\200\352\262\214_\353\246\254\353\267\260\353\252\251\353\241\235.png"
new file mode 100644
index 0000000..7d70930
Binary files /dev/null and "b/keyword/chapter06/images/\354\213\244\354\212\265-2-\355\212\271\354\240\225\352\260\200\352\262\214_\353\246\254\353\267\260\353\252\251\353\241\235.png" differ
diff --git a/keyword/chapter06/keyword.md b/keyword/chapter06/keyword.md
new file mode 100644
index 0000000..a37c2ae
--- /dev/null
+++ b/keyword/chapter06/keyword.md
@@ -0,0 +1,433 @@
+### **📦 실습**
+---
+1. 회원가입 API
+    - Repository 함수
+        ```javascript
+        // 회원 데이터 삽입 (회원 등록) & 회원 ID 반환
+        export const addMember = async(data) => {
+            const member = await prisma.member.findFirst({where: {email: data.email}}); // 해당 이메일로 등록된 회원(중복 회원)이 존재하는지 확인
+            if (member){ // 해당 이메일로 등록된 회원이 있을 경우
+                return null;
+            }
+            const created = await prisma.member.create({data: data}); // 회원 생성
+            return created.id; // 생성된 회원 ID 반환
+        };
+
+        // 회원 정보 조회
+        export const getMember = async (memberId) => {
+            const member = await prisma.member.findFirstOrThrow({ where: {id: memberId}});
+            // prisma에서 member 테이블에 접근하여 해당 memberId와 일치하는, 첫 번째 레코드를 조회한다. 
+            // 해당 레코드가 없을 시 예외를 던진다(에러 발생).
+            return member;
+        };
+
+        // 음식 - 선호_음식_종류 매핑
+        export const setFavoriteFoodKind = async(memberId, favoriteFoodKindId) => {
+            await prisma.memberFavoriteFoodKind.create({
+                data:{ // 새 레코드의 필드와 값을 지정한다. 
+                    memberId: memberId,
+                    foodKindId: favoriteFoodKindId
+                },
+            });
+        };
+
+        // 회원 - 선호_음식_종류 반환
+        export const getMemberFavoriteFoodKindByMemberId = async (memberId) => {
+            const favoriteFoodKinds = await prisma.memberFavoriteFoodKind.findMany({ // 여러 레코드 조회, 조건에 맞는 모든 레코드를 배열 형태로 반환
+                select: { // 반환할 필드 명시
+                    id: true,
+                    memberId: true,
+                    foodKindId: true,
+                    foodKind: true, // 참조하는 foodKind 테이블
+                },
+                where: { memberId: memberId },
+                orderBy: {foodKindId: "asc"}, // foodKindId 기준 오름차순 정렬
+            });
+            return favoriteFoodKinds;
+        }
+        ```
+    - 테스트 결과<br/>
+        ![실습-1-회원등록](images/실습-1-회원등록.png)
+    - 동일한 이메일로 회원가입하는 경우<br/>
+        ![images/실습-1-중복된_회원](images/실습-1-중복된_회원.png)
+        - 회원 이메일로 조회했을 때 이미 데이터가 존재할 경우 에러를 발생시켰다.  
+2. 특정 가게의 리뷰 목록 조회 API
+    - Repository 함수
+        ```javascript
+        // 특정 식당의 모든 리뷰 조회
+        export const getAllRestaurantReviews = async (restaurantId, cursor) => {
+            const reviews = await prisma.review.findMany({ // Prisma ORM을 사용하여 review 테이블에서 여러 개의 레코드를 조회한다. 
+                select: {
+                    id: true,
+                    member: true,
+                    restaurant: true,
+                    rating: true,
+                    createdAt: true,
+                    content: true,
+                    status: true
+                },
+                where: { restaurantId: restaurantId, id: { gt: cursor }},
+                orderBy: { id: "asc"},
+                take: 5,
+            })
+            const formattedReviews = reviews.map(review => ({
+                ...review,
+                id: review.id.toString(),
+                member: {
+                    id: review.member.id.toString(),
+                    name: review.member.name,
+                    nickname: review.member.nickname,
+                    birth: review.member.birth,
+                    gender: review.member.gender,
+                    location: review.member.location,
+                    phoneNumber: review.member.phoneNumber
+                },
+                restaurant: {
+                    id: review.restaurant.id.toString(),
+                    name: review.restaurant.name
+                },
+            }));
+
+            return formattedReviews;
+        }
+        ```
+    - 테스트 결과<br/>
+        ![실습-2-특정가게_리뷰목록](images/실습-2-특정가게_리뷰목록.png)
+### 🎯 핵심 키워드
+---
+- ORM (Object-Relation Mapping)
+    - 객체 지향 프로그래밍 언어에서 데이터베이스를 관리하기 위한 기술로 객체와 관계형 데이터베이스 간의 변환을 자동으로 처리하는 기능을 제공한다.
+    - 개발자는 SQL을 직접 작성하지 않고(개발 속도 ↑) 데이터베이스 작업을 객체 지향 언어의 코드로 할 수 있다.
+    - 특정 데이터베이스에 종속되지 않고 다양한 DBMS를 쉽게 교체할 수 있다.
+    - ORM 도구: Prisma
+        - Node.js 및 TypeScript를 위한 최신 ORM 도구로 데이터베이스와 상호작용하는 작업을 더 간편하고 효율적으로 수행할 수 있도록 돕는다.
+        1. **Prisma Client**
+            - 데이터베이스에 쿼리를 실행하기 위한 자동 생성된 타입 안전한 코드
+            - 이를 통해 TypeScript를 사용할 때 타입 오류를 방지하고 코드 자동 완성 기능을 사용할 수 있다.
+        2. **Prisma Migrate**
+            - 데이터베이스 스키마를 관리하는 기능
+            - Migration 파일을 생성하고 버전 관리를 통해 스키마 변경을 쉽게 관리할 수 있다.
+        3. **Prisma Studio**
+            - 데이터베이스를 시각적으로 탐색하고 관리할 수 있는 웹 기반 UI
+            - 데이터를 조회, 편집, 삭제하는 작업을 직관적으로 수행할 수 있다.
+        - ex. prisma client를 사용해 리뷰 데이터를 생성(리뷰 등록)하고 조회하는 코드
+        ```javascript
+        // prisma/schema.prisma
+        
+        ...
+        
+        // 리뷰 모델
+        model Review{
+          id BigInt @id @default(autoincrement())
+          member Member @relation(fields: [memberId], references: [id])
+          memberId BigInt @map("member_id")
+          restaurant Restaurant @relation(fields: [restaurantId], references: [id])
+          restaurantId BigInt @map("restaurant_id")  
+          rating Decimal @db.Decimal(2, 1) @default(0.0)
+          content String
+          createdAt DateTime @map("created_at") @db.Timestamp(6) @default(now()) 
+          updatedAt DateTime @map("updated_at") @db.Timestamp(6) @default(now())
+          status Int @default(1)  
+        
+          replys Reply[]
+          images Image[]
+        
+          @@index([memberId], map: "member_id")
+          @@index([restaurantId], map: "restaurant_id")
+          @@map("review")
+        }
+        
+        ...
+        ```
+        ```javascript
+        // src/db.config.js
+        
+        import { PrismaClient } from '@prisma/client';
+        // 데이터베이스와 상호 작용하기 위한 기본 클라이언트(PrismaClient)를 가져온다. 
+        
+        export const prisma = new PrismaClient({ log: ["query"] });
+        // PrismaClient의 새 인스턴스 생성
+        // 실행되는 모든 쿼리를 콘솔에 로깅하도록 한다.
+        ```
+        ```javascript
+        // src/repositories/review.repository.js
+        
+        import { prisma, pool } from "../db.config.js";
+        
+        // 리뷰 등록 및 리뷰 ID 반환
+        export const addReview = async(data) => {
+        		// 리뷰를 등록하고자 하는 식당이 존재하는지 조건을 만족하는 첫 번재 데이터를 추출하여 확인
+            const restaurant = await prisma.restaurant.findFirst( {
+                where: {
+                    id: data.restaurant // 리뷰를 등록하고자 하는 식당의 ID로 확인한다. 
+                }
+            })
+            if (restaurant == null){ // 식당이 존재하지 않을 시
+                return null;
+            } 
+            const created = await prisma.review.create({ // 리뷰 생성
+                data: { // 생성할 데이터 객체
+                    ...data, // data 객체의 속성을 펼친다.
+                    member: {
+                        connect: { // member 테이블과 관계 연결
+                            id: data.member 
+                        }
+                    },
+                    restaurant:{ 
+                        connect: { // restaurant 테이블과 관계 연결
+                            id: data.restaurant
+                        }
+                    }
+                }
+            });
+            return created.id; // 생성된 리뷰의 ID 반환
+        }
+        
+        export const getReview = async(reviewId) => {
+        		// 해당 리뷰 ID에 일치하는 리뷰 조회 (데이터가 없을 시 예외 발생)
+            const review = await prisma.review.findFirstOrThrow({
+                select: { // 반환할 필드 명시
+                    id: true, 
+                    member: true, // 참조하는 member테이블
+                    restaurant: true, // 참조하는 restaurant 테이블
+                    rating: true,
+                    content: true,
+                    createdAt: true,
+                    status: true
+                },
+                where: {
+                    id: reviewId // 해당 reviewId와 일치하는 리뷰 조회
+                }
+            });
+            const formattedReview = { // 리뷰 데이터 형식화
+                ...review, // 위에서 select한 속성들을 펼친다. 
+                id: review.id.toString(), 
+                // DB의 id 필드가 BigInt 타입으로 정의되어 있는데
+                // javaScript에선 BigInt 타입은 JSON으로 변환할 수 없어
+                // BigInt 타입의 id를 문자열로 변환해주었다. 
+                member: { // 참조하는 member 테이블에서 추출할 속성
+                    id: review.member.id.toString(),
+                    name: review.member.name,
+                },
+                restaurant: {
+                    id: review.restaurant.id.toString(),
+                    name: review.restaurant.name,
+                },
+            }
+            return formattedReview;
+        }
+        ```
+        - Prisma 사용 흐름
+            1. prisma/schema.prisma 파일에서 데이터베이스 모델을 정의한다.
+            2. 스키마 변경 사항을 데이터베이스에 적용하기 위해 Prisma Migration을 실행한다.
+            3. 데이터베이스 작업을 수행하기 위해 Prisma Client를 생성한다.
+            4. Prisma Client를 사용해 쿼리를 작성하여 데이터베이스에 CRUD 작업을 수행한다.
+    - 기타 ORM 도구
+        1. Entity Framework: .NET 환경에서 사용되는 ORM
+        2. Hibernate: Java 생태계에서 가장 많이 사용하는 ORM 프레임워크
+- Prisma 문서 살펴보기
+    - ex. Prisma의 Connection Pool 관리 방법
+        - Prisma는 데이터베이스와의 효율적인 연결 관리를 위해 자체적인 Connection Pool을 사용한다. 이는 데이터베이스 연결을 재사용하여 성능을 향상시키고 특히 서버리스 환경에서의 연결 문제를 완화하는 데 도움을 준다.
+        - 동작 방식
+            - Prisma의 쿼리 엔진은 첫 번째 데이터베이스 연결 시 커넥션 풀을 생성한다.
+            - 이후 쿼리가 실행될 때마다 기존 연결을 재사용하거나 필요에 따라 새로운 연결을 추가한다.
+            - 이러한 방식으로 데이터베이스 연결의 효율성을 높이고 불필요한 연결 생성을 최소화한다.
+        - 기본적으로 Prisma는 머신의 물리적 CPU 수를 기반으로 커넥션 풀의 크기를 결정한다.
+            - 커넥션 풀 크기를 수동으로 설정하려면 데이터베이스 연결 URL에 connection_limit 파라미터를 추가한다.
+                ```javascript
+                datasource db {
+                  provider = "mysql"
+                  url      = "mysql://root:mypassword@localhost:3306/restaurant_service?connection_limit=5"
+                }
+                ```
+                - 이 경우 커넥션 풀의 크기가 5로 제한된다.
+    - ex. Prisma의 Migration 관리 방법
+        - Prisma의 Migration 관리: 데이터베이스 스키마와 애플리케이션의 데이터 모델을 일관되게 유지하고 스키마 변경을 효율적으로 관리하기 위한 도구
+        - Prisma 스키마 파일(schema.prisma)에서 데이터 모델을 정의하고 이를 기반으로 데이터베이스 스키마를 생성하거나 업데이트한다.
+        - 스키마 변경 시, 해당 변경 사항을 반영한 SQL 마이그레이션 파일을 자동으로 생성하여 버전 관리가 가능하다.
+        - 생성된 마이그레이션 파일을 개발, 테스트, 프로덕션 환경에 적용하여 스키마 변경을 일관되게 유지한다.
+        - 주요 명령어
+            - **prisma migrate dev**
+                - 개발 환경에서 스키마 변경 시 새로운 Migration 파일을 생성하고 이를 데이터베이스에 적용한다.
+                - Prisma Client를 자동으로 생성하여 코드에서 데이터베이스와 상호작용할 수 있도록 한다.
+            - **prisma migrate deploy**
+                - 프로덕션 환경에서 대기 중인 Migration을 순차적으로 적용한다.
+                - 이 명령어는 CI/CD 파이프라인에서 사용되어 스키마 변경을 자동화한다.
+            - **prisma migrate reset**
+                - 개발 환경에서 데이터베이스를 초기화하고 모든 Migration을 다시 적용한다.
+                - 테스트 데이터베이스를 재설정하거나 스키마를 초기 상태로 되돌릴 때 유용하다.
+        - Migration 워크플로우
+            1. schema.prisma 파일에서 데이터 모델을 수정한다.
+            2. prisma migrate dev 명령어를 실행하여 새로운 마이그레이션 파일을 생성하고 이를 데이터베이스에 적용한다.
+            3. 생성된 Migration 파일과 schema.prisma 파일을 버전 관리 시스템에 커밋하여 변경 이력을 추적한다.
+            4. 프로덕션 환경에서는 prisma migrate deploy 명령어를 사용하여 대기 중인 Migration을 적용한다.
+- ORM(Prisma)을 사용하여 좋은 점과 나쁜 점
+    1. 좋은 점
+        - TypeScript와 긴밀하게 통합되어 있어 모든 쿼리에 대해 자동으로 타입을 생성한다. 이를 통해 코드 작성 시 실수를 줄이고 안전하게 개발할 수 있다.
+        - Prisma의 직관적인 API 덕분에 복잡한 데이터베이스 작업도 쉽게 구현할 수 있어 개발 속도가 빨라진다.
+        - Prisma Migrate를 통해 데이터베이스 스키마를 자동으로 관리하고 버전 기록을 남길 수 있다.
+        - MySQL, PostgreSQL, SQLite, SQL Server 등 다양한 관계형 데이터베이스와 호환된다.
+    2. 나쁜 점
+        - ORM이 자동으로 생성한 쿼리는 수작업으로 최적화된 SQL보다 느릴 수 있다. 복잡한 쿼리일수록 비효율적이 될 가능성이 크다.
+        - 데이터베이스의 고유 기능을 활용하거나 세부적인 쿼리 최적화가 어려워 성능을 세밀하게 조정하기 힘들 수 있다.
+        - 데이터베이스 구조가 복잡할 경우 모든 관계를 적절히 매핑하는 데 한계가 있다.
+        - 자동 생성된 쿼리의 성능 문제나 오류를 해결하기가 어렵고 복잡할 수 있다.
+        - 특정 ORM 라이브러리에 의존하게 되면,유지보수나 변경 시 어려움을 겪을 수 있다.
+- 다양한 ORM 라이브러리 살펴보기
+    - ex. Sequelize
+        - Node.js에서 사용하는 ORM 라이브러리
+        - 자바스크립트 코드로 데이터베이스 작업을 수행할 수 있으며 복잡한 SQL 쿼리를 작성하지 않고도 데이터베이스와 상호작용할 수 있다.
+        - 데이터베이스 테이블을 모델로 정의하여 다룬다. 각 모델은 테이블의 구조를 정의하고 데이터를 쉽게 CRUD 작업할 수 있도록 지원한다.
+        - 복잡한 쿼리를 쉽게 작성할 수 있는 메서드와 기능을 제공한다. findAll, create, update 등의 메서드를 통해 SQL 쿼리를 간단히 작성할 수 있다.
+            ```javascript
+            // 회원 데이터 생성
+            async function createMember() {
+                const member = await Member.create({
+                    locationAddress: '서울시 관악구',
+            		    email: 'ahnnn000@gmail.com',
+            	      phoneNumber: '010-9836-3964',
+            	      memberName: '안성진',
+            	      nickname: '웬티',
+            	      gender: 1,
+            	      birth: 2000-04-24
+                });
+            }
+            
+            // 모든 회원 데이터 조회
+            async function getMembers() {
+                const members = await Member.findAll();
+            }
+            ```
+        - Sequelize 모델
+            - Sequelize 모델은 데이터베이스의 테이블을 코드 상에서 객체로 표현한 것이다. (데이터베이스의 테이블과 1:1로 매핑된다)
+            - 이 모델을 통해 SQL 쿼리를 직접 작성하지 않고도 데이터베이스와 상호작용할 수 있다. CRUD 작업을 JavaScript 코드로 쉽게 수행할 수 있도록 해준다.
+            - ex. Member 모델 정의
+                ```javascript
+                const { DataTypes, Model } = require('sequelize'); 
+                // DataTypes: 데이터 타입 정의 모듈(string, integer 등)
+                // Model: 모델 클래스를 확장하는 기본 클래스. 이를 상속받아 데이터베이스 테이블과 매핑되는 객체가 된다. 
+                // Sequelize 라이브러리 사용
+                const sequelize = require('../config/database'); 
+                // 데이터베이스 설정 파일(database.js)에서 설정한 Sequelize 인스턴스를 가져온다. 
+                class Member extends Model {} // Model 클래스를 상속받는다. 
+                Member.init( // 모델을 초기화하고 테이블의 컬럼을 정의한다. 
+                  {
+                    id: {
+                      **type**: DataTypes.BIGINT,
+                      **primaryKey**: true,
+                      **autoIncrement**: true,
+                    },
+                    locationAddress: {
+                      type: DataTypes.TEXT,
+                      **allowNull**: false,
+                    },
+                    email: {
+                      type: DataTypes.STRING(50),
+                      allowNull: false,
+                      unique: true,
+                    },
+                    phoneNumber: {
+                      type: DataTypes.STRING(15),
+                      allowNull: true,
+                    },
+                    memberName: {
+                      type: DataTypes.STRING(30),
+                      allowNull: false,
+                    },
+                    nickname: {
+                      type: DataTypes.STRING(30),
+                      allowNull: false,
+                    },
+                    gender: {
+                      type: DataTypes.INTEGER,
+                      allowNull: false,
+                    },
+                    birth: {
+                      type: DataTypes.STRING(10),
+                      allowNull: false,
+                    },
+                    points: {
+                      type: DataTypes.BIGINT,
+                      defaultValue: 0,
+                      allowNull: false,
+                    },
+                    createdAt: {
+                      type: DataTypes.DATE(6),
+                      allowNull: false,
+                    },
+                    updatedAt: {
+                      type: DataTypes.DATE(6),
+                      allowNull: false,
+                    },
+                    status: {
+                      type: DataTypes.INTEGER,
+                      allowNull: false,
+                    },
+                    inactiveAt: {
+                      type: DataTypes.DATE(6),
+                      allowNull: true,
+                    },
+                  },
+                  {
+                    sequelize, // Sequelize 인스턴스
+                    modelName: 'Member', // 모델 이름 설정
+                    tableName: 'member', // 매핑될 데이터베이스의 테이블 이름
+                    timestamps: true, // createdAt, updatedAt 자동 관리 활성화
+                  }
+                );
+                module.exports = Member; // Member 모델을 외부에서 사용하도록 내보낸다. 
+                ```
+    - ex. TypeORM
+        - **TypeScript**와 **JavaScript**를 위한 ORM 라이브러리
+        - 데코레이터를 사용하여 엔터티와 테이블, 컬럼 등을 정의한다. 이를 통해 객체와 데이터베이스 테이블 간의 매핑을 간단하게 설정할 수 있다.
+        - 엔터티를 기반으로 데이터베이스 테이블을 자동 생성하고 스키마를 동기화할 수 있다.
+        - 복잡한 SQL 쿼리를 TypeORM의 쿼리 빌더를 사용하여 쉽게 작성할 수 있다.
+        - 데코레이터를 사용하여 컬럼에 대한 유효성 검사를 설정할 수 있다.
+        - 관계된 엔터티를 지연 로딩(Lazy Loading)할 수 있는 기능을 제공한다.
+- 페이지네이션을 사용햐는 다른 API 찾아보기
+    - ex. https://docs.github.com/en/rest/using-the-rest-api/using-pagination-in-the-rest-api?apiVersion=2022-11-28
+        - **GitHub REST API**
+            - 페이지네이션을 사용해 대규모 데이터를 효율적으로 처리한다.
+            - 기본적으로 한 페이지에 일정 수의 항목만 반환하며 link 헤더를 통해 다음 페이지, 이전 페이지 등으로 이동할 수 있는 URL을 제공한다.
+            - per_page 매개변수를 사용해 페이지당 항목 수를 조정할 수 있다.
+            - ex. 이슈 목록을 요청할 경우 (기본적으로 한 페이지에 30개 반환)
+                ```javascript
+                GET /repos/{owner}/{repo}/issues?per_page=10&page=2
+                ```
+                - per_page=10: 페이지당 10개의 이슈를 요청한다.
+                - page=2: 두 번째 페이지를 요청한다.
+    - ex. https://developers.notion.com/reference/intro#pagination
+        - **Notion의 REST API**
+            - 대량의 데이터를 효율적으로 처리하기 위해 페이지네이션을 사용한다.
+            - 이는 한 번의 요청으로 반환되는 데이터 양을 제한하고 추가 데이터를 가져오기 위해 후속 요청을 수행하는 방식
+            - 주요 요소
+                1. **page_size**
+                    - 한 번의 API 요청으로 반환되는 항목의 최대 수를 지정한다.
+                    - 기본값은 100이며 최대 100까지 설정할 수 있습니다.
+                    - ex. page_size=50 → 한 번의 요청으로 최대 50개의 항목 반환
+                2. **start_cursor**
+                    - 데이터의 특정 지점부터 반환을 시작하기 위해 사용되는 커서
+                    - 이전 응답의 next_cursor 필드에서 가져온다. 이를 통해 다음 페이지의 데이터를 요청할 수 있다.
+            - 데이터베이스의 항목을 조회할 경우의 페이지네이션 구현
+                1. **첫 번째 요청**
+                    ```javascript
+                    POST https://api.notion.com/v1/databases/{database_id}/query
+                    Content-Type: application/json
+                    Notion-Version: 2022-06-28
+                    {
+                      "page_size": 100
+                    }
+                    ```
+                    - 최대 100개의 항목을 반환하며 응답에는 next_cursor와 has_more 필드가 포함된다.
+                2. **후속 요청**
+                    ```javascript
+                    POST https://api.notion.com/v1/databases/{database_id}/query
+                    Content-Type: application/json
+                    Notion-Version: 2022-06-28
+                    {
+                      "page_size": 100,
+                      "start_cursor": "{next_cursor}"
+                    }
+                    ```
+                    - 첫 번째 응답에서 has_more가 true이고 next_cursor가 존재하면 다음과 같이 후속 요청을 보낸다.
+                    - 여기서 {next_cursor}는 이전 응답의 next_cursor 값을 사용한다. 이러한 방식으로 모든 데이터를 순차적으로 가져올 수 있다.
\ No newline at end of file
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png" "b/mission/chapter05/images/\353\257\270\354\205\230-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..5b2a71f
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png" "b/mission/chapter05/images/\353\257\270\354\205\230-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..8ba6107
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png" "b/mission/chapter05/images/\353\257\270\354\205\230-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..fa3485a
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" "b/mission/chapter05/images/\353\257\270\354\205\230-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..3c0897f
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png" "b/mission/chapter05/images/\353\257\270\354\205\230-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..d3293bf
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" "b/mission/chapter05/images/\353\257\270\354\205\230-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..8988db0
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png" "b/mission/chapter05/images/\353\257\270\354\205\230-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..3d9e30a
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter05/images/\353\257\270\354\205\230-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..dbd6bae
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter05/images/\353\257\270\354\205\230-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..6fd7460
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter05/images/\353\257\270\354\205\230-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png" "b/mission/chapter05/images/\353\257\270\354\205\230-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png"
new file mode 100644
index 0000000..70e6b46
Binary files /dev/null and "b/mission/chapter05/images/\353\257\270\354\205\230-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png" differ
diff --git a/mission/chapter05/mission.md b/mission/chapter05/mission.md
new file mode 100644
index 0000000..21d6a8b
--- /dev/null
+++ b/mission/chapter05/mission.md
@@ -0,0 +1,364 @@
+### 🔥 미션
+---
+> GitHub 저장소 주소<br/>
+> [https://github.com/asjasj3964/UMC-7th-Node.js-Workbook](https://github.com/asjasj3964/UMC-7th-Node.js-Workbook)
+
+<br/>모든 코드에 대해 설명을 하면 너무 길어질 것 같아 데이터 삽입 및 조회 과정이 있는 Repository 함수만 가져왔습니다.<br/>
+
+1. 특정 지역에 식당 추가하기 API
+    - Repository 함수
+        ```javascript
+        // 식당 데이터 삽입 (식당 등록) & 식당 ID 반환
+        export const addRestaurant = async(data) => {
+            const conn = await pool.getConnection();
+            try{
+                // 해당 위치의 식당(중복된 식당)의 사용자가 있는지 확인
+                const [confirm] = await pool.query(
+                    `SELECT EXISTS(SELECT 1 FROM restaurant WHERE region_id = ? and restaurant_name = ?) as isExistRestaurant`, 
+                    [data.region, data.name] 
+                );
+                if (confirm[0].isExistRestaurant) { // 중복된 식당일 경우
+                    return null;
+                }
+                // 식당 생성
+                const [result] = await pool.query(
+                    `INSERT INTO restaurant (ceo_id, region_id, restaurant_name, introduction, start_time, end_time) VALUES (?, ?, ?, ?, ?, ?);`,
+                    [
+                        data.ceoId,
+                        data.region,
+                        data.name,
+                        data.introduction,
+                        data.startTime,
+                        data.endTime,
+                    ]
+                ); // 식당 데이터 삽입
+                return result.insertId;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 식당 ID로 식당 조회
+        export const getRestaurant = async(restaurantId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [restaurant] = await pool.query(
+                    `SELECT * FROM restaurant WHERE id = ?`,
+                    restaurantId
+                )
+                console.log(restaurant);
+                if (restaurant.length == 0){
+                    return null;
+                }
+                return restaurant;
+            }catch (err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 식당 - 지역 반환
+        export const getrestaurantRegionByRestaurantId = async (restaurantId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [region] = await pool.query(`
+                    SELECT rest.id, rest.region_id, re.address
+                    FROM restaurant rest JOIN region re ON rest.region_id = re.id
+                    WHERE rest.id = ?`,
+                    restaurantId
+                ); // restaurant 테이블과 region 테이블을 join해 해당 식당의 위치 정보를 조회한다. 
+                return region;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 식당 ceo 반환
+        export const getrestaurantCeoByCeoId = async (restaurantCeoId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [restaurantCeo] = await pool.query(`
+                    SELECT rest.id, rest.ceo_id, mem.member_name
+                    FROM restaurant rest JOIN member mem ON rest.ceo_id = mem.id
+                    WHERE rest.ceo_id = ?`,
+                    restaurantCeoId
+                ); // restaurant 테이블과 member 테이블을 join해 해당 식당의 CEO(회원) 정보를 조회한다.
+                return restaurantCeo;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+        ```
+    - 테스트 결과<br/>
+        ![식당 등록](images/미션-1-식당_등록.png)
+    - 이미 등록된 식당을 등록할 경우<br/>
+        ![중복된 식당](images/미션-1-중복된_식당.png
+        )
+        - 같은 위치와 이름의 식당을 중복 등록할 수 없게 하였다.
+
+2. 식당에 리뷰 추가하기 API
+    - Repository 함수 
+        ```javascript
+        // 리뷰 데이터 삽입 (리뷰 등록) & 리뷰 ID 반환
+        export const addReview = async(data) => {
+            const conn = await pool.getConnection();
+            try{
+                // 리뷰를 추가하려는 가게가 존재하는지 검증
+                const [confirm] = await pool.query(
+                    `SELECT EXISTS(SELECT 1 FROM restaurant WHERE id = ?)as isExistRestaurant;`,
+                    data.restaurant
+                );
+                if (!confirm[0].isExistRestaurant){ // 등록하려는 식당이 존재하지 않을 경우
+                    return null;
+                }
+                // 리뷰 생성
+                const [result] = await pool.query(
+                    `INSERT INTO review (member_id, restaurant_id, rating, content) VALUES (?, ?, ?, ?);`,
+                    [
+                        data.member,
+                        data.restaurant, 
+                        data.rating,
+                        data.content
+                    ]
+                ); // 리뷰 데이터 삽입
+                return result.insertId;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 리뷰 ID로 리뷰 조회
+        export const getReview = async(reviewId) => {
+            const conn = await pool.getConnection();
+            try{
+                const[review] = await pool.query(
+                    `SELECT * FROM review WHERE id = ?`,
+                    reviewId
+                )
+                console.log(review);
+                if (review.length == 0){
+                    return null;
+                }
+                return review;
+            }catch (err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 리뷰 ID로 리뷰 등록한 식당의 이름 알아내기
+        export const getReviewRestaurantByReviewId = async(reviewId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [review] = await pool.query(`
+                    SELECT re.id, re.restaurant_id, rest.restaurant_name
+                    FROM review as re JOIN restaurant rest ON re.restaurant_id = rest.id
+                    WHERE re.id = ?`,
+                    reviewId
+                ); // review 테이블과 restaurant 테이블을 join해 해당 리뷰의 식당 정보를 조회한다.
+                return review;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 리뷰 작성자 ID로 작성자의 이름 알아내기
+        export const getReviewWriterByWriterId = async(reviewWriterId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [reviewWriter] = await pool.query(`
+                    SELECT re.id, re.member_id, mem.member_name
+                    FROM review as re JOIN member mem ON re.member_id = mem.id
+                    WHERE re.member_id = ?`,
+                    reviewWriterId
+                ); // review 테이블과 member 테이블을 join해 해당 리뷰의 작성자(회원) 정보를 조회한다.
+                return reviewWriter;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+        ```
+    - 테스트 결과<br/>
+        ![리뷰 등록](images/미션-2-리뷰_등록.png)
+    - 존재하지 않는 식당에 등록할 경우<br/>
+        ![존재하지 않는 식당](images/미션-2-존재하지않는_식당.png)
+        - 존재하지 않는 ID(150)의 식당에 리뷰를 등록할 경우 에러를 발생시켰다. 
+3. 식당에 미션 추가하기 API
+    - Repository 함수 
+        ```javascript
+        // 미션 데이터 삽입 (미션 등록) & 미션 ID 반환 
+        export const addMission = async(data) => {
+            const conn = await pool.getConnection();
+            try{
+                // 등록하려는 식당 ID, 미션 이름, 미션 내용과 모두 일치하는 중복 미션이 존재하는지 확인
+                const [confirm1] = await pool.query(
+                    `SELECT EXISTS(SELECT 1 FROM mission WHERE restaurant_id = ? and mission_name = ? and introduction = ?) as isExistMission;`,
+                    [data.restaurant, data.name, data.introduction]
+                );
+                // 등록하려는 식당이 존재하는지 확인
+                const [confirm2] = await pool.query(
+                    `SELECT EXISTS(SELECT 1 FROM restaurant WHERE id = ?) as isExistRestaurant;`,
+                    data.restaurant
+                );
+                // 중복 미션이 있거나 식당이 존재하지 않을 시
+                if (confirm1[0].isExistMission || (!confirm2[0].isExistRestaurant)){
+                    return null;
+                }
+                // 미션 생성
+                const [result] = await pool.query( 
+                    `INSERT INTO mission (restaurant_id, mission_name, introduction, deadline, points) VALUES (?, ?, ?, ?, ?);`,
+                    [data.restaurant, data.name, data.introduction, data.deadline, data.points]
+                ); // 미션 데이터 삽입
+                return result.insertId;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 미션 ID로 미션 조회
+        export const getMission = async(missionId) => {
+            const conn = await pool.getConnection();
+            try{
+                const[mission] = await pool.query(
+                    `SELECT * FROM mission WHERE id = ?`,
+                    missionId
+                );
+                console.log(mission);
+                if (mission.length == 0){
+                    return null;
+                }
+                return mission;
+            }catch (err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+
+        // 미션 ID로 식당 조회
+        export const getRestaurantByMissionId = async(missionId) => {
+            const conn = await pool.getConnection();
+            try{
+                const [restaurant] = await pool.query(`
+                    SELECT mi.id, mi.restaurant_id, rest.restaurant_name
+                    FROM mission mi JOIN restaurant rest ON mi.restaurant_id = rest.id
+                    WHERE mi.id = ?`,
+                    missionId
+                ); // mission 테이블과 restaurant 테이블을 join해 해당 회원의 식당 정보를 조회한다. 
+                return restaurant;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+        ```
+    - 테스트 결과<br/>
+        ![미션 등록](images/미션-3-미션_등록.png)
+    - 존재하지 않는 식당에 미션을 등록할 경우<br/>
+        ![존재하지 않는 식당](images/미션-3-존재하지않는_식당.png)
+        - 존재하지 않는 ID(140)의 식당에 미션을 등록할 경우 에러를 발생시켰다.
+    - 이미 등록된 미션을 등록할 경우<br/>
+        ![중복된 미션](images/미션-3-중복된_미션.png)
+        - 같은 식당, 미션명, 미션 설명의 미션을 중복 등록할 수 없게 하였다.
+4. 가게의 미션을 도전 중인 미션에 추가하기 API
+    - Repository 함수 
+        ```javascript
+        // 특정 미션 상태 업데이트(진행 X -> 진행 중)
+        export const updateMissionStatus = async(missionId) => {
+            const conn = await pool.getConnection();
+            try{
+                // 업데이트할 미션이 존재하는지 미션 ID로 조회하여 확인
+                const [confirm1] = await pool.query(
+                    `SELECT EXISTS(SELECT 1 FROM mission WHERE id = ?) as isExistMission;`,
+                    missionId
+                );
+                // 해당 미션의 상태를 확인하기 위해 status 선택
+                const [confirm2] = await pool.query(
+                    `SELECT status FROM mission WHERE id = ?`,
+                    missionId
+                );
+                // 해당 미션이 존재하지 않거나 상태가 진행 X가 아닐 경우
+                if((!confirm1[0].isExistMission) || (confirm2[0].status != 0)){
+                    return null;
+                }
+                // 해당 미션의 status 값을 1(진행 중)로 변경
+                await pool.query(`
+                    UPDATE mission SET status = 1 WHERE id = ?;`,
+                    missionId
+                );
+                // 미션 ID로 조회해서 해당 미션 정보를 모두 조회한다.
+                const [mission] = await pool.query(`
+                    SELECT * FROM mission WHERE id = ?;`,
+                    missionId
+                )
+                return mission;
+            }catch(err){
+                throw new Error(`
+                    🚫 오류 발생 🚫 
+                    요청 파라미터 확인 바람 (${err})
+                `);
+            }finally{
+                conn.release();
+            }
+        }
+        ```
+    - 테스트 결과 <br/>
+        ![미션 진행 중으로 업데이트](images/미션-4-진행중_업데이트.png)
+        - 미션 3에서 등록한 미션(도전하기 전의 상태(0))을 진행 중으로 업데이트 하였다. 
+    - 도전할 수 없는 미션(이미 진행 중이거나 완료한 미션)의 경우
+        ![도전할 수 없는 미션](images/미션-4-도전할수없는_미션.png)
+        - 방금 전에 업데이트 시킨 미션(이미 진행 중인 상태)을 또 테스트 해보았다.
+        - 미션의 상태(status)가 0(진행하기 전)이 아닐 경우엔 에러를 발생시켰다. 
+    - 존재하지 않는 미션을 업데이트할 경우
+        ![존재하지 않는 미션](images/미션-4-존재하지않는_미션.png)
+        - 업데이트 하려는 미션의 ID로 조회했을 때 존재하지 않을 경우엔 에러를 발생시켰다. 
\ No newline at end of file
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..70d6e7a
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\213\235\353\213\271_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..40eb013
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-1-\354\244\221\353\263\265\353\220\234_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..207bc23
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-2-\353\246\254\353\267\260_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..382bb74
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-2-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png"
new file mode 100644
index 0000000..463f33d
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\353\257\270\354\205\230_\353\223\261\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png"
new file mode 100644
index 0000000..5e53076
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\354\213\235\353\213\271.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..75700a7
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-3-\354\244\221\353\263\265\353\220\234_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..bce3a0c
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\217\204\354\240\204\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\257\270\354\205\230_\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\257\270\354\205\230_\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png"
new file mode 100644
index 0000000..0f3671e
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\353\257\270\354\205\230_\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..632c6c8
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..3cdad9f
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-1-4-\354\247\204\355\226\211\354\244\221_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-2-\355\212\271\354\240\225\355\232\214\354\233\220-\353\246\254\353\267\260\353\252\251\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-2-\355\212\271\354\240\225\355\232\214\354\233\220-\353\246\254\353\267\260\353\252\251\353\241\235.png"
new file mode 100644
index 0000000..30d789f
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-2-\355\212\271\354\240\225\355\232\214\354\233\220-\353\246\254\353\267\260\353\252\251\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-3-\355\212\271\354\240\225\352\260\200\352\262\214_\353\257\270\354\205\230\353\252\251\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-3-\355\212\271\354\240\225\352\260\200\352\262\214_\353\257\270\354\205\230\353\252\251\353\241\235.png"
new file mode 100644
index 0000000..fce1ce0
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-3-\355\212\271\354\240\225\352\260\200\352\262\214_\353\257\270\354\205\230\353\252\251\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-4-\355\212\271\354\240\225\355\232\214\354\233\220_\354\247\204\355\226\211\354\244\221\354\235\270_\353\257\270\354\205\230\353\252\251\353\241\235.png" "b/mission/chapter06/images/\353\257\270\354\205\230-4-\355\212\271\354\240\225\355\232\214\354\233\220_\354\247\204\355\226\211\354\244\221\354\235\270_\353\257\270\354\205\230\353\252\251\353\241\235.png"
new file mode 100644
index 0000000..8ef5fa3
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-4-\355\212\271\354\240\225\355\232\214\354\233\220_\354\247\204\355\226\211\354\244\221\354\235\270_\353\257\270\354\205\230\353\252\251\353\241\235.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-5-\353\257\270\354\205\230_\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270.png" "b/mission/chapter06/images/\353\257\270\354\205\230-5-\353\257\270\354\205\230_\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270.png"
new file mode 100644
index 0000000..b411f4c
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-5-\353\257\270\354\205\230_\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-5-\354\231\204\353\243\214\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\231\204\353\243\214\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..7b8e17a
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\231\204\353\243\214\355\225\240\354\210\230\354\227\206\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-5-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..fb4713e
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\241\264\354\236\254\355\225\230\354\247\200\354\225\212\353\212\224_\353\257\270\354\205\230.png" differ
diff --git "a/mission/chapter06/images/\353\257\270\354\205\230-5-\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png" "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png"
new file mode 100644
index 0000000..9a33115
Binary files /dev/null and "b/mission/chapter06/images/\353\257\270\354\205\230-5-\354\247\204\355\226\211\354\231\204\353\243\214_\354\227\205\353\215\260\354\235\264\355\212\270\354\240\204\354\235\230_\353\257\270\354\205\230.png" differ
diff --git a/mission/chapter06/mission.md b/mission/chapter06/mission.md
new file mode 100644
index 0000000..9cc93e6
--- /dev/null
+++ b/mission/chapter06/mission.md
@@ -0,0 +1,483 @@
+### 🔥 미션
+---
+> GitHub 저장소 주소<br/>
+> [https://github.com/asjasj3964/UMC-7th-Node.js-Workbook](https://github.com/asjasj3964/UMC-7th-Node.js-Workbook)
+
+1. 5주차 때 작성했던 API를 Prisma ORM을 사용하여 구현하기
+    1. 특정 지역에 식당 추가하기 API
+        - Repository 함수 수정
+            ```javascript
+            // 식당 데이터 삽입 (식당 등록) & 식당 ID 반환 
+            export const addRestaurant = async(data) => {
+                // 등록하고자 하는 식당의 이름과 위치가 같은 중복 식당이 존재하는지 확인
+                const restaurant = await prisma.restaurant.findFirst({
+                    where: {
+                        name: data.name, 
+                        regionId: data.region
+                    }
+                });
+                if (restaurant){ // 중복 식당일 경우
+                    return null;
+                }
+                const created = await prisma.restaurant.create({
+                    data: {
+                        ...data,
+                        region: {
+                            connect: { id: data.region } // region 테이블 관계 연결
+                        },
+                        ceo: {
+                            connect: { id: data.ceo }  // ceo(member) 테이블 관계 연결
+                        }, 
+                    }
+                });
+                return created.id;
+            }
+
+            // 식당 ID로 식당 조회
+            export const getRestaurant = async(restaurantId) => {
+                const restaurant = await prisma.restaurant.findFirstOrThrow({ 
+                    select: {
+                        id: true,
+                        ceo: true,
+                        region: true,
+                        name: true,
+                        introduction: true, 
+                        startTime: true,
+                        endTime: true,
+                        totalRating: true,
+                    },
+                    where: { id: restaurantId }
+                });
+                    const formattedRestaurant = {
+                        ...restaurant,
+                        id: restaurant.id.toString(),
+                        region: {
+                            id: restaurant.region.id.toString(),
+                            address: restaurant.region.address,
+                        },
+                        ceo: {
+                            id: restaurant.ceo.id.toString(),
+                            name: restaurant.ceo.name.toString()
+                        }
+                    };
+                return formattedRestaurant;
+            }
+            ```
+        - 테스트 결과<br/>
+            ![식당 등록](images/미션-1-1-식당_등록.png)
+        - 이미 등록된 식당을 등록할 경우<br/>
+            ![중복된 식당](images/미션-1-1-중복된_식당.png
+            )
+            - 같은 위치와 이름의 식당을 중복 등록할 수 없게 하였다.
+
+    2. 식당에 리뷰 추가하기 API
+        - Repository 함수 수정
+            ```javascript
+            // 리뷰 데이터 삽입 (리뷰 등록) & 리뷰 ID 반환
+            export const addReview = async(data) => {
+                // 리뷰를 추가하려는 식당이 존재하는지 검증
+                const restaurant = await prisma.restaurant.findFirst( {
+                    where: {
+                        id: data.restaurant // 등록할 식당의 ID를 가진 가게가 있는지 확인
+                    }
+                })
+                if (restaurant == null){ // 해당 식당이 존재하지 않다면
+                    return null;
+                } 
+                const created = await prisma.review.create({
+                    data: {
+                        ...data,
+                        member: {
+                            connect: { // member 테이블과 관계 연결
+                                id: data.member
+                            }
+                        },
+                        restaurant:{
+                            connect: { // restaurant 테이블과 관계 연결
+                                id: data.restaurant
+                            }
+                        }
+                    }
+                });
+                return created.id;
+            }
+
+            // 리뷰 ID로 리뷰 조회
+            export const getReview = async(reviewId) => {
+                const review = await prisma.review.findFirstOrThrow({
+                    select: {
+                        id: true,
+                        member: true,
+                        restaurant: true,
+                        rating: true,
+                        content: true,
+                        createdAt: true,
+                        status: true
+                    },
+                    where: {
+                        id: reviewId
+                    }
+                });
+                const formattedReview = {
+                    ...review,
+                    id: review.id.toString(),
+                    member: {
+                        id: review.member.id.toString(),
+                        name: review.member.name,
+                    },
+                    restaurant: {
+                        id: review.restaurant.id.toString(),
+                        name: review.restaurant.name,
+                    },
+                }
+                return formattedReview;
+            }
+            ```
+        - 테스트 결과<br/>
+            ![리뷰 등록](images/미션-1-2-리뷰_등록.png)
+        - 존재하지 않는 식당에 등록할 경우<br/>
+            ![존재하지 않는 식당](images/미션-1-2-존재하지않는_식당.png)
+            - 존재하지 않는 ID(100)의 식당에 리뷰를 등록할 경우 에러를 발생시켰다. 
+    3. 식당에 미션 추가하기 API
+        - Repository 함수 수정
+            ```javascript
+            // 미션 데이터 삽입 (미션 등록) & 미션 ID 반환 
+            export const addMission = async(data) => {
+                // 등록하려는 식당 ID, 미션 이름, 미션 내용과 모두 일치하는 중복 미션이 존재하는지 확인
+                const mission = await prisma.mission.findFirst({
+                    where: {
+                        restaurantId: data.restaurant, 
+                        name: data.name, 
+                        introduction: data.introduction
+                    }
+                });
+                // 등록하려는 식당이 존재하는지 확인
+                const restaurant = await prisma.restaurant.findFirst({
+                    where: {
+                        id: data.restaurant
+                    }
+                });
+                if (mission != null || restaurant == null){ // 중복 미션이 있거나 식당이 존재하지 않을 시 
+                    return null;
+                }
+                const created = await prisma.mission.create({ // 미션 생성
+                    data: { // 생성할 데이터 객체
+                        ...data, // 매개변수로 전달 받은 data 객체의 모든 속성을 복사한다.
+                        restaurant: {
+                            connect: { id: data.restaurant } // restaurant 테이블과 관계 연결
+                        }
+                    }
+                });
+                return created.id; // 생성된 미션 ID 반환
+            }
+
+            // 미션 ID로 미션 조회
+            export const getMission = async(missionId) => {
+                const mission = await prisma.mission.findFirstOrThrow({ 
+                    select: {
+                        id: true,
+                        restaurant: true,
+                        name: true,
+                        introduction: true,
+                        deadline: true,
+                        points: true,
+                        status: true
+                    },
+                    where: { id: missionId }});
+
+                const formattedMission = {
+                    ...mission,
+                    id: mission.id.toString(),
+                    points: mission.points.toString(),
+                    restaurant: {
+                        id: mission.restaurant.id.toString(),
+                        name: mission.restaurant.name,
+                    },
+                };
+                console.log(formattedMission);
+                return formattedMission;
+            }
+            ```
+        - 테스트 결과<br/>
+            ![미션 등록](images/미션-1-3-미션_등록.png)
+        - 존재하지 않는 식당에 미션을 등록할 경우<br/>
+            ![존재하지 않는 식당](images/미션-1-3-존재하지않는_식당.png)
+            - 존재하지 않는 ID(100)의 식당에 미션을 등록할 경우 에러를 발생시켰다.
+        - 이미 등록된 미션을 등록할 경우<br/>
+            ![중복된 미션](images/미션-1-3-중복된_미션.png)
+            - 같은 식당, 미션명, 미션 설명의 미션을 중복 등록할 수 없게 하였다.
+    4. 가게의 미션을 도전 중인 미션에 추가하기 API
+        - Repository 함수 수정
+            ```javascript
+            // 특정 미션 상태 업데이트(진행 X -> 진행 중)
+            export const updateMissionStatus = async(missionId) => {
+                // 업데이트할 미션이 존재하는지 확인
+                const mission = await prisma.mission.findFirst({
+                    where: {
+                        id: missionId
+                    }
+                });
+                // 해당 미션의 상태를 확인하기 위해 status 선택
+                const missionStatus = await prisma.mission.findFirst({
+                    select: {
+                        status: true
+                    },
+                    where: {
+                        id: missionId
+                    }
+                });
+                // 해당 미션이 존재하지 않거나 상태가 진행 X가 아닐 경우
+                if (mission == null || missionStatus.status != 0){
+                    return null;
+                }
+                const missionUpdated = await prisma.mission.update({
+                    where: {
+                        id: missionId
+                    },
+                    data: {
+                        status: 1 // status 값을 1(진행 중)로 변경
+                    },
+                    select: {
+                        id: true, 
+                        restaurant: true,
+                        name: true,  
+                        introduction: true, 
+                        deadline: true, 
+                        points: true,
+                        status: true,
+                    }
+                });
+                const formattedMission = {
+                    ...missionUpdated,
+                    id: missionUpdated.id.toString(),
+                    points: missionUpdated.points.toString(),
+                    restaurant: {
+                        id: missionUpdated.restaurant.id.toString(),
+                        name: missionUpdated.restaurant.name
+                    },
+                };
+
+                return formattedMission;
+            }
+            ```
+        - 업데이트하기 전(진행 X)의 데이터<br/> 
+            ![진행 X인 미션](images/미션-1-4-진행중_업데이트전의_미션.png)
+        - 테스트 결과 <br/>
+            ![미션 진행 중으로 업데이트](images/미션-1-4-미션_진행중_업데이트.png)
+        - 도전할 수 없는 미션(이미 진행 중이거나 완료한 미션)의 경우
+            ![도전할 수 없는 미션](images/미션-1-4-도전할수없는_미션.png)
+            - 방금 전에 업데이트 시킨 미션(이미 진행 중인 상태)을 또 테스트 해보았다.
+            - 미션의 상태(status)가 0(진행하기 전)이 아닐 경우엔 에러를 발생시켰다. 
+        - 존재하지 않는 미션을 업데이트할 경우
+            ![존재하지 않는 미션](images/미션-1-4-존재하지않는_미션.png)
+            - 업데이트 하려는 미션의 ID로 조회했을 때 존재하지 않을 경우엔 에러를 발생시켰다. 
+2. 특정 회원이 작성한 리뷰 목록 조회 API
+    - Repository 함수
+        ```javascript
+        // 특정 회원의 모든 리뷰 조회
+        export const getAllMemberReviews = async(memberId, cursor) => {
+            const reviews = await prisma.review.findMany({
+                select: {
+                    id: true,
+                    member: true, // 참조하는 member 테이블
+                    restaurant: true, // 참조하는 restaurantn 테이블
+                    rating: true,
+                    content: true,
+                    status: true
+                },
+                where: { memberId: memberId, id: { gt: cursor }},
+                // 리뷰의 ID가 cursor보다 큰 레코드만 가져온다. 
+                // gt: "greater than", 값이 cursor보다 큰 데이터를 필터링한다. (페이징 구현)
+                orderBy: { id: "asc"}, // ID 기준 오름차순 정렬
+                take: 5, // 5개의 레코드만 조회
+            })
+
+            // review 객체의 형변환 (BigInt 처리를 위함)
+            const formattedReviews = reviews.map(review => ({ // reviews(DB에서 추출한 리뷰 데이터) 배열을 map() 메서드로 각 review 객체 변환
+                ...review, // review 객체의 모든 속성 복사
+                id: review.id.toString(),
+                // DB의 id 필드가 BigInt 타입으로 정의되어 있는데
+                // javaScript에선 BigInt 타입은 JSON으로 변환할 수 없어
+                // BigInt 타입의 id를 문자열로 변환해주었다. 
+                member: { // 참조하는 member 테이블에서 추출할 속성
+                    id: review.member.id.toString(),
+                    name: review.member.name,
+                    nickname: review.member.nickname,
+                    birth: review.member.birth,
+                    gender: review.member.gender,
+                    location: review.member.location,
+                    phoneNumber: review.member.phoneNumber
+                },
+                restaurant: { // 참조하는 restaurant 테이블에서 추출할 속성
+                    id: review.restaurant.id.toString(),
+                    name: review.restaurant.name
+                },
+            }));
+            
+            return formattedReviews;
+        }
+        ```
+    - 테스트 결과<br/>
+        ![특정 회원의 리뷰 목록](images/미션-2-특정회원-리뷰목록.png)
+3. 특정 식당의 미션 목록 조회 API
+    - Repository 함수
+        ```javascript
+        // 특정 식당의 모든 미션 조회
+        export const getAllRestaurantMissions = async(restaurantId, cursor) => {
+            const missions = await prisma.mission.findMany({
+                select: {
+                    id: true,
+                    restaurant: true,
+                    points: true,
+                    name: true,
+                    introduction: true,
+                    status: true
+                },
+                where: { restaurantId: restaurantId, id: { gt: cursor }},
+                orderBy: { id: "asc" },
+                take: 5
+            })
+            const formattedMissions = missions.map(mission => ({
+                ...mission,
+                id: mission.id.toString(),
+                points: mission.points.toString(),
+                restaurant: {
+                    id: mission.restaurant.id.toString(),
+                    name: mission.restaurant.name
+                },
+            }));
+
+            return formattedMissions;
+        }
+        ```
+    - 테스트 결과<br/>
+        ![특정 식당의 미션 목록](images/미션-3-특정가게_미션목록.png)
+4. 특정 회원의 진행 중인 미션 목록 조회 API
+    - Repository 함수
+        ```javascript
+        // 특정 회원의 모든 진행 중인 미션 조회
+        export const getAllMemberMissions = async(memberId, cursor) => {
+            const memberMissions = await prisma.memberMission.findMany({
+                select: {
+                    id: true,
+                    member: true,
+                    mission: true,
+                },
+                where: { 
+                    memberId: memberId, 
+                    mission: {
+                        status: 1 // mission 객체의 status가 1(진행 중)인 미션들만 조회온다.
+                    },
+                    id: {gt: cursor}
+                },
+                orderBy: {id: "asc"},
+                take: 5
+            })
+
+            const formattedMemberMissions = memberMissions.map(memberMission => ({
+                ...memberMission,
+                id: memberMission.id.toString(),
+                member: {
+                    id: memberMission.member.id.toString(),
+                    nickname: memberMission.member.nickname,
+                },
+                mission: {
+                    id: memberMission.mission.id.toString(),
+                    restaurantId: memberMission.mission.restaurantId.toString(),
+                    name: memberMission.mission.name,
+                    introduction: memberMission.mission.introduction,
+                    points: memberMission.mission.points.toString(),
+                    deadline: memberMission.mission.deadline,
+                    status: memberMission.mission.status,
+                    
+                },
+            }));
+            
+            return formattedMemberMissions;
+        }
+        ```
+    - 테스트 결과<br/>
+        ![특정 회원의 진행 중인 미션 목록](images/미션-4-특정회원_진행중인_미션목록.png)
+5. 특정 회원의 진행 중인 미션을 진행 완료로 바꾸기 API
+    - Repository 함수
+        ```javascript
+        // 특정 회원의 특정 미션의 상태 업데이트(진행 중 -> 진행 완료)
+        export const updateMissionCompleted = async(memberId, missionId) => {
+            // 특정 회원에 주어진 특정 미션이 존재하는지 확인
+            const confirmMemberMission = await prisma.memberMission.findFirst({
+                where: {
+                    missionId: missionId,
+                    memberId: memberId
+                }
+            })
+
+            // 해당 미션의 상태를 확인하기 위해 status 선택
+            const missionStatus = await prisma.mission.findFirst({
+                select: {
+                    status: true
+                },
+                where: {
+                    id: missionId
+                }
+            })
+
+            // 해당 미션이 존재하지 않거나 미션의 상태가 1(진행 중)이 아닐 경우 에러 처리
+            if (confirmMemberMission == null || missionStatus.status != 1){
+                return null;
+            }
+            
+            const memberMission = await prisma.memberMission.update({
+                where: {
+                    // update 메서드는 지정한 Unique key를 사용하여 레코드를 찾기 때문에 
+                    // memberId, missionId로 이루어진 복합 고유 키인 memberId_missionId_unique을 만들어주었다. 
+                    memberId_missionId_unique: {
+                        memberId: memberId,
+                        missionId: missionId
+                    } 
+                },
+                data: { // 수정할 내용 정의
+                    mission:{
+                        update:{ // mission의 특정 속성 업데이트
+                            status: 2 // 진행 완료로 업데이트
+                        }
+                }},
+                select: { // 반환할 특정 속성 지정
+                    id: true,
+                    member: true,
+                    mission: true,
+                }
+            })
+
+            const formattedMemberMissions = {
+                ...memberMission,
+                id: memberMission.id.toString(),
+                member: {
+                    id: memberMission.member.id.toString(),
+                    nickname: memberMission.member.nickname,
+                },
+                mission: {
+                    id: memberMission.mission.id.toString(),
+                    restaurantId: memberMission.mission.restaurantId.toString(),
+                    name: memberMission.mission.name,
+                    introduction: memberMission.mission.introduction,
+                    points: memberMission.mission.points.toString(),
+                    deadline: memberMission.mission.deadline,
+                    status: memberMission.mission.status,
+                },
+            };
+
+            return formattedMemberMissions;
+        }
+        ```
+    - 업데이트하기 전(진행 중)의 데이터<br/> 
+        ![진행 중인 미션](images/미션-5-진행완료_업데이트전의_미션.png)
+        - 미션 1-4에서 진행 중으로 바꾼 미션을 진행 완료로 업데이트 해보겠다. 
+    - 테스트 결과 <br/>
+        ![미션 완료로 업데이트](images/미션-5-미션_진행완료_업데이트.png)
+    - 완료할 수 없는 미션(진행하지도 않았거나 이미 완료한 미션)의 경우
+        ![완료할 수 없는 미션](images/미션-5-완료할수없는_미션.png)
+        - 방금 전에 업데이트 시킨 미션(이미 진행완료인 상태)을 또 테스트 해보았다. 
+        - 미션의 상태(status)가 1(진행 중)이 아닐 경우엔 에러를 발생시켰다. 
+    - 특정 회원에게 할당되지 않은 미션을 업데이트할 경우
+        ![존재하지 않는 미션](images/미션-5-존재하지않는_미션.png)
+        - 회원의 ID 및 미션의 ID로 조회했을 때 존재하지 않을 경우엔 에러를 발생시켰다.
\ No newline at end of file