codeweaver 2.0.0 → 2.2.0

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

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

@@ -1,9 +1,10 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import ProductController from "./product.controller";
+import { resolve } from "@/utilities/container";
 
 const router = Router();
-const productController = new ProductController();
+const productController = resolve(ProductController);
 
 // CRUD Routes
 
@@ -63,8 +64,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();
   })
 );
 
@@ -103,7 +107,8 @@ router.get(
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.get(req.params.id);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.get(id);
     res.json(product);
   })
 );
@@ -164,7 +169,8 @@ router.get(
 router.put(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.update(req.params.id, req.body);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.update(id, req.body);
     res.json(product);
   })
 );
@@ -192,7 +198,8 @@ router.put(
 router.delete(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const product = await productController.delete(req.params.id);
+    const id = await productController.validateId(req.params.id);
+    const product = await productController.delete(id);
     res.json(product);
   })
 );

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

@@ -1,133 +1,121 @@
-import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
 import {
-  Product,
+  memoizeAsync,
+  onError,
+  rateLimit,
+  timeout,
+  before,
+} from "utils-decorators";
+import {
   ProductCreationDto,
   ProductDto,
   ProductUpdateDto,
   ZodProductCreationDto,
   ZodProductUpdateDto,
 } from "./dto/product.dto";
-import { Validate, ZodInput } from "ts-zod4-decorators";
-import { ResponseError } from "@/utilities/types";
-import { parseId } from "@/utilities/error-handling";
+import { MapAsyncCache } from "@/utilities/cache/memory-cache";
+import { convert, stringToInteger } from "@/utilities/conversion";
 import config from "@/config";
-
-// 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,
-  },
-];
+import { ResponseError } from "@/utilities/error-handling";
+import { products } from "@/db";
+import { Product, ZodProduct } from "@/entities/product.entity";
+import { Injectable } from "@/utilities/container";
 
 function exceedHandler() {
   const message = "Too much call in allowed window";
   throw new ResponseError(message, 429);
 }
 
