Effect-TS의 Layer 시스템으로 Hono 백엔드에 타입 안전한 의존성 주입 구현하기

Effect<A, E, R>
//     │  │  └── Requirements: 실행에 필요한 의존성
//     │  └───── Error: 예상 가능한 도메인 에러
//     └──────── Success: 성공 시 반환값

import { Context, Effect } from "effect"
 
// 도메인 타입
interface User {
  id: string
  name: string
  email: string
}
 
interface UserProfile extends User {
  displayName: string
}
 
// 도메인 에러 타입 — _tag로 판별 가능한 유니언
class UserNotFoundError {
  readonly _tag = "UserNotFoundError"
  constructor(readonly userId: string) {}
}
 
class DatabaseError {
  readonly _tag = "DatabaseError"
  constructor(readonly cause: unknown) {}
}
 
type AppError = UserNotFoundError | DatabaseError

// UserRepository 서비스 — Tag가 곧 식별자
class UserRepository extends Context.Tag("UserRepository")<
  UserRepository,
  {
    readonly findById: (id: string) => Effect.Effect<User, UserNotFoundError | DatabaseError>
    readonly findAll: () => Effect.Effect<User[], DatabaseError>
    readonly save: (user: User) => Effect.Effect<void, DatabaseError>
  }
>() {}
 
// 서비스를 사용하는 비즈니스 로직
const getUserProfile = (
  userId: string
): Effect.Effect<UserProfile, UserNotFoundError | DatabaseError, UserRepository> =>
  Effect.gen(function* () {
    const repo = yield* UserRepository
    const user = yield* repo.findById(userId)
    return { ...user, displayName: `${user.name} (${user.email})` }
  })

import { Context, Effect, Layer, Config } from "effect"
 
// AppConfig 서비스 정의
class AppConfig extends Context.Tag("AppConfig")<
  AppConfig,
  {
    readonly databaseUrl: string
    readonly jwtSecret: string
  }
>() {}
 
// Database 서비스 정의
class Database extends Context.Tag("Database")<
  Database,
  {
    readonly query: (query: string, params: unknown[]) => Effect.Effect<unknown[], DatabaseError>
  }
>() {}

import postgres from "postgres"
 
// Config 레이어 — 환경변수를 타입 안전하게 읽기
const ConfigLive = Layer.effect(
  AppConfig,
  Effect.gen(function* () {
    const databaseUrl = yield* Config.string("DATABASE_URL")
    const jwtSecret = yield* Config.string("JWT_SECRET")
    return { databaseUrl, jwtSecret }
  })
)
 
// Database 레이어 — AppConfig에 의존
const DatabaseLive = Layer.effect(
  Database,
  Effect.gen(function* () {
    const config = yield* AppConfig
    const sql = postgres(config.databaseUrl)
    return {
      query: (query: string, params: unknown[]) =>
        Effect.tryPromise({
          try: () => sql.unsafe(query, params as postgres.ParameterOrFragment<never>[]),
          catch: (e) => new DatabaseError(e),
        }),
    }
  })
)
 
// UserRepository 레이어 — Database에 의존
const UserRepositoryLive = Layer.effect(
  UserRepository,
  Effect.gen(function* () {
    const db = yield* Database
    return {
      findById: (id: string) =>
        Effect.gen(function* () {
          const rows = yield* db.query("SELECT * FROM users WHERE id = $1", [id])
          if (rows.length === 0) return yield* Effect.fail(new UserNotFoundError(id))
          return rows[0] as User
        }),
      findAll: () =>
        db.query("SELECT * FROM users", []).pipe(
          Effect.map((rows) => rows as User[])
        ),
      save: (user: User) =>
        db
          .query("INSERT INTO users VALUES ($1, $2, $3)", [user.id, user.name, user.email])
          .pipe(Effect.map(() => undefined)),
    }
  })
)

// 의존성 그래프를 선언적으로 조합
const AppLayer = UserRepositoryLive.pipe(
  Layer.provide(DatabaseLive),  // UserRepository의 Database 요구 충족
  Layer.provide(ConfigLive)     // Database의 AppConfig 요구 충족
)

import { ManagedRuntime } from "effect"
 
// 앱 시작 시 한 번만 생성 — 이후 모든 요청이 재사용
const AppRuntime = ManagedRuntime.make(AppLayer)
 
// 앱 종료 시 리소스 정리
process.on("SIGTERM", () => AppRuntime.dispose())

import { Hono, type Context as HonoContext } from "hono"
import { Cause, Effect, Exit, ManagedRuntime, Option } from "effect"
 
// AppRuntime — 모듈 스코프에서 한 번만 생성
const AppRuntime = ManagedRuntime.make(AppLayer)
 
// AppError를 구체 타입으로 고정 — exhaustive switch 보장
const handleEffect = async <A>(
  c: HonoContext,
  effect: Effect.Effect<A, AppError>
) => {
  const exit = await AppRuntime.runPromiseExit(effect)
  return Exit.match(exit, {
    onSuccess: (value) => c.json(value),
    onFailure: (cause) => {
      const maybeError = Cause.failureOption(cause)
      if (Option.isNone(maybeError)) {
        return c.json({ error: "Internal Server Error" }, 500)
      }
      const error = maybeError.value
      // AppError = UserNotFoundError | DatabaseError
      // 두 케이스를 모두 커버하므로 default 없이 exhaustive
      switch (error._tag) {
        case "UserNotFoundError":
          return c.json({ error: `User ${error.userId} not found` }, 404)
        case "DatabaseError":
          return c.json({ error: "Database error" }, 500)
      }
    },
  })
}
 
const app = new Hono()
 
