마이크로서비스 아키텍처와 모놀리식 아키텍처의 장단점을 비교해주세요.

// 모놀리식의 문제점 예시
// 하나의 기능 변경이 전체에 영향을 미침

// 결제 모듈의 버그가 전체 서비스 다운으로 이어질 수 있음
class PaymentService {
  processPayment(order: Order) {
    // 이 함수에 버그가 생기면 전체 앱에 영향
    throw new Error('결제 시스템 오류')
  }
}

// 배포 시 전체 애플리케이션 재시작 필요
// 결제 코드 한 줄 수정해도 전체 서비스 배포 필요

// 동기 통신 - REST API
// 주문 서비스에서 사용자 정보 조회
class OrderService {
  async createOrder(userId: string, items: Item[]) {
    // 사용자 서비스 HTTP 호출
    const user = await fetch(`http://user-service/api/users/${userId}`)
      .then(res => res.json())

    // 결제 서비스 HTTP 호출
    const payment = await fetch('http://payment-service/api/payments', {
      method: 'POST',
      body: JSON.stringify({ userId, amount: this.calculateTotal(items) })
    }).then(res => res.json())

    return { orderId: Date.now(), user, payment, items }
  }
}

// 비동기 통신 - 메시지 브로커 (Kafka)
// 주문 완료 이벤트 발행
class OrderService {
  async completeOrder(orderId: string) {
    await this.orderRepository.complete(orderId)

    // 이벤트 발행 - 다른 서비스가 구독
    await this.kafka.publish('order.completed', {
      orderId,
      userId: order.userId,
      amount: order.totalAmount,
      timestamp: new Date()
    })
  }
}

// 알림 서비스에서 이벤트 구독
class NotificationService {
  @KafkaSubscribe('order.completed')
  async onOrderCompleted(event: OrderCompletedEvent) {
    await this.emailSender.send(event.userId, '주문이 완료되었습니다.')
    await this.smsSender.send(event.userId, '주문 완료')
  }
}

// 마이크로서비스의 복잡성 예시

// 분산 트랜잭션 관리 - Saga 패턴 필요
class OrderSaga {
  async executeOrderCreation(order: Order) {
    try {
      // 1. 재고 서비스에서 재고 확인/감소
      await this.inventoryService.reserve(order.items)

      // 2. 결제 서비스에서 결제 처리
      const payment = await this.paymentService.charge(order.amount)

      // 3. 주문 생성
      await this.orderRepository.create(order)

    } catch (error) {
      // 실패 시 보상 트랜잭션 (Compensating Transaction)
      await this.inventoryService.release(order.items)  // 재고 복구
      await this.paymentService.refund(payment.id)      // 결제 취소
      throw error
    }
  }
}

// 서비스 간 네트워크 오류 처리 - Circuit Breaker
class PaymentServiceClient {
  private circuitBreaker = new CircuitBreaker({
    failureThreshold: 5,  // 5번 실패 시 차단
    resetTimeout: 60000,  // 60초 후 재시도
  })

  async charge(amount: number) {
    return this.circuitBreaker.execute(async () => {
      const response = await fetch('http://payment-service/charge', {
        method: 'POST',
        body: JSON.stringify({ amount }),
        signal: AbortSignal.timeout(3000) // 3초 타임아웃
      })
      if (!response.ok) throw new Error('결제 서비스 오류')
      return response.json()
    })
  }
}

// 모놀리스를 모듈로 잘 구조화하면 나중에 마이크로서비스로 분리 용이
// Next.js 풀스택 예시 - 도메인별 모듈 구조

// app/
// ├── (api)/
// │   ├── users/       → 나중에 user-service로 분리 가능
// │   ├── orders/      → 나중에 order-service로 분리 가능
// │   └── payments/    → 나중에 payment-service로 분리 가능
// ├── lib/
// │   ├── users/       (DB 접근, 비즈니스 로직)
// │   ├── orders/
// │   └── payments/
// └── components/

// 명확한 모듈 경계를 유지하면 마이크로서비스 전환이 쉬워짐
// lib/orders/service.ts
export class OrderService {
  // 외부에서는 이 서비스만 사용 (내부 구현 은닉)
  async createOrder(data: CreateOrderDto): Promise<Order> { /* ... */ }
}

// 다른 모듈에서 직접 DB 접근 금지 - 서비스를 통해서만
// ❌ import { db } from '@/lib/orders/db'  // 내부 구현 직접 접근
// ✅ import { OrderService } from '@/lib/orders/service'  // 공개 인터페이스만