// UserError: 사용자 관련 에러 (예: 사용자 없음, 권한 부족)
export class UserError extends Error {
  constructor(
    message: string = "사용자 관련 에러가 발생했습니다.",
    public code: string = "USER_ERROR",
    public status: number = 400,
    public details?: Record<string, any>, // 추가적인 에러 세부 정보 (선택적)
  ) {
    super(message);
    this.name = "UserError";
  }
}
 
// DatabaseError: 데이터베이스 관련 에러 (예: 쿼리 실패, 연결 끊김)
export class DatabaseError extends Error {
  constructor(
    message: string = "데이터베이스 에러가 발생했습니다.",
    public code: string = "DB_ERROR",
    public status: number = 500,
    public query?: string, // 실패한 쿼리 (선택적)
  ) {
    super(message);
    this.name = "DatabaseError";
  }
}
 
// LogError: 로깅 시스템 관련 에러 (예: 로그 기록 실패)
export class LogError extends Error {
  constructor(
    message: string = "로깅 에러가 발생했습니다.",
    public code: string = "LOG_ERROR",
    public status: number = 500,
    public logData?: any, // 기록하려던 로그 데이터 (선택적)
  ) {
    super(message);
    this.name = "LogError";
  }
}

export const getUser = async (id: string) => {
  try {
    const user = await db.findById(id);
    if (!user) {
      throw new NotFoundError("USER_NOT_FOUND");
    }
    return user;
  } catch (error) {
    throw error; // 에러를 상위로 전달
  }
};
 
// Route Handler
export const GET = async (request: NextRequest) => {
  try {
    const userId = request.query.id;
    const user = await getUser(userId);
 
    return NextResponse.json({ ok: true, data: user });
  } catch (error) {
    logService.error(error);
 
    if (error instanceof NotFoundError) {
      return NextResponse.json({ ok: false, status: 404, code: error.code });
    }
 
    return NextResponse.json({
      ok: false,
      status: 500,
      code: "INTERNAL_SERVER_ERROR",
    });
  }
};
 
// Server Action
export const getDataById = () => {
  try {
    const userId = request.query.id;
    const user = await getUser(userId);
 
    return { ok: true, data: user };
  } catch (error) {
    logService.error(error);
 
    if (error instanceof DatabaseError) {
      return { ok: false, error };
    }
 
    if (error instanceof LoggingError) {
      return { ok: false, error };
    }
 
    // ...
  }
};

"use client";
 
import React, { useState } from "react";
 
const ProblematicComponent = () => {
  throw new Error("의도적인 렌더링 에러");
 
  return <div>렌더링되지 않음</div>;
};
 
const ComponentWithError = () => {
  return (
    <ErrorBoundary>
      <ProblematicComponent />
    </ErrorBoundary>
  );
};

"use client";
 
import { useState, useEffect } from "react";
import { useRouter } from "next/navigation";
 
const UserDashboard = () => {
  const [errorMessage, setErrorMessage] = useState<string | null>(null);
  const router = useRouter();
 
  useEffect(() => {
    const fetchUserData = async () => {
      try {
        const response = await fetch("/api/user");
        const data = await response.json();
 
        if (!response.ok) {
          throw {
            message: data.message || "알 수 없는 에러",
            code: data.code,
            status: response.status,
          };
        }
      } catch (error: any) {
        switch (error.code) {
          case "USER_NOT_FOUND":
            setErrorMessage("사용자를 찾을 수 없습니다.");
            router.push("/login");
            break;
          case "FORBIDDEN":
            setErrorMessage("접근 권한이 없습니다.");
            break;
          default:
            setErrorMessage("서버 에러가 발생했습니다. 다시 시도해주세요.");
        }
      }
    };
 
    fetchUserData();
  }, [router]);
 
  return (
    <div>
      {errorMessage ? (
        <div className="alert">{errorMessage}</div>
      ) : (
        <h1>사용자 대시보드</h1>
      )}
    </div>
  );
};

export const ERROR_CODES = {
  USER_NOT_FOUND: "USER_NOT_FOUND",
  FORBIDDEN: "FORBIDDEN",
  INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR",
} as const;
 
export const ERROR_MESSAGES = {
  [ERROR_CODES.USER_NOT_FOUND]: "사용자를 찾을 수 없습니다.",
  [ERROR_CODES.FORBIDDEN]: "접근 권한이 없습니다.",
  [ERROR_CODES.INTERNAL_SERVER_ERROR]: "서버에서 에러가 발생했습니다.",
};

if (!user) {
  return NextResponse.json({
    ok: false,
    status: 404,
    code: ERROR_CODES.USER_NOT_FOUND,
    message: ERROR_MESSAGES[ERROR_CODES.USER_NOT_FOUND],
  });
}

if (error.code === ERROR_CODES.USER_NOT_FOUND) {
  router.push("/login");
} else if (error.code === ERROR_CODES.FORBIDDEN) {
  alert("접근 권한이 없습니다.");
} else {
  alert("서버에서 에러가 발생했습니다.");
}

import { describe, it, expect, vi } from "vitest";
import { GET } from "./route";
import { NextRequest } from "next/server";
 
describe("GET /api/user", () => {
  it("should return 404 when user not found", async () => {
    const request = new NextRequest("http://localhost:3000/api/user?id=1");
    vi.mock("./db", () => ({ findById: vi.fn().mockResolvedValue(null) }));
    const response = await GET(request);
    expect(response.status).toBe(404);
    expect(await response.json()).toEqual({
      ok: false,
      status: 404,
      code: "USER_NOT_FOUND",
    });
  });
 
  it("should return 500 when internal server error", async () => {
    const request = new NextRequest("http://localhost:3000/api/user?id=1");
    vi.mock("./db", () => ({
      findById: vi.fn().mockRejectedValue(new Error("DB Error")),
    }));
    const response = await GET(request);
    expect(response.status).toBe(500);
    expect(await response.json()).toEqual({
      ok: false,
      status: 500,
      code: "INTERNAL_SERVER_ERROR",
    });
  });
});

import { describe, it, expect } from "vitest";
import { render, screen } from "@testing-library/react";
import { ErrorBoundary } from "./ErrorBoundary";
import { ProblematicComponent } from "./ProblematicComponent";
 
describe("ErrorBoundary", () => {
  it("should render fallback UI when error occurs", () => {
    const ProblematicComponent = () => {
      throw new Error("Test Error");
    };
    render(
      <ErrorBoundary>
        <ProblematicComponent />
      </ErrorBoundary>,
    );
    expect(screen.getByText("에러가 발생했습니다.")).toBeInTheDocument();
  });
});