feat: add Product service and database entity

Author: Matelz

deno.json

@@ -14,6 +14,7 @@
     "@types/cookie-parser": "npm:@types/cookie-parser@^1.4.8",
     "@types/cors": "npm:@types/cors@^2.8.18",
     "@types/express": "npm:@types/express@^5.0.1",
+    "@types/moment": "npm:@types/moment@^2.13.0",
     "@types/pg": "npm:@types/pg@^8.15.1",
     "@types/supertest": "npm:@types/supertest@^6.0.3",
     "bcrypt": "npm:bcrypt@^6.0.0",
@@ -24,6 +25,7 @@
     "express": "npm:express@^5.1.0",
     "@langchain/mistralai": "npm:@langchain/mistralai@^0.2.0",
     "jose": "npm:jose@^6.0.11",
+    "moment": "npm:moment@^2.30.1",
     "pg": "npm:pg@^8.16.0",
     "socket.io": "npm:socket.io@^4.8.1",
     "socket.io-client": "npm:socket.io-client@^4.8.1",

src/database/schema.ts

@@ -1,4 +1,5 @@
 import {
+  boolean,
   doublePrecision,
   pgEnum,
   pgTable,
@@ -52,6 +53,7 @@ export const product = pgTable("product", {
   name: text("name").notNull(),
   description: text("description"),
   price: doublePrecision().notNull(),
+  available: boolean("available").notNull().default(true),
   createdAt: timestamp("created_at").notNull().defaultNow(),
   updatedAt: timestamp("updated_at").notNull().$onUpdate(() => new Date()),
 });

src/handlers/ProductHandler.ts

@@ -0,0 +1,113 @@
+import { ZodError } from "zod";
+import { IDatabase } from "../interfaces/IDatabase.ts";
+import { IHandlerReturn } from "../interfaces/IHandlerReturn.ts";
+import { IProduct } from "../interfaces/IProduct.ts";
+import { ProductService } from "../services/ProductService.ts";
+
+export class ProductHandler {
+    private productService: ProductService;
+
+    constructor(db: IDatabase) {
+        this.productService = new ProductService(db);
+    }
+
+    async createProduct(product: Partial<IProduct>): Promise<IHandlerReturn> {
+        try {
+            product.createdAt = new Date();
+            product.updatedAt = new Date();
+            const newProduct = await this.productService.createProduct(product);
+            if (!newProduct) {
+                return {
+                    status: 500,
+                    message: "There was an error creating the product",
+                }
+            }
+
+            return {
+                status: 201,
+                message: "Product created successfully",
+                data: newProduct,
+            }
+        } catch (error) {
+            if (error instanceof ZodError) {
+                return {
+                    status: 400,
+                    message: "Invalid product data",
+                    error: error.toString(),
+                }
+            }
+            
+            if (error instanceof Error) {
+                return {
+                    status: 500,
+                    message: error.message,
+                }
+            }
+
+            return {
+                status: 500,
+                message: "There was an error creating the product",
+            }
+        }
+    }
+
+    async getProducts(): Promise<IHandlerReturn> {
+        try {
+            const products = await this.productService.getAllProducts();
+            if (!products) {
+                return {
+                    status: 500,
+                    message: "There was an error getting the products",
+                }
+            }
+
+            return {
+                status: 200,
+                message: "Products retrieved successfully",
+                data: products,
+            }
+        } catch (error) {
+            if (error instanceof Error) {
+                return {
+                    status: 500,
+                    message: error.message,
+                }
+            }
+
+            return {
+                status: 500,
+                message: "There was an error getting the products",
+            }
+        }
+    }
+
+    async getProductById(id: number): Promise<IHandlerReturn> {
+        try {
+            const product = await this.productService.getProductById(id);
+            if (!product) {
+                return {
+                    status: 404,
+                    message: "Product not found",
+                }
+            }
+
+            return {
+                status: 200,
+                message: "Product retrieved successfully",
+                data: product,
+            }
+        } catch (error) {
+            if (error instanceof Error) {
+                return {
+                    status: 500,
+                    message: error.message,
+                }
+            }
+
+            return {
+                status: 500,
+                message: "There was an error getting the product",
+            }
+        }
+    }
+}

src/interfaces/IProduct.ts

@@ -0,0 +1,9 @@
+export interface IProduct {
+  id: number;
+  name: string;
+  description: string;
+  price: number;
+  available: boolean;
+  createdAt: Date;
+  updatedAt: Date;
+}

src/main.ts

@@ -5,6 +5,7 @@ import cors from "npm:cors";
 import { Server } from "npm:socket.io";
 import { MockDatabase } from "./database/MockDatabase.ts";
 import { OrderHandler } from "./handlers/OrderHandler.ts";
+import { ProductHandler } from "./handlers/ProductHandler.ts";
 import { addMessage } from "./lc/model.ts";
 import { ValidateJWT } from "./middlewares/ValidateJWT.ts";
 import { AuthenticationService } from "./services/AuthenticationService.ts";
@@ -28,6 +29,7 @@ const JWTmiddleware = new ValidateJWT(authenticationService);
 
 // Instantiate the handlers
 export const orderHandler = new OrderHandler(db);
+export const productHandler = new ProductHandler(db);
 
 app.use(cookieParser());
 app.use(express.json());
@@ -106,9 +108,9 @@ app.post("/auth/login", async (req, res) => {
 app.post("/order", JWTmiddleware.validateToken, async (req, res) => {
   const order = req.body;
   const userId = req.user!.id;
-  
+
   const result = await orderHandler.createOrder(order, userId as number);
-  
+
   res.status(result.status).json({
     message: result.message,
     data: result.data,
@@ -121,17 +123,17 @@ app.get("/order/:id", JWTmiddleware.validateToken, async (req, res) => {
   const userId = req.user!.id;
 
   const result = await orderHandler.getOrderById(Number(id), userId as number);
-  
+
   res.status(result.status).json({
     message: result.message,
     data: result.data,
     error: result.error,
   });
 });
 
-app.get("/orders", async (_req, res) => {
+app.get("/orders", JWTmiddleware.validateToken, async (_req, res) => {
   const result = await orderHandler.getOrders();
-  
+
   res.status(result.status).json({
     message: result.message,
     data: result.data,
@@ -169,6 +171,42 @@ app.patch("/order/:id", JWTmiddleware.validateToken, async (req, res) => {
   });
 });
 
+// Product section
+app.post("/product", JWTmiddleware.validateToken, async (req, res) => {
+  const product = req.body;
+  
+
+  const result = await productHandler.createProduct(product);
+  
+
+  res.status(result.status).json({
+    message: result.message,
+    data: result.data,
+    error: result.error,
+  });
+});
+
+app.get("/product/:id", JWTmiddleware.validateToken, async (req, res) => {
+  const { id } = req.params;
+
+  const result = await productHandler.getProductById(Number(id));
+  res.status(result.status).json({
+    message: result.message,
+    data: result.data,
+    error: result.error,
+  });
+});
+
+app.get("/products", JWTmiddleware.validateToken, async (_req, res) => {
+  const result = await productHandler.getProducts();
+  res.status(result.status).json({
+    message: result.message,
+    data: result.data,
+    error: result.error,
+  });
+});
+
+
 app.get("/hidden", JWTmiddleware.validateToken, (_req, res) => {
   res.status(200).json({ message: "This is a hidden route" });
 });
@@ -200,14 +238,14 @@ io.use((socket, next) => {
   socket.user = {
     id: 2,
     name: "Lucas",
-  }
+  };
 
   next();
 });
 
 io.on("connection", (socket) => {
   socket.on("message", async (e) => {
-    await addMessage({message: e, user: socket.user!}).then((final) => {
+    await addMessage({ message: e, user: socket.user! }).then((final) => {
       socket.emit("message", final);
     });
   });

src/mocks/Product.ts

@@ -0,0 +1,13 @@
+import { faker } from "@faker-js/faker";
+import { IProduct } from "../interfaces/IProduct.ts";
+
+export function generateMockProduct(): Partial<IProduct> {
+  return {
+    name: faker.food.dish(),
+    description: faker.food.description(),
+    price: faker.number.float({ min: 10.0, max: 50.0 }),
+    available: true,
+    createdAt: faker.date.recent(),
+    updatedAt: faker.date.future(),
+  };
+}

src/schemas/zodSchema.ts

@@ -37,3 +37,13 @@ export const orderSchema = z.object({
   createdAt: z.date().describe("Data de criação do pedido"),
   updatedAt: z.date().describe("Data de atualização do pedido"),
 });
+
+export const productSchema = z.object({
+  id: z.number().describe("ID do produto").optional(),
+  name: z.string().describe("Nome do produto"),
+  price: z.number().describe("Preço do produto"),
+  description: z.string().describe("Descrição do produto").optional(),
+  available: z.boolean().describe("Disponibilidade do produto"),
+  createdAt: z.date().describe("Data de criação do produto"),
+  updatedAt: z.date().describe("Data de atualização do produto"),
+});

src/services/AuthenticationService.ts

@@ -46,8 +46,8 @@ export class AuthenticationService {
     await this.db.insert(saltTable, {
       userId: newUser.id,
       salt: salt,
-    })
-    
+    });
+
     return newUser.id;
   }
 

src/services/OrderService.ts

@@ -21,7 +21,13 @@ export class OrderService {
       userId: id,
     };
 
-    const newOrder = await this.db.insert(orderTable, order as IOrder);
+    const newOrder = await this.db.insert(orderTable, {
+      userId: order.userId,
+      status: order.status,
+      total: order.total,
+      createdAt: new Date(),
+      updatedAt: new Date(),
+    } as IOrder);
     if (!newOrder) {
       throw new Error("There was an error creating your order");
     }
@@ -73,6 +79,11 @@ export class OrderService {
       throw new Error("No items found for this order");
     }
 
+    for (const item of items) {
+      //@ts-ignore yes
+      delete item.table;
+    }
+
     return items;
   }
 
@@ -100,6 +111,12 @@ export class OrderService {
 
   async getOrders() {
     const orders = await this.db.selectAll(orderTable);
+    for (const order of orders) {
+      const items = await this.getOrderItems(order.id);
+      //@ts-ignore yes
+      order.items = items;
+    }
+
     if (!orders) {
       throw new Error("No orders found");
     }

src/services/ProductService.ts

@@ -0,0 +1,44 @@
+import { product as productTable } from "../database/schema.ts";
+import { IDatabase } from "../interfaces/IDatabase.ts";
+import { productSchema } from "../schemas/zodSchema.ts";
+import { validateData } from "./decorators.ts";
+
+export class ProductService {
+  private db: IDatabase;
+
+  constructor(db: IDatabase) {
+    this.db = db;
+  }
+
+  async getAllProducts() {
+    const products = await this.db.selectAll(productTable);
+    if (!products) {
+      throw new Error("There was an error getting the products");
+    }
+    return products;
+  }
+
+  async getProductById(id: number) {
+    const product = await this.db.select(productTable, id);
+    if (!product) {
+      throw new Error("There was an error getting the product");
+    }
+    return product;
+  }
+
+  @validateData(productSchema)
+  async createProduct(product: Partial<typeof productTable.$inferInsert>) {
+    const newProduct = await this.db.insert(
+      productTable,
+      {
+        ...product,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      } as typeof productTable.$inferInsert,
+    );
+    if (!newProduct) {
+      throw new Error("There was an error creating the product");
+    }
+    return newProduct;
+  }
+}