const fs = require('fs');

console.log("1. 파일 읽기 요청 시작");

// 비동기 파일 읽기 (백그라운드로 위임 = 논블로킹)
fs.readFile('large-file.txt', 'utf8', (err, data) => {
    // 백그라운드 작업이 모두 끝난 후, 이벤트 루프에 의해 나중에 실행되는 콜백(Callback) 함수
    console.log("3. 이벤트 루프: 백그라운드 파일 읽기 완료, 콜백 실행!");
});

// 파일 읽기(I/O)를 기다리지 않고 곧바로 이어서 실행됨
console.log("2. 다른 비즈니스 로직 즉시 실행 중...");

console.log('--- [시뮬레이션 시작] ---');

// 1. 매크로태스크 (Task Queue) 등록
setTimeout(() => {
  console.log('⏱️ [매크로태스크] setTimeout 콜백 실행!');
}, 0);

// 2. 마이크로태스크 (Microtask Queue) 등록
Promise.resolve().then(() => {
  console.log('💎 [마이크로태스크] Promise.then 1 실행!');
}).then(() => {
  console.log('💎 [마이크로태스크] Promise.then 2 실행!');
});

// 3. 동기 코드 (Call Stack) 실행
console.log('🏁 [동기] 동기식 작업 1');
console.log('🏁 [동기] 동기식 작업 2 - (호출 스택이 비워지기 대기)');

console.log('앱 실행 시작');

// 이 시점에 동기적으로 math.js 파일을 읽고 실행합니다.
const math = require('./math.js');

console.log('모듈 로드 완료:', math);

// 최상단에 import 선언 (실행 전 엔진이 미리 분석함)
import { add } from './math.js';

console.log('실제 코드 실행 구간 (평가 단계)');
console.log('가져온 함수 실행:', add(1, 2));

{
  "name": "my-project",
  "version": "1.0.0",
  "description": "",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [],
  "author": "",
  "license": "ISC",
  "dependencies": {
    "express": "^4.18.2"
  }
}

console.log("1. process.cwd():", process.cwd());
console.log("2. __dirname:", __dirname);
console.log("3. __filename:", __filename);
console.log("4. process.platform:", process.platform);

const fs = require('fs');

console.log('1. 파일 읽기 시작 (OS 백그라운드로 작업 위임)');

// 비동기 방식이므로 파일을 다 읽을 때까지 기다리지 않음
fs.readFile('big-data.txt', 'utf8', (err, data) => {
  // OS가 파일을 다 읽고 나면 이벤트 루프가 이 콜백 함수를 실행해 줌
  console.log('3. 파일 읽기 완료 (콜백 실행됨, 데이터 처리 시작)');
});

// 메인 스레드는 파일이 읽히는 동안 블로킹되지 않고 즉시 다음 작업을 수행함
console.log('2. 다음 로직 수행 (서버는 멈추지 않고 다른 접속 처리 가능!)');

const path = require('path');
const os = require('os');

// 1. path.join() 테스트
console.log('--- path.join() ---');
console.log(path.join('/users', 'minstudio', '../temp'));
// 결과: /users/temp
// 설명: minstudio로 들어갔다가 ../ 로 다시 나와서 temp로 진입함

// 2. path.resolve() 테스트
console.log('\n--- path.resolve() ---');
console.log(path.resolve('users', 'minstudio', '/temp'));
// 결과: /temp
// 설명: 맨 오른쪽 '/temp'가 절대경로이므로 그 앞의 폴더들은 모두 무시됨!

// 3. os 모듈 정보 조회
console.log('\n--- OS 시스템 정보 ---');
console.log(`OS 플랫폼: ${os.platform()}`);
console.log(`CPU 코어 수: ${os.cpus().length}개`);

const EventEmitter = require('events');

// 1. 커스텀 이벤트 방출기 생성
const myEmitter = new EventEmitter();

// 2. 이벤트 리스너(Listener) 등록 (수신 대기)
myEmitter.on('userLogin', (username) => {
  console.log(`[이벤트 수신!] 환영합니다, ${username}님! DB 로그인을 기록합니다.`);
});

