Handle expected Prisma API errors quietly

Co-authored-by: Neil Raina <makeitraina@users.noreply.github.com>

Author: cursoragent

src/app/api/core/utils/withErrorHandler.ts

@@ -7,6 +7,77 @@ import { ZodError, ZodFormattedError } from 'zod'
 
 export type RequestHandler = (req: NextRequest, params: any) => Promise<NextResponse>
 
+type ErrorResponse = {
+  status: number
+  message: string | ZodFormattedError<string>
+  errors?: unknown[]
+  shouldLog: boolean
+}
+
+const getZodErrorMessage = (error: ZodError) => {
+  const flattened = error.flatten()
+  const allMessages = [...flattened.formErrors, ...Object.values(flattened.fieldErrors).flat()].filter(Boolean)
+
+  return allMessages[0] || (error.format() as ZodFormattedError<string>)
+}
+
+const shouldLogStatus = (status: number) => status >= httpStatus.INTERNAL_SERVER_ERROR
+
+const getPrismaErrorResponse = (error: PrismaClientKnownRequestError): ErrorResponse => {
+  if (error.code === 'P2025' || error.code === 'P2023') {
+    return {
+      status: httpStatus.NOT_FOUND,
+      message: 'The requested resource was not found',
+      shouldLog: false,
+    }
+  }
+
+  return {
+    status: httpStatus.BAD_REQUEST,
+    message: 'Something went wrong',
+    shouldLog: true,
+  }
+}
+
+const getErrorResponse = (error: unknown): ErrorResponse => {
+  if (error instanceof ZodError) {
+    return {
+      status: httpStatus.UNPROCESSABLE_ENTITY,
+      message: getZodErrorMessage(error),
+      shouldLog: false,
+    }
+  }
+
+  if (error instanceof CopilotApiError) {
+    const status = error.status || httpStatus.BAD_REQUEST
+
+    return {
+      status,
+      message: error.body.message || 'Something went wrong',
+      shouldLog: shouldLogStatus(status),
+    }
+  }
+
+  if (error instanceof APIError) {
+    return {
+      status: error.status,
+      message: error.message || 'Something went wrong',
+      errors: error.errors,
+      shouldLog: shouldLogStatus(error.status),
+    }
+  }
+
+  if (error instanceof PrismaClientKnownRequestError) {
+    return getPrismaErrorResponse(error)
+  }
+
+  return {
+    status: (error as StatusableError).status || httpStatus.BAD_REQUEST,
+    message: (error as MessagableError).body?.message || 'Something went wrong',
+    shouldLog: true,
+  }
+}
+
 /**
  * Reusable utility that wraps a given request handler with a global error handler to standardize response structure
  * in case of failures. Catches exceptions thrown from the handler, and returns a formatted error response.
@@ -27,42 +98,13 @@ export type RequestHandler = (req: NextRequest, params: any) => Promise<NextResp
  */
 export const withErrorHandler = (handler: RequestHandler): RequestHandler => {
   return async (req: NextRequest, params: any) => {
-    // Execute the handler wrapped in a try... catch block
     try {
       return await handler(req, params)
     } catch (error: unknown) {
-      // Format error in a readable way
+      const { status, message, errors, shouldLog } = getErrorResponse(error)
 
-      let formattedError = error
-      if (error instanceof ZodError) {
-        formattedError = error.format() as ZodFormattedError<string>
-      }
-      console.error(formattedError)
-
-      // Default staus and message for JSON error response
-      let status: number = (error as StatusableError).status || httpStatus.BAD_REQUEST
-      let message: string | ZodFormattedError<string> = (error as MessagableError).body?.message || 'Something went wrong'
-      let errors: unknown[] | undefined = undefined
-
-      // Build a proper response based on the type of Error encountered
-      if (error instanceof ZodError) {
-        status = httpStatus.UNPROCESSABLE_ENTITY
-        const flattened = error.flatten()
-        const allMessages = [...flattened.formErrors, ...Object.values(flattened.fieldErrors).flat()].filter(Boolean)
-        message = allMessages[0] || (formattedError as ZodFormattedError<string>)
-      } else if (error instanceof CopilotApiError) {
-        status = error.status || status
-        message = error.body.message || message
-      } else if (error instanceof APIError) {
-        status = error.status
-        message = error.message || message
-        errors = error.errors
-      } else if (error instanceof PrismaClientKnownRequestError) {
-        if (error.code === 'P2025') {
-          // Code for NOT FOUND in Prisma
-          status = httpStatus.NOT_FOUND
-          message = 'The requested resource was not found'
-        }
+      if (shouldLog) {
+        console.error(error instanceof ZodError ? error.format() : error)
       }
 
       return NextResponse.json({ error: message, errors }, { status })

src/app/api/tests/utils/withErrorHandler.test.ts

@@ -5,6 +5,7 @@ import APIError from '@api/core/exceptions/api'
 import { NextRequest, NextResponse } from 'next/server'
 import { withErrorHandler } from '@api/core/utils/withErrorHandler'
 import { CopilotApiError } from '@/types/CopilotApiError'
+import { PrismaClientKnownRequestError } from '@prisma/client/runtime/library'
 import { z } from 'zod'
 
 jest.mock('@/utils/CopilotAPI', () => ({
@@ -13,10 +14,21 @@ jest.mock('@/utils/CopilotAPI', () => ({
 
 describe('withErrorHandler util', () => {
   let req: NextRequest
+  const buildPrismaError = (code: string) =>
+    new PrismaClientKnownRequestError('Prisma known request error', {
+      code,
+      clientVersion: 'test',
+      meta: {},
+    })
 
   beforeEach(() => {
     jest.clearAllMocks()
     req = buildNextRequest(`/?token=iu-token`)
+    jest.spyOn(console, 'error').mockImplementation(() => undefined)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
   })
 
   it('catches and builds proper response for APIError', async () => {
@@ -28,6 +40,7 @@ describe('withErrorHandler util', () => {
     const response = await nextResponse.json()
     expect(response.error).toBe('Please provide a valid token')
     expect(nextResponse.status).toBe(httpStatus.UNAUTHORIZED)
+    expect(console.error).not.toHaveBeenCalled()
   })
 
   it('catches and builds proper response for ZodError', async () => {
@@ -38,9 +51,9 @@ describe('withErrorHandler util', () => {
 
     const nextResponse = await withErrorHandler(handler)(req, null)
     const response = await nextResponse.json()
-    expect(response.error[0].expected).toBe('string')
-    expect(response.error[0].received).toBe('number')
+    expect(response.error).toBe('Expected string, received number')
     expect(nextResponse.status).toBe(httpStatus.UNPROCESSABLE_ENTITY)
+    expect(console.error).not.toHaveBeenCalled()
   })
 
   it('catches and builds proper response for CopilotApiError', async () => {
@@ -52,6 +65,57 @@ describe('withErrorHandler util', () => {
     const response = await nextResponse.json()
     expect(response.error).toBe('Please provide a valid token')
     expect(nextResponse.status).toBe(httpStatus.UNAUTHORIZED)
+    expect(console.error).not.toHaveBeenCalled()
+  })
+
+  it('catches and builds proper response for Prisma not found errors without logging', async () => {
+    const handler = async (_req: NextRequest, _params: any) => {
+      throw buildPrismaError('P2025')
+    }
+
+    const nextResponse = await withErrorHandler(handler)(req, null)
+    const response = await nextResponse.json()
+    expect(response.error).toBe('The requested resource was not found')
+    expect(nextResponse.status).toBe(httpStatus.NOT_FOUND)
+    expect(console.error).not.toHaveBeenCalled()
+  })
+
+  it('catches and builds proper response for invalid Prisma UUID errors without logging', async () => {
+    const handler = async (_req: NextRequest, _params: any) => {
+      throw buildPrismaError('P2023')
+    }
+
+    const nextResponse = await withErrorHandler(handler)(req, null)
+    const response = await nextResponse.json()
+    expect(response.error).toBe('The requested resource was not found')
+    expect(nextResponse.status).toBe(httpStatus.NOT_FOUND)
+    expect(console.error).not.toHaveBeenCalled()
+  })
+
+  it('logs unclassified Prisma known request errors', async () => {
+    const error = buildPrismaError('P2002')
+    const handler = async (_req: NextRequest, _params: any) => {
+      throw error
+    }
+
+    const nextResponse = await withErrorHandler(handler)(req, null)
+    const response = await nextResponse.json()
+    expect(response.error).toBe('Something went wrong')
+    expect(nextResponse.status).toBe(httpStatus.BAD_REQUEST)
+    expect(console.error).toHaveBeenCalledWith(error)
+  })
+
+  it('logs unexpected errors', async () => {
+    const error = new Error('boom')
+    const handler = async (_req: NextRequest, _params: any) => {
+      throw error
+    }
+
+    const nextResponse = await withErrorHandler(handler)(req, null)
+    const response = await nextResponse.json()
+    expect(response.error).toBe('Something went wrong')
+    expect(nextResponse.status).toBe(httpStatus.BAD_REQUEST)
+    expect(console.error).toHaveBeenCalledWith(error)
   })
 
   it('returns proper response if no errors are encountered', async () => {