// Order Service — 주문을 생성하려면 다른 서비스를 동기적으로 호출해야 함
class OrderService {
  async createOrder(userId: string, items: OrderItem[]): Promise<Order> {
    // 1. User Service에 동기 호출 — 실패하면 주문 불가
    const user = await fetch(`${USER_SERVICE_URL}/users/${userId}`);
    if (!user.ok) throw new Error("유저 서비스 응답 없음");

    // 2. Inventory Service에 동기 호출 — 실패하면 주문 불가
    const stock = await fetch(`${INVENTORY_SERVICE_URL}/check`, {
      method: "POST",
      body: JSON.stringify({ items }),
    });
    if (!stock.ok) throw new Error("재고 서비스 응답 없음");

    // 3. Pricing Service에 동기 호출 — 실패하면 주문 불가
    const price = await fetch(`${PRICING_SERVICE_URL}/calculate`, {
      method: "POST",
      body: JSON.stringify({ items, userId }),
    });
    if (!price.ok) throw new Error("가격 서비스 응답 없음");

    // 4. 주문 저장 — 공유 DB 사용 🚨
    const order = await sharedDb.query(
      `INSERT INTO orders (user_id, items, total) VALUES ($1, $2, $3)`,
      [userId, JSON.stringify(items), (await price.json()).total]
    );

    // 5. Payment Service에 동기 호출
    await fetch(`${PAYMENT_SERVICE_URL}/charge`, {
      method: "POST",
      body: JSON.stringify({ orderId: order.id, amount: order.total }),
    });

    return order;
  }
}

# docker-compose.yml — 서비스는 5개인데 DB는 1개
services:
  order-service:
    depends_on: [user-service, inventory-service, pricing-service, payment-service, shared-db]
  user-service:
    depends_on: [shared-db]
  inventory-service:
    depends_on: [shared-db, pricing-service]  # 재고가 왜 가격에 의존?
  pricing-service:
    depends_on: [shared-db]
  payment-service:
    depends_on: [shared-db, user-service]     # 결제가 왜 유저에 의존?
  shared-db:
    image: postgres:16

// 회원가입 하나를 처리하기 위해 호출해야 하는 서비스들:

// 1. EmailFormatValidationService (이메일 형식 검증)
//    POST /validate-email-format
//    → { valid: true }

// 2. PasswordStrengthCheckerService (비밀번호 강도 체크)
//    POST /check-password-strength
//    → { strength: "strong" }

// 3. UsernameAvailabilityService (유저네임 중복 체크)
//    POST /check-username
//    → { available: true }

// 4. UserCreationService (유저 생성)
//    POST /create-user
//    → { userId: "123" }

// 5. WelcomeEmailService (환영 이메일 발송)
//    POST /send-welcome-email
//    → { sent: true }

// 6. DefaultSettingsInitializerService (기본 설정 초기화)
//    POST /init-default-settings
//    → { initialized: true }

// 회원가입 오케스트레이션 — 6개 서비스 호출
async function registerUser(data: RegisterData) {
  const emailValid = await fetch(`${EMAIL_VALIDATION_URL}/validate-email-format`, {
    method: "POST", body: JSON.stringify({ email: data.email })
  });

  const pwStrength = await fetch(`${PW_CHECKER_URL}/check-password-strength`, {
    method: "POST", body: JSON.stringify({ password: data.password })
  });

  const nameAvail = await fetch(`${USERNAME_URL}/check-username`, {
    method: "POST", body: JSON.stringify({ username: data.username })
  });

  // ... 나머지 3개 서비스 호출

  // 이 중 하나라도 실패하면? 롤백은? 재시도는?
  // 6개 서비스의 버전 관리는? 로그 추적은?
  // 지연 시간: 네트워크 왕복 6번 = 최소 수십 ms 추가
}

