Route Handlers vs tRPC: 타입 안전한 API를 만드는 두 가지 방법

return (await response.json()) as { review: string; message: string };

// app/api/generate-review/route.ts
export async function POST(request: NextRequest) {
  // request.json()의 반환 타입은 any — 여기서도 사실상 타입 단언과 같은 문제가 있음
  const payload: ReviewPayload = await request.json();
 
  if (!payload.placeName || !payload.placeUrl) {
    return NextResponse.json(
      { error: '필수 필드가 누락되었습니다.' },
      { status: 400 }
    );
  }
 
  const review = await generateReview(payload);
  return NextResponse.json({ review, message: '생성 완료' });
}

export const generateReview = async (
  payload: ReviewPayload
): Promise<{ review: string; message: string }> => {
  const response = await fetch('/api/generate-review', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
 
  if (!response.ok) {
    const errorData = await response.json().catch(() => ({}));
    throw new Error(errorData.error || '리뷰 생성에 실패했습니다.');
  }
 
  // ⚠️ 서버가 실제로 이 구조를 반환하는지 검증할 방법이 없음
  return (await response.json()) as { review: string; message: string };
};

// 서버 (src/server/routers/review.ts)
export const reviewRouter = router({
  generate: publicProcedure
    .input(reviewPayloadSchema)
    .mutation(async ({ input }) => {
      const review = await generateReview(input);
      return { review, message: '생성 완료' };
    }),
});

// 클라이언트
import type { AppRouter } from '@/server/routers/_app';
 
const { mutate } = trpc.review.generate.useMutation();
 
mutate(
  { placeName: '서울 맛집', placeUrl: 'https://...' },
  {
    onSuccess: (data) => {
      // data: { review: string; message: string } — 자동 추론
      console.log(data.review);
    },
  }
);

// Zod 스키마 하나로 해결
const reviewPayloadSchema = z.object({
  placeName: z.string().min(1, '장소명을 입력해주세요'),
  placeUrl: z.string().url('올바른 URL을 입력해주세요'),
  userDraft: z.string().optional(),
});
 
// 스키마에서 타입 추출
type ReviewPayload = z.infer<typeof reviewPayloadSchema>;
// → { placeName: string; placeUrl: string; userDraft?: string }
 
// tRPC 프로시저에서 사용하면
publicProcedure
  .input(reviewPayloadSchema)  // 런타임 검증 + 타입 추론
  .mutation(async ({ input }) => {
    // input: ReviewPayload — 자동 추론됨
  })

// 관리자 전용 프로시저
const adminProcedure = publicProcedure.use(({ ctx, next }) => {
  if (!ctx.user?.isAdmin) {
    throw new TRPCError({ code: 'UNAUTHORIZED' });
  }
  return next({ ctx: { ...ctx, user: ctx.user } });
});
 
// 이 라우터의 모든 프로시저는 관리자만 실행 가능
export const adminRouter = router({
  getWhitelist: adminProcedure.query(async () => {
    return await db.whitelist.findMany();
  }),
  deleteUser: adminProcedure
    .input(z.object({ userId: z.string() }))
    .mutation(async ({ input }) => {
      return await db.user.delete({ where: { id: input.userId } });
    }),
});

// 공용 스키마 정의 (src/shared/schemas/review.ts)
export const reviewPayloadSchema = z.object({
  placeName: z.string().min(1),
  placeUrl: z.string().url(),
  userDraft: z.string().optional(),
});
 
export const reviewResponseSchema = z.object({
  review: z.string(),
  message: z.string(),
});
 
export type ReviewPayload = z.infer<typeof reviewPayloadSchema>;
export type ReviewResponse = z.infer<typeof reviewResponseSchema>;

// 서버 — Zod로 입력 검증
export async function POST(request: NextRequest) {
  const body = await request.json();
  const result = reviewPayloadSchema.safeParse(body);
 
  if (!result.success) {
    return NextResponse.json({ error: result.error.message }, { status: 400 });
  }
 
  const review = await generateReview(result.data);
  return NextResponse.json({ review, message: '생성 완료' });
}

// 클라이언트 — as 대신 런타임 검증
import { reviewResponseSchema } from '@/shared/schemas/review';
import type { ReviewPayload, ReviewResponse } from '@/shared/schemas/review';
 
export const generateReview = async (
  payload: ReviewPayload
): Promise<ReviewResponse> => {
  const response = await fetch('/api/generate-review', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(payload),
  });
 
  if (!response.ok) {
    const errorData = await response.json().catch(() => ({}));
    throw new Error(errorData.error || '리뷰 생성에 실패했습니다.');
  }
 
  const data = await response.json();
  return reviewResponseSchema.parse(data); // as 대신 런타임 검증
};