codeweaver 1.0.14 → 1.1.0

package/src/packages/ts-zod-decorators/zod-output.decorator.ts

@@ -0,0 +1,11 @@
+import { ZodObject } from "zod";
+import ZodValidator from "./validator.class";
+
+export const ZodOutput =
+  <T extends ZodObject<any, any>>(schema: T): MethodDecorator =>
+  (target, propertyKey) =>
+    ZodValidator.registerMethodValidationOutputSchema(
+      target,
+      propertyKey as string,
+      schema
+    );

package/src/routers/index.ts

@@ -11,12 +11,12 @@ const router = Router();
  *     description: Returns the home page.
  *     responses:
  *       200:
- *         description: home page
+ *         description: Hi there!
  */
 router.get(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("Home");
+    res.send("Hi there!");
   })
 );
 

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