myEmitter.on('error', (err) => {
  console.error(`[에러 이벤트 수신!] 시스템 경고: ${err.message}`);
});

// 3. 이벤트 방출(Emit) - 특정 상황 발생 시 호출
console.log('--- 1. userLogin 이벤트 발생 ---');
myEmitter.emit('userLogin', '홍길동');

console.log('\n--- 2. error 이벤트 발생 ---');
myEmitter.emit('error', new Error('알 수 없는 DB 연결 오류!'));

const fs = require('fs');

// 메모리가 1GB밖에 없는 서버라도 스트림을 사용하면 대용량 파일도 거뜬합니다!
console.log('--- Stream 파이프라인 전송 시작 ---');

// 1. 읽기 스트림(수도꼭지) 생성 (기본 단위: 64KB)
const readStream = fs.createReadStream('big-video.mp4'); 
// 2. 쓰기 스트림(하수구) 생성
const writeStream = fs.createWriteStream('big-video-copy.mp4');

let chunkCount = 0;

// 데이터가 단위 크기(Chunk)만큼 쪼개져서 들어올 때마다 발생하는 이벤트
readStream.on('data', (chunk) => {
    chunkCount++;
    console.log(`> 데이터 청크(Chunk) 수신 완료! (진행: ${chunkCount}번째, 크기: ${chunk.length} bytes)`);
    console.log(`> 파일에 쓰는 중... (메모리 점유율 최소 유지)`);
});

// 모든 데이터를 다 읽었을 때 발생하는 이벤트
readStream.on('end', () => {
    console.log('\n✅ 전송 완료! (이벤트: readStream.on("end"))');
    console.log('(설명: 파일 전체를 메모리에 올리지 않아 서버가 안전합니다)');
});

// 스트림을 잇는 가장 완벽한 방법 (파이프 연결)
// 위 동작을 내부적으로 자동 처리하며 읽고 쓰는 속도(Backpressure)를 알아서 조절합니다.
readStream.pipe(writeStream);

const http = require('http');

// 1. 웹 서버 객체 생성
const server = http.createServer((req, res) => {
  // 브라우저에서 요청(Request)이 들어올 때마다 이 콜백 함수가 실행됩니다.
  
  // 클라이언트가 요청한 URL(주소)에 따라 분기 처리 (라우팅)
  if (req.url === '/') {
    // 2. 응답(Response) 헤더 작성 (상태코드 200 정상, HTML 문서임을 알림)
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    
    // 3. 실제 데이터 전송 및 응답 종료
    res.end('<h1>Welcome to Home</h1><p>메인 페이지입니다.</p>');
    console.log('[서버 로그] GET / 요청 처리 완료');
    
  } else if (req.url === '/about') {
    res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
    res.end('<h1>About Us Page</h1><p>Node.js로 만든 서버입니다.</p>');
    console.log('[서버 로그] GET /about 요청 처리 완료');
    
  } else {
    // 404 Not Found 에러 처리
    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
    res.end('404 Not Found - 페이지를 찾을 수 없습니다.');
    console.log(`[서버 로그] 잘못된 접근: ${req.url}`);
  }
});

// 2. 서버 실행 및 포트(Port) 할당
server.listen(3000, () => {
  console.log('서버가 3000번 포트에서 대기(Listen) 중입니다...');
  console.log('브라우저를 열고 http://localhost:3000 으로 접속해 보세요.');
});

const express = require('express');
const app = express();

// 1. 첫 번째 미들웨어: Logger (모든 요청에 대해 무조건 실행됨)
app.use((req, res, next) => {
  console.log(`[미들웨어 1: Logger] 접속 시간 기록 완료. -> next() 호출`);
  next(); // 다음 미들웨어로 바통 터치!
});

// 2. 두 번째 미들웨어: Auth (권한 검증)
app.use((req, res, next) => {
  console.log(`[미들웨어 2: Auth] 사용자 권한 검증 성공! -> next() 호출`);
  next();
});

