feat: Product router, controller, service and repository created

backend/src/abstracts/product.abstract.ts

@@ -0,0 +1,34 @@
+type PrismaProduct = {
+  id: string;
+  title: string;
+  size: string;
+  color: string;
+  description: string;
+  gender: string;
+  category: string;
+  price: number;
+  imageUrl: string;
+  createdAt: Date;
+  updatedAt: Date;
+};
+
+type PrismaProducts = PrismaProduct[];
+
+abstract class ProductProvider {
+  abstract getProducts(): Promise<PrismaProducts | Error>;
+
+  abstract getProductById(id: string): Promise<PrismaProduct | Error>;
+
+  abstract createProduct(
+    title: string,
+    size: string,
+    color: string,
+    description: string,
+    gender: string,
+    category: string,
+    price: number,
+    imageUrl: string
+  ): Promise<PrismaProduct | Error>;
+
+  abstract deleteProduct(id: string): Promise<PrismaProduct | Error>;
+}

backend/src/controllers/algorithm.controller.ts

@@ -1,5 +1,5 @@
 import { Request, Response, NextFunction } from "express";
-import { BadRequestError } from "../errors/errors.js";
+import { HttpBadRequestError } from "../errors/http.error.js";
 import { AlgorithmServiceInterface } from "../../types.js";
 
 class AlgorithmController {
@@ -13,7 +13,7 @@ class AlgorithmController {
     try {
       const prompt: string = req.body.prompt;
       if (!prompt) {
-        return next(new BadRequestError("No string was provided!"));
+        return next(new HttpBadRequestError());
       }
 
       const isEcoFriendly: boolean =
@@ -23,8 +23,8 @@ class AlgorithmController {
         return res.status(200).json("Clothing is not eco-friendly!");
       }
       return res.status(200).json("Clothing is eco-friendly!");
-    } catch (err) {
-      next(err);
+    } catch (e) {
+      next(e);
     }
   };
 }

backend/src/controllers/product.controller.ts

@@ -0,0 +1,70 @@
+import { Request, Response, NextFunction } from "express";
+
+class ProductController {
+  constructor(private service: ProductProvider) {
+    this.service = service;
+  }
+
+  getProducts = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response<any, Record<string, any>> | void> => {
+    try {
+      const products = await this.service.getProducts();
+      return res.status(200).json(products);
+    } catch (e) {
+      next(e);
+    }
+  };
+
+  getProductById = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response<any, Record<string, any>> | void> => {
+    try {
+      const product = await this.service.getProductById(req.params.id);
+      return res.status(200).json(product);
+    } catch (e) {
+      next(e);
+    }
+  };
+
+  postProduct = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response<any, Record<string, any>> | void> => {
+    try {
+      const newProduct = await this.service.createProduct(
+        req.body.title,
+        req.body.size,
+        req.body.color,
+        req.body.description,
+        req.body.gender,
+        req.body.category,
+        req.body.price,
+        req.body.imageUrl
+      );
+      return res.status(201).json(newProduct);
+    } catch (e) {
+      next(e);
+    }
+  };
+
+  deleteProduct = async (
+    req: Request,
+    res: Response,
+    next: NextFunction
+  ): Promise<Response<any, Record<string, any>> | void> => {
+    try {
+      const product = await this.service.deleteProduct(req.params.id);
+      return res.status(200).json(product);
+    } catch (e) {
+      next(e);
+    }
+  };
+}
+
+export default ProductController;

backend/src/errors/http.error.ts

@@ -0,0 +1,7 @@
+export class HttpBadRequestError extends Error {}
+
+export class HttpUnauthorizedError extends Error {}
+
+export class HttpForbiddenError extends Error {}
+
+export class HttpNotFoundError extends Error {}

backend/src/errors/prisma.error.ts

@@ -0,0 +1,11 @@
+export class PrismaClientKnownRequestError extends Error {}
+
+export class PrismaClientUnknownRequestError extends Error {}
+
+export class PrismaClientRustPanicError extends Error {}
+
+export class PrismaClientInitializationError extends Error {}
+
+export class PrismaClientValidationError extends Error {}
+
+export class PrismaGenericError extends Error {}

backend/src/errors/product.error.ts

