codeweaver 1.1.0 → 2.1.0

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

@@ -1,237 +1,212 @@
-import { 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 "@pkg/ts-zod-decorators";
-import { ResponseError } from "@/types";
-import { tryParseId } from "@/utilities";
-
-// 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 { MapAsyncCache } from "@/utilities/cache/memory-cache";
+import { convert, stringToInteger } from "@/utilities/conversion";
+import config from "@/config";
+import { ResponseError } from "@/utilities/error-handling";
+import { products } from "@/db";
+import { Product, ZodProduct } from "@/entities/product.entity";
 
 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 getProductErrorHandler(e: Error) {
-  const message = "User not found.";
+function productNotFoundHandler(e: ResponseError) {
+  const message = "Product 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 productsCache = new MapAsyncCache<ProductDto[]>(config.cacheSize);
+const productCache = new MapAsyncCache<ProductDto>(config.cacheSize);
+
 /**
  * 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: productNotFoundHandler,
+  })
+  /**
+   * 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: 60000,
-    allowedCalls: 300,
+    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
-  ) {
-    products.push({
+  public async create(product: Product): Promise<void> {
+    const newProduct: Product = {
       ...product,
       id: products.length + 1,
-    } satisfies Product);
+    };
 
-    return product;
+    products.push(newProduct);
+    await productCache.set(newProduct.id.toString(), newProduct as ProductDto);
+    await productsCache.delete("key");
   }
 
-  @timeout(20000)
+  @memoizeAsync({
+    cache: productsCache,
+    keyResolver: () => "key",
+    expirationTimeMs: config.memoizeTime,
+  })
+  @timeout(config.timeout)
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Retrieves all products with truncated descriptions
    * @returns List of products with summarized descriptions
    */
-  public async getAll(): Promise<Product[]> {
-    return products.map(
-      (product) =>
-        ({
-          ...product,
-          description: product.description?.substring(0, 50) + "..." || "",
-        } satisfies Product)
-    );
+  public async getAll(): Promise<ProductDto[]> {
+    return products as ProductDto[];
   }
 
+  @memoizeAsync({
+    cache: productCache,
+    keyResolver: (id: number) => id.toString(),
+    expirationTimeMs: config.memoizeTime,
+  })
   @onError({
-    func: getProductErrorHandler,
+    func: productNotFoundHandler,
   })
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * 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<Product | ResponseError> {
-    const productId = tryParseId(id);
-    if (typeof productId != "number") return productId satisfies ResponseError;
-    const product = products.find((product) => product.id === productId);
-
-    if (!product)
-      return {
-        status: 404,
-        message: "Product dose not exist.",
-      } satisfies ResponseError;
-
-    return product satisfies 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({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    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 | ResponseError>} Updated product or error object
+   * @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
-  ): Promise<Product | ResponseError> {
+    id: number,
+    updateData: ProductUpdateDto
+  ): Promise<ProductDto> {
     const product = await this.get(id);
-    if ("id" in product == false) return product satisfies ResponseError;
-
-    if (product) Object.assign(product, updateData);
-    else
-      return {
-        status: 404,
-        message: "Product not found",
-      } satisfies ResponseError;
+    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);
+    }
 
     return product;
   }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Deletes a product by ID
-   * @param {string} id - Product ID to delete
-   * @returns {Promise<Product | ResponseError>} Deleted product or error object
+   * @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<Product | ResponseError> {
-    const productId = tryParseId(id);
-    if (typeof productId != "number") return productId satisfies ResponseError;
-    const index = products.findIndex((product) => product.id === productId);
-
-    if (index == -1)
-      return {
-        status: 404,
-        message: "Product dose not exist.",
-      } satisfies ResponseError;
-
-    return products.splice(index, 1)[0] satisfies Product;
+  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,21 +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.string().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 UserCreationDto = {
+  username: string;
+  email: string;
+  password: string;
+};
 
-export type User = z.infer<typeof ZodUser>;
-export type UserCreationDto = z.infer<typeof ZodUserCreationDto>;
+export type UserDto = {
+  id: number;
+  username: string;
+  email: string;
+};

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

@@ -1,7 +1,6 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
-import { sendError } from "@/utilities";
 
 const router = Router();
 const userController = new UserController();
@@ -46,8 +45,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();
   })
 );
 
@@ -72,10 +72,9 @@ router.post(
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const user = await userController.get(req.params.id);
-
-    if ("id" in user == false) sendError(res, user);
-    else res.json(user);
+    const id = await userController.validateId(req.params.id);
+    const user = await userController.get(id);
+    res.json(user);
   })
 );