// 3. 최종 라우터 (클라이언트에게 응답을 반환하고 체인 종료)
app.get('/', (req, res) => {
  console.log(`[최종 라우터: app.get("/")] 환영 페이지 응답(res.send) 전송 완료! ✅`);
  res.send('<h1>Welcome to Express</h1><p>미들웨어를 무사히 통과했습니다.</p>');
});

app.listen(3000, () => {
  console.log('Express 서버가 3000번 포트에서 대기 중입니다...');
});

const express = require('express');
const app = express();

// 1. URL 파라미터 (req.params)
// 콜론(:)으로 시작하는 경로는 변수처럼 취급됩니다.
app.get('/users/:id', (req, res) => {
  const userId = req.params.id; // '999' 추출
  
  console.log(`[Route 매칭] app.get("/users/:id")`);
  console.log(`> req.params 객체 추출 결과:`, req.params);
  
  res.send(`<h1>유저 상세 정보</h1><p>조회된 유저 ID: ${userId}</p>`);
});

// 2. 쿼리 스트링 (req.query)
// URL 뒤에 ?keyword=apple&sort=desc 형태로 붙어오는 검색/필터 조건
app.get('/search', (req, res) => {
  const keyword = req.query.keyword; // 'apple'
  const sort = req.query.sort;       // 'desc'
  
  console.log(`\n[Route 매칭] app.get("/search")`);
  console.log(`> req.query 객체 추출 결과:`, req.query);
  
  res.send(`<h1>검색 결과</h1><p>검색어: ${keyword}, 정렬: ${sort}</p>`);
});

app.listen(3000, () => {
  console.log('서버가 3000번 포트에서 대기 중입니다...');
});

const express = require('express');
const app = express();

// 1. 일반 미들웨어 (데이터 주입)
app.use((req, res, next) => {
  req.user = 'Minstudio Admin'; // req 객체에 새로운 데이터 주입
  console.log(`[미들웨어 A: Data Injector] req.user 주입 완료 -> next()`);
  next(); // 다음 미들웨어나 라우터로 정상 진행
});

// 2. 유효성 검사 라우터 (에러 발생 시나리오)
app.get('/error', (req, res, next) => {
  console.log(`[미들웨어 B: Validator] 필수 파라미터 누락 확인! -> next(err) 호출`);
  
  // next() 안에 값이 들어가면 정상 라우터를 모두 건너뛰고 에러 핸들러로 직행합니다!
  next(new Error('Missing Param')); 
});

// 3. 정상 동작하는 최종 라우터
app.get('/normal', (req, res) => {
  console.log(`[최종 라우터: app.get("/normal")] 미들웨어가 넘긴 값: ${req.user}`);
  res.send(`정상 응답 완료! (유저: ${req.user})`);
});

// 4. 에러 전용 핸들링 미들웨어 (반드시 매개변수가 4개여야 함)
// 위치: 보통 모든 라우터 선언이 끝난 app.js 맨 마지막에 위치합니다.
app.use((err, req, res, next) => {
  console.error(`\n[에러 전용 미들웨어: (err, req, res, next)]`);
  console.error(`> 잡힌 에러: ${err.message}`);
  console.error(`🚨 클라이언트로 500 오류 반환. 서버 다운 방지 성공!`);
  res.status(500).send('서버 내부 오류가 발생했습니다.');
});

app.listen(3000, () => console.log('서버가 3000번 포트에서 대기 중입니다...'));

const express = require('express');
const path = require('path');
const app = express();

// 1. 모든 요청에 대해 로그를 남기는 커스텀 미들웨어
app.use((req, res, next) => {
  console.log(`[서버 로그] 클라이언트가 ${req.url} 을(를) 요청했습니다.`);
  next();
});

// 2. 정적 파일 폴더 개방 (Static File Serving)
// 클라이언트가 서버의 'public' 폴더 안에 있는 파일들에 자유롭게 접근할 수 있게 됩니다.
// 핵심: URL에 '/public'을 적지 않아도, Node.js가 자동으로 public 폴더 내부를 뒤져서 파일을 찾아줍니다!
app.use(express.static(path.join(__dirname, 'public')));

