throws 대신 타입으로 에러를 추적하고, Layer로 의존성을 주입하는 Effect-TS 백엔드 설계

// 기존 방식: 에러 정보가 타입에서 완전히 사라짐
async function fetchUser(id: string): Promise<User> {
  // DB 오류? 네트워크 오류? 유저 없음? 아무것도 알 수 없음
}
 
// Effect: 발생 가능한 모든 에러와 필요한 의존성이 시그니처에 드러남
const fetchUser = (id: string): Effect.Effect<User, NotFoundError | DbError, Database> => ...

import { Data, Effect } from "effect"
 
class UserNotFoundError extends Data.TaggedError("UserNotFoundError")<{
  userId: string
}> {}
 
class DatabaseConnectionError extends Data.TaggedError("DatabaseConnectionError")<{
  cause: unknown
}> {}
 
// 이 함수가 어떤 에러를 낼 수 있는지 시그니처만 봐도 알 수 있음
const getUser = (id: string): Effect.Effect<
  User,
  UserNotFoundError | DatabaseConnectionError,
  Database
> =>
  Effect.flatMap(Database, (db) =>
    db.findUser(id).pipe(
      Effect.catchTag("DatabaseConnectionError", () =>
        Effect.fail(new UserNotFoundError({ userId: id }))
      )
    )
  )

import { Context, Effect, Layer } from "effect"
import { Pool } from "pg"
 
// DatabaseConnectionError는 위 섹션에서 정의한 클래스를 재사용
class Database extends Context.Service<Database>()("Database", {
  effect: Effect.succeed({
    query: (_sql: string) => Effect.succeed([] as unknown[])
  })
}) {}
 
// 프로덕션 구현체 레이어 — 레이어 초기화 시 커넥션 풀을 생성하고 재사용
const DatabaseLive = Layer.effect(
  Database,
  Effect.sync(() => {
    const pool = new Pool({ connectionString: process.env.DATABASE_URL })
    return {
      query: (sql: string) =>
        Effect.tryPromise({
          try: () => pool.query(sql).then(r => r.rows as unknown[]),
          catch: (cause) => new DatabaseConnectionError({ cause })
        })
    }
  })
)
 
// 테스트 구현체 레이어 — 진짜 DB 없이 교체
const DatabaseTest = Layer.succeed(Database, {
  query: (_sql: string) => Effect.succeed([{ id: "1", name: "Test" }])
})

import { Context, Effect, Layer, Data } from "effect"
 
// 도메인 에러 정의
// DatabaseConnectionError는 "타입 안전한 에러 설계" 섹션에서 정의한 클래스를 사용
class UserNotFoundError extends Data.TaggedError("UserNotFoundError")<{
  userId: string
}> {}
 
interface User {
  id: string
  name: string
  email: string
}
 
// Repository 서비스 계약 — 기본 구현은 인터페이스 명세를 위한 플레이스홀더
class UserRepository extends Context.Service<UserRepository>()(
  "UserRepository",
  {
    effect: Effect.succeed({
      findById: (_id: string): Effect.Effect<User | null, DatabaseConnectionError> =>
        Effect.succeed(null)
    })
  }
) {}
 
// 프로덕션 구현체 — Database Layer에 의존
const UserRepositoryLive = Layer.effect(
  UserRepository,
  Effect.map(Database, (db) => ({
    findById: (id: string) =>
      db.query(`SELECT * FROM users WHERE id = $1`).pipe(
        Effect.map((rows) => (rows.length > 0 ? (rows[0] as User) : null))
      )
  }))
)
 
// 비즈니스 로직 — 시그니처가 에러와 의존성을 모두 명시
const getUserOrFail = (
  id: string
): Effect.Effect<User, UserNotFoundError | DatabaseConnectionError, UserRepository> =>
  Effect.flatMap(UserRepository, (repo) =>
    repo.findById(id).pipe(
      Effect.flatMap((user) =>
        user
          ? Effect.succeed(user)
          : Effect.fail(new UserNotFoundError({ userId: id }))
      )
    )
  )

import { Effect, Layer } from "effect"
import { describe, it, expect } from "vitest"
 
// 테스트용 레이어 — 고정된 데이터 반환
const UserRepositoryTest = Layer.succeed(UserRepository, {
  findById: (id: string) =>
    id === "existing-user"
      ? Effect.succeed({ id, name: "테스트 유저", email: "test@example.com" } as User)
      : Effect.succeed(null)
})
 