app.get("/users/:id", async (c) => {
  const userId = c.req.param("id")
  return handleEffect(c, getUserProfile(userId))
})
 
app.get("/users", async (c) => {
  const effect = Effect.gen(function* () {
    const repo = yield* UserRepository
    return yield* repo.findAll()
  })
  return handleEffect(c, effect)
})
 
app.post("/users", async (c) => {
  // 실제 구현에서는 @hono/effect-validator 또는 zod로 body를 검증한 뒤 사용하세요.
  const body = await c.req.json<{ name: string; email: string }>()
  const effect = Effect.gen(function* () {
    const repo = yield* UserRepository
    const user: User = { id: crypto.randomUUID(), name: body.name, email: body.email }
    yield* repo.save(user)
    return user
  })
  return handleEffect(c, effect)
})
 
export default app

import { it, expect } from "@effect/vitest"
import { Effect, Layer } from "effect"
 
// 인메모리 구현 — 같은 인터페이스, 다른 구현
const UserRepositoryTest = Layer.succeed(UserRepository, {
  findById: (id: string) =>
    id === "existing-user"
      ? Effect.succeed({ id, name: "테스트 유저", email: "test@example.com" })
      : Effect.fail(new UserNotFoundError(id)),
  findAll: () =>
    Effect.succeed([
      { id: "1", name: "Alice", email: "alice@example.com" },
      { id: "2", name: "Bob", email: "bob@example.com" },
    ]),
  save: (_user: User) => Effect.succeed(undefined),
})
 
// 실제 앱에서 여러 서비스를 조합하듯, 테스트 레이어도 Layer.mergeAll로 조합합니다.
// 여기서는 UserRepository 하나지만, EmailService, CacheService 등을 추가할 수 있습니다.
const TestLayer = Layer.mergeAll(UserRepositoryTest)
 
it.effect("존재하는 유저 프로필을 정상 반환한다", () =>
  Effect.gen(function* () {
    const profile = yield* getUserProfile("existing-user")
    expect(profile.displayName).toBe("테스트 유저 (test@example.com)")
  }).pipe(Effect.provide(TestLayer))
)
 
it.effect("존재하지 않는 유저는 UserNotFoundError를 반환한다", () =>
  Effect.gen(function* () {
    // Effect.either는 에러를 Left, 성공을 Right로 감싸 값처럼 다루게 합니다.
    // Rust의 Result나 Go의 (value, error) 튜플과 비슷한 개념입니다.
    const result = yield* getUserProfile("unknown-user").pipe(Effect.either)
    expect(result._tag).toBe("Left")
    if (result._tag === "Left") {
      expect(result.left._tag).toBe("UserNotFoundError")
      expect(result.left.userId).toBe("unknown-user")
    }
  }).pipe(Effect.provide(TestLayer))
)

import { PgClient } from "@effect/sql-pg"
import { DrizzlePgClient } from "@effect/sql-drizzle/Pg"
import { eq } from "drizzle-orm"
import { pgTable, text, varchar } from "drizzle-orm/pg-core"
import { Config, Effect, Layer } from "effect"
 
const usersTable = pgTable("users", {
  id: varchar("id", { length: 36 }).primaryKey(),
  name: text("name").notNull(),
  email: text("email").notNull(),
})
 
const PgLive = PgClient.layerConfig({
  url: Config.string("DATABASE_URL"),
})
 
const DrizzleLive = DrizzlePgClient.layer.pipe(Layer.provide(PgLive))
 
// UserRepository의 Drizzle 구현 — UserRepositoryLive의 대안
const UserRepositoryDrizzleLive = Layer.effect(
  UserRepository,
  Effect.gen(function* () {
    const db = yield* DrizzlePgClient
    return {
      findById: (id: string) =>
        Effect.gen(function* () {
          const rows = yield* db.select().from(usersTable).where(eq(usersTable.id, id))
          if (rows.length === 0) return yield* Effect.fail(new UserNotFoundError(id))
          return rows[0]
        }),
      findAll: () => db.select().from(usersTable),
      save: (user: User) =>
        db.insert(usersTable).values(user).pipe(Effect.map(() => undefined)),
    }
  })
)
 
// Drizzle 기반 최종 레이어 — raw SQL 버전(AppLayer)의 대안
const AppLayerDrizzle = UserRepositoryDrizzleLive.pipe(Layer.provide(DrizzleLive))

// 잘못된 패턴 — 요청마다 DB 연결 풀이 새로 생성됨
app.get("/users", async (c) => {
  const runtime = ManagedRuntime.make(AppLayer) // ❌
  return c.json(await runtime.runPromise(getAllUsers))
})
 
// 올바른 패턴 — 모듈 스코프에서 한 번만 생성
const AppRuntime = ManagedRuntime.make(AppLayer) // ✅
app.get("/users", async (c) => {
  return c.json(await AppRuntime.runPromise(getAllUsers))
})

// 컴파일 오류 — function*에서 await는 문법 오류
const fetchUser = (id: string) =>
  Effect.gen(function* () {
    const user = await fetch(`/api/users/${id}`).then((r) => r.json()) // ❌ SyntaxError
    return user
  })
 
// 올바른 방법 — Promise를 Effect로 올리고 yield*로 실행
const fetchUser = (id: string) =>
  Effect.tryPromise({
    try: () => fetch(`/api/users/${id}`).then((r) => r.json()),
    catch: (e) => new FetchError(e),
  })

// 비동기 Effect에 runSync를 쓰면 런타임에 예외 발생
const result = Effect.runSync(someAsyncEffect) // ❌
 
// 호출 스택을 Effect로 점진 전환하거나, 경계를 명확히 정해 runPromise로 탈출
const result = await Effect.runPromise(someAsyncEffect) // ✅