비즈니스 로직의 실패 경로를 타입으로 추적하기

// 기존 방식: 에러가 숨어있다
async function processOrder(userId: string): Promise<Order> {
  // 이 함수가 무엇을 throw할 수 있는지 타입에서 알 수 없다
}
 
// ROP 방식: 실패 경로가 타입에 드러난다
type Result<T, E> = { ok: true; value: T } | { ok: false; error: E }
 
function processOrder(userId: string): Result<Order, UserNotFound | InsufficientStock>
// 함수 시그니처만 봐도 "무엇이 잘못될 수 있는가"가 보인다

Effect<Success, Error, Requirements>
//      ↑성공값   ↑에러 합집합  ↑실행에 필요한 서비스

import { Effect, Context, Layer, Data } from "effect"
 
// 에러 타입 정의 (아래 섹션에서 자세히 다룹니다)
class UserNotFound extends Data.TaggedError("UserNotFound")<{ userId: string }> {}
 
// 서비스 인터페이스를 Tag로 정의
class UserRepo extends Context.Tag("UserRepo")<
  UserRepo,
  { findById: (id: string) => Promise<User | null> }
>() {}
 
// 세 파라미터 모두 활용하는 Effect
const findUser = (userId: string): Effect.Effect<User, UserNotFound, UserRepo> =>
  Effect.gen(function* () {
    const repo = yield* UserRepo                              // Requirements에서 꺼내기
    const raw = yield* Effect.promise(() => repo.findById(userId))
    if (!raw) return yield* Effect.fail(new UserNotFound({ userId }))
    return raw
  })
 
// Layer로 실제 구현 제공
const UserRepoLive = Layer.succeed(UserRepo, {
  findById: (id) => db.users.findUnique({ where: { id } })
})
 
// provide()로 Requirements를 충족해야 실행 가능
const program = findUser("u-1").pipe(Effect.provide(UserRepoLive))
// program 타입: Effect<User, UserNotFound, never>
//                                          ↑ Requirements가 never → 실행 가능
 
await Effect.runPromise(program)

import { Data } from "effect"
 
class UserNotFound extends Data.TaggedError("UserNotFound")<{
  userId: string
}> {}
 
class InsufficientStock extends Data.TaggedError("InsufficientStock")<{
  itemId: string
  requested: number
  available: number
}> {}
 
class PaymentDeclined extends Data.TaggedError("PaymentDeclined")<{
  reason: string
}> {}

import { Effect } from "effect"
 
// ── 타입 시그니처 (각 도메인 모듈에서 실제 구현) ──────────────────────
// findUser: (id: string) => Effect.Effect<User, UserNotFound>
// loadCart: (id: string) => Effect.Effect<Cart, CartNotFound>
// reserveStock: (cart: Cart) => Effect.Effect<Reservation, InsufficientStock>
// chargeUser: (user: User, reservation: Reservation) => Effect.Effect<Payment, PaymentDeclined>
// createOrder: (user: User, reservation: Reservation, payment: Payment) => Effect.Effect<Order, never>
 
// ── 조합 ──────────────────────────────────────────────────────────────
const processOrder = (userId: string, cartId: string) =>
  Effect.gen(function* () {
    // yield*로 Effect를 실행하고 성공값을 꺼냄
    // 실패하면 즉시 에러 선로로 전환 — 이후 코드는 실행되지 않음
    const user      = yield* findUser(userId)
    const cart      = yield* loadCart(cartId)
    const reserved  = yield* reserveStock(cart)
    const payment   = yield* chargeUser(user, reserved)
    return yield* createOrder(user, reserved, payment)
  })
 
// 반환 타입 (TypeScript가 자동 추론):
// Effect<Order, UserNotFound | CartNotFound | InsufficientStock | PaymentDeclined, never>
// ↑ 발생 가능한 모든 에러가 타입에 자동으로 합산됩니다

import { Effect } from "effect"
 
// 도메인 레이어: 일부 에러만 처리하고 나머지는 타입에 남긴다
const processOrderWithApiErrors = (userId: string, cartId: string) =>
  processOrder(userId, cartId).pipe(
    // UserNotFound를 처리 → 에러 타입에서 제거됨
    Effect.catchTag("UserNotFound", (e) =>
      Effect.fail(new ApiError({ status: 404, message: `사용자 ${e.userId}를 찾을 수 없습니다` }))
    ),
    Effect.catchTag("PaymentDeclined", (e) =>
      Effect.fail(new ApiError({ status: 402, message: e.reason }))
    )
    // 반환 타입: Effect<Order, ApiError | InsufficientStock | CartNotFound, never>
    // 아직 처리되지 않은 에러가 타입에 그대로 남아있다
  )

