Backend

// Node.js Express 백엔드 예제
const express = require('express');
const bcrypt = require('bcrypt');
const jwt = require('jsonwebtoken');

const app = express();
app.use(express.json());

// 사용자 데이터 (실제로는 DB 사용)
const users = [];

// 회원가입 API
app.post('/api/auth/register', async (req, res) => {
    try {
        const { email, password, name } = req.body;

        // 이메일 중복 체크
        if (users.find(u => u.email === email)) {
            return res.status(400).json({ error: '이미 등록된 이메일입니다' });
        }

        // 비밀번호 해싱
        const hashedPassword = await bcrypt.hash(password, 10);
        const user = { id: users.length + 1, email, password: hashedPassword, name };
        users.push(user);

        res.status(201).json({ message: '회원가입 성공', userId: user.id });
    } catch (error) {
        res.status(500).json({ error: '서버 오류' });
    }
});

// 로그인 API
app.post('/api/auth/login', async (req, res) => {
    const { email, password } = req.body;
    const user = users.find(u => u.email === email);

    if (!user || !(await bcrypt.compare(password, user.password))) {
        return res.status(401).json({ error: '인증 실패' });
    }

    const token = jwt.sign({ userId: user.id }, process.env.JWT_SECRET, { expiresIn: '24h' });
    res.json({ token, user: { id: user.id, email: user.email, name: user.name } });
});

// 인증 미들웨어
const authMiddleware = (req, res, next) => {
    const token = req.headers.authorization?.split(' ')[1];
    if (!token) return res.status(401).json({ error: '토큰 필요' });

    try {
        req.user = jwt.verify(token, process.env.JWT_SECRET);
        next();
    } catch {
        res.status(401).json({ error: '유효하지 않은 토큰' });
    }
};

// 보호된 리소스
app.get('/api/profile', authMiddleware, (req, res) => {
    const user = users.find(u => u.id === req.user.userId);
    res.json({ profile: { id: user.id, email: user.email, name: user.name } });
});

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

# Python FastAPI 백엔드 예제
from fastapi import FastAPI, HTTPException, Depends, status
from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
from pydantic import BaseModel, EmailStr
from passlib.context import CryptContext
import jwt
from datetime import datetime, timedelta

app = FastAPI(title="Backend API", version="1.0.0")
security = HTTPBearer()
pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

# 설정
SECRET_KEY = "your-secret-key"
ALGORITHM = "HS256"

# 모델 정의
class UserCreate(BaseModel):
    email: EmailStr
    password: str
    name: str

class UserLogin(BaseModel):
    email: EmailStr
    password: str

# 임시 데이터 저장소 (실제로는 DB 사용)
users_db: dict = {}

def create_token(user_id: int) -> str:
    """JWT 토큰 생성"""
    expire = datetime.utcnow() + timedelta(hours=24)
    payload = {"user_id": user_id, "exp": expire}
    return jwt.encode(payload, SECRET_KEY, algorithm=ALGORITHM)

def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security)):
    """토큰 검증 의존성"""
    try:
        payload = jwt.decode(credentials.credentials, SECRET_KEY, algorithms=[ALGORITHM])
        return payload["user_id"]
    except jwt.ExpiredSignatureError:
        raise HTTPException(status_code=401, detail="토큰 만료")
    except jwt.InvalidTokenError:
        raise HTTPException(status_code=401, detail="유효하지 않은 토큰")

@app.post("/api/auth/register", status_code=status.HTTP_201_CREATED)
async def register(user: UserCreate):
    """회원가입 API"""
    if user.email in users_db:
        raise HTTPException(status_code=400, detail="이미 등록된 이메일입니다")

    user_id = len(users_db) + 1
    hashed_password = pwd_context.hash(user.password)
    users_db[user.email] = {
        "id": user_id, "email": user.email,
        "password": hashed_password, "name": user.name
    }
    return {"message": "회원가입 성공", "user_id": user_id}

@app.post("/api/auth/login")
async def login(credentials: UserLogin):
    """로그인 API"""
    user = users_db.get(credentials.email)
    if not user or not pwd_context.verify(credentials.password, user["password"]):
        raise HTTPException(status_code=401, detail="인증 실패")

    token = create_token(user["id"])
    return {"token": token, "user": {"id": user["id"], "email": user["email"], "name": user["name"]}}

@app.get("/api/profile")
async def get_profile(user_id: int = Depends(verify_token)):
    """보호된 프로필 조회 API"""
    user = next((u for u in users_db.values() if u["id"] == user_id), None)
    if not user:
        raise HTTPException(status_code=404, detail="사용자를 찾을 수 없습니다")
    return {"profile": {"id": user["id"], "email": user["email"], "name": user["name"]}}

# 실행: uvicorn main:app --reload