codeweaver 1.0.14 → 1.1.0

package/src/routers/products/index.ts

@@ -1,20 +1,10 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
+import ProductController from "./product.controller";
+import { sendError } from "@/utilities";
 
 const router = Router();
-
-// Array to store products (as a mock database)
-const products = [
-  { id: 1, name: "Product1" },
-  { id: 2, name: "Product2" },
-  { id: 3, name: "Product3" },
-  { id: 4, name: "Product4" },
-  { id: 5, name: "Product5" },
-  { id: 6, name: "Product6" },
-  { id: 7, name: "Product7" },
-  { id: 8, name: "Product8" },
-  { id: 9, name: "Product9" },
-];
+const productController = new ProductController();
 
 // CRUD Routes
 
@@ -22,28 +12,59 @@ const products = [
  * @swagger
  * /products:
  *   post:
- *     summary: Create an product
+ *     summary: Create a product
  *     description: Create a new product.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - in: body
+ *         name: product
+ *         required: true
+ *         schema:
+ *           type: object
+ *           required:
+ *             - name
+ *             - price
+ *             - category
+ *             - stock
+ *           properties:
+ *             id:
+ *               type: integer
+ *               example: 1
+ *             name:
+ *               type: string
+ *               example: "New Product"
+ *             price:
+ *               type: number
+ *               example: 1499
+ *             description:
+ *               type: string
+ *               example: "This is a detailed description."
+ *             category:
+ *               type: string
+ *               enum:
+ *                 - Electronics
+ *                 - Appliances
+ *                 - Sports
+ *                 - Kitchen
+ *                 - Mobile Accessories
+ *                 - Computer Accessories
+ *                 - Home Appliances
+ *                 - Books
+ *               example: "Electronics"
+ *             stock:
+ *               type: integer
+ *               example: 50
  *     responses:
  *       201:
- *         description: product created
+ *         description: Product created
  */
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = { id: products.length + 1, name: req.body.name };
-    products.push(product);
+    const product = await productController.create(req.body);
     res.status(201).json(product);
   })
 );
@@ -60,7 +81,7 @@ router.post(
 router.get(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    res.json(products);
+    res.json(await productController.getAll());
   })
 );
 
@@ -68,7 +89,7 @@ router.get(
  * @swagger
  * /products/{id}:
  *   get:
- *     summary: Get an product by ID
+ *     summary: Get a product by ID
  *     parameters:
  *       - name: id
  *         in: path
@@ -78,15 +99,14 @@ router.get(
  *           type: integer
  *     responses:
  *       200:
- *         description: An product object
- *       404:
- *         description: product not found
+ *         description: A product object
  */
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = products.find((i) => i.id === parseInt(req.params.id));
-    if (!product) res.status(404).send("product not found");
+    const product = await productController.get(req.params.id);
+
+    if ("id" in product == false) sendError(res, product);
     else res.json(product);
   })
 );
@@ -95,7 +115,12 @@ router.get(
  * @swagger
  * /products/{id}:
  *   put:
- *     summary: Update an product
+ *     summary: Update a product
+ *     description: Update an existing product.
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
  *     parameters:
  *       - name: id
  *         in: path
@@ -103,32 +128,49 @@ router.get(
  *         description: The ID of the product to update
  *         schema:
  *           type: integer
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             properties:
- *               name:
- *                 type: string
- *               description:
- *                 type: string
+ *       - in: body
+ *         name: product
+ *         required: true
+ *         schema:
+ *           type: object
+ *           properties:
+ *             name:
+ *               type: string
+ *               example: "Updated Product"
+ *             price:
+ *               type: number
+ *               example: 2000
+ *             description:
+ *               type: string
+ *               example: "This is a detailed description."
+ *             category:
+ *               type: string
+ *               enum:
+ *                 - Electronics
+ *                 - Appliances
+ *                 - Sports
+ *                 - Kitchen
+ *                 - Mobile Accessories
+ *                 - Computer Accessories
+ *                 - Home Appliances
+ *                 - Books
+ *               example: "Sports"
+ *             stock:
+ *               type: integer
+ *               example: 70
  *     responses:
  *       200:
- *         description: product updated
+ *         description: Product updated
  *       404:
- *         description: product not found
+ *         description: Product not found
  */
 router.put(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = products.find((i) => i.id === parseInt(req.params.id));
-    if (!product) res.status(404).send("product not found");
-    else {
-      Object.assign(product, { id: req.body.id, name: req.body.name });
-      res.json(product);
-    }
+    const product = await productController.update(req.params.id, req.body);
+
+    if ("id" in product == false) sendError(res, product);
+    else res.json(product);
   })
 );
 
