brew install vapor

vapor new MyFirstServer
cd MyFirstServer
vapor build

import Vapor

func routes(_ app: Application) throws {
    // GET /hello 엔드포인트
    app.get("hello") { req async -> String in
        return "Hello, Vapor! 🚀"
    }
    
    // GET /hello/:name 엔드포인트 (파라미터 사용)
    app.get("hello", ":name") { req async throws -> String in
        guard let name = req.parameters.get("name") else {
            throw Abort(.badRequest)
        }
        return "Hello, \(name)! 👋"
    }
    
    // POST /user 엔드포인트 (JSON 받기)
    app.post("user") { req async throws -> User in
        let user = try req.content.decode(User.self)
        // 여기서 데이터베이스에 저장하는 로직을 추가할 수 있어
        return user
    }
}

// User 모델 정의
struct User: Content {
    var name: String
    var email: String
    var age: Int
}

vapor run

dependencies: [
    .package(url: "https://github.com/vapor/vapor.git", from: "4.0.0"),
    .package(url: "https://github.com/vapor/fluent.git", from: "4.0.0"),
    .package(url: "https://github.com/vapor/fluent-postgres-driver.git", from: "2.0.0")
]

import Fluent
import FluentPostgresDriver
import Vapor

public func configure(_ app: Application) throws {
    // 데이터베이스 설정
    app.databases.use(.postgres(
        hostname: Environment.get("DATABASE_HOST") ?? "localhost",
        port: Environment.get("DATABASE_PORT").flatMap(Int.init(_:)) ?? 5432,
        username: Environment.get("DATABASE_USERNAME") ?? "vapor",
        password: Environment.get("DATABASE_PASSWORD") ?? "password",
        database: Environment.get("DATABASE_NAME") ?? "vapor_db"
    ), as: .psql)
    
    // 마이그레이션 추가
    app.migrations.add(CreateUser())
    
    // 라우트 등록
    try routes(app)
}

import Fluent
import Vapor

final class User: Model, Content {
    static let schema = "users"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "name")
    var name: String
    
    @Field(key: "email")
    var email: String
    
    @Field(key: "age")
    var age: Int
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    @Timestamp(key: "updated_at", on: .update)
    var updatedAt: Date?
    
    init() { }
    
    init(id: UUID? = nil, name: String, email: String, age: Int) {
        self.id = id
        self.name = name
        self.email = email
        self.age = age
    }
}

import Fluent

struct CreateUser: AsyncMigration {
    func prepare(on database: Database) async throws {
        try await database.schema("users")
            .id()
            .field("name", .string, .required)
            .field("email", .string, .required)
            .field("age", .int, .required)
            .field("created_at", .datetime)
            .field("updated_at", .datetime)
            .unique(on: "email")  // 이메일 중복 방지
            .create()
    }
    
    func revert(on database: Database) async throws {
        try await database.schema("users").delete()
    }
}

vapor run migrate

import Vapor

func routes(_ app: Application) throws {
    let users = app.grouped("users")
    
    // CREATE - 새 사용자 생성
    users.post { req async throws -> User in
        let user = try req.content.decode(User.self)
        try await user.save(on: req.db)
        return user
    }
    
    // READ - 모든 사용자 조회
    users.get { req async throws -> [User] in
        try await User.query(on: req.db).all()
    }
    
    // READ - 특정 사용자 조회
    users.get(":id") { req async throws -> User in
        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        return user
    }
    
    // UPDATE - 사용자 정보 수정
    users.put(":id") { req async throws -> User in
        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        let updatedUser = try req.content.decode(User.self)
        user.name = updatedUser.name
        user.email = updatedUser.email
        user.age = updatedUser.age
        
        try await user.save(on: req.db)
        return user
    }
    
    // DELETE - 사용자 삭제
    users.delete(":id") { req async throws -> HTTPStatus in
        guard let user = try await User.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        try await user.delete(on: req.db)
        return .noContent
    }
}

dependencies: [
    .package(url: "https://github.com/vapor/jwt.git", from: "4.0.0")
]

import JWT

public func configure(_ app: Application) throws {
    // JWT 시크릿 키 설정 (환경 변수에서 가져오기)
    app.jwt.signers.use(.hs256(key: Environment.get("JWT_SECRET") ?? "secret-key"))
    
    // ... 나머지 설정
}

import Vapor
import JWT

// JWT 페이로드 정의
struct UserPayload: JWTPayload {
    var userId: UUID
    var email: String
    var exp: ExpirationClaim  // 만료 시간
    
    func verify(using signer: JWTSigner) throws {
        try exp.verifyNotExpired()
    }
}

// 로그인 요청 구조체
struct LoginRequest: Content {
    var email: String
    var password: String
}