// 3. 만약 public 폴더에도 파일이 없고, 라우터에도 매칭되지 않는다면?
app.use((req, res) => {
  res.status(404).send('404 Not Found: 파일을 찾을 수 없습니다.');
});

app.listen(3000, () => {
  console.log('서버가 3000번 포트에서 대기 중입니다...');
});

const express = require('express');
const app = express();

// 💡 중요: 클라이언트가 POST 방식 등으로 보내는 JSON 형태의 본문(req.body)을 
// 자동으로 파싱(해석)해주기 위해 반드시 필요한 설정입니다.
app.use(express.json());

// 1. URL Params 추출 (경로의 일부를 변수로 사용)
// 클라이언트 요청: GET /users/999
app.get('/users/:id', (req, res) => {
  console.log(`\n[URL Params] 매칭 라우터: /users/:id`);
  console.log(`> 추출된 req.params:`, req.params); // { id: '999' }
  res.send(`유저 ID ${req.params.id} 조회 성공`);
});

// 2. Query String 추출 (주소창 물음표 뒤의 옵션들)
// 클라이언트 요청: GET /products?search=macbook&sort=price
app.get('/products', (req, res) => {
  console.log(`\n[Query String] 매칭 라우터: /products`);
  console.log(`> 추출된 req.query:`, req.query); // { search: 'macbook', sort: 'price' }
  res.send(`검색어: ${req.query.search}, 정렬: ${req.query.sort}`);
});

// 3. HTTP Body 추출 (POST 요청 시 내부에 숨겨진 방대한 데이터)
// 클라이언트 요청: POST /login (Body: {"email":"a@b.com", "pw":"1234"})
app.post('/login', (req, res) => {
  console.log(`\n[HTTP Body] 매칭 라우터: POST /login`);
  console.log(`> 추출된 req.body:`, req.body); // { email: 'a@b.com', pw: '1234' }
  res.send(`${req.body.email} 님 환영합니다.`);
});

app.listen(3000, () => {
  console.log('서버가 3000번 포트에서 대기 중입니다...');
});

const express = require('express');
const app = express();

// ❌ 나쁜 설계 1: 명사 대신 동사(get)를 남용한 방식
app.get('/getUsers', (req, res) => {
  console.log(`\n[나쁜 설계] GET /getUsers 요청 수신`);
  console.log(`> 🚨 피드백: URL에 "get"이라는 동사가 들어갔습니다!`);
  console.log(`> HTTP 메서드(GET) 자체가 이미 행동을 의미하므로 주소에는 명사만 써야 합니다.`);
  res.send('나쁜 설계 예시 1');
});

// ❌ 나쁜 설계 2: 목적에 맞지 않는 HTTP 메서드(POST)와 동사(delete) 사용
app.post('/deleteUser/:id', (req, res) => {
  console.log(`\n[나쁜 설계] POST /deleteUser/${req.params.id} 요청 수신`);
  console.log(`> 🚨 피드백: "삭제"를 하는데 왜 POST 메서드를 썼나요?`);
  console.log(`> 주소에 "deleteUser"처럼 동작을 명시하면 REST 원칙에 어긋납니다.`);
  res.send('나쁜 설계 예시 2');
});

// ✅ 좋은 설계 1 (RESTful): 복수형 명사 + 올바른 HTTP 메서드(GET)
app.get('/users', (req, res) => {
  console.log(`\n[좋은 설계] GET /users 요청 수신`);
  console.log(`> ✅ 완벽합니다! (자원: 복수형 명사 / 행동: GET 메서드)`);
  console.log(`> 의도: "전체 유저(Users) 목록을 조회해줘."`);
  res.send('좋은 설계 예시 1');
});

// ✅ 좋은 설계 2 (RESTful): 계층 관계 + 올바른 HTTP 메서드(DELETE)
app.delete('/users/:id', (req, res) => {
  console.log(`\n[좋은 설계] DELETE /users/${req.params.id} 요청 수신`);
  console.log(`> ✅ 완벽합니다! (자원: 특정 유저 / 행동: DELETE 메서드)`);
  console.log(`> 의도: "유저(Users) 중 ID가 ${req.params.id}번인 자원을 삭제해줘."`);
  res.send('좋은 설계 예시 2');
});