// 하나의 UserService로 병합 — 이게 적절한 크기
class UserService {
  async register(data: RegisterData): Promise<User> {
    // 검증 (네트워크 호출 없이 함수 호출)
    this.validateEmail(data.email);
    this.checkPasswordStrength(data.password);
    await this.ensureUsernameAvailable(data.username);

    // 생성
    const user = await this.userRepository.create(data);

    // 후처리 (비동기 이벤트로)
    await this.eventBus.publish("user.registered", { userId: user.id });
    // → 이메일 발송, 기본 설정 초기화는 이벤트 구독자가 처리

    return user;
  }

  private validateEmail(email: string): void { /* ... */ }
  private checkPasswordStrength(pw: string): void { /* ... */ }
  private async ensureUsernameAvailable(name: string): Promise<void> { /* ... */ }
}

// N+1 쿼리의 교과서적 예시
async function getOrdersWithUsers(): Promise<OrderWithUser[]> {
  // 1번 쿼리: 주문 목록 조회
  const orders = await db.query<Order>("SELECT * FROM orders LIMIT 100");

  // N번 쿼리: 각 주문의 유저 정보를 개별 조회 🚨
  const result: OrderWithUser[] = [];
  for (const order of orders) {
    // 이 쿼리가 100번 실행됨!
    const user = await db.query<User>(
      "SELECT * FROM users WHERE id = $1",
      [order.userId]
    );
    result.push({ ...order, user: user[0] });
  }

  return result;
  // 총 쿼리 수: 1 + 100 = 101번
  // 주문이 1000개면? 1001번.
}

// 마이크로서비스 간 N+1 — 더 심각함
async function getOrderDetails(orderId: string) {
  const order = await fetch(`${ORDER_SERVICE}/orders/${orderId}`);         // ~50ms
  const user = await fetch(`${USER_SERVICE}/users/${order.userId}`);       // ~50ms
  const items = await fetch(`${INVENTORY_SERVICE}/items?ids=${order.itemIds}`); // ~50ms
  const payment = await fetch(`${PAYMENT_SERVICE}/payments/${order.paymentId}`); // ~50ms
  const shipping = await fetch(`${SHIPPING_SERVICE}/tracking/${order.trackingId}`); // ~50ms

  // 총 지연: ~250ms (순차 호출)
  // 이걸 목록 페이지에서 20개 주문에 대해 하면? ~5000ms
}

// 해결 1: JOIN 쿼리 (SQL 레벨)
async function getOrdersWithUsers(): Promise<OrderWithUser[]> {
  // 1번의 쿼리로 끝!
  const result = await db.query<OrderWithUser>(`
    SELECT o.*, u.name as user_name, u.email as user_email
    FROM orders o
    JOIN users u ON o.user_id = u.id
    LIMIT 100
  `);
  return result;
  // 총 쿼리 수: 1번
}

// 해결 2: Batch Loading (ORM 레벨)
async function getOrdersWithUsers(): Promise<OrderWithUser[]> {
  const orders = await db.query<Order>("SELECT * FROM orders LIMIT 100");

  // 유저 ID를 모아서 한 번에 조회 (IN 절)
  const userIds = [...new Set(orders.map(o => o.userId))];
  const users = await db.query<User>(
    "SELECT * FROM users WHERE id = ANY($1)",
    [userIds]
  );

  // 메모리에서 매핑
  const userMap = new Map(users.map(u => [u.id, u]));
  return orders.map(order => ({
    ...order,
    user: userMap.get(order.userId)!
  }));
  // 총 쿼리 수: 2번 (100이 아니라 2!)
}

// 해결 3: DataLoader 패턴 (GraphQL에서 자주 사용)
const userLoader = new DataLoader<string, User>(async (userIds) => {
  const users = await db.query<User>(
    "SELECT * FROM users WHERE id = ANY($1)",
    [userIds]
  );
  const userMap = new Map(users.map(u => [u.id, u]));
  return userIds.map(id => userMap.get(id)!);
});

// 개별 호출처럼 보이지만 자동으로 배치됨
const user1 = await userLoader.load("user-1");
const user2 = await userLoader.load("user-2");
// → 실제로는 하나의 쿼리: SELECT * FROM users WHERE id IN ('user-1', 'user-2')