// 로그인 응답 구조체
struct LoginResponse: Content {
    var token: String
    var user: User.Public
}

extension User {
    struct Public: Content {
        var id: UUID?
        var name: String
        var email: String
    }
    
    var publicView: Public {
        Public(id: id, name: name, email: email)
    }
}

func routes(_ app: Application) throws {
    // 회원가입
    app.post("register") { req async throws -> User.Public in
        let user = try req.content.decode(User.self)
        
        // 비밀번호 해싱 (Bcrypt 사용)
        user.passwordHash = try Bcrypt.hash(user.password)
        
        try await user.save(on: req.db)
        return user.publicView
    }
    
    // 로그인
    app.post("login") { req async throws -> LoginResponse in
        let loginRequest = try req.content.decode(LoginRequest.self)
        
        // 이메일로 사용자 찾기
        guard let user = try await User.query(on: req.db)
            .filter(\.$email == loginRequest.email)
            .first() else {
            throw Abort(.unauthorized, reason: "Invalid email or password")
        }
        
        // 비밀번호 검증
        guard try Bcrypt.verify(loginRequest.password, created: user.passwordHash) else {
            throw Abort(.unauthorized, reason: "Invalid email or password")
        }
        
        // JWT 토큰 생성
        let payload = UserPayload(
            userId: try user.requireID(),
            email: user.email,
            exp: .init(value: Date().addingTimeInterval(86400))  // 24시간 후 만료
        )
        
        let token = try req.jwt.sign(payload)
        
        return LoginResponse(token: token, user: user.publicView)
    }
}

import Vapor
import JWT

struct JWTAuthenticator: AsyncRequestAuthenticator {
    func authenticate(request: Request) async throws {
        // Authorization 헤더에서 토큰 추출
        guard let token = request.headers.bearerAuthorization?.token else {
            return
        }
        
        // 토큰 검증 및 페이로드 추출
        let payload = try request.jwt.verify(token, as: UserPayload.self)
        
        // 사용자 정보 조회
        guard let user = try await User.find(payload.userId, on: request.db) else {
            return
        }
        
        // 인증된 사용자 정보를 request에 저장
        request.auth.login(user)
    }
}

// 보호된 라우트 그룹 만들기
func routes(_ app: Application) throws {
    let protected = app.grouped(JWTAuthenticator())
        .grouped(User.guardMiddleware())
    
    // 인증이 필요한 라우트들
    protected.get("profile") { req async throws -> User.Public in
        let user = try req.auth.require(User.self)
        return user.publicView
    }
    
    protected.put("profile") { req async throws -> User.Public in
        let user = try req.auth.require(User.self)
        let updatedData = try req.content.decode(User.self)
        
        user.name = updatedData.name
        try await user.save(on: req.db)
        
        return user.publicView
    }
}

Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

mkdir MyPerfectServer
cd MyPerfectServer
swift package init --type executable

// swift-tools-version:5.7
import PackageDescription

let package = Package(
    name: "MyPerfectServer",
    platforms: [
        .macOS(.v12)
    ],
    dependencies: [
        .package(url: "https://github.com/PerfectlySoft/Perfect-HTTPServer.git", from: "3.0.0")
    ],
    targets: [
        .executableTarget(
            name: "MyPerfectServer",
            dependencies: [
                .product(name: "PerfectHTTPServer", package: "Perfect-HTTPServer")
            ]
        )
    ]
)

import PerfectHTTP
import PerfectHTTPServer

// 라우트 설정
var routes = Routes()

// GET /hello 엔드포인트
routes.add(method: .get, uri: "/hello") { request, response in
    response.setHeader(.contentType, value: "application/json")
    response.setBody(string: "{\"message\": \"Hello, Perfect! 🚀\"}")
    response.completed()
}

// GET /hello/:name 엔드포인트
routes.add(method: .get, uri: "/hello/{name}") { request, response in
    let name = request.urlVariables["name"] ?? "Guest"
    response.setHeader(.contentType, value: "application/json")
    response.setBody(string: "{\"message\": \"Hello, \(name)! 👋\"}")
    response.completed()
}

// POST /user 엔드포인트
routes.add(method: .post, uri: "/user") { request, response in
    do {
        guard let jsonData = request.postBodyString?.data(using: .utf8),
              let json = try JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
              let name = json["name"] as? String,
              let email = json["email"] as? String else {
            response.status = .badRequest
            response.setBody(string: "{\"error\": \"Invalid request\"}")
            response.completed()
            return
        }
        
        let responseData: [String: Any] = [
            "name": name,
            "email": email,
            "message": "User created successfully"
        ]
        
        let responseJson = try JSONSerialization.data(withJSONObject: responseData)
        response.setHeader(.contentType, value: "application/json")
        response.setBody(bytes: Array(responseJson))
        response.completed()
    } catch {
        response.status = .internalServerError
        response.setBody(string: "{\"error\": \"Server error\"}")
        response.completed()
    }
}