@@ -136,7 +178,7 @@ router.put(
  * @swagger
  * /products/{id}:
  *   delete:
- *     summary: Delete an product
+ *     summary: Delete a product
  *     parameters:
  *       - name: id
  *         in: path
@@ -147,20 +189,18 @@ router.put(
  *     responses:
  *       204:
  *         description: product deleted
+ *       400:
+ *         description: invalid request
  *       404:
  *         description: product not found
  */
 router.delete(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const productIndex = products.findIndex(
-      (i) => i.id === parseInt(req.params.id)
-    );
-    if (productIndex === -1) res.status(404).send("product not found");
-    else {
-      products.splice(productIndex, 1);
-      res.status(204).send();
-    }
+    const product = await productController.delete(req.params.id);
+
+    if ("id" in product == false) sendError(res, product);
+    else res.json(product);
   })
 );
 

package/src/routers/products/product.controller.ts

@@ -0,0 +1,237 @@
+import { onError, rateLimit, timeout } from "utils-decorators";
+import {
+  Product,
+  ProductCreationDto,
+  ProductUpdateDto,
+  ZodProductCreationDto,
+  ZodProductUpdateDto,
+} from "./dto/product.dto";
+import { Validate, ZodInput } from "@pkg/ts-zod-decorators";
+import { ResponseError } from "@/types";
+import { tryParseId } from "@/utilities";
+
+// Array to store products (as a mock database)
+const products: Product[] = [
+  {
+    id: 1,
+    name: "ASUS ROG Zephyrus G15",
+    price: 45000000,
+    description: "Gaming laptop with AMD Ryzen 9 5900HS and RTX 3080 GPU",
+    category: "Electronics",
+    stock: 15,
+  },
+  {
+    id: 2,
+    name: "Sony WH-1000XM5 Wireless Headphones",
+    price: 12000000,
+    description:
+      "Premium noise-canceling over-ear headphones with 30hr battery",
+    category: "Electronics",
+    stock: 8,
+  },
+  {
+    id: 3,
+    name: "LG Smart Inverter Microwave",
+    price: 25000000,
+    description: "1.7 cu.ft countertop microwave with smart sensor cooking",
+    category: "Appliances",
+    stock: 5,
+  },
+  {
+    id: 4,
+    name: "Trek Marlin 5 Mountain Bike",
+    price: 18000000,
+    description: "Entry-level mountain bike with aluminum frame and 21 speeds",
+    category: "Sports",
+    stock: 3,
+  },
+  {
+    id: 5,
+    name: "DeLonghi Espresso Machine",
+    price: 6500000,
+    description: "Compact espresso maker with manual milk frother",
+    category: "Kitchen",
+    stock: 12,
+  },
+  {
+    id: 6,
+    name: "Anker Wireless Charger",
+    price: 1200000,
+    description: "15W fast wireless charger with anti-slip surface",
+    category: "Mobile Accessories",
+    stock: 30,
+  },
+  {
+    id: 7,
+    name: "Logitech MX Master 3 Mouse",
+    price: 4500000,
+    description: "Ergonomic wireless mouse with Darkfield tracking",
+    category: "Computer Accessories",
+    stock: 18,
+  },
+  {
+    id: 8,
+    name: "Kindle Paperwhite",
+    price: 3800000,
+    description: 'Waterproof e-reader with 6.8" 300ppi display',
+    category: "Electronics",
+    stock: 9,
+  },
+  {
+    id: 9,
+    name: "Dyson V11 Vacuum Cleaner",
+    price: 32000000,
+    description: "Cordless stick vacuum with LCD screen and 60min runtime",
+    category: "Home Appliances",
+    stock: 7,
+  },
+];
+
+function exceedHandler() {
+  const message = "Too much call in allowed window";
+
+  throw new Error(message, {
+    cause: { status: 500, message } satisfies ResponseError,
+  });
+}
+
+function getProductErrorHandler(e: Error) {
+  const message = "User not found.";
+
+  throw new Error(message, {
+    cause: { status: 404, message, details: e.message } satisfies ResponseError,
+  });
+}
+
+/**
+ * Controller for handling product-related operations
+ * @class ProductController
+ * @desc Provides methods for product management including CRUD operations
+ */
+export default class ProductController {
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @Validate
+  /**
+   * Creates a new product with validated data
+   * @param product - Product creation data validated by Zod schema
+   * @returns Newly created product with generated ID
+   */
+  public async create(
+    @ZodInput(ZodProductCreationDto) product: ProductCreationDto
+  ) {
+    products.push({
+      ...product,
+      id: products.length + 1,
+    } satisfies Product);
+
+    return product;
+  }
+
+  @timeout(20000)
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Retrieves all products with truncated descriptions
+   * @returns List of products with summarized descriptions
+   */
+  public async getAll(): Promise<Product[]> {
+    return products.map(
+      (product) =>
+        ({
+          ...product,
+          description: product.description?.substring(0, 50) + "..." || "",
+        } satisfies Product)
+    );
+  }
+
+  @onError({
+    func: getProductErrorHandler,
+  })
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Finds a product by its ID
+   * @param id - Product ID as string
+   * @returns Product details or error object if not found
+   */
+  public async get(id: string): Promise<Product | ResponseError> {
+    const productId = tryParseId(id);
+    if (typeof productId != "number") return productId satisfies ResponseError;
+    const product = products.find((product) => product.id === productId);
+
+    if (!product)
+      return {
+        status: 404,
+        message: "Product dose not exist.",
+      } satisfies ResponseError;
+
+    return product satisfies Product;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @Validate
+  /**
+   * Updates an existing product
+   * @param {string} id - Product ID to update
+   * @param {ProductUpdateDto} updateData - Partial product data to update
+   * @returns {Promise<Product | ResponseError>} Updated product or error object
+   * @throws {ResponseError} 404 - Product not found
+   * @throws {ResponseError} 400 - Invalid ID format or update data
+   */
+  public async update(
+    id: string,
+    @ZodInput(ZodProductUpdateDto) updateData: ProductUpdateDto
+  ): Promise<Product | ResponseError> {
+    const product = await this.get(id);
+    if ("id" in product == false) return product satisfies ResponseError;
+
+    if (product) Object.assign(product, updateData);
+    else
+      return {
+        status: 404,
+        message: "Product not found",
+      } satisfies ResponseError;
+
+    return product;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Deletes a product by ID
+   * @param {string} id - Product ID to delete
+   * @returns {Promise<Product | ResponseError>} Deleted product or error object
+   * @throws {ResponseError} 404 - Product not found
+   * @throws {ResponseError} 400 - Invalid ID format
+   */
+  public async delete(id: string): Promise<Product | ResponseError> {
+    const productId = tryParseId(id);
+    if (typeof productId != "number") return productId satisfies ResponseError;
+    const index = products.findIndex((product) => product.id === productId);
+
+    if (index == -1)
+      return {
+        status: 404,
+        message: "Product dose not exist.",
+      } satisfies ResponseError;
+
+    return products.splice(index, 1)[0] satisfies Product;
+  }
+}

package/src/routers/users/dto/user.dto.ts

@@ -1,9 +1,21 @@
 import { z } from "zod";
 
-export const CreateUserDto = z.object({
+/**
+ * Zod schema for User entity
+ * @typedef {Object} ZodUser
+ * @property {number} id - Unique identifier (min 1)
+ * @property {string} username - Username (min 3 chars)
+ * @property {string} email - Valid email format
+ * @property {string} password - Password (min 6 chars)
+ */
+export const ZodUser = z.object({
+  id: z.number().min(1).int(),
   username: z.string().min(3),
   email: z.string().email(),
   password: z.string().min(6),
 });
 
-export type CreateUser = z.infer<typeof CreateUserDto>;
+export const ZodUserCreationDto = ZodUser.omit({ id: true });
+
+export type User = z.infer<typeof ZodUser>;
+export type UserCreationDto = z.infer<typeof ZodUserCreationDto>;

package/src/routers/users/index.ts

@@ -1,6 +1,7 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
+import { sendError } from "@/utilities";
 
 const router = Router();
 const userController = new UserController();
@@ -11,70 +12,87 @@ const userController = new UserController();
  *   post:
  *     summary: Create a user
  *     description: Create a new user.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - username
- *               - email
- *               - password
- *             properties:
- *               username:
- *                 type: string
- *               email:
- *                 type: string
- *               password:
- *                 type: string
- *             example: # Sample object
- *               username: JessicaSmith
- *               email: william.howard.taft@my-own-personal-domain.com
- *               password: password123
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - in: body
+ *         name: user
+ *         required: true
+ *         schema:
+ *           type: object
+ *           required:
+ *             - username
+ *             - email
+ *             - password
+ *           properties:
+ *             username:
+ *               type: string
+ *               minLength: 3
+ *               example: JessicaSmith
+ *             email:
+ *               type: string
+ *               format: email
+ *               example: user@example.com
+ *             password:
+ *               type: string
+ *               minLength: 6
+ *               example: securePassword123
  *     responses:
  *       201:
- *         description: product created
+ *         description: User created
  */
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const result = await userController.createUser(req.body);
-    res.status(201).json({ message: result });
+    const user = await userController.create(req.body);
+    res.status(201).json(user);
   })
 );
 
 /**
  * @swagger
- * /user:
+ * /users/{id}:
  *   get:
- *     summary: Get user home
- *     description: Returns the user home page.
+ *     summary: Get a user by ID
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product
+ *         schema:
+ *           type: integer
  *     responses:
  *       200:
- *         description: User home page
+ *         description: A user object
+ *       404:
+ *         description: user not found
  */
 router.get(
-  "/",
+  "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Home");
+    const user = await userController.get(req.params.id);
+
+    if ("id" in user == false) sendError(res, user);
+    else res.json(user);
   })
 );
 
 /**
  * @swagger
- * /user/profile:
+ * /users:
  *   get:
- *     summary: Get user profile
- *     description: Returns user profile information.
+ *     summary: Get users
+ *     description: Returns a list of user objects.
  *     responses:
  *       200:
- *         description: User profile information
+ *         description: A list of user objects
  */
 router.get(
-  "/profile",
+  "/",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Profile");
+    res.json(await userController.getAll());
   })
 );