codeweaver 1.1.0 → 2.1.0

package/src/routers/orders/{index.ts → index.router.ts}

@@ -1,7 +1,6 @@
 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();
@@ -11,7 +10,7 @@ const orderController = new OrderController();
  * /orders:
  *   post:
  *     summary: Create a new order
- *     description: Creates an order with user details and products.
+ *     description: Creates an order with order details and products.
  *     consumes:
  *       - application/json
  *     produces:
@@ -59,8 +58,9 @@ const orderController = new OrderController();
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const order = await orderController.create(req.body);
-    res.status(201).json(order);
+    const order = await orderController.validateOrderCreationDto(req.body);
+    await orderController.create(order);
+    res.status(201).send();;
   })
 );
 
@@ -100,9 +100,9 @@ router.get(
 router.get(
   "/: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);
+    const id = await orderController.validateId(req.params.id);
+    const order = await orderController.get(id);
+    res.json(order);
   })
 );
 
@@ -125,9 +125,9 @@ router.get(
 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);
+    const id = await orderController.validateId(req.params.id);
+    const order = await orderController.cancel(id);
+    res.json(order);
   })
 );
 
@@ -152,9 +152,9 @@ router.patch(
 router.patch(
   "/:id/deliver",
   asyncHandler(async (req: Request, res: Response) => {
-    const order = await orderController.deliver(req.params.id);
-    if ("id" in order == false) sendError(res, order);
-    else res.json(order);
+    const id = await orderController.validateId(req.params.id);
+    const order = await orderController.deliver(id);
+    res.json(order);
   })
 );
 

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

@@ -1,191 +1,189 @@
-import { onError, rateLimit, timeout } from "utils-decorators";
+import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
 import {
-  Order,
+  OrderDto,
   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"),
-  },
-];
+import { ResponseError } from "@/utilities/error-handling";
+import { convert, stringToInteger } from "@/utilities/conversion";
+import config from "@/config";
+import { orders } from "@/db";
+import { Order, ZodOrder } from "@/entities/order.entity";
+import { MapAsyncCache } from "@/utilities/cache/memory-cache";
 
 function exceedHandler() {
   const message = "Too much call in allowed window";
-
-  throw new Error(message, {
-    cause: { status: 500, message } satisfies ResponseError,
-  });
+  throw new ResponseError(message, 429);
 }
 