app.listen(3000, () => console.log('서버가 3000번 포트에서 시작되었습니다.'));

/* === 1. app.js (서버 코드) === */
const express = require('express');
const app = express();

// 1. EJS를 템플릿 엔진으로 사용하겠다고 설정합니다.
app.set('view engine', 'ejs');

app.get('/', (req, res) => {
  // DB에서 가져온 데이터라고 가정해봅시다.
  const data = { 
    title: 'Minstudio', 
    isLogged: true 
  };
  
  console.log('[서버] views/index.ejs 파일을 읽어서 데이터를 주입(Render)합니다.');
  
  // 2. index.ejs 템플릿에 data 객체를 주입하여 렌더링 후 클라이언트에 전송합니다.
  res.render('index', data); 
});

app.listen(3000, () => console.log('서버 실행 중...'));


/* === 2. views/index.ejs (템플릿 코드) === */
<h1><%= title %></h1>

<% if (isLogged) { %>
  <button>로그아웃</button>
<% } else { %>
  <button>로그인</button>
<% } %>

const mysql = require('mysql2/promise');

async function testSingleConnection() {
  console.log('\n[일반 연결 모드] 100건의 쿼리를 매번 연결/해제하며 실행합니다...');
  const start = Date.now();
  
  for (let i = 0; i < 100; i++) {
    // ⚠️ 매번 악수(Handshake) 비용 발생: 엄청난 병목 현상
    const conn = await mysql.createConnection({ host: 'localhost', user: 'root', database: 'test' });
    await conn.query('SELECT 1');
    await conn.end(); 
  }
  
  const end = Date.now();
  console.log(`> 🐢 처리 완료: 총 ${end - start}ms 소요 (매우 느림)`);
}

async function testConnectionPool() {
  console.log('\n[커넥션 풀 모드] 10개의 커넥션을 풀(Pool)에 미리 만들어두고 재사용합니다...');
  
  // ⚡ 서버 시작 시 한 번만 풀(Pool)을 생성합니다.
  const pool = mysql.createPool({ host: 'localhost', user: 'root', database: 'test', connectionLimit: 10 });
  const start = Date.now();
  
  // 100건의 쿼리가 풀에서 빈 커넥션을 빌려 쓰고 즉시 반납합니다.
  const promises = [];
  for (let i = 0; i < 100; i++) {
    promises.push(pool.query('SELECT 1'));
  }
  await Promise.all(promises); // 비동기 병렬 처리
  
  const end = Date.now();
  console.log(`> ⚡ 처리 완료: 총 ${end - start}ms 소요 (약 8배 빠름!)`);
  
  await pool.end();
}

async function main() {
  await testSingleConnection();
  await testConnectionPool();
}
main();

const mongoose = require('mongoose');

// 1. 유저 스키마(규칙) 정의
const userSchema = new mongoose.Schema({
  name: { type: String, required: true }, // 필수 문자열
  age: { type: Number, min: 0 }           // 0 이상의 숫자
});

// 2. 모델 생성
const User = mongoose.model('User', userSchema);

async function testValidation() {
  console.log('[테스트 1] 정상 데이터 저장 시도: { name: "Minstudio", age: 30 }');
  try {
    const user1 = new User({ name: 'Minstudio', age: 30 });
    await user1.validate(); // DB 저장 전 Mongoose 검증만 수행
    console.log('> ✅ 검증 통과! DB에 정상 저장됩니다.\n');
  } catch (err) { console.log(err.message); }

  console.log('[테스트 2] 타입 오류 시도: { name: "User", age: "서른살" }');
  try {
    const user2 = new User({ name: 'User', age: '서른살' });
    await user2.validate();
  } catch (err) {
    console.log('> 🚨 검증 실패 (ValidationError): "age" 필드에는 Number(숫자)만 가능합니다!\n');
  }

  console.log('[테스트 3] 필수값 누락 시도: { age: 25 }');
  try {
    const user3 = new User({ age: 25 });
    await user3.validate();
  } catch (err) {
    console.log('> 🚨 검증 실패 (ValidationError): "name" 필드는 required: true 이므로 생략 불가!\n');
  }
}