// 서버 설정
let server = HTTPServer()
server.serverPort = 8080
server.addRoutes(routes)

do {
    try server.start()
    print("🚀 Server started on port 8080")
} catch {
    print("❌ Server failed to start: \(error)")
}

swift run

dependencies: [
    .package(url: "https://github.com/PerfectlySoft/Perfect-PostgreSQL.git", from: "3.0.0")
]

import PerfectPostgreSQL

// 데이터베이스 연결 설정
let connection = PGConnection()
let status = connection.connectdb(
    "host=localhost port=5432 dbname=mydb user=postgres password=password"
)

guard status == .ok else {
    print("❌ Database connection failed")
    exit(1)
}

// 쿼리 실행 함수
func executeQuery(_ query: String) -> PGResult? {
    return connection.exec(statement: query)
}

// 사용자 생성 라우트
routes.add(method: .post, uri: "/user") { request, response in
    guard let jsonData = request.postBodyString?.data(using: .utf8),
          let json = try? JSONSerialization.jsonObject(with: jsonData) as? [String: Any],
          let name = json["name"] as? String,
          let email = json["email"] as? String else {
        response.status = .badRequest
        response.completed()
        return
    }
    
    let query = """
        INSERT INTO users (name, email) 
        VALUES ('\(name)', '\(email)') 
        RETURNING id, name, email
    """
    
    guard let result = executeQuery(query),
          result.status() == .tuplesOK else {
        response.status = .internalServerError
        response.completed()
        return
    }
    
    // 결과 파싱
    let id = result.getFieldString(tupleIndex: 0, fieldIndex: 0) ?? ""
    let userName = result.getFieldString(tupleIndex: 0, fieldIndex: 1) ?? ""
    let userEmail = result.getFieldString(tupleIndex: 0, fieldIndex: 2) ?? ""
    
    let responseData: [String: Any] = [
        "id": id,
        "name": userName,
        "email": userEmail
    ]
    
    if let responseJson = try? JSONSerialization.data(withJSONObject: responseData) {
        response.setHeader(.contentType, value: "application/json")
        response.setBody(bytes: Array(responseJson))
    }
    
    response.completed()
}

let query = "INSERT INTO users (name, email) VALUES ($1, $2)"
let result = connection.exec(statement: query, params: [name, email])

import Vapor
import Fluent

// 게시글 모델
final class Post: Model, Content {
    static let schema = "posts"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "title")
    var title: String
    
    @Field(key: "content")
    var content: String
    
    @Parent(key: "user_id")
    var user: User
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    @Children(for: \.$post)
    var comments: [Comment]
    
    init() { }
}

// 댓글 모델
final class Comment: Model, Content {
    static let schema = "comments"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "content")
    var content: String
    
    @Parent(key: "post_id")
    var post: Post
    
    @Parent(key: "user_id")
    var user: User
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    init() { }
}

// API 라우트 설정
func routes(_ app: Application) throws {
    let api = app.grouped("api", "v1")
    
    // 게시글 관련 라우트
    let posts = api.grouped("posts")
    
    // 모든 게시글 조회 (페이지네이션 포함)
    posts.get { req async throws -> Page<Post> in
        try await Post.query(on: req.db)
            .with(\.$user)
            .paginate(for: req)
    }
    
    // 특정 게시글 조회
    posts.get(":id") { req async throws -> Post in
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        try await post.$user.load(on: req.db)
        try await post.$comments.load(on: req.db)
        return post
    }
    
    // 게시글 생성 (인증 필요)
    let protected = posts.grouped(JWTAuthenticator()).grouped(User.guardMiddleware())
    
    protected.post { req async throws -> Post in
        let user = try req.auth.require(User.self)
        let post = try req.content.decode(Post.self)
        post.$user.id = try user.requireID()
        try await post.save(on: req.db)
        return post
    }
    
    // 게시글 수정
    protected.put(":id") { req async throws -> Post in
        let user = try req.auth.require(User.self)
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        // 작성자만 수정 가능
        guard post.$user.id == user.id else {
            throw Abort(.forbidden)
        }
        
        let updatedPost = try req.content.decode(Post.self)
        post.title = updatedPost.title
        post.content = updatedPost.content
        try await post.save(on: req.db)
        return post
    }
    
    // 게시글 삭제
    protected.delete(":id") { req async throws -> HTTPStatus in
        let user = try req.auth.require(User.self)
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        guard post.$user.id == user.id else {
            throw Abort(.forbidden)
        }
        
        try await post.delete(on: req.db)
        return .noContent
    }
    
    // 댓글 관련 라우트
    let comments = posts.group(":postId", "comments")
    
    // 특정 게시글의 댓글 조회
    comments.get { req async throws -> [Comment] in
        guard let postId = req.parameters.get("postId", as: UUID.self) else {
            throw Abort(.badRequest)
        }
        
        return try await Comment.query(on: req.db)
            .filter(\.$post.$id == postId)
            .with(\.$user)
            .all()
    }
    
    // 댓글 작성
    let protectedComments = comments.grouped(JWTAuthenticator()).grouped(User.guardMiddleware())
    
    protectedComments.post { req async throws -> Comment in
        let user = try req.auth.require(User.self)
        guard let postId = req.parameters.get("postId", as: UUID.self) else {
            throw Abort(.badRequest)
        }
        
        let comment = try req.content.decode(Comment.self)
        comment.$user.id = try user.requireID()
        comment.$post.id = postId
        try await comment.save(on: req.db)
        return comment
    }
}

