[refactor] API 오류 정규화 및 인증 오류 처리 개선

src/app/app-download/page.tsx

@@ -32,7 +32,12 @@ export default function AppDownloadPage() {
             rel="noopener noreferrer"
             className="flex-1 flex items-center justify-center gap-4  rounded-xl bg-[#1D1D1F] hover:bg-black text-white py-3.5 px-4 transition-all duration-200 shadow-sm hover:shadow-md hover:-translate-y-0.5"
           >
-            <svg viewBox="0 0 384 512" className="w-5 h-5 fill-current" role="img" aria-label="Apple Logo">
+            <svg
+              viewBox="0 0 384 512"
+              className="w-5 h-5 fill-current"
+              role="img"
+              aria-label="Apple Logo"
+            >
               <path d="M318.7 268.7c-.2-36.7 16.4-64.4 50-84.8-18.8-26.9-47.2-41.7-84.7-44.6-35.5-2.8-74.3 20.7-88.5 20.7-15 0-49.4-19.7-76.4-19.7C63.3 141.2 4 184.8 4 273.5q0 39.3 14.4 81.2c12.8 36.7 59 126.7 107.2 125.2 25.2-.6 43-17.9 75.8-17.9 31.8 0 48.3 17.9 76.4 17.9 48.6-.7 90.4-82.5 102.6-119.3-65.2-30.7-61.7-90-61.7-91.9zm-56.6-164.2c27.3-32.4 24.8-61.9 24-72.5-24.1 1.4-52 16.4-67.9 34.9-17.5 19.8-27.8 44.3-25.6 71.9 26.1 2 49.9-11.4 69.5-34.3z" />
             </svg>
             <div className="flex flex-col items-start text-left">

src/entities/dashboard/api/getDashboardSummary.ts

@@ -1,12 +1,16 @@
-import { dashboardUrl, get } from "@/shared/api";
+import { dashboardUrl, get, normalizeApiError } from "@/shared/api";
 import type { BaseResponseType } from "@/shared/api/types";
 import type { DashboardSummaryDTO } from "../model/types";
 import { dashboardSummarySchema } from "./schemas";
 
 export async function getDashboardSummary(): Promise<DashboardSummaryDTO> {
-  const response = await get<BaseResponseType<unknown>>(
-    dashboardUrl.getSummary(),
-  );
+  try {
+    const response = await get<BaseResponseType<unknown>>(
+      dashboardUrl.getSummary(),
+    );
 
-  return dashboardSummarySchema.parse(response.data);
-}
+    return dashboardSummarySchema.parse(response.data);
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+}

src/entities/dashboard/api/index.ts

@@ -1,2 +1,2 @@
 export { getDashboardSummary } from "./getDashboardSummary";
-export { useGetDashboardSummary } from "./useGetDashboardSummary";
+export { useGetDashboardSummary } from "./useGetDashboardSummary";

src/entities/dashboard/api/schemas.ts

@@ -8,4 +8,4 @@ export const dashboardSummarySchema = z.object({
   totalMachines: z.number(),
   malfunctionMachines: z.number(),
   suspendedStudents: z.number(),
-});
+});

src/entities/dashboard/api/useGetDashboardSummary.ts

@@ -14,4 +14,4 @@ export const useGetDashboardSummary = ({
     queryFn: getDashboardSummary,
     enabled,
   });
-};
+};

src/entities/dashboard/index.ts

@@ -3,4 +3,4 @@ export { mapDashboard } from "./lib/mapDashboard";
 export type {
   DashboardItem,
   DashboardSummaryDTO,
-} from "./model/types";
+} from "./model/types";

src/entities/dashboard/model/types.ts

@@ -6,4 +6,4 @@ export type DashboardSummaryDTO = z.infer<typeof dashboardSummarySchema>;
 export interface DashboardItem {
   label: string;
   value: string;
-}
+}

src/entities/machine/api/deleteMachine.ts

