Scala 3에서 EitherT·IO로 에러 누수 막기

// Scala 3
sealed trait AppError derives CanEqual:
  def message: String

object AppError:
  final case class Validation(message: String) extends AppError
  final case class NotFound(message: String) extends AppError
  final case class Conflict(message: String) extends AppError

  // 외부 시스템/인프라 계층
  final case class Upstream(
    service: String,
    status: Option[Int],
    message: String
  ) extends AppError

  final case class Timeout(service: String, message: String) extends AppError
  final case class Unexpected(message: String, cause: Throwable) extends AppError

import cats.data.EitherT
import cats.effect.IO

type AppIO[A] = EitherT[IO, AppError, A]

object AppIO:
  def ok[A](a: A): AppIO[A] = EitherT.rightT(a)
  def fail[A](e: AppError): AppIO[A] = EitherT.leftT(e)

  def fromIO[A](ioa: IO[A]): AppIO[A] = EitherT.liftF(ioa)

import cats.syntax.all.*

extension [A](ioa: IO[A])
  def toAppIO(mapper: Throwable => AppError): AppIO[A] =
    EitherT(
      ioa.attempt.map {
        case Right(a) => Right(a)
        case Left(t)  => Left(mapper(t))
      }
    )

import cats.data.EitherT
import cats.effect.IO
import cats.syntax.all.*

final case class User(id: String, name: String)

trait UserClient:
  def fetchUser(id: String): AppIO[User]

final class LiveUserClient(/* http backend 등 */) extends UserClient:

  private def mapThrowable(t: Throwable): AppError =
    // 타임아웃/네트워크/디코딩 등 구체 매핑 권장
    AppError.Unexpected("http call failed", t)

  def fetchUser(id: String): AppIO[User] =
    val io: IO[User] =
      // 실제로는 http 요청 + JSON decode
      IO.pure(User(id, "alice"))

    io.toAppIO(mapThrowable)

final case class HttpResponse(status: Int, body: String)

def decodeUser(body: String): Either[AppError, User] =
  // JSON decode 실패를 Validation/Upstream 등으로 분류
  Right(User("1", "alice"))

def fetchUserHttp(id: String): IO[HttpResponse] =
  IO.pure(HttpResponse(200, "{...}"))

def fetchUser(id: String): AppIO[User] =
  EitherT(
    fetchUserHttp(id).attempt.map {
      case Left(t) => Left(AppError.Unexpected("network failure", t))
      case Right(resp) =>
        resp.status match
          case 200 => decodeUser(resp.body)
          case 404 => Left(AppError.NotFound(s"user ${id} not found"))
          case 409 => Left(AppError.Conflict("conflict"))
          case 429 => Left(AppError.Upstream("user-service", Some(429), "rate limited"))
          case s   => Left(AppError.Upstream("user-service", Some(s), s"unexpected status: ${s}"))
    }
  )

final case class Order(id: String, userId: String)

trait OrderRepo:
  def find(id: String): AppIO[Order]

final class OrderService(userClient: UserClient, orderRepo: OrderRepo):
  def getOrderView(orderId: String): AppIO[(Order, User)] =
    for
      order <- orderRepo.find(orderId)
      user  <- userClient.fetchUser(order.userId)
    yield (order, user)

final case class HttpOut(status: Int, body: String)

def toHttpOut(e: AppError): HttpOut = e match
  case AppError.Validation(m) => HttpOut(400, m)
  case AppError.NotFound(m)   => HttpOut(404, m)
  case AppError.Conflict(m)   => HttpOut(409, m)
  case AppError.Timeout(s, m) => HttpOut(504, s"${s}: ${m}")
  case AppError.Upstream(s, st, m) =>
    // 업스트림 실패를 그대로 노출할지, 502로 통일할지 정책화
    HttpOut(502, s"upstream=${s} status=${st.getOrElse(0)} msg=${m}")
  case AppError.Unexpected(m, _) => HttpOut(500, m)

def handle[A](app: AppIO[A])(encode: A => String): IO[HttpOut] =
  app.value.map {
    case Right(a) => HttpOut(200, encode(a))
    case Left(e)  => toHttpOut(e)
  }

import cats.effect.{IO, Resource}
import cats.data.EitherT

final class DbConn:
  def queryOrder(id: String): IO[Option[Order]] = IO.pure(None)

def dbResource: Resource[IO, DbConn] =
  Resource.make(IO(new DbConn))(_ => IO.unit)

final class LiveOrderRepo(conn: DbConn) extends OrderRepo:
  def find(id: String): AppIO[Order] =
    EitherT.liftF(conn.queryOrder(id)).flatMap {
      case Some(o) => AppIO.ok(o)
      case None    => AppIO.fail(AppError.NotFound(s"order ${id} not found"))
    }

def program(orderId: String): IO[HttpOut] =
  dbResource.use { conn =>
    val repo = LiveOrderRepo(conn)
    val userClient = new LiveUserClient()
    val svc = OrderService(userClient, repo)
    handle(svc.getOrderView(orderId)) { case (o, u) => s"${o.id}:${u.name}" }
  }