// HTTP 핸들러 레이어: catchAll + exhaustive check로 모든 에러를 처리
const handler = processOrderWithApiErrors(userId, cartId).pipe(
  Effect.catchAll((error) => {
    switch (error._tag) {
      case "ApiError":
        return Effect.succeed({ status: error.status, body: error.message })
      case "InsufficientStock":
        return Effect.succeed({ status: 409, body: "재고가 부족합니다" })
      case "CartNotFound":
        return Effect.succeed({ status: 404, body: "장바구니를 찾을 수 없습니다" })
      default: {
        // 이 줄에서 컴파일 에러가 나면 처리하지 않은 케이스가 있다는 증거
        const _exhaustive: never = error
        return _exhaustive
      }
    }
  })
)
// 반환 타입: Effect<{ status: number; body: string }, never, never>
// Error 채널이 never → 모든 에러가 처리되었다는 컴파일타임 보증

import { Schema, Effect } from "effect"
 
const CreateOrderSchema = Schema.Struct({
  userId: Schema.String,
  cartId: Schema.String,
  items: Schema.Array(
    Schema.Struct({
      id: Schema.String,
      qty: Schema.Number.pipe(Schema.positive())  // Schema.Positive는 없음. 이렇게 써야 한다
    })
  )
})
 
type CreateOrderDTO = Schema.Schema.Type<typeof CreateOrderSchema>
 
// raw 입력을 검증하고 Effect로 반환
const parseBody = (raw: unknown) =>
  Schema.decodeUnknown(CreateOrderSchema)(raw)
// 반환: Effect<CreateOrderDTO, ParseError, never>
 
// HTTP 핸들러에서 자연스럽게 연결
const handleRequest = (rawBody: unknown) =>
  Effect.gen(function* () {
    const dto   = yield* parseBody(rawBody)             // ParseError
    const order = yield* processOrder(dto.userId, dto.cartId)  // 도메인 에러들
    return order
  }).pipe(
    Effect.catchTag("ParseError", () =>
      Effect.fail(new ApiError({ status: 400, message: "잘못된 요청 형식입니다" }))
    )
    // 이후 도메인 에러 처리 체인 연결...
  )

// 파이프라인 구성 — 아직 아무것도 실행되지 않는다
const program = handleRequest(req.body).pipe(
  Effect.provide(UserRepoLive)
)
 
// 실행 — 여기서 비로소 비동기 작업이 시작된다
const result = await Effect.runPromise(program)
//                          ↑ Error 채널이 never여야 컴파일 통과
//                            에러가 남아있으면 런타임에 예외로 전환됨
 
// 에러를 직접 다루고 싶다면 runPromiseExit 사용
const exit = await Effect.runPromiseExit(program)
// Exit<결과값, 에러> — 성공/실패 양쪽을 명시적으로 처리 가능

// 기존 레거시 코드 — 변경 없음
async function legacyFindUser(id: string): Promise<User | null> {
  return db.users.findById(id)
}
 
// Effect 경계에서 래핑
const findUser = (userId: string): Effect.Effect<User, UserNotFound> =>
  Effect.tryPromise({
    try: async () => {
      const user = await legacyFindUser(userId)
      if (!user) throw new Error("not found")
      return user
    },
    catch: () => new UserNotFound({ userId })
  })
 
// 이제 findUser는 Effect 파이프라인에서 사용할 수 있다

// 피해야 할 패턴: 도메인 레이어에서 너무 일찍 뭉개기
const badPattern = findUser(id).pipe(
  Effect.catchAll(() => Effect.fail(new Error("something went wrong")))
  // 상위 레이어는 이제 에러 종류를 알 수 없다 — UserNotFound인지 DbError인지 구분 불가
)
 
// 권장 패턴: 에러 타입을 유지한 채 HTTP 레이어로 전달
const goodPattern = (id: string) =>
  findUser(id).pipe(
    // 별도의 catchAll 없이 UserNotFound 타입을 그대로 유지
    Effect.map((user) => ({ ...user, processedAt: Date.now() }))
    // HTTP 핸들러에서 catchTag("UserNotFound", e => ...) 로 최종 변환
  )
// 반환 타입: Effect<{ ...User; processedAt: number }, UserNotFound, never>
// 에러 정보가 살아있으므로 호출자가 원하는 방식으로 처리할 수 있다