@@ -0,0 +1,9 @@
+import { del, machineUrl, normalizeApiError } from "@/shared/api";
+
+export async function deleteMachine(id: number): Promise<void> {
+  try {
+    await del(machineUrl.deleteMachine(id));
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+}

src/entities/machine/api/getMachines.ts

@@ -1,4 +1,4 @@
-import { get, machineUrl } from "@/shared/api";
+import { get, machineUrl, normalizeApiError } from "@/shared/api";
 import type { BaseResponseType } from "@/shared/api/types";
 import { mapMachines } from "../lib/mapMachine";
 import type {
@@ -30,10 +30,14 @@ async function getMachinesByType(
 export async function getMachines(
   params?: MachineParamsType,
 ): Promise<MachineItem[]> {
-  const [washers, dryers] = await Promise.all([
-    getMachinesByType("WASHER", params),
-    getMachinesByType("DRYER", params),
-  ]);
+  try {
+    const [washers, dryers] = await Promise.all([
+      getMachinesByType("WASHER", params),
+      getMachinesByType("DRYER", params),
+    ]);
 
-  return [...washers, ...dryers];
-}
+    return [...washers, ...dryers];
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+}

src/entities/machine/api/schemas.ts

@@ -4,10 +4,7 @@ import { z } from "zod";
 export const machineTypeSchema = z.enum(["WASHER", "DRYER"]);
 
 // 기기 고장 상태
-export const machineConditionStatusSchema = z.enum([
-  "NORMAL",
-  "MALFUNCTION",
-]);
+export const machineConditionStatusSchema = z.enum(["NORMAL", "MALFUNCTION"]);
 
 // 기기 사용 가능 상태
 export const machineAvailabilityStatusSchema = z.enum([
@@ -39,4 +36,4 @@ export const machineResponseSchema = z.object({
   totalCount: z.number(),
   totalPages: z.number(),
   currentPage: z.number(),
-});
+});

src/entities/machine/api/updateMachineStatus.ts

@@ -0,0 +1,20 @@
+import { machineUrl, normalizeApiError, put } from "@/shared/api";
+import type { MachineConditionStatusDTO } from "../model/types";
+
+type UpdateMachineStatusParams = {
+  id: number;
+  status: MachineConditionStatusDTO;
+};
+
+export async function updateMachineStatus({
+  id,
+  status,
+}: UpdateMachineStatusParams): Promise<void> {
+  try {
+    await put(machineUrl.updateMachineStatus(id), {
+      status,
+    });
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+}

src/entities/machine/api/useDeleteMachine.ts

@@ -1,11 +1,12 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { del, machineQueryKeys, machineUrl } from "@/shared/api";
+import { machineQueryKeys } from "@/shared/api";
+import { deleteMachine } from "./deleteMachine";
 
 export const useDeleteMachine = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: (id: number) => del(machineUrl.deleteMachine(id)),
+    mutationFn: deleteMachine,
     onSuccess: () => {
       queryClient.invalidateQueries({
         queryKey: machineQueryKeys.all,

src/entities/machine/api/useGetMachines.ts

@@ -20,4 +20,4 @@ export const useGetMachines = (
     queryFn: () => fetchMachines(params),
     enabled: options?.enabled,
   });
-};
+};

src/entities/machine/api/useUpdateMachineStatus.ts

@@ -1,18 +1,12 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { machineQueryKeys, machineUrl, put } from "@/shared/api";
-import type { MachineConditionStatusDTO } from "../model/types";
+import { machineQueryKeys } from "@/shared/api";
+import { updateMachineStatus } from "./updateMachineStatus";
 
 export const useUpdateMachineStatus = () => {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: ({
-      id,
-      status,
-    }: {
-      id: number;
-      status: MachineConditionStatusDTO;
-    }) => put(machineUrl.updateMachineStatus(id), { status }),
+    mutationFn: updateMachineStatus,
     onSuccess: () => {
       queryClient.invalidateQueries({
         queryKey: machineQueryKeys.all,

src/entities/machine/model/types.ts

@@ -53,4 +53,4 @@ export type MachineResponseType = z.infer<typeof machineResponseSchema>;
 // 조회 파라미터
 export interface MachineParamsType {
   floor?: number;
-}
+}

src/entities/report/api/getMalfunctionReports.ts

@@ -1,25 +1,26 @@
-import { get, reportUrl } from "@/shared/api";
+import { get, normalizeApiError, reportUrl } from "@/shared/api";
 import type { BaseResponseType } from "@/shared/api/types";
-import type {
-  ReportParamsType,
-  ReportResponseType,
-} from "../model/types";
+import type { ReportParamsType, ReportResponseType } from "../model/types";
 import { reportResponseSchema } from "./schemas";
 
 export const getMalfunctionReports = async (
   params?: ReportParamsType,
 ): Promise<BaseResponseType<ReportResponseType>> => {
-  const response = await get<BaseResponseType<unknown>>(
-    reportUrl.getMalfunctionReports(),
-    {
-      params,
-    },
-  );
+  try {
+    const response = await get<BaseResponseType<unknown>>(
+      reportUrl.getMalfunctionReports(),
+      {
+        params,
+      },
+    );
 
-  const parsedData = reportResponseSchema.parse(response.data);
+    const parsedData = reportResponseSchema.parse(response.data);
 
-  return {
-    ...response,
-    data: parsedData,
-  };
-};
+    return {
+      ...response,
+      data: parsedData,
+    };
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+};

src/entities/report/api/schemas.ts

@@ -29,4 +29,4 @@ export const reportResponseSchema = z.object({
   totalCount: z.number(),
   totalPages: z.number(),
   currentPage: z.number(),
-});
+});

src/entities/report/api/updateReportStatus.ts

@@ -0,0 +1,24 @@
+import { normalizeApiError, put, reportUrl } from "@/shared/api";
+import type { BaseResponseType } from "@/shared/api/types";
+import type { ReportStatusType } from "../model/types";
+
+type UpdateReportStatusParams = {
+  id: number;
+  status: ReportStatusType;
+};
+
+export async function updateReportStatus({
+  id,
+  status,
+}: UpdateReportStatusParams): Promise<void> {
+  try {
+    await put<BaseResponseType<null>>(
+      reportUrl.updateMalfunctionReportStatus(id),
+      {
+        status,
+      },
+    );
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
+}

src/entities/report/api/useUpdateReportStatus.ts

@@ -1,25 +1,25 @@
 import { useMutation, useQueryClient } from "@tanstack/react-query";
-import { put, reportUrl, reportQueryKeys } from "@/shared/api";
-import type { BaseResponseType } from "@/shared/api/types";
-import type { ReportStatusType } from "../model/types";
+import { reportQueryKeys } from "@/shared/api";
+import { updateReportStatus } from "./updateReportStatus";
 
 export function useUpdateReportStatus() {
   const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async ({ id, status }: { id: number; status: ReportStatusType }) => {
-      await put<BaseResponseType<null>>(reportUrl.updateMalfunctionReportStatus(id), {
-        status,
-      });
-    },
+    mutationFn: updateReportStatus,
     onSuccess: () => {
       queryClient.invalidateQueries({
         queryKey: reportQueryKeys.all,
       });
+
       alert("신고 상태가 변경되었습니다.");
     },
-    onError: () => {
-      alert("신고 상태 변경 중 오류가 발생했습니다.");
+    onError: (error) => {
+      alert(
+        error instanceof Error
+          ? error.message
+          : "신고 상태 변경 중 오류가 발생했습니다.",
+      );
     },
   });
 }

src/entities/report/model/types.ts

@@ -15,4 +15,4 @@ export type ReportResponseType = z.infer<typeof reportResponseSchema>;
 // 고장 신고 목록 조회 요청 파라미터
 export interface ReportParamsType {
   status?: ReportStatusType;
-}
+}

src/entities/reservation/api/deleteReservation.ts

@@ -1,5 +1,9 @@
-import { del, reservationUrl } from "@/shared/api";
+import { del, normalizeApiError, reservationUrl } from "@/shared/api";
 
-export async function deleteReservation(id: number) {
-  await del(reservationUrl.deleteReservation(id));
+export async function deleteReservation(id: number): Promise<void> {
+  try {
+    await del(reservationUrl.deleteReservation(id));
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
 }

src/entities/reservation/api/getMachineReservationHistory.ts

@@ -1,24 +1,33 @@
-import { get, reservationUrl } from "@/shared/api";
+import { get, normalizeApiError, reservationUrl } from "@/shared/api";
 import type { BaseResponseType } from "@/shared/api/types";
 import { mapMachineReservationHistory } from "../lib/mapReservationHistory";
 import type {
   MachineReservationHistory,
   MachineReservationHistoryParamsType,
-  MachineReservationHistoryResponseType,
 } from "../model/historyTypes";
+import { machineReservationHistoryResponseSchema } from "./schemas";
 
 export async function getMachineReservationHistory(
   params?: MachineReservationHistoryParamsType,
 ): Promise<MachineReservationHistory | null> {
-  const response = await get<
-    BaseResponseType<MachineReservationHistoryResponseType>
-  >(reservationUrl.getMachineReservationHistory(), {
-    params,
-  });
+  try {
+    const response = await get<BaseResponseType<unknown>>(
+      reservationUrl.getMachineReservationHistory(),
+      {
+        params,
+      },
+    );
 
-  const machine = response.data.machines[0];
+    const parsedData = machineReservationHistoryResponseSchema.parse(
+      response.data,
+    );
 
-  if (!machine) return null;
+    const machine = parsedData.machines[0];
 
-  return mapMachineReservationHistory(machine);
+    if (!machine) return null;
+
+    return mapMachineReservationHistory(machine);
+  } catch (error) {
+    throw normalizeApiError(error);
+  }
 }