codeweaver 1.0.15 → 2.0.0

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

@@ -0,0 +1,41 @@
+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>;
+export type OrderDto = z.infer<typeof ZodOrder>;

package/src/routers/orders/index.router.ts

@@ -0,0 +1,157 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+import OrderController from "./order.controller";
+
+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 all orders
+ *     responses:
+ *       200:
+ *         description: List of orders
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const orders = await orderController.getAll();
+    res.json(orders);
+  })
+);
+
+/**
+ * @swagger
+ * /orders/{id}:
+ *   get:
+ *     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 details
+ */
+router.get(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const order = await orderController.get(req.params.id);
+    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);
+    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) => {
+    const order = await orderController.deliver(req.params.id);
+    res.json(order);
+  })
+);
+
+export = router;

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

@@ -0,0 +1,178 @@
+import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
+import {
+  Order,
+  OrderDto,
+  OrderCreationDto,
+  ZodOrderCreationDto,
+} from "./dto/order.dto";
+import { Validate, ZodInput } from "ts-zod4-decorators";
+import { ResponseError } from "@/utilities/types";
+import { parseId } from "@/utilities/error-handling";
+import config from "@/config";
+
+// 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 ResponseError(message, 429);
+}
+
+function getOrderErrorHandler(e: Error) {
+  const message = "Order not found.";
+  throw new ResponseError(message, 404, e.message);
+}
+
+/**
+ * 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: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    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;
+  }
+
+  @memoizeAsync(config.memoizeTime)
+  @timeout(config.timeout)
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Retrieves all orders
+   * @returns List of orders
+   */
+  public async getAll(): Promise<OrderDto[]> {
+    return orders;
+  }
+
+  @memoizeAsync(config.memoizeTime)
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    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<OrderDto> {
+    const orderId = parseId(id);
+    const order = orders.find((order) => order.id === orderId);
+    if (order == null) throw new ResponseError("User dose not exist.", 404);
+    return order satisfies Order;
+  }
+
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Cancel an existing order
+   * @param {string} id - Order ID to cancel
+   * @returns {Promise<Order>} 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<OrderDto> {
+    let order = await this.get(id);
+    if (order.status != "Processing") {
+      throw new ResponseError(
+        "Cancellation is not available unless the order is in processing status.",
+        400
+      );
+    }
+
+    order.status = "Canceled";
+    order.deliveredAt = new Date();
+    return order satisfies Order;
+  }
+
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Mark an order as delivered
+   * @param {string} id - Order ID to mark as delivered
+   * @returns {Promise<Order>} 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<OrderDto> {
+    let order = await this.get(id);
+    if (order.status != "Processing") {
+      throw new ResponseError(
+        "Delivery is only available when the order is in processing status.",
+        400
+      );
+    }
+
+    order.status = "Delivered";
+    order.deliveredAt = new Date();
+    return order satisfies Order;
+  }
+}

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

@@ -0,0 +1,37 @@
+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>;
+export type ProductDto = z.infer<typeof ZodProduct>;

package/src/routers/products/index.router.ts

@@ -0,0 +1,200 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+import ProductController from "./product.controller";
+
+const router = Router();
+const productController = new ProductController();
+
+// CRUD Routes
+
+/**
+ * @swagger
+ * /products:
+ *   post:
+ *     summary: Create a product
+ *     description: Create a new product.
+ *     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
+ */
+router.post(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = await productController.create(req.body);
+    res.status(201).json(product);
+  })
+);
+
+/**
+ * @swagger
+ * /products:
+ *   get:
+ *     summary: Get all products
+ *     responses:
+ *       200:
+ *         description: A list of products
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.json(await productController.getAll());
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   get:
+ *     summary: Get a product by ID
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: A product object
+ */
+router.get(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = await productController.get(req.params.id);
+    res.json(product);
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   put:
+ *     summary: Update a product
+ *     description: Update an existing product.
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product to update
+ *         schema:
+ *           type: integer
+ *       - 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
+ *       404:
+ *         description: Product not found
+ */
+router.put(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = await productController.update(req.params.id, req.body);
+    res.json(product);
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   delete:
+ *     summary: Delete a product
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product to delete
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       204:
+ *         description: product deleted
+ *       400:
+ *         description: invalid request
+ *       404:
+ *         description: product not found
+ */
+router.delete(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = await productController.delete(req.params.id);
+    res.json(product);
+  })
+);
+
+export = router;