codeweaver 1.0.15 → 1.1.0

package/src/routers/orders/dto/order.dto.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+
+/**
+ * Zod schema for Order entity
+ * @typedef {Object} ZodOrder
+ * @property {number} id - Unique identifier (min 1)
+ * @property {number} userId - Associated user ID (min 1)
+ * @property {{productId: number, quantity: number}[]} products - Array of ordered products
+ * @property {"Processing"|"Delivered"|"Canceled"} status - Order status
+ * @property {number} total - Total price (min 1000)
+ * @property {Date} createdAt - Creation timestamp
+ * @property {Date} [canceledAt] - Cancellation timestamp
+ * @property {Date} [deliveredAt] - Delivery timestamp
+ */
+export const ZodOrder = z.object({
+  id: z.number().min(1).int(),
+  userId: z.number().min(1).int(),
+  products: z.array(
+    z.object({
+      productId: z.number().min(1).int(),
+      quantity: z.number().min(1).int(),
+    })
+  ),
+  status: z.enum(["Processing", "Delivered", "Canceled"]),
+  total: z.number().min(1000),
+  createdAt: z.date(),
+  canceledAt: z.date().optional(),
+  deliveredAt: z.date().optional(),
+});
+
+export const ZodOrderCreationDto = ZodOrder.omit({
+  id: true,
+  status: true,
+  createdAt: true,
+  canceledAt: true,
+  deliveredAt: true,
+});
+
+export type Order = z.infer<typeof ZodOrder>;
+export type OrderCreationDto = z.infer<typeof ZodOrderCreationDto>;

package/src/routers/orders/index.ts

@@ -1,39 +1,160 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
+import OrderController from "./order.controller";
+import { sendError } from "@/utilities";
 
 const router = Router();
+const orderController = new OrderController();
+
+/**
+ * @swagger
+ * /orders:
+ *   post:
+ *     summary: Create a new order
+ *     description: Creates an order with user details and products.
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - in: body
+ *         name: order
+ *         required: true
+ *         schema:
+ *           type: object
+ *           required:
+ *             - userId
+ *             - products
+ *             - total
+ *           properties:
+ *             userId:
+ *               type: integer
+ *               minimum: 1
+ *               example: 1
+ *             products:
+ *               type: array
+ *               description: Array of products in the order
+ *               items:
+ *                 type: object
+ *                 required:
+ *                   - productId
+ *                   - quantity
+ *                 properties:
+ *                   productId:
+ *                     type: integer
+ *                     minimum: 1
+ *                     example: 3
+ *                   quantity:
+ *                     type: integer
+ *                     minimum: 1
+ *                     example: 2
+ *             total:
+ *               type: number
+ *               minimum: 1000
+ *               example: 250000
+ *     responses:
+ *       201:
+ *         description: Order created
+ */
+router.post(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const order = await orderController.create(req.body);
+    res.status(201).json(order);
+  })
+);
 
 /**
  * @swagger
  * /orders:
  *   get:
- *     summary: Get order home
- *     description: Returns the order home page.
+ *     summary: Get all orders
  *     responses:
  *       200:
- *         description: Order home page
+ *         description: List of orders
  */
 router.get(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("Order Home");
+    const orders = await orderController.getAll();
+    res.json(orders);
   })
 );
 
 /**
  * @swagger
- * /orders/history:
+ * /orders/{id}:
  *   get:
- *     summary: Get order history
- *     description: Returns order history.
+ *     summary: Get order details
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: Numeric ID of the order to retrieve
+ *         type: integer
+ *         example: 101
  *     responses:
  *       200:
- *         description: Order history
+ *         description: Order details
  */
 router.get(
-  "/history",
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const order = await orderController.get(req.params.id);
+    if ("id" in order == false) sendError(res, order);
+    else res.json(order);
+  })
+);
+
+/**
+ * @swagger
+ * /orders/{id}/cancel:
+ *   patch:
+ *     summary: Cancel order
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: Numeric ID of the order to cancel
+ *         type: integer
+ *         example: 101
+ *     responses:
+ *       200:
+ *         description: Order canceled successfully
+ */
+router.patch(
+  "/:id/cancel",
+  asyncHandler(async (req: Request, res: Response) => {
+    const order = await orderController.cancel(req.params.id);
+    if ("id" in order == false) sendError(res, order);
+    else res.json(order);
+  })
+);
+
+/**
+ * @swagger
+ * /orders/{id}/deliver:
+ *   patch:
+ *     summary: Mark order as delivered
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: Numeric ID of the order to deliver
+ *         type: integer
+ *         example: 101
+ *     responses:
+ *       200:
+ *         description: Order marked as delivered
+ *       400:
+ *         description: Delivery is only available when the order is in processing status.
+ */
+router.patch(
+  "/:id/deliver",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("Order History");
+    const order = await orderController.deliver(req.params.id);
+    if ("id" in order == false) sendError(res, order);
+    else res.json(order);
   })
 );
 

package/src/routers/orders/order.controller.ts