// 요청: GET /posts?page=2&per=20
// 2페이지, 페이지당 20개 항목

{
  "items": [...],
  "metadata": {
    "page": 2,
    "per": 20,
    "total": 150
  }
}

// 성공 응답
struct APIResponse<T: Content>: Content {
    var success: Bool
    var data: T?
    var message: String?
    
    static func success(data: T, message: String? = nil) -> APIResponse {
        APIResponse(success: true, data: data, message: message)
    }
}

// 에러 응답
struct APIError: Content {
    var success: Bool = false
    var error: ErrorDetail
    
    struct ErrorDetail: Content {
        var code: String
        var message: String
        var details: [String: String]?
    }
}

// 사용 예제
posts.get { req async throws -> APIResponse<[Post]> in
    let posts = try await Post.query(on: req.db).all()
    return .success(data: posts, message: "Posts retrieved successfully")
}

import XCTVapor
@testable import App

final class UserTests: XCTestCase {
    var app: Application!
    
    override func setUp() async throws {
        app = Application(.testing)
        try configure(app)
        try await app.autoMigrate()
    }
    
    override func tearDown() async throws {
        try await app.autoRevert()
        app.shutdown()
    }
    
    // 사용자 생성 테스트
    func testCreateUser() async throws {
        let userData = User(name: "Test User", email: "test@example.com", age: 25)
        
        try app.test(.POST, "users", beforeRequest: { req in
            try req.content.encode(userData)
        }, afterResponse: { res in
            XCTAssertEqual(res.status, .ok)
            
            let user = try res.content.decode(User.self)
            XCTAssertEqual(user.name, "Test User")
            XCTAssertEqual(user.email, "test@example.com")
            XCTAssertNotNil(user.id)
        })
    }
    
    // 사용자 조회 테스트
    func testGetUser() async throws {
        // 테스트 데이터 생성
        let user = User(name: "Test User", email: "test@example.com", age: 25)
        try await user.save(on: app.db)
        
        let userId = try user.requireID()
        
        try app.test(.GET, "users/\(userId)", afterResponse: { res in
            XCTAssertEqual(res.status, .ok)
            
            let fetchedUser = try res.content.decode(User.self)
            XCTAssertEqual(fetchedUser.id, user.id)
            XCTAssertEqual(fetchedUser.name, user.name)
        })
    }
    
    // 인증 테스트
    func testAuthenticatedRoute() async throws {
        // 사용자 생성 및 로그인
        let user = User(name: "Test User", email: "test@example.com", age: 25)
        user.passwordHash = try Bcrypt.hash("password123")
        try await user.save(on: app.db)
        
        var token: String!
        
        try app.test(.POST, "login", beforeRequest: { req in
            try req.content.encode(LoginRequest(email: "test@example.com", password: "password123"))
        }, afterResponse: { res in
            let response = try res.content.decode(LoginResponse.self)
            token = response.token
        })
        
        // 인증이 필요한 라우트 테스트
        try app.test(.GET, "profile", beforeRequest: { req in
            req.headers.bearerAuthorization = BearerAuthorization(token: token)
        }, afterResponse: { res in
            XCTAssertEqual(res.status, .ok)
        })
    }
    
    // 에러 처리 테스트
    func testNotFound() async throws {
        try app.test(.GET, "users/00000000-0000-0000-0000-000000000000", afterResponse: { res in
            XCTAssertEqual(res.status, .notFound)
        })
    }
}

swift test

# Dockerfile
FROM swift:5.9-jammy as build

WORKDIR /build

# 의존성 복사 및 빌드
COPY ./Package.* ./
RUN swift package resolve

# 소스 코드 복사
COPY . .

# 릴리즈 빌드
RUN swift build -c release --static-swift-stdlib