-function getProductErrorHandler(e: Error) {
-  const message = "Product not found.";
-  throw new ResponseError(message, 404, e.message);
+function invalidInputHandler(e: ResponseError) {
+  const message = "Invalid input";
+  throw new ResponseError(message, 400, e.message);
 }
 
+const productsCache = new MapAsyncCache<ProductDto[]>(config.cacheSize);
+const productCache = new MapAsyncCache<ProductDto>(config.cacheSize);
+
+@Injectable()
 /**
  * Controller for handling product-related operations
  * @class ProductController
  * @desc Provides methods for product management including CRUD operations
  */
 export default class ProductController {
+  // constructor(private readonly productService: ProductService) { }
+
+  @onError({
+    func: invalidInputHandler,
+  })
+  /**
+   * 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 validateId(id: string): Promise<number> {
+    return stringToInteger(id);
+  }
+
+  @onError({
+    func: invalidInputHandler,
+  })
+  /**
+   * Validates and creates a new Product from the given DTO.
+   *
+   * @param {ProductCreationDto} product - The incoming ProductCreationDto to validate and transform.
+   * @returns {Product} A fully formed Product object ready for persistence.
+   */
+  public async validateProductCreationDto(
+    product: ProductCreationDto
+  ): Promise<Product> {
+    const newProduct = await ZodProductCreationDto.parseAsync(product);
+    return { ...newProduct, id: products.length + 1 };
+  }
+
+  @onError({
+    func: invalidInputHandler,
+  })
+  /**
+   * Validates and creates a new Product from the given DTO.
+   *
+   * @param {ProductUpdateDto} product - The incoming ProductCreationDto to validate and transform.
+   * @returns {Product} A fully formed Product object ready for persistence.
+   */
+  public async validateProductUpdateDto(
+    product: ProductCreationDto
+  ): Promise<Product> {
+    const productDto = await ZodProductUpdateDto.parseAsync(product);
+    let updatedProduct: Product = convert(productDto, ZodProduct);
+    return { ...updatedProduct, id: products.length + 1 };
+  }
+
   @rateLimit({
     timeSpanMs: config.rateLimitTimeSpan,
     allowedCalls: config.rateLimitAllowedCalls,
     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
+   * @param {Product} product - Product creation data validated by Zod schema
+   * @returns {Promise<void>}
+   * @throws {ResponseError} 500 - When rate limit exceeded
+   * @throws {ResponseError} 400 - Invalid input data
    */
-  public async create(
-    @ZodInput(ZodProductCreationDto) product: ProductCreationDto
-  ): Promise<ProductDto> {
-    products.push({
+  public async create(product: Product): Promise<void> {
+    const newProduct: Product = {
       ...product,
       id: products.length + 1,
-    } satisfies Product);
+    };
 
-    return product as ProductDto;
+    products.push(newProduct);
+    await productCache.set(newProduct.id.toString(), newProduct as ProductDto);
+    await productsCache.delete("key");
   }
 
-  @memoizeAsync(config.memoizeTime)
+  @memoizeAsync({
+    cache: productsCache,
+    keyResolver: () => "key",
+    expirationTimeMs: config.memoizeTime,
+  })
   @timeout(config.timeout)
   @rateLimit({
     timeSpanMs: config.rateLimitTimeSpan,
@@ -139,15 +127,13 @@ export default class ProductController {
    * @returns List of products with summarized descriptions
    */
   public async getAll(): Promise<ProductDto[]> {
-    return products.map((product) => ({
-      ...product,
-      description: product.description?.substring(0, 50) + "..." || "",
-    }));
+    return products as ProductDto[];
   }
 
-  @memoizeAsync(config.memoizeTime)
-  @onError({
-    func: getProductErrorHandler,
+  @memoizeAsync({
+    cache: productCache,
+    keyResolver: (id: number) => id.toString(),
+    expirationTimeMs: config.memoizeTime,
   })
   @rateLimit({
     timeSpanMs: config.rateLimitTimeSpan,
@@ -156,14 +142,15 @@ export default class ProductController {
   })
   /**
    * Finds a product by its ID
-   * @param id - Product ID as string
+   * @param {number} id - Product ID as string
    * @returns Product details or error object if not found
    */
-  public async get(id: string): Promise<ProductDto> {
-    const productId = parseId(id);
-    const product = products.find((product) => product.id === productId);
-    if (product == null) throw new ResponseError("User dose not exist.", 404);
-    return product;
+  public async get(id: number): Promise<ProductDto> {
+    const product = products.find((product) => product.id === id);
+    if (product == null) {
+      throw new ResponseError("Product not found");
+    }
+    return convert(product!, ZodProduct);
   }
 
   @rateLimit({
@@ -171,24 +158,23 @@ export default class ProductController {
     allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
-  @Validate
   /**
    * Updates an existing product
-   * @param {string} id - Product ID to update
+   * @param {number} id - Product ID to update
    * @param {ProductUpdateDto} updateData - Partial product data to update
    * @returns {Promise<Product>} 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
+    id: number,
+    updateData: ProductUpdateDto
   ): Promise<ProductDto> {
     const product = await this.get(id);
-    if ("id" in product == false) return product satisfies ResponseError;
-
-    if (product) {
+    if (product != null) {
       Object.assign(product, updateData);
+      await productCache.set(id.toString(), product);
+      await productsCache.delete("key");
     } else {
       throw new ResponseError("Product dose not exist.", 404);
     }
@@ -203,15 +189,18 @@ export default class ProductController {
   })
   /**
    * Deletes a product by ID
-   * @param {string} id - Product ID to delete
+   * @param {number} id - Product ID to delete
    * @returns {Promise<Product>} Deleted product or error object
    * @throws {ResponseError} 404 - Product not found
    * @throws {ResponseError} 400 - Invalid ID format
    */
-  public async delete(id: string): Promise<ProductDto> {
-    const productId = parseId(id);
-    const index = products.findIndex((product) => product.id === productId);
-    if (index == -1) throw new ResponseError("Product dose not exist.", 404);
+  public async delete(id: number): Promise<ProductDto> {
+    const index = products.findIndex((product) => product.id === id);
+    if (index == -1) {
+      throw new ResponseError("Product dose not exist.", 404);
+    }
+    await productCache.delete(id.toString());
+    await productsCache.delete("key");
     return products.splice(index, 1)[0];
   }
 }

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

@@ -1,23 +1,17 @@
-import { z } from "zod";
-
-/**
- * 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.email(),
-  password: z.string().min(6),
-});
+import { ZodUser } from "@/entities/user.entity";
+import z from "zod";
 
 export const ZodUserCreationDto = ZodUser.omit({ id: true });
 export const ZodUserDto = ZodUser.omit({ password: true });
 
-export type User = z.infer<typeof ZodUser>;
-export type UserCreationDto = z.infer<typeof ZodUserCreationDto>;
-export type UserDto = z.infer<typeof ZodUserDto>;
+export type UserCreationDto = {
+  username: string;
+  email: string;
+  password: string;
+};
+
+export type UserDto = {
+  id: number;
+  username: string;
+  email: string;
+};

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

@@ -1,9 +1,10 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
+import { resolve } from "@/utilities/container";
 
 const router = Router();
-const userController = new UserController();
+const userController = resolve(UserController);
 
 /**
  * @swagger
@@ -45,8 +46,9 @@ const userController = new UserController();
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const user = await userController.create(req.body);
-    res.status(201).json(user);
+    const user = await userController.validateUserCreationDto(req.body);
+    await userController.create(user);
+    res.status(201).send();
   })
 );
 
@@ -71,7 +73,8 @@ router.post(
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const user = await userController.get(req.params.id);
+    const id = await userController.validateId(req.params.id);
+    const user = await userController.get(id);
     res.json(user);
   })
 );