-function getOrderErrorHandler(e: Error) {
+function orderNotFoundHandler(e: ResponseError) {
   const message = "Order not found.";
+  throw new ResponseError(message, 404, e.message);
+}
 
-  throw new Error(message, {
-    cause: { status: 404, message, details: e.message } satisfies ResponseError,
-  });
+function invalidInputHandler(e: ResponseError) {
+  const message = "Invalid input";
+  throw new ResponseError(message, 400, e.message);
 }
 
+const ordersCache = new MapAsyncCache<OrderDto[]>(config.cacheSize);
+const orderCache = new MapAsyncCache<OrderDto>(config.cacheSize);
+
 /**
  * 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,
+  // constructor(private readonly orderService: OrderService) { }
+
+  @onError({
+    func: orderNotFoundHandler,
   })
-  @Validate
   /**
-   * Create a new order
-   * @param {OrderCreationDto} order - Order creation data
-   * @returns {Promise<Order>} Newly created order
+   * Validates a string ID and converts it to a number.
+   *
+   * @param {string} id - The ID to validate and convert.
+   * @returns {number} The numeric value of the provided ID.
    */
-  public async create(@ZodInput(ZodOrderCreationDto) order: OrderCreationDto) {
-    const newOrder = {
-      ...order,
+  public async validateId(id: string): Promise<number> {
+    return stringToInteger(id);
+  }
+
+  @onError({
+    func: invalidInputHandler,
+  })
+  /**
+   * Validates and creates a new Order from the given DTO.
+   *
+   * @param {OrderCreationDto} order - The incoming OrderCreationDto to validate and transform.
+   * @returns {Order} A fully formed Order object ready for persistence.
+   */
+  public async validateOrderCreationDto(
+    order: OrderCreationDto
+  ): Promise<Order> {
+    const newOrder = await ZodOrderCreationDto.parseAsync(order);
+    return {
+      ...newOrder,
       id: orders.length + 1,
-      createdAt: new Date(),
       status: "Processing",
-    } satisfies Order;
+      createdAt: new Date(),
+    };
+  }
 
-    orders.push(newOrder);
-    return newOrder;
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Create a new order
+   * @param {Order} order - Order creation data
+   * @returns {Promise<void>}
+   * @throws {ResponseError} 500 - When rate limit exceeded
+   * @throws {ResponseError} 400 - Invalid input data
+   */
+  public async create(order: Order): Promise<void> {
+    orders.push(order);
+    await orderCache.set(order.id.toString(), order as OrderDto);
+    await ordersCache.delete("key");
   }
 
-  @timeout(20000)
+  @memoizeAsync({
+    cache: ordersCache,
+    keyResolver: () => "key",
+    expirationTimeMs: config.memoizeTime,
+  })
+  @timeout(config.timeout)
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Retrieves all orders
    * @returns List of orders
    */
-  public async getAll(): Promise<Order[]> {
-    return orders;
+  public async getAll(): Promise<OrderDto[]> {
+    return orders as OrderDto[];
   }
 
+  @memoizeAsync({
+    cache: orderCache,
+    keyResolver: (id: number) => id.toString(),
+    expirationTimeMs: config.memoizeTime,
+  })
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
-  @onError({
-    func: getOrderErrorHandler,
-  })
   /**
    * Finds an order by its ID
-   * @param id - Order ID as string
+   * @param {number} 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;
+  public async get(id: number): Promise<OrderDto> {
+    const order = orders.find((order) => order.id === id);
+    if (order == null) {
+      throw new ResponseError("Order not found");
+    }
+    return convert(order!, ZodOrder);
   }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Cancel an existing order
-   * @param {string} id - Order ID to cancel
-   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @param {number} 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<Order | ResponseError> {
+  public async cancel(id: number): Promise<OrderDto> {
     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;
-
+    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;
+
+    await orderCache.set(id.toString(), order);
+    await ordersCache.delete("key");
+    return order;
   }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Mark an order as delivered
-   * @param {string} id - Order ID to mark as delivered
-   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @param {number} 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<Order | ResponseError> {
+  public async deliver(id: number): Promise<OrderDto> {
     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;
-
+    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;
+
+    await orderCache.set(id.toString(), order);
+    await ordersCache.delete("key");
+    return order;
   }
 }

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

@@ -1,36 +1,92 @@
-import { z } from "zod";
+import { ZodProduct } from "@/entities/product.entity";
+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)
+ * DTO for creating a Product.
+ * Derived from the full Product schema by omitting the system-generated id.
  */
-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 });
+
+/**
+ * DTO for updating a Product.
+ * All fields are optional to support partial updates (PATCH semantics).
+ */
 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>;
+/**
+ * Product categories supported by the system.
+ * Centralized to avoid repeating the union type in multiple places.
+ */
+export type ProductCategory =
+  | "Electronics"
+  | "Appliances"
+  | "Sports"
+  | "Kitchen"
+  | "Mobile Accessories"
+  | "Computer Accessories"
+  | "Home Appliances"
+  | "Books";
+
+/**
+ * Data required to create a Product.
+ */
+export type ProductCreationDto = {
+  /** Product name. */
+  name: string;
+
+  /** Product price. */
+  price: number;
+
+  /** Category from the predefined list. */
+  category: ProductCategory;
+
+  /** Stock count in inventory. Non-negative. */
+  stock: number;
+
+  /** Optional product description. */
+  description?: string | undefined;
+};
+
+/**
+ * Data for updating a Product.
+ * All fields are optional to support partial updates.
+ */
+export type ProductUpdateDto = {
+  /** Optional product name. */
+  name?: string | undefined;
+
+  /** Optional product price. */
+  price?: number | undefined;
+
+  /** Optional product description. */
+  description?: string | undefined;
+
+  /** Optional product category. Must be one of the predefined categories if provided. */
+  category?: ProductCategory | undefined;
+
+  /** Optional stock count in inventory. */
+  stock?: number | undefined;
+};
+
+/**
+ * Data Transfer Object representing a full Product (as returned by APIs, etc.).
+ */
+export type ProductDto = {
+  /** Unique identifier for the product. */
+  id: number;
+
+  /** Product name. */
+  name: string;
+
+  /** Product price. */
+  price: number;
+
+  /** Category of the product. */
+  category: ProductCategory;
+
+  /** Stock count in inventory. */
+  stock: number;
+
+  /** Optional product description. */
+  description?: string | undefined;
+};

package/src/routers/products/{index.ts → index.router.ts}

@@ -1,7 +1,6 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import ProductController from "./product.controller";
-import { sendError } from "@/utilities";
 
 const router = Router();
 const productController = new ProductController();
@@ -64,8 +63,11 @@ const productController = new ProductController();
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.create(req.body);
-    res.status(201).json(product);
+    const product = await productController.validateProductCreationDto(
+      req.body
+    );
+    await productController.create(product);
+    res.status(201).send();
   })
 );
 
@@ -104,10 +106,9 @@ router.get(
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.get(req.params.id);
-
-    if ("id" in product == false) sendError(res, product);
-    else res.json(product);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.get(id);
+    res.json(product);
   })
 );
 
@@ -167,10 +168,9 @@ router.get(
 router.put(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.update(req.params.id, req.body);
-
-    if ("id" in product == false) sendError(res, product);
-    else res.json(product);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.update(id, req.body);
+    res.json(product);
   })
 );
 
@@ -197,10 +197,9 @@ router.put(
 router.delete(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.delete(req.params.id);
-
-    if ("id" in product == false) sendError(res, product);
-    else res.json(product);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.delete(id);
+    res.json(product);
   })
 );