implemented enchanced error handler, consistent server side error handling

Author: Kuzma02

server/app.js

@@ -39,6 +39,10 @@ const {
   productLimiter
 } = require('./middleware/advancedRateLimiter');
 
+const {
+  handleServerError
+} = require('./utills/errorHandler');
+
 const app = express();
 
 // Trust proxy for accurate IP addresses
@@ -157,11 +161,7 @@ app.use('*', (req, res) => {
 
 // Global error handler
 app.use((err, req, res, next) => {
-  console.error('Error:', err.message);
-  res.status(500).json({
-    error: 'Internal server error',
-    requestId: req.reqId
-  });
+  handleServerError(err, res, `${req.method} ${req.path}`);
 });
 
 const PORT = process.env.PORT || 3001;

server/controllers/category.js

@@ -1,87 +1,116 @@
 const { PrismaClient } = require("@prisma/client");
 const prisma = new PrismaClient();
+const { asyncHandler, AppError } = require("../utills/errorHandler");
 
-async function createCategory(request, response) {
-  try {
-    const { name } = request.body;
-    const category = await prisma.category.create({
-      data: {
-        name,
-      },
-    });
-    return response.status(201).json(category);
-  } catch (error) {
-    console.error("Error creating category:", error);
-    return response.status(500).json({ error: "Error creating category" });
+const createCategory = asyncHandler(async (request, response) => {
+  const { name } = request.body;
+
+  if (!name || name.trim().length === 0) {
+    throw new AppError("Category name is required", 400);
+  }
+
+  const category = await prisma.category.create({
+    data: {
+      name: name.trim(),
+    },
+  });
+  return response.status(201).json(category);
+});
+
+const updateCategory = asyncHandler(async (request, response) => {
+  const { id } = request.params;
+  const { name } = request.body;
+
+  if (!id) {
+    throw new AppError("Category ID is required", 400);
+  }
+
+  if (!name || name.trim().length === 0) {
+    throw new AppError("Category name is required", 400);
+  }
+
+  const existingCategory = await prisma.category.findUnique({
+    where: {
+      id: id,
+    },
+  });
+
+  if (!existingCategory) {
+    throw new AppError("Category not found", 404);
+  }
+
+  const updatedCategory = await prisma.category.update({
+    where: {
+      id: existingCategory.id,
+    },
+    data: {
+      name: name.trim(),
+    },
+  });
+
+  return response.status(200).json(updatedCategory);
+});
+
+const deleteCategory = asyncHandler(async (request, response) => {
+  const { id } = request.params;
+
+  if (!id) {
+    throw new AppError("Category ID is required", 400);
   }
-}
-
-async function updateCategory(request, response) {
-  try {
-    const { id } = request.params;
-    const { name } = request.body;
-
-    const existingCategory = await prisma.category.findUnique({
-      where: {
-        id: id,
-      },
-    });
-
-    if (!existingCategory) {
-      return response.status(404).json({ error: "Category not found" });
-    }
-
-    const updatedCategory = await prisma.category.update({
-      where: {
-        id: existingCategory.id,
-      },
-      data: {
-        name,
-      },
-    });
-
-    return response.status(200).json(updatedCategory);
-  } catch (error) {
-    return response.status(500).json({ error: "Error updating category" });
+
+  const existingCategory = await prisma.category.findUnique({
+    where: {
+      id: id,
+    },
+  });
+
+  if (!existingCategory) {
+    throw new AppError("Category not found", 404);
   }
-}
-
-async function deleteCategory(request, response) {
-  try {
-    const { id } = request.params;
-    await prisma.category.delete({
-      where: {
-        id: id,
-      },
-    });
-    return response.status(204).send();
-  } catch (error) {
-    console.log(error);
-    return response.status(500).json({ error: "Error deleting category" });
+
+  // Check if category has products
+  const productsWithCategory = await prisma.product.findFirst({
+    where: {
+      categoryId: id,
+    },
+  });
+
+  if (productsWithCategory) {
+    throw new AppError("Cannot delete category that has products", 400);
   }
-}
 
-async function getCategory(request, response) {
+  await prisma.category.delete({
+    where: {
+      id: id,
+    },
+  });
+  return response.status(204).send();
+});
+
+const getCategory = asyncHandler(async (request, response) => {
   const { id } = request.params;
+
+  if (!id) {
+    throw new AppError("Category ID is required", 400);
+  }
+
   const category = await prisma.category.findUnique({
     where: {
       id: id,
     },
   });
+  
   if (!category) {
-    return response.status(404).json({ error: "Category not found" });
+    throw new AppError("Category not found", 404);
   }
+  
   return response.status(200).json(category);
-}
-
-async function getAllCategories(request, response) {
-  try {
-    const categories = await prisma.category.findMany({});
-    return response.json(categories);
-  } catch (error) {
-    return response.status(500).json({ error: "Error fetching categories" });
-  }
-}
+});
+
+const getAllCategories = asyncHandler(async (request, response) => {
+  const categories = await prisma.category.findMany({});
+  return response.json(categories);
+});
 
 module.exports = {
   createCategory,