Refactored Error Handleing. Modified Country API using new error hand…

src/AppError.ts

@@ -0,0 +1,71 @@
+export class AppError extends Error {
+  public readonly name: string
+  public readonly httpCode: number
+  public readonly isOperational: boolean
+  public readonly details?: Record<string, any>
+
+  constructor(
+    name: string = AppErrorTypes.INTERNAL_SERVER_ERROR,
+    message: string = AppErrorDetails[AppErrorTypes.INTERNAL_SERVER_ERROR]
+      .message,
+    httpCode: number = AppErrorDetails[AppErrorTypes.INTERNAL_SERVER_ERROR]
+      .httpCode,
+    isOperational = true,
+    details?: Record<string, any>
+  ) {
+    super(message)
+    Object.setPrototypeOf(this, new.target.prototype)
+    this.name = name
+    this.httpCode = httpCode
+    this.isOperational = isOperational
+    this.details = details
+    Error.captureStackTrace(this)
+  }
+}
+
+export function createAppError(
+  errorType: AppErrorTypes,
+  details?: Record<string, any>
+): AppError {
+  const { message, httpCode } = AppErrorDetails[errorType]
+  return new AppError(errorType, message, httpCode, true, details)
+}
+
+export enum AppErrorTypes {
+  NOT_FOUND_ERROR = 'NOT_FOUND_ERROR',
+  MULTIPLE_RECORDS_FOUND_ERROR = 'MULTIPLE_RECORDS_FOUND_ERROR',
+  VALIDATION_ERROR = 'VALIDATION_ERROR',
+  AUTHENTICATION_ERROR = 'AUTHENTICATION_ERROR',
+  PERMISSION_DENIED_ERROR = 'PERMISSION_DENIED_ERROR',
+  INTERNAL_SERVER_ERROR = 'INTERNAL_SERVER_ERROR'
+}
+
+const AppErrorDetails: Record<
+  AppErrorTypes,
+  { message: string; httpCode: number }
+> = {
+  [AppErrorTypes.VALIDATION_ERROR]: {
+    message: 'Invalid input data',
+    httpCode: 400
+  },
+  [AppErrorTypes.AUTHENTICATION_ERROR]: {
+    message: 'Authentication failed',
+    httpCode: 401
+  },
+  [AppErrorTypes.NOT_FOUND_ERROR]: {
+    message: 'Resource not found',
+    httpCode: 404
+  },
+  [AppErrorTypes.INTERNAL_SERVER_ERROR]: {
+    message: 'An internal server error occurred',
+    httpCode: 500
+  },
+  [AppErrorTypes.PERMISSION_DENIED_ERROR]: {
+    message: 'Insufficient permission for this action',
+    httpCode: 403
+  },
+  [AppErrorTypes.MULTIPLE_RECORDS_FOUND_ERROR]: {
+    message: 'Multple records has been found',
+    httpCode: 400
+  }
+}

src/ErrorHandler.ts

@@ -0,0 +1,30 @@
+import { type Response } from 'express'
+import { AppError } from './AppError'
+
+class ErrorHandler {
+  public async handleError(error: Error, response: Response): Promise<void> {
+    console.error(error)
+    await this.sendErrorResponse(error, response)
+  }
+
+  private async sendErrorResponse(
+    error: Error,
+    response: Response
+  ): Promise<void> {
+    if (error instanceof AppError) {
+      response.status(error.httpCode).json({
+        status: false,
+        message: error.message,
+        data: null
+      })
+    } else {
+      response.status(500).json({
+        status: false,
+        message: 'Something went wrong. Please contact administrator.',
+        data: null
+      })
+    }
+  }
+}
+
+export const errorHandler = new ErrorHandler()

src/app.ts

@@ -1,7 +1,7 @@
 import bodyParser from 'body-parser'
 import cookieParser from 'cookie-parser'
 import cors from 'cors'
-import type { Express } from 'express'
+import type { Express, NextFunction, Request, Response } from 'express'
 import express from 'express'
 import fs from 'fs'
 import passport from 'passport'
@@ -18,6 +18,7 @@ import mentorRouter from './routes/mentor/mentor.route'
 import profileRouter from './routes/profile/profile.route'
 import path from 'path'
 import countryRouter from './routes/country/country.route'
+import { errorHandler } from './ErrorHandler'
 
 const app = express()
 const staticFolder = 'uploads'
@@ -48,6 +49,10 @@ app.use('/api/categories', categoryRouter)
 app.use('/api/emails', emailRouter)
 app.use('/api/countries', countryRouter)
 