describe("getUserOrFail", () => {
  it("존재하는 유저를 반환한다", async () => {
    const result = await Effect.runPromise(
      getUserOrFail("existing-user").pipe(
        Effect.provide(UserRepositoryTest)
      )
    )
    expect(result.name).toBe("테스트 유저")
  })
 
  it("없는 유저면 UserNotFoundError를 반환한다", async () => {
    const result = await Effect.runPromise(
      getUserOrFail("ghost").pipe(
        Effect.provide(UserRepositoryTest),
        Effect.flip // 에러를 성공 채널로 뒤집어서 검증
      )
    )
    expect(result._tag).toBe("UserNotFoundError")
    expect(result.userId).toBe("ghost")
  })
})

import { Effect, Layer } from "effect"
 
// UserRepositoryLive가 DatabaseLive를 의존 → Layer.provide로 연결
const AppLayer = Layer.provide(UserRepositoryLive, DatabaseLive)
 
const getUserProgram = (id: string) =>
  Effect.gen(function* () {
    const user = yield* getUserOrFail(id)
    yield* Effect.log(`유저 조회 성공: ${user.name}`)
    return user
  })
 
// 진입점에서 에러를 타입별로 최종 처리한 뒤 실행
const main = getUserProgram("some-id").pipe(
  Effect.catchTag("UserNotFoundError", (err) =>
    Effect.logWarning(`존재하지 않는 유저: ${err.userId}`)
  ),
  Effect.catchTag("DatabaseConnectionError", () =>
    Effect.logError("데이터베이스 연결 실패")
  ),
  Effect.provide(AppLayer)
)
 
Effect.runPromise(main)

// 주의: catchAll로 Effect.void를 반환하면 user 타입이 User | void가 됨
const bad = Effect.gen(function* () {
  const user = yield* getUserOrFail("123").pipe(
    Effect.catchAll(() => Effect.void) // user가 void가 되어버림
  )
  console.log(user.name) // 타입 오류: void에는 name이 없음
})
 
// 에러를 타입별로 처리하거나, 진입점에서 일괄 처리
const good = getUserOrFail("123").pipe(
  Effect.catchTag("UserNotFoundError", (err) =>
    Effect.logWarning(`유저 없음: ${err.userId}`).pipe(
      Effect.andThen(Effect.fail(err)) // 에러를 재전파
    )
  )
)

import { Effect, Schedule } from "effect"
 
// ServiceUnavailableError도 Data.TaggedError로 정의되어 있다고 가정
const resilientFetch = getUserOrFail("123").pipe(
  // 100ms 지수 백오프로 최대 3회 재시도
  Effect.retry(Schedule.exponential("100 millis").pipe(Schedule.take(3))),
  // 5초 타임아웃
  Effect.timeout("5 seconds"),
  // 타임아웃 시 커스텀 에러로 변환
  Effect.catchTag("TimeoutException", () => Effect.fail(new ServiceUnavailableError()))
)

import { Effect } from "effect"
 
const getUserWithTracing = (id: string) =>
  getUserOrFail(id).pipe(
    Effect.withSpan("user.getById", {
      attributes: { "user.id": id }
    })
  )
 
// 중첩 스팬도 자연스럽게 부모-자식 계층 구조를 이룸
// getOrder, fulfillOrder는 동일한 패턴의 다른 도메인 Effect 함수라고 가정
const processOrder = (orderId: string) =>
  Effect.gen(function* () {
    const order = yield* getOrder(orderId)           // 예시: 주문 조회 Effect
    const user = yield* getUserWithTracing(order.userId)
    return yield* fulfillOrder(order, user)          // 예시: 주문 처리 Effect
  }).pipe(Effect.withSpan("order.process"))

// 나쁜 패턴 — Effect 계산 중간에 런타임을 깨뜨림
const bad = async () => {
  const user = await Effect.runPromise(getUser("123"))
  const order = await Effect.runPromise(getOrder(user.id))
}
 
// 좋은 패턴 — 끝까지 Effect 체인으로 연결하고 진입점에서 한 번만 실행
const good = Effect.gen(function* () {
  const user = yield* getUser("123")
  const order = yield* getOrder(user.id)
  return order
})

// 나쁜 패턴 — catchAll로 모든 에러를 null로 바꿔버림
const bad = getUser("123").pipe(
  Effect.catchAll(() => Effect.succeed(null))
)
 
// 좋은 패턴 — 에러 타입별로 적절히 처리
const good = getUser("123").pipe(
  Effect.catchTag("UserNotFoundError", () => Effect.succeed(defaultUser)),
  Effect.catchTag("DatabaseConnectionError", (err) =>
    Effect.logError("DB 연결 실패").pipe(
      Effect.andThen(Effect.fail(new ServiceUnavailableError()))
    )
  )
)