# 런타임 이미지
FROM ubuntu:jammy

# 필요한 런타임 라이브러리 설치
RUN apt-get update && apt-get install -y \
    libcurl4 \
    libxml2 \
    && rm -r /var/lib/apt/lists/*

# 빌드된 바이너리 복사
WORKDIR /app
COPY --from=build /build/.build/release/App /app
COPY --from=build /build/Public /app/Public
COPY --from=build /build/Resources /app/Resources

# 포트 노출
EXPOSE 8080

# 실행
ENTRYPOINT ["./App"]
CMD ["serve", "--env", "production", "--hostname", "0.0.0.0", "--port", "8080"]

# 이미지 빌드
docker build -t my-vapor-app .

# 컨테이너 실행
docker run -p 8080:8080 my-vapor-app

# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      DATABASE_HOST: db
      DATABASE_PORT: 5432
      DATABASE_USERNAME: vapor
      DATABASE_PASSWORD: password
      DATABASE_NAME: vapor_db
      JWT_SECRET: your-secret-key
    depends_on:
      - db
    restart: unless-stopped
  
  db:
    image: postgres:15
    environment:
      POSTGRES_USER: vapor
      POSTGRES_PASSWORD: password
      POSTGRES_DB: vapor_db
    volumes:
      - postgres_data:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  postgres_data:

docker-compose up -d

# Procfile 생성
web: App serve --env production --hostname 0.0.0.0 --port $PORT

# 배포
heroku create my-vapor-app
git push heroku main

# EC2 인스턴스 접속
ssh -i your-key.pem ubuntu@your-ec2-ip

# Docker 설치
sudo apt-get update
sudo apt-get install docker.io docker-compose

# 코드 클론 및 실행
git clone your-repo
cd your-repo
docker-compose up -d

# .github/workflows/deploy.yml
name: Deploy

on:
  push:
    branches: [ main ]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Setup Swift
        uses: swift-actions/setup-swift@v1
        with:
          swift-version: '5.9'
      
      - name: Run tests
        run: swift test
  
  deploy:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      
      - name: Login to Docker Hub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      
      - name: Build and push
        uses: docker/build-push-action@v4
        with:
          push: true
          tags: your-username/my-vapor-app:latest
      
      - name: Deploy to server
        uses: appleboy/ssh-action@master
        with:
          host: ${{ secrets.SERVER_HOST }}
          username: ${{ secrets.SERVER_USER }}
          key: ${{ secrets.SSH_PRIVATE_KEY }}
          script: |
            cd /app
            docker-compose pull
            docker-compose up -d

ab -n 1000 -c 10 http://localhost:8080/api/users

wrk -t12 -c400 -d30s http://localhost:8080/api/users

// ❌ N+1 쿼리 문제
let users = try await User.query(on: db).all()
for user in users {
    // 각 사용자마다 별도 쿼리 실행 (비효율적!)
    let posts = try await user.$posts.get(on: db)
}

// ✅ Eager Loading 사용
let users = try await User.query(on: db)
    .with(\.$posts)  // 한 번의 쿼리로 모든 게시글 가져오기
    .all()

// ✅ 필요한 필드만 선택
let users = try await User.query(on: db)
    .field(\.$id)
    .field(\.$name)
    .field(\.$email)
    .all()

// ✅ 인덱스 활용
struct CreateUser: AsyncMigration {
    func prepare(on database: Database) async throws {
        try await database.schema("users")
            .id()
            .field("email", .string, .required)
            .field("name", .string, .required)
            .unique(on: "email")
            .create()
        
        // 자주 검색하는 필드에 인덱스 추가
        try await database.schema("users")
            .createIndex(on: "email")
            .run()
    }
}

import Redis

// Redis 설정
app.redis.configuration = try RedisConfiguration(
    hostname: "localhost",
    port: 6379
)

// 캐시 사용 예제
func getUser(id: UUID, req: Request) async throws -> User {
    let cacheKey = "user:\(id)"
    
    // 캐시에서 먼저 확인
    if let cached = try await req.redis.get(cacheKey, as: User.self) {
        return cached
    }
    
    // 캐시에 없으면 데이터베이스에서 조회
    guard let user = try await User.find(id, on: req.db) else {
        throw Abort(.notFound)
    }
    
    // 캐시에 저장 (1시간 TTL)
    try await req.redis.setex(cacheKey, to: user, expirationInSeconds: 3600)
    
    return user
}

// 캐시 무효화
func updateUser(id: UUID, req: Request) async throws -> User {
    let user = try await User.find(id, on: req.db)
    // ... 업데이트 로직
    
    // 캐시 삭제
    try await req.redis.delete("user:\(id)")
    
    return user
}

// ❌ 순차 처리 (느림)
let user = try await fetchUser(id: userId, on: db)
let posts = try await fetchPosts(userId: userId, on: db)
let comments = try await fetchComments(userId: userId, on: db)

// ✅ 병렬 처리 (빠름)
async let user = fetchUser(id: userId, on: db)
async let posts = fetchPosts(userId: userId, on: db)
async let comments = fetchComments(userId: userId, on: db)

let result = try await (user, posts, comments)

// ✅ TaskGroup 사용 (더 많은 작업을 병렬로)
let userIds = [UUID(), UUID(), UUID()]

let users = try await withThrowingTaskGroup(of: User.self) { group in
    for id in userIds {
        group.addTask {
            try await fetchUser(id: id, on: db)
        }
    }
    
    var results: [User] = []
    for try await user in group {
        results.append(user)
    }
    return results
}

// Vapor 설정
app.http.server.configuration.responseCompression = .enabled

// 특정 라우트에만 적용
let compressed = app.grouped(FileMiddleware(publicDirectory: app.directory.publicDirectory))
compressed.get("large-data") { req async throws -> [String: Any] in
    // 큰 데이터 반환
}

// ❌ 위험
let query = "SELECT * FROM users WHERE email = '\(email)'"

// ✅ 안전 (Parameterized Query)
let query = "SELECT * FROM users WHERE email = $1"
let result = try await db.raw(query).bind(email).all()

// HTML 이스케이프 처리
import Vapor

extension String {
    var htmlEscaped: String {
        self.replacingOccurrences(of: "&", with: "&")
            .replacingOccurrences(of: "<", with: "<")
            .replacingOccurrences(of: ">", with: ">")
            .replacingOccurrences(of: "\"", with: """)
            .replacingOccurrences(of: "'", with: "'")
    }
}

// CSRF 미들웨어 구현
struct CSRFMiddleware: AsyncMiddleware {
    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
        if request.method == .POST || request.method == .PUT || request.method == .DELETE {
            guard let token = request.headers.first(name: "X-CSRF-Token"),
                  try request.application.jwt.verify(token, as: CSRFPayload.self) != nil else {
                throw Abort(.forbidden, reason: "Invalid CSRF token")
            }
        }
        return try await next.respond(to: request)
    }
}

import Redis

struct RateLimitMiddleware: AsyncMiddleware {
    let maxRequests: Int
    let windowSeconds: Int
    
    func respond(to request: Request, chainingTo next: AsyncResponder) async throws -> Response {
        let ip = request.remoteAddress?.ipAddress ?? "unknown"
        let key = "rate_limit:\(ip)"
        
        let count = try await request.redis.incr(key)
        
        if count == 1 {
            try await request.redis.expire(key, after: windowSeconds)
        }
        
        if count > maxRequests {
            throw Abort(.tooManyRequests, reason: "Rate limit exceeded")
        }
        
        return try await next.respond(to: request)
    }
}

// 사용
app.middleware.use(RateLimitMiddleware(maxRequests: 100, windowSeconds: 60))

# Nginx 리버스 프록시 설정
server {
    listen 80;
    server_name yourdomain.com;
    return 301 https://$server_name$request_uri;
}

server {
    listen 443 ssl http2;
    server_name yourdomain.com;
    
    ssl_certificate /etc/letsencrypt/live/yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/yourdomain.com/privkey.pem;
    
    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_ciphers HIGH:!aNULL:!MD5;
    
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

// .env 파일 (절대 Git에 커밋하지 말 것!)
DATABASE_URL=postgresql://user:password@localhost:5432/mydb
JWT_SECRET=your-super-secret-key-here
REDIS_URL=redis://localhost:6379

// .env.example 파일 (Git에 커밋)
DATABASE_URL=postgresql://user:password@localhost:5432/mydb
JWT_SECRET=change-this-in-production
REDIS_URL=redis://localhost:6379

// 코드에서 사용
let databaseURL = Environment.get("DATABASE_URL") ?? "default-value"

import Fluent
import Vapor

// 사용자 모델
final class User: Model, Content {
    static let schema = "users"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "username")
    var username: String
    
    @Field(key: "email")
    var email: String
    
    @Field(key: "password_hash")
    var passwordHash: String
    
    @Field(key: "bio")
    var bio: String?
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    @Children(for: \.$author)
    var posts: [Post]
    
    @Children(for: \.$user)
    var comments: [Comment]
    
    init() { }
}

// 게시글 모델
final class Post: Model, Content {
    static let schema = "posts"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "title")
    var title: String
    
    @Field(key: "content")
    var content: String
    
    @Field(key: "slug")
    var slug: String
    
    @Parent(key: "author_id")
    var author: User
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    @Timestamp(key: "updated_at", on: .update)
    var updatedAt: Date?
    
    @Children(for: \.$post)
    var comments: [Comment]
    
    @Siblings(through: PostTag.self, from: \.$post, to: \.$tag)
    var tags: [Tag]
    
    @Children(for: \.$post)
    var likes: [Like]
    
    init() { }
}

// 댓글 모델
final class Comment: Model, Content {
    static let schema = "comments"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "content")
    var content: String
    
    @Parent(key: "post_id")
    var post: Post
    
    @Parent(key: "user_id")
    var user: User
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    init() { }
}

// 태그 모델
final class Tag: Model, Content {
    static let schema = "tags"
    
    @ID(key: .id)
    var id: UUID?
    
    @Field(key: "name")
    var name: String
    
    @Siblings(through: PostTag.self, from: \.$tag, to: \.$post)
    var posts: [Post]
    
    init() { }
}

// 게시글-태그 중간 테이블
final class PostTag: Model {
    static let schema = "post_tags"
    
    @ID(key: .id)
    var id: UUID?
    
    @Parent(key: "post_id")
    var post: Post
    
    @Parent(key: "tag_id")
    var tag: Tag
    
    init() { }
}

// 좋아요 모델
final class Like: Model, Content {
    static let schema = "likes"
    
    @ID(key: .id)
    var id: UUID?
    
    @Parent(key: "post_id")
    var post: Post
    
    @Parent(key: "user_id")
    var user: User
    
    @Timestamp(key: "created_at", on: .create)
    var createdAt: Date?
    
    init() { }
}

import Vapor
import Fluent

struct PostController: RouteCollection {
    func boot(routes: RoutesBuilder) throws {
        let posts = routes.grouped("api", "v1", "posts")
        
        // 공개 라우트
        posts.get(use: index)
        posts.get(":id", use: show)
        posts.get("search", use: search)
        posts.get("tag", ":tagName", use: byTag)
        
        // 인증 필요 라우트
        let protected = posts.grouped(JWTAuthenticator()).grouped(User.guardMiddleware())
        protected.post(use: create)
        protected.put(":id", use: update)
        protected.delete(":id", use: delete)
        protected.post(":id", "like", use: toggleLike)
        protected.post(":id", "comments", use: addComment)
    }
    
    // 게시글 목록 조회 (페이지네이션)
    func index(req: Request) async throws -> Page<Post.Public> {
        let posts = try await Post.query(on: req.db)
            .with(\.$author)
            .with(\.$tags)
            .sort(\.$createdAt, .descending)
            .paginate(for: req)
        
        return posts.map { $0.asPublic() }
    }
    
    // 게시글 상세 조회
    func show(req: Request) async throws -> Post.Detail {
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        try await post.$author.load(on: req.db)
        try await post.$tags.load(on: req.db)
        try await post.$comments.load(on: req.db)
        try await post.$likes.load(on: req.db)
        
        return post.asDetail()
    }
    
    // 게시글 생성
    func create(req: Request) async throws -> Post.Public {
        let user = try req.auth.require(User.self)
        let input = try req.content.decode(Post.Create.self)
        
        let post = Post()
        post.title = input.title
        post.content = input.content
        post.slug = input.title.slugified()
        post.$author.id = try user.requireID()
        
        try await post.save(on: req.db)
        
        // 태그 추가
        if let tagNames = input.tags {
            for tagName in tagNames {
                let tag = try await Tag.query(on: req.db)
                    .filter(\.$name == tagName)
                    .first() ?? Tag(name: tagName)
                
                if tag.id == nil {
                    try await tag.save(on: req.db)
                }
                
                try await post.$tags.attach(tag, on: req.db)
            }
        }
        
        try await post.$author.load(on: req.db)
        try await post.$tags.load(on: req.db)
        
        return post.asPublic()
    }
    
    // 게시글 수정
    func update(req: Request) async throws -> Post.Public {
        let user = try req.auth.require(User.self)
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        // 작성자만 수정 가능
        guard post.$author.id == user.id else {
            throw Abort(.forbidden)
        }
        
        let input = try req.content.decode(Post.Update.self)
        post.title = input.title ?? post.title
        post.content = input.content ?? post.content
        
        try await post.save(on: req.db)
        try await post.$author.load(on: req.db)
        try await post.$tags.load(on: req.db)
        
        return post.asPublic()
    }
    
    // 게시글 삭제
    func delete(req: Request) async throws -> HTTPStatus {
        let user = try req.auth.require(User.self)
        guard let post = try await Post.find(req.parameters.get("id"), on: req.db) else {
            throw Abort(.notFound)
        }
        
        guard post.$author.id == user.id else {
            throw Abort(.forbidden)
        }
        
        try await post.delete(on: req.db)
        return .noContent
    }
    
    // 좋아요 토글
    func toggleLike(req: Request) async throws -> Post.LikeStatus {
        let user = try req.auth.require(User.self)
        guard let postId = req.parameters.get("id", as: UUID.self) else {
            throw Abort(.badRequest)
        }
        
        let existingLike = try await Like.query(on: req.db)
            .filter(\.$post.$id == postId)
            .filter(\.$user.$id == try user.requireID())
            .first()
        
        if let like = existingLike {
            try await like.delete(on: req.db)
            return Post.LikeStatus(liked: false, count: try await countLikes(postId: postId, db: req.db))
        } else {
            let like = Like()
            like.$post.id = postId
            like.$user.id = try user.requireID()
            try await like.save(on: req.db)
            return Post.LikeStatus(liked: true, count: try await countLikes(postId: postId, db: req.db))
        }
    }
    
    // 댓글 추가
    func addComment(req: Request) async throws -> Comment.Public {
        let user = try req.auth.require(User.self)
        guard let postId = req.parameters.get("id", as: UUID.self) else {
            throw Abort(.badRequest)
        }
        
        let input = try req.content.decode(Comment.Create.self)
        
        let comment = Comment()
        comment.content = input.content
        comment.$post.id = postId
        comment.$user.id = try user.requireID()
        
        try await comment.save(on: req.db)
        try await comment.$user.load(on: req.db)
        
        return comment.asPublic()
    }
    
    // 검색
    func search(req: Request) async throws -> [Post.Public] {
        guard let query = req.query[String.self, at: "q"] else {
            throw Abort(.badRequest, reason: "Search query required")
        }
        
        let posts = try await Post.query(on: req.db)
            .group(.or) { group in
                group.filter(\.$title, .custom("ILIKE"), "%\(query)%")
                group.filter(\.$content, .custom("ILIKE"), "%\(query)%")
            }
            .with(\.$author)
            .with(\.$tags)
            .all()
        
        return posts.map { $0.asPublic() }
    }
    
    // 태그별 조회
    func byTag(req: Request) async throws -> [Post.Public] {
        guard let tagName = req.parameters.get("tagName") else {
            throw Abort(.badRequest)
        }
        
        guard let tag = try await Tag.query(on: req.db)
            .filter(\.$name == tagName)
            .first() else {
            return []
        }
        
        try await tag.$posts.load(on: req.db)
        
        for post in tag.posts {
            try await post.$author.load(on: req.db)
            try await post.$tags.load(on: req.db)
        }
        
        return tag.posts.map { $0.asPublic() }
    }
    
    private func countLikes(postId: UUID, db: Database) async throws -> Int {
        try await Like.query(on: db)
            .filter(\.$post.$id == postId)
            .count()
    }
}

// DTO (Data Transfer Object) 정의
extension Post {
    struct Create: Content {
        var title: String
        var content: String
        var tags: [String]?
    }
    
    struct Update: Content {
        var title: String?
        var content: String?
    }
    
    struct Public: Content {
        var id: UUID?
        var title: String
        var slug: String
        var content: String
        var author: User.Public
        var tags: [String]
        var createdAt: Date?
        var updatedAt: Date?
    }
    
    struct Detail: Content {
        var id: UUID?
        var title: String
        var slug: String
        var content: String
        var author: User.Public
        var tags: [String]
        var comments: [Comment.Public]
        var likeCount: Int
        var createdAt: Date?
        var updatedAt: Date?
    }
    
    struct LikeStatus: Content {
        var liked: Bool
        var count: Int
    }
    
    func asPublic() -> Public {
        Public(
            id: id,
            title: title,
            slug: slug,
            content: content,
            author: author.publicView,
            tags: tags.map { $0.name },
            createdAt: createdAt,
            updatedAt: updatedAt
        )
    }
    
    func asDetail() -> Detail {
        Detail(
            id: id,
            title: title,
            slug: slug,
            content: content,
            author: author.publicView,
            tags: tags.map { $0.name },
            comments: comments.map { $0.asPublic() },
            likeCount: likes.count,
            createdAt: createdAt,
            updatedAt: updatedAt
        )
    }
}

extension Comment {
    struct Create: Content {
        var content: String
    }
    
    struct Public: Content {
        var id: UUID?
        var content: String
        var user: User.Public
        var createdAt: Date?
    }
    
    func asPublic() -> Public {
        Public(
            id: id,
            content: content,
            user: user.publicView,
            createdAt: createdAt
        )
    }
}

extension String {
    func slugified() -> String {
        let allowed = CharacterSet.alphanumerics.union(CharacterSet(charactersIn: "-"))
        return self.lowercased()
            .components(separatedBy: allowed.inverted)
            .filter { !$0.isEmpty }
            .joined(separator: "-")
    }
}