@@ -0,0 +1 @@
+export class ProductNotFoundError extends Error {}

backend/src/index.ts

@@ -2,44 +2,20 @@ import express, { Express } from "express";
 import cors from "cors";
 import { PORT } from "./config/config.js";
 import errorHandler from "./middlewares/error.middleware.js";
-
+import { PrismaClient } from "@prisma/client";
 import algorithmRouter from "./routes/algorithm.routes.js";
+import productRouter from "./routes/product.routes.js";
 
-import { PrismaClient } from '@prisma/client'
-const prisma = new PrismaClient()
 export const app: Express = express();
+export const prisma = new PrismaClient();
 
 app.use(express.json());
 
 app.use(cors());
 
 app.use("/api/v1/algorithm", algorithmRouter);
 
-app.post("/product", async (request, response) => {
-  const {title, size, color, description, gender, category, price, imageUrl} = request.body
-  const newProduct = await prisma.product.create({
-      data: {
-          title, size, color, description, gender, category, price, imageUrl
-      }
-  })
-  response.json(newProduct)
-}) 
-
-app.get("/products", async (request, response) => {
-  //add filtering 
-  const prods = await prisma.product.findMany();
-
-  response.json(prods);
-});
-
-app.get("/product/:id", async (request, response) => {
-  let prodID = request.params.id;
-  const product = await prisma.product.findUnique({
-    where: {id: prodID}
-  })
-
-  response.json(product);
-});
+app.use("/api/v1/products", productRouter);
 
 app.use(errorHandler);
 

backend/src/middlewares/error.middleware.ts

@@ -1,30 +1,45 @@
 import { Request, Response, NextFunction } from "express";
 import {
-  BadRequestError,
-  ForbiddenError,
-  NotFoundError,
-  UnauthorizedError,
-} from "../errors/errors.js";
-
+  HttpBadRequestError,
+  HttpForbiddenError,
+  HttpNotFoundError,
+  HttpUnauthorizedError,
+} from "../errors/http.error.js";
+import {
+  PrismaClientInitializationError,
+  PrismaClientRustPanicError,
+  PrismaClientUnknownRequestError,
+  PrismaClientValidationError,
+  PrismaGenericError,
+} from "../errors/prisma.error.js";
+import { ProductNotFoundError } from "../errors/product.error.js";
 export default function errorHandler(
-  err: Error,
+  e: Error,
   req: Request,
   res: Response,
   next: NextFunction
 ) {
-  if (err instanceof BadRequestError) {
-    res.status(400).json(err.message);
-  } else if (err instanceof UnauthorizedError) {
-    res.status(401).json(err.message);
-  } else if (err instanceof ForbiddenError) {
-    res.status(403).json(err.message);
-  } else if (err instanceof NotFoundError) {
-    res.status(404).json(err.message);
+  if (e instanceof HttpBadRequestError) {
+    res.status(400).json({ error: "Bad Request Error" });
+  } else if (e instanceof HttpUnauthorizedError) {
+    res.status(401).json({ error: "Unauthorized Error" });
+  } else if (e instanceof HttpForbiddenError) {
+    res.status(403).json({ error: "Forbidden Error" });
+  } else if (e instanceof HttpNotFoundError) {
+    res.status(404).json({ error: "Not Found Error" });
+  } else if (e instanceof PrismaClientUnknownRequestError) {
+    res.status(500).json({ error: "Prisma Client Unknown Request Error" });
+  } else if (e instanceof PrismaClientRustPanicError) {
+    res.status(500).json({ error: "Prisma Client Rust Panic Error" });
+  } else if (e instanceof PrismaClientInitializationError) {
+    res.status(500).json({ error: "Prisma Client Initialization Error" });
+  } else if (e instanceof PrismaClientValidationError) {
+    res.status(500).json({ error: "Prisma Client Validation Error" });
+  } else if (e instanceof PrismaGenericError) {
+    res.status(500).json({ error: "Prisma Generic Error" });
+  } else if (e instanceof ProductNotFoundError) {
+    res.status(500).json({ error: "Product Not Found Error" });
   } else {
-    res.status(500).json({
-      name: err.name,
-      message: err.message,
-      stack: err.stack,
-    });
+    res.status(500).json({ error: "Unexpected error" });
   }
 }