try-catch 없이 실패를 타입으로 선언하면 서비스 테스트가 달라집니다

// Promise — 뭘 던질지 시그니처로 알 수 없음
async function findUser(id: string): Promise<User> { ... }
 
// Effect — 실패와 의존성이 시그니처에 선언됨
const findUser = (id: string): Effect.Effect<User, UserNotFound | DbError, Database> => ...

import { Data, Effect } from "effect";
 
class UserNotFound extends Data.TaggedError("UserNotFound")<{
  id: string;
}> {}
 
class DbError extends Data.TaggedError("DbError")<{
  cause: unknown;
}> {}

const program = Effect.gen(function* () {
  const user = yield* findUser("123");
  // E 채널: UserNotFound | DbError 자동 합성됨
  return user;
}).pipe(
  // UserNotFound만 로컬 처리 → E 채널에서 제거됨
  Effect.catchTag("UserNotFound", (e) =>
    Effect.succeed({ id: e.id, name: "Guest" })
  )
  // DbError는 E 채널에 남아 있음 → 호출자가 처리해야 함
);
// 타입: Effect<User, DbError, Database>

import { Context, Effect, Layer } from "effect";
 
interface DatabaseService {
  query: (sql: string, params: unknown[]) => Effect.Effect<unknown[], DbError>;
}
 
// "Database"는 런타임 식별자, DatabaseService는 정적 타입
const Database = Context.GenericTag<DatabaseService>("Database");
 
const DatabaseLive = Layer.succeed(Database, {
  query: (sql, params) =>
    Effect.tryPromise({
      try: () => pool.query(sql, params).then((r) => r.rows),
      catch: (e) => new DbError({ cause: e }),
    }),
});

// user.service.ts
import { Effect } from "effect";
 
// 실제 프로젝트에서는 Effect Schema나 Zod로 검증하는 것을 권장합니다
const parseUser = (row: unknown): User => {
  const r = row as Record<string, unknown>;
  return {
    id: r["id"] as string,
    name: r["name"] as string,
    email: r["email"] as string,
  };
};
 
@Injectable()
export class UserService {
  findOne(id: string): Effect.Effect<User, UserNotFound | DbError, Database> {
    return Effect.gen(function* () {
      const db = yield* Database;
      // db.query가 DbError를 E 채널에 갖고 있으므로 yield*로 자동 전파됩니다
      const rows = yield* db.query(`SELECT * FROM users WHERE id = $1`, [id]);
 
      if (rows.length === 0) {
        return yield* new UserNotFound({ id });
      }
 
      return parseUser(rows[0]);
    });
  }
}

// effect.interceptor.ts — 글로벌 인터셉터
import { Injectable, NestInterceptor, ExecutionContext, CallHandler } from "@nestjs/common";
import { Effect } from "effect";
import { Observable, from, of, switchMap } from "rxjs";
 
@Injectable()
export class EffectInterceptor implements NestInterceptor {
  intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
    return next.handle().pipe(
      switchMap((value) => {
        if (Effect.isEffect(value)) {
          return from(
            Effect.runPromise(
              value.pipe(Effect.provide(DatabaseLive))
            )
          );
        }
        return of(value);
      })
    );
  }
}

// user.service.spec.ts
import { Effect, Exit, Cause, Layer } from "effect";
 
const TestDatabase = Layer.succeed(Database, {
  query: (_sql, _params) =>
    Effect.succeed([{ id: "123", name: "Alice", email: "alice@example.com" }]),
});
 
describe("UserService.findOne", () => {
  it("유저가 존재하면 User를 반환한다", async () => {
    const result = await Effect.runPromise(
      userService.findOne("123").pipe(Effect.provide(TestDatabase))
    );
 
    expect(result.name).toBe("Alice");
  });
 
  it("유저가 없으면 UserNotFound 에러가 발생한다", async () => {
    const EmptyDatabase = Layer.succeed(Database, {
      query: () => Effect.succeed([]),
    });
 
    // runPromiseExit: 성공/실패 모두 Exit<A, E>로 반환 (reject 없음)
    const exit = await Effect.runPromiseExit(
      userService.findOne("999").pipe(Effect.provide(EmptyDatabase))
    );
 
    expect(Exit.isFailure(exit)).toBe(true);
    if (Exit.isFailure(exit) && Cause.isFail(exit.cause)) {
      expect(exit.cause.error).toBeInstanceOf(UserNotFound);
      expect((exit.cause.error as UserNotFound).id).toBe("999");
    }
  });
});

// user.handler.ts (Hono)
import { Effect } from "effect";
 
app.get("/users/:id", async (c) => {
  const handler = Effect.gen(function* () {
    const user = yield* userService.findOne(c.req.param("id"));
    return c.json(user);
  }).pipe(
    // E: UserNotFound | DbError → DbError
    Effect.catchTag("UserNotFound", (e) =>
      Effect.succeed(c.json({ error: `User ${e.id} not found` }, 404))
    ),
    // E: DbError → never
    Effect.catchTag("DbError", (e) => {
      console.error(e.cause);
      return Effect.succeed(c.json({ error: "Internal server error" }, 500));
    }),
    // R: Database → never (runPromise 컴파일 조건 충족)
    Effect.provide(DatabaseLive)
  );
 
  return Effect.runPromise(handler);
});

import { Effect, Schedule, Data } from "effect";
 
class RateLimitError extends Data.TaggedError("RateLimitError")<{}> {}
class ModelUnavailableError extends Data.TaggedError("ModelUnavailableError")<{}> {}
 
// RateLimitError에 한해서만 재시도하는 스케줄
const rateLimitSchedule = Schedule.exponential("1 second").pipe(
  Schedule.intersect(Schedule.recurs(3)),
  Schedule.whileInput(
    (e: RateLimitError | ModelUnavailableError) => e._tag === "RateLimitError"
  )
);
 
const callLLM = (prompt: string) =>
  Effect.gen(function* () {
    // ... gpt-4o 호출
  }).pipe(
    // RateLimit은 지수 백오프로 최대 3회 재시도
    // ModelUnavailableError는 스케줄 조건 불충족 → 아래 catchTag로 전달
    Effect.retry(rateLimitSchedule),
    // ModelUnavailable이면 fallback 모델로
    Effect.catchTag("ModelUnavailableError", () => callFallbackLLM(prompt))
  );