feat: improve TRPC error propagation (#129)

Author: aimensahnoun

src/app/api/trpc/[trpc]/route.ts

@@ -1,9 +1,47 @@
 import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
+import { TRPC_ERROR_CODES_BY_KEY } from "@trpc/server/rpc";
 import type { NextRequest } from "next/server";
 
 import { appRouter } from "@/server/index";
 import { createTRPCContext } from "@/server/trpc";
 
+// Create automatic mapping from TRPC error codes to HTTP status codes
+const TRPC_TO_HTTP_STATUS = {
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_SUPPORTED: 405,
+  TIMEOUT: 408,
+  CONFLICT: 409,
+  PRECONDITION_FAILED: 412,
+  PAYLOAD_TOO_LARGE: 413,
+  UNPROCESSABLE_CONTENT: 422,
+  TOO_MANY_REQUESTS: 429,
+  CLIENT_CLOSED_REQUEST: 499,
+  INTERNAL_SERVER_ERROR: 500,
+} as const;
+
+function getHttpStatusFromTrpcError(errorCode: number | string): number {
+  if (typeof errorCode === "string" && errorCode in TRPC_TO_HTTP_STATUS) {
+    return TRPC_TO_HTTP_STATUS[errorCode as keyof typeof TRPC_TO_HTTP_STATUS];
+  }
+
+  if (typeof errorCode === "number") {
+    for (const [trpcCode, jsonRpcCode] of Object.entries(
+      TRPC_ERROR_CODES_BY_KEY,
+    )) {
+      if (jsonRpcCode === errorCode && trpcCode in TRPC_TO_HTTP_STATUS) {
+        return TRPC_TO_HTTP_STATUS[
+          trpcCode as keyof typeof TRPC_TO_HTTP_STATUS
+        ];
+      }
+    }
+  }
+
+  return 500;
+}
+
 /**
  * This wraps the `createTRPCContext` helper and provides the required context for the tRPC API when
  * handling a HTTP request (e.g. when you make requests from Client Components).
@@ -29,6 +67,15 @@ const handler = (req: NextRequest) =>
             );
           }
         : undefined,
+    responseMeta({ errors }) {
+      if (errors.length > 0) {
+        const firstError = errors[0];
+        const httpStatus = getHttpStatusFromTrpcError(firstError.code);
+        return { status: httpStatus };
+      }
+
+      return { status: 200 };
+    },
   });
 
 export { handler as GET, handler as POST };

src/lib/errors.ts

@@ -1,6 +1,78 @@
+import { TRPCError } from "@trpc/server";
+import type { TRPC_ERROR_CODE_KEY } from "@trpc/server/rpc";
+import { isAxiosError } from "axios";
+
 export class ResourceNotFoundError extends Error {
   constructor(message: string) {
     super(message);
     this.name = "ResourceNotFoundError";
   }
 }
+
+function mapStatusCodeToTRPCCode(statusCode: number): TRPC_ERROR_CODE_KEY {
+  if (statusCode >= 400 && statusCode < 500) {
+    switch (statusCode) {
+      case 400:
+        return "BAD_REQUEST";
+      case 401:
+        return "UNAUTHORIZED";
+      case 403:
+        return "FORBIDDEN";
+      case 404:
+        return "NOT_FOUND";
+      case 409:
+        return "CONFLICT";
+      case 422:
+        return "UNPROCESSABLE_CONTENT";
+      case 429:
+        return "TOO_MANY_REQUESTS";
+      default:
+        return "BAD_REQUEST";
+    }
+  }
+
+  return "INTERNAL_SERVER_ERROR";
+}
+
+export function toTRPCError(error: unknown): TRPCError {
+  if (error instanceof TRPCError) {
+    return error;
+  }
+
+  if (isAxiosError(error)) {
+    const statusCode = error.response?.status || 500;
+    const message = error.response?.data?.message || error.message;
+    const code = mapStatusCodeToTRPCCode(statusCode);
+    return new TRPCError({ code, message, cause: error });
+  }
+
+  if (error instanceof ResourceNotFoundError) {
+    return new TRPCError({
+      code: "NOT_FOUND",
+      message: error.message,
+      cause: error,
+    });
+  }
+
+  // Handle regular Error objects with custom status codes
+  if (error instanceof Error) {
+    const errorWithStatus = error as Error & {
+      status?: number;
+      statusCode?: number;
+    };
+    const statusCode = errorWithStatus.status || errorWithStatus.statusCode;
+
+    if (statusCode) {
+      const code = mapStatusCodeToTRPCCode(statusCode);
+      return new TRPCError({ code, message: error.message, cause: error });
+    }
+  }
+
+  const message =
+    error instanceof Error ? error.message : "Unknown error occurred";
+  return new TRPCError({
+    code: "INTERNAL_SERVER_ERROR",
+    message,
+    cause: error,
+  });
+}

src/server/routers/compliance.ts

@@ -1,6 +1,7 @@
 import { apiClient } from "@/lib/axios";
 import { PaymentDetailsStatus } from "@/lib/constants/bank-account";
 import { Gender } from "@/lib/constants/compliance";
+import { toTRPCError } from "@/lib/errors";
 import { bankAccountSchema } from "@/lib/schemas/bank-account";
 import { complianceFormSchema } from "@/lib/schemas/compliance";
 import { filterDefinedValues } from "@/lib/utils";
@@ -129,14 +130,7 @@ export const complianceRouter = router({
 
         return { success: true };
       } catch (error) {
-        console.error("Error updating agreement status:", error);
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message:
-            error instanceof Error
-              ? error.message
-              : "Failed to update agreement status",
-        });
+        throw toTRPCError(error);
       }
     }),
 
@@ -403,28 +397,7 @@ export const complianceRouter = router({
           throw error;
         }
 
-        // Map API client errors to appropriate error codes
-        if (error instanceof AxiosError) {
-          const status = error.response?.status;
-          // Map client errors (400, 422) to BAD_REQUEST
-          if (status === 400 || status === 422) {
-            throw new TRPCError({
-              code: "BAD_REQUEST",
-              message:
-                error.response?.data?.message ||
-                "Invalid payment details provided",
-            });
-          }
-        }
-
-        // Otherwise wrap it in a TRPCError
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message:
-            error instanceof Error
-              ? `Failed to allow payment details: ${error.message}`
-              : "Failed to allow payment details",
-        });
+        throw toTRPCError(error);
       }
     }),
 
@@ -496,13 +469,7 @@ export const complianceRouter = router({
         };
       } catch (error) {
         console.error("Error getting payment details:", error);
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message:
-            error instanceof Error
-              ? `Failed to retrieve payment details: ${error.message}`
-              : "Failed to retrieve payment details",
-        });
+        throw toTRPCError(error);
       }
     }),
 
@@ -563,13 +530,7 @@ export const complianceRouter = router({
           throw error;
         }
 
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message:
-            error instanceof Error
-              ? `Failed to retrieve payment details by ID: ${error.message}`
-              : "Failed to retrieve payment details by ID",
-        });
+        throw toTRPCError(error);
       }
     }),
 
@@ -602,13 +563,7 @@ export const complianceRouter = router({
         }
 
         console.error("Error finding user by email:", error);
-        throw new TRPCError({
-          code: "INTERNAL_SERVER_ERROR",
-          message:
-            error instanceof Error
-              ? `Failed to find user by email: ${error.message}`
-              : "Failed to find user by email",
-        });
+        throw toTRPCError(error);
       }
     }),
 });

src/server/routers/invoice-me.ts

@@ -1,3 +1,4 @@
+import { toTRPCError } from "@/lib/errors";
 import { TRPCError } from "@trpc/server";
 import { and, desc, eq } from "drizzle-orm";
 import { ulid } from "ulid";
@@ -14,19 +15,22 @@ export const invoiceMeRouter = router({
     )
     .mutation(async ({ ctx, input }) => {
       const { db, user } = ctx;
+      try {
+        if (!user) {
+          throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "You must be logged in to create an invoice me link",
+          });
+        }
 
-      if (!user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "You must be logged in to create an invoice me link",
+        await db.insert(invoiceMeTable).values({
+          id: ulid(),
+          label: input.label,
+          userId: user.id,
         });
+      } catch (error) {
+        throw toTRPCError(error);
       }
-
-      await db.insert(invoiceMeTable).values({
-        id: ulid(),
-        label: input.label,
-        userId: user.id,
-      });
     }),
   getAll: protectedProcedure.query(async ({ ctx }) => {
     const { db, user } = ctx;
@@ -37,55 +41,69 @@ export const invoiceMeRouter = router({
         message: "You must be logged in to get your invoice me links",
       });
     }
+    try {
+      const invoiceMeLinks = await db.query.invoiceMeTable.findMany({
+        where: eq(invoiceMeTable.userId, user.id),
+        orderBy: desc(invoiceMeTable.createdAt),
+      });
 
-    const invoiceMeLinks = await db.query.invoiceMeTable.findMany({
-      where: eq(invoiceMeTable.userId, user.id),
-      orderBy: desc(invoiceMeTable.createdAt),
-    });
-
-    return invoiceMeLinks;
+      return invoiceMeLinks;
+    } catch (error) {
+      throw toTRPCError(error);
+    }
   }),
   delete: protectedProcedure
     .input(z.string())
     .mutation(async ({ ctx, input }) => {
       const { db, user } = ctx;
 
-      if (!user) {
-        throw new TRPCError({
-          code: "UNAUTHORIZED",
-          message: "You must be logged in to delete an invoice me link",
-        });
-      }
+      try {
+        if (!user) {
+          throw new TRPCError({
+            code: "UNAUTHORIZED",
+            message: "You must be logged in to delete an invoice me link",
+          });
+        }
 
-      await db
-        .delete(invoiceMeTable)
-        .where(
-          and(eq(invoiceMeTable.id, input), eq(invoiceMeTable.userId, user.id)),
-        );
+        await db
+          .delete(invoiceMeTable)
+          .where(
+            and(
+              eq(invoiceMeTable.id, input),
+              eq(invoiceMeTable.userId, user.id),
+            ),
+          );
+      } catch (error) {
+        throw toTRPCError(error);
+      }
     }),
   getById: publicProcedure.input(z.string()).query(async ({ ctx, input }) => {
     const { db } = ctx;
 
-    const invoiceMeLink = await db.query.invoiceMeTable.findFirst({
-      where: eq(invoiceMeTable.id, input),
-      with: {
-        user: {
-          columns: {
-            name: true,
-            email: true,
-            id: true,
+    try {
+      const invoiceMeLink = await db.query.invoiceMeTable.findFirst({
+        where: eq(invoiceMeTable.id, input),
+        with: {
+          user: {
+            columns: {
+              name: true,
+              email: true,
+              id: true,
+            },
           },
         },
-      },
-    });
-
-    if (!invoiceMeLink) {
-      throw new TRPCError({
-        code: "NOT_FOUND",
-        message: "Invoice me link not found",
       });
-    }
 
-    return invoiceMeLink;
+      if (!invoiceMeLink) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Invoice me link not found",
+        });
+      }
+
+      return invoiceMeLink;
+    } catch (error) {
+      throw toTRPCError(error);
+    }
   }),
 });