testValidation();

/* === 1. app.js (GitHub에 공개될 소스 코드) === */
// 💡 dotenv 모듈을 불러와서 로컬 PC의 .env 파일(금고)을 엽니다.
require('dotenv').config();

// Github에 올라가는 소스코드에는 진짜 비밀번호가 전혀 보이지 않습니다!
// 오직 process.env.변수명 이라는 '열쇠 이름'만 적어둡니다.
const password = process.env.DB_PASSWORD;

console.log('[보안 점검] 소스코드 안전 상태: 양호 (하드코딩 없음)');
console.log(`[서버 내부 로직] DB 연결 시도 (패스워드: ${password})`);


/* === 2. .env (로컬 PC 금고 파일, GitHub 업로드 제외) === */
DB_PASSWORD=super_secret_1234

/* === app.js (Express 서버 코드) === */
const express = require('express');
const app = express();

// 1. 비동기 라우터 로직
app.get('/api/data', async (req, res, next) => {
  try {
    const type = req.query.type;
    console.log(`\n[Server] GET /api/data?type=${type} 요청 수신`);
    
    if (type === 'success') {
      return res.status(200).json({ message: "정상 처리되었습니다." });
    } else if (type === 'clientError') {
      // 💡 개발자가 의도적으로 발생시킨 에러
      const error = new Error("잘못된 파라미터가 전달되었습니다.");
      error.statusCode = 400; // 커스텀 속성 부여
      throw error;
    } else {
      // 💣 예기치 못한 치명적 에러 발생 (DB 다운 등)
      throw new Error("데이터베이스 연결 시간 초과!");
    }
  } catch (err) {
    // 에러가 발생하면 catch에서 잡아서 전역 에러 미들웨어로 넘깁니다!
    next(err); 
  }
});

// 2. 🛡️ 전역 에러 처리 미들웨어 (반드시 인자가 4개여야 합니다)
app.use((err, req, res, next) => {
  console.log("🚨 [Global Error Middleware] 에러 포착됨!");
  
  // 에러 객체에 상태 코드가 있으면 쓰고, 없으면 500 (서버 에러)
  const status = err.statusCode || 500;
  
  // 보안을 위해 500 에러는 클라이언트에게 구체적인 원인을 숨깁니다.
  const responseMessage = status === 500 
    ? "서버 내부 오류가 발생했습니다." 
    : err.message;
    
  console.error(`[Server Log] 상세 에러 원인: ${err.message} (상태코드: ${status})`);
  
  // 클라이언트에게 에러 응답 전송
  res.status(status).json({ error: responseMessage });
});

app.listen(3000, () => console.log('서버 실행 중...'));

const express = require('express');
const app = express();

// 가상의 서버 메모리 세션 저장소 (보통 DB나 Redis 사용)
const sessionDB = {};

app.post('/login', (req, res) => {
  const { id, pw } = req.body;
  if (id === 'admin' && pw === '1234') {
    // 1. 유니크한 세션 ID(입장권 번호) 생성
    const sessionId = 'xyz_' + Math.random().toString(36).substr(2, 9);
    
    // 2. 서버의 장부(Session)에 유저 정보 기록
    sessionDB[sessionId] = { userId: id, role: 'admin' };
    
    // 3. 브라우저에게 쿠키(Cookie) 발급 및 응답
    res.cookie('session_id', sessionId, { httpOnly: true });
    return res.json({ success: true, message: '로그인 성공' });
  }
  res.status(401).json({ success: false, message: '인증 실패' });
});

app.get('/profile', (req, res) => {
  // 클라이언트가 보낸 쿠키에서 세션 ID 확인
  const sessionId = req.cookies.session_id;
  const user = sessionDB[sessionId];
  
  if (user) {
    res.json({ authorized: true, user });
  } else {
    res.status(401).json({ authorized: false, message: '세션 만료됨' });
  }
});

const express = require('express');
const jwt = require('jsonwebtoken'); // JWT 라이브러리 사용
const app = express();