@@ -0,0 +1,191 @@
+import { onError, rateLimit, timeout } from "utils-decorators";
+import {
+  Order,
+  OrderCreationDto,
+  ZodOrderCreationDto,
+} from "./dto/order.dto";
+import { Validate, ZodInput } from "@pkg/ts-zod-decorators";
+import { ResponseError } from "@/types";
+import { tryParseId } from "@/utilities";
+
+// Array to store orders (as a mock database)
+const orders: Order[] = [
+  {
+    id: 1,
+    userId: 1,
+    products: [
+      { productId: 2, quantity: 1 },
+      { productId: 6, quantity: 2 },
+    ],
+    status: "Delivered",
+    total: 14400,
+    createdAt: new Date("2024-01-15"),
+    deliveredAt: new Date("2024-02-10"),
+  },
+  {
+    id: 2,
+    userId: 3,
+    products: [
+      { productId: 9, quantity: 1 },
+      { productId: 7, quantity: 1 },
+    ],
+    status: "Processing",
+    total: 36500,
+    createdAt: new Date("2024-03-20"),
+  },
+  {
+    id: 3,
+    userId: 2,
+    products: [
+      { productId: 1, quantity: 1 },
+      { productId: 4, quantity: 2 },
+    ],
+    status: "Canceled",
+    total: 81000,
+    createdAt: new Date("2024-05-01"),
+    canceledAt: new Date("2024-05-03"),
+  },
+];
+
+function exceedHandler() {
+  const message = "Too much call in allowed window";
+
+  throw new Error(message, {
+    cause: { status: 500, message } satisfies ResponseError,
+  });
+}
+
+function getOrderErrorHandler(e: Error) {
+  const message = "Order not found.";
+
+  throw new Error(message, {
+    cause: { status: 404, message, details: e.message } satisfies ResponseError,
+  });
+}
+
+/**
+ * Controller for handling order-related operations
+ * @class OrderController
+ * @desc Provides methods for order management including creation, status updates and retrieval
+ */
+export default class OrderController {
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @Validate
+  /**
+   * Create a new order
+   * @param {OrderCreationDto} order - Order creation data
+   * @returns {Promise<Order>} Newly created order
+   */
+  public async create(@ZodInput(ZodOrderCreationDto) order: OrderCreationDto) {
+    const newOrder = {
+      ...order,
+      id: orders.length + 1,
+      createdAt: new Date(),
+      status: "Processing",
+    } satisfies Order;
+
+    orders.push(newOrder);
+    return newOrder;
+  }
+
+  @timeout(20000)
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Retrieves all orders
+   * @returns List of orders
+   */
+  public async getAll(): Promise<Order[]> {
+    return orders;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @onError({
+    func: getOrderErrorHandler,
+  })
+  /**
+   * Finds an order by its ID
+   * @param id - Order ID as string
+   * @returns Order details or error object if not found
+   */
+  public async get(id: string): Promise<Order | ResponseError> {
+    const orderId = tryParseId(id);
+    if (typeof orderId != "number") return orderId satisfies ResponseError;
+    const order = orders.find((order) => order.id === orderId);
+
+    if (!order)
+      return {
+        status: 404,
+        message: "Order dose not exist.",
+      } satisfies ResponseError;
+
+    return order satisfies Order;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Cancel an existing order
+   * @param {string} id - Order ID to cancel
+   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @throws {ResponseError} 404 - Order not found
+   * @throws {ResponseError} 400 - Invalid ID format or invalid status for cancellation
+   */
+  public async cancel(id: string): Promise<Order | ResponseError> {
+    let order = await this.get(id);
+    if ("id" in order == false) return order satisfies ResponseError;
+
+    if (order.status != "Processing")
+      return {
+        status: 400,
+        message:
+          "Cancellation is not available unless the order is in processing status.",
+      } satisfies ResponseError;
+
+    order.status = "Canceled";
+    order.deliveredAt = new Date();
+    return order satisfies Order;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Mark an order as delivered
+   * @param {string} id - Order ID to mark as delivered
+   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @throws {ResponseError} 404 - Order not found
+   * @throws {ResponseError} 400 - Invalid ID format or invalid status for delivery
+   */
+  public async deliver(id: string): Promise<Order | ResponseError> {
+    let order = await this.get(id);
+    if ("id" in order == false) return order satisfies ResponseError;
+
+    if (order.status != "Processing")
+      return {
+        status: 400,
+        message:
+          "Delivery is only available when the order is in processing status.",
+      } satisfies ResponseError;
+
+    order.status = "Delivered";
+    order.deliveredAt = new Date();
+    return order satisfies Order;
+  }
+}

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+
+/**
+ * Zod schema for Product entity
+ * @typedef {Object} ZodProduct
+ * @property {number} id - Unique identifier (min 1)
+ * @property {string} name - Product name (min 2 chars)
+ * @property {number} price - Product price (min 1000)
+ * @property {string} [description] - Optional description (min 10 chars)
+ * @property {string} category - Product category from predefined enum
+ * @property {number} stock - Available stock quantity (min 0)
+ */
+export const ZodProduct = z.object({
+  id: z.number().min(1).int(),
+  name: z.string().min(2),
+  price: z.number().min(1000),
+  description: z.string().min(10).optional(),
+  category: z.enum([
+    "Electronics",
+    "Appliances",
+    "Sports",
+    "Kitchen",
+    "Mobile Accessories",
+    "Computer Accessories",
+    "Home Appliances",
+    "Books",
+  ]),
+  stock: z.number().min(0).int(),
+});
+
+export const ZodProductCreationDto = ZodProduct.omit({ id: true });
+export const ZodProductUpdateDto = ZodProductCreationDto.partial();
+
+export type Product = z.infer<typeof ZodProduct>;
+export type ProductCreationDto = z.infer<typeof ZodProductCreationDto>;
+export type ProductUpdateDto = z.infer<typeof ZodProductUpdateDto>;

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);
   })
 );