+app.use(async (err: Error, req: Request, res: Response, next: NextFunction) => {
+  await errorHandler.handleError(err, res)
+})
+
 if (!fs.existsSync(staticFolder)) {
   fs.mkdirSync(staticFolder, { recursive: true })
   console.log('Directory created successfully!')

src/controllers/country.controller.ts

@@ -1,25 +1,20 @@
 import type { Request, Response } from 'express'
 import type { ApiResponse } from '../types'
 import type Country from '../entities/country.entity'
-import { getAllCountries } from '../services/country.service'
+import { getAllCountries, getCountryById } from '../services/country.service'
 
 export const getCountries = async (
   req: Request,
   res: Response
 ): Promise<ApiResponse<Country[]>> => {
-  try {
-    const data = await getAllCountries()
-    if (!data) {
-      return res.status(404).json({ message: 'Countries Not Found' })
-    }
-    return res.status(200).json({ data, message: 'Countries Found' })
-  } catch (err) {
-    if (err instanceof Error) {
-      console.error('Error executing query', err)
-      return res
-        .status(500)
-        .json({ error: 'Internal server error', message: err.message })
-    }
-    throw err
-  }
+  const data = await getAllCountries()
+  return res.status(200).json({ data, message: 'Countries Found' })
+}
+
+export const getCountryWithId = async (
+  req: Request,
+  res: Response
+): Promise<ApiResponse<Country[]>> => {
+  const data = await getCountryById(req.params.id)
+  return res.status(200).json({ data, message: 'Country Details' })
 }

src/routes/country/country.route.ts

@@ -1,8 +1,13 @@
 import express from 'express'
-import { getCountries } from '../../controllers/country.controller'
+import {
+  getCountries,
+  getCountryWithId
+} from '../../controllers/country.controller'
+import { asyncHandler } from '../../utils'
 
 const countryRouter = express.Router()
 
-countryRouter.get('/', getCountries)
+countryRouter.get('/', asyncHandler(getCountries))
+countryRouter.get('/:id', asyncHandler(getCountryWithId))
 
 export default countryRouter

src/services/country.service.ts

@@ -1,13 +1,25 @@
+import { AppErrorTypes, createAppError } from '../AppError'
 import { dataSource } from '../configs/dbConfig'
 import Country from '../entities/country.entity'
 
-export const getAllCountries = async (): Promise<Country[] | null> => {
+export const getAllCountries = async (): Promise<Country[]> => {
   const countryRepository = dataSource.getRepository(Country)
-  const countries: Country[] = await countryRepository.find({
+  const countries = await countryRepository.find({
     select: ['uuid', 'code', 'name']
   })
   if (countries && countries.length > 0) {
     return countries
   }
-  return null
+  throw createAppError(AppErrorTypes.NOT_FOUND_ERROR)
+}
+
+export const getCountryById = async (id: string): Promise<Country> => {
+  const countryRepository = dataSource.getRepository(Country)
+  const country = await countryRepository.findOneBy({
+    uuid: id
+  })
+  if (country) {
+    return country
+  }
+  throw createAppError(AppErrorTypes.NOT_FOUND_ERROR)
 }

src/utils.ts

@@ -1,6 +1,6 @@
 import { JWT_SECRET, CLIENT_URL } from './configs/envConfig'
 import jwt from 'jsonwebtoken'
-import type { Response } from 'express'
+import type { NextFunction, Request, Response } from 'express'
 import type Mentor from './entities/mentor.entity'
 import path from 'path'
 import multer from 'multer'
@@ -11,6 +11,7 @@ import { randomUUID } from 'crypto'
 import { certificatesDir } from './app'
 import type Mentee from './entities/mentee.entity'
 import { type ZodError } from 'zod'
+import { type ApiResponse } from './types'
 
 export const signAndSetCookie = (res: Response, uuid: string): void => {
   const token = jwt.sign({ userId: uuid }, JWT_SECRET ?? '')
@@ -299,3 +300,15 @@ export const formatValidationErrors = (
     message: `${issue.path.join('.')} is ${issue.message}`
   }))
 }
+
+export const asyncHandler =
+  (
+    fn: (
+      req: Request,
+      res: Response,
+      next: NextFunction
+    ) => Promise<ApiResponse<any>>
+  ) =>
+  (req: Request, res: Response, next: NextFunction) => {
+    Promise.resolve(fn(req, res, next)).catch(next)
+  }