const SECRET_KEY = "my_super_secret_key"; // 서버만 알고 있는 절대 비밀키

app.post('/login', (req, res) => {
  const { id, pw } = req.body;
  if (id === 'admin' && pw === '1234') {
    // 💥 [핵심] 서버 메모리나 DB에 아무것도 저장하지 않습니다!
    // 오직 비밀키로 서명(Signature)을 하여 JWT 홀로그램 신분증을 만들어줍니다.
    const token = jwt.sign(
      { userId: id, role: "admin" }, // Payload (유저 정보)
      SECRET_KEY,                    // Signature 생성을 위한 비밀키
      { expiresIn: '1h' }            // 토큰 유효기간
    );
    
    // 브라우저에게 토큰(문자열)을 그냥 전달합니다.
    return res.json({ success: true, token });
  }
  res.status(401).json({ success: false, message: '인증 실패' });
});

app.get('/profile', (req, res) => {
  // 클라이언트가 헤더에 담아 보낸 토큰 추출: "Bearer eyJhbG..."
  const authHeader = req.headers.authorization;
  if (!authHeader) return res.status(401).json({ message: '토큰 없음' });
  
  const token = authHeader.split(' ')[1];
  
  try {
    // 💥 [핵심] DB 조회 없이 토큰 자체의 서명만 검사합니다!
    const decoded = jwt.verify(token, SECRET_KEY);
    
    // 서명이 일치하면 위조되지 않은 진짜 신분증입니다.
    res.json({ authorized: true, user: decoded });
  } catch(e) {
    res.status(401).json({ authorized: false, message: '위조되거나 만료된 토큰' });
  }
});

const express = require('express');
const cors = require('cors');
const bcrypt = require('bcrypt'); // 비밀번호 해싱 라이브러리
const app = express();

// 1. 🧱 CORS 설정: 공식 프론트엔드 도메인만 접근을 허용합니다!
const corsOptions = {
  origin: ['http://my-frontend.com'], // 화이트리스트
  optionsSuccessStatus: 200
};
app.use(cors(corsOptions));
app.use(express.json());

// 2. 회원가입 API (비밀번호 암호화)
app.post('/register', async (req, res) => {
  try {
    const { password } = req.body;
    
    // 💥 [핵심] 사용자의 비밀번호 원본을 절대 그대로 저장하지 않습니다!
    // 10번(saltRounds) 반복해서 해싱(갈아버림)을 수행합니다.
    const saltRounds = 10;
    const hashedPassword = await bcrypt.hash(password, saltRounds);
    
    // DB에 암호화된 비밀번호(hashedPassword)를 저장하는 로직
    // db.users.insert({ password: hashedPassword });
    
    res.json({ success: true, hash: hashedPassword });
  } catch(e) {
    res.status(500).json({ success: false, message: '서버 오류' });
  }
});

const express = require('express');
const multer = require('multer');
const app = express();

// 1. 하드디스크(Disk) 저장소 엔진 설정
const storage = multer.diskStorage({
  destination: function (req, file, cb) {
    cb(null, 'uploads/'); // 저장될 폴더 경로
  },
  filename: function (req, file, cb) {
    // 파일명이 겹치지 않도록 현재 시간 추가
    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
    cb(null, file.fieldname + '-' + uniqueSuffix + '-' + file.originalname);
  }
});

// 미들웨어 생성
const upload = multer({ storage: storage });

// 2. 단일 파일 업로드 라우터 ('avatar'라는 이름의 폼 필드 대기)
app.post('/profile', upload.single('avatar'), (req, res) => {
  // 💥 Multer가 파일 수신을 완료하면 req.file 객체를 만들어 줍니다!
  if (!req.file) return res.status(400).send('업로드 실패');
  
  res.json({
    message: '업로드 성공!',
    fileInfo: {
      original: req.file.originalname,
      savedPath: req.file.path,
      size: req.file.size
    }
  });
});

const express = require('express');
const Joi = require('joi'); // Joi 라이브러리 임포트
const app = express();
app.use(express.json());

// 1. 체크리스트 (Schema) 정의
const signupSchema = Joi.object({
  // username: 3~15자 영문/숫자 조합, 필수
  username: Joi.string().alphanum().min(3).max(15).required(),
  
  // age: 숫자만 허용, 필수 아님
  age: Joi.number(),
  
  // email: 이메일 형식, 필수
  email: Joi.string().email().required()
});

app.post('/signup', (req, res) => {
  // 2. req.body를 미리 정의해둔 스키마와 대조하여 검문
  const { error, value } = signupSchema.validate(req.body);
  
  // 3. 하나라도 규칙에 어긋나면? -> DB 접근 차단 및 에러 반환!
  if (error) {
    return res.status(400).json({ 
      success: false, 
      message: error.details[0].message // Joi가 알려주는 친절한 에러 이유
    });
  }
  
  // 검문 통과 시 정상 로직 수행 (DB 저장 등)
  // ...
  res.status(201).json({ success: true, message: '회원가입 완료' });
});

const express = require('express');
const { Server } = require('socket.io'); // Socket.io 모듈
const http = require('http');

const app = express();
const server = http.createServer(app); // Express로 HTTP 서버 생성

// HTTP 서버 위에 Socket.io 서버 얹기
const io = new Server(server, { cors: { origin: '*' } });

// 클라이언트가 터널을 뚫고 처음 접속할 때 발생하는 이벤트 ('connection')
io.on('connection', (socket) => {
  console.log(`🔌 새 클라이언트 접속: ${socket.id}`);

  // 클라이언트가 'chat_message' 라는 이름으로 무전기를 칠 때
  socket.on('chat_message', (data) => {
    console.log(`수신: [${data.sender}] "${data.text}"`);
    
    // 💥 [핵심] 현재 접속해 있는 모든 사람에게(나 포함) 확성기로 방송!
    io.emit('chat_message', data);
  });

  // 클라이언트가 터널을 끊고 나갈 때
  socket.on('disconnect', () => {
    console.log(`접속 종료: ${socket.id}`);
  });
});

server.listen(3000, () => {
  console.log('Socket.io 서버 실행 완료 (포트 3000)');
});

const winston = require('winston');

// 1. Winston 로거 생성 및 설정
const logger = winston.createLogger({
  level: 'info', // 'info' 레벨 이상의 로그만 기록하겠다 (info, warn, error)
  format: winston.format.json(), // 로그를 JSON 형태로 깔끔하게 저장
  transports: [
    // 에러(error) 전용 로그 파일 (블랙박스)
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    // 모든 로그(info 이상)를 기록하는 통합 파일
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

// 2. 개발 환경일 경우, 터미널(Console) 창에도 색상을 입혀서 같이 출력해 줌
if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

module.exports = logger;

// 사용 예시 (다른 라우터 파일에서)
// const logger = require('./logger');
// logger.info("회원가입 완료"); 
// logger.error("DB 접속 에러!"); 

// 테스트할 함수 (가정: 다른 파일에서 불러옴)
function calculateDiscount(price, userType) {
  if (userType === 'VIP') return price * 0.8;
  else if (userType === 'NORMAL') return price;
  
  throw new Error('Unknown User Type');
}

// 테스트 묶음 정의
describe('할인율 계산 함수 테스트', () => {
  
  // 1. 성공 케이스 테스트
  test('VIP 유저는 1만원짜리를 사면 8천원이 되어야 한다.', () => {
    // expect(실제 실행 결과).toBe(내가 예상한 정답)
    expect(calculateDiscount(10000, 'VIP')).toBe(8000);
  });
  
  // 2. 다른 성공 케이스 테스트
  test('일반 유저는 할인이 적용되지 않는다.', () => {
    expect(calculateDiscount(10000, 'NORMAL')).toBe(10000);
  });
  
  // 3. 에러 발생 테스트
  test('이상한 등급을 넣으면 반드시 에러가 터져야 한다.', () => {
    // 에러를 검사할 때는 함수를 한 번 더 감싸서 전달해야 함
    expect(() => calculateDiscount(10000, 'GHOST')).toThrow();
  });
  
});