codeweaver 2.0.0 → 2.2.0

package/src/entities/order.entity.ts

@@ -0,0 +1,68 @@
+import z from "zod";
+
+/**
+ * Zod schema for the Order entity.
+ * This schema validates orders to ensure data integrity before processing.
+ */
+export const ZodOrder = z.object({
+  /** Unique identifier for the order (positive integer). */
+  id: z.number().min(1).int(),
+
+  /** ID of the user who placed the order (positive integer). */
+  userId: z.number().min(1).int(),
+
+  /** Array of ordered products with their quantities. */
+  products: z.array(
+    z.object({
+      /** Product identifier referenced in the catalog */
+      productId: z.number().min(1).int(),
+
+      /** Quantity of the product ordered (at least 1) */
+      quantity: z.number().min(1).int(),
+    })
+  ),
+
+  /** Current status of the order */
+  status: z.enum(["Processing", "Delivered", "Canceled"]),
+
+  /** Total price of the order (minimum value constraint is 1000) */
+  total: z.number().min(1000),
+
+  /** Timestamp when the order was created */
+  createdAt: z.date(),
+
+  /** Optional timestamp when the order was canceled */
+  canceledAt: z.date().optional(),
+
+  /** Optional timestamp when the order was delivered */
+  deliveredAt: z.date().optional(),
+});
+
+export type Order = {
+  /** Unique identifier for the order */
+  id: number;
+
+  /** User ID who placed the order */
+  userId: number;
+
+  /** List of products in the order with quantities */
+  products: {
+    productId: number;
+    quantity: number;
+  }[];
+
+  /** Order status: Processing, Delivered, or Canceled */
+  status: "Processing" | "Delivered" | "Canceled";
+
+  /** Total price of the order */
+  total: number;
+
+  /** Order creation timestamp */
+  createdAt: Date;
+
+  /** Optional cancellation timestamp (if canceled) */
+  canceledAt?: Date | undefined;
+
+  /** Optional delivery timestamp (if delivered) */
+  deliveredAt?: Date | undefined;
+};

package/src/entities/product.entity.ts

@@ -0,0 +1,75 @@
+import z from "zod";
+
+/**
+ * Zod schema for the Product entity.
+ * This schema validates product data to ensure consistency
+ * before it is stored or processed.
+ */
+export const ZodProduct = z.object({
+  /** Unique identifier for the product. Must be a positive integer. */
+  id: z.number().min(1).int(),
+
+  /** Product name. Minimum length of 2 characters. */
+  name: z.string().min(2),
+
+  /** Product price. Minimum value of 1000 (assuming your currency unit). */
+  price: z.number().min(1000),
+
+  /** Optional product description. Minimum length of 10 characters if provided. */
+  description: z.string().min(10).optional(),
+
+  /** Product category from a predefined list. */
+  category: z.enum([
+    "Electronics",
+    "Appliances",
+    "Sports",
+    "Kitchen",
+    "Mobile Accessories",
+    "Computer Accessories",
+    "Home Appliances",
+    "Books",
+  ]),
+
+  /** Stock count in inventory. Non-negative integer. */
+  stock: z.number().min(0).int(),
+});
+
+/**
+ * TypeScript type for a Product entity.
+ * Mirrors the Zod schema with an optional description.
+ */
+export type Product = {
+  /** Unique identifier for the product. */
+  id: number;
+
+  /** Display name of the product. */
+  name: string;
+
+  /** Price of the product in the chosen currency. */
+  price: number;
+
+  /**
+   * Category of the product.
+   * Must be one of the predefined categories:
+   * - Electronics, Appliances, Sports, Kitchen, Mobile Accessories,
+   *   Computer Accessories, Home Appliances, Books
+   */
+  category:
+    | "Electronics"
+    | "Appliances"
+    | "Sports"
+    | "Kitchen"
+    | "Mobile Accessories"
+    | "Computer Accessories"
+    | "Home Appliances"
+    | "Books";
+
+  /** Current stock level in inventory. Non-negative. */
+  stock: number;
+
+  /**
+   * Optional product description.
+   * Includes more details about the product when provided.
+   */
+  description?: string | undefined;
+};

package/src/entities/user.entity.ts

@@ -0,0 +1,38 @@
+import z from "zod";
+
+/**
+ * Zod schema for the User entity.
+ * This schema validates user data to ensure it meets basic integrity requirements
+ * before being stored or processed.
+ */
+export const ZodUser = z.object({
+  /** Unique identifier for the user. Must be a positive integer. */
+  id: z.number().min(1).int(),
+
+  /** Username chosen by the user. Minimum length of 3 characters. */
+  username: z.string().min(3),
+
+  /** Email address of the user. Must be a valid email format. */
+  email: z.email(),
+
+  /** Password for the user. Minimum length of 6 characters. */
+  password: z.string().min(6),
+});
+
+/**
+ * TypeScript type for a User entity.
+ * Mirrors the Zod schema.
+ */
+export type User = {
+  /** Unique identifier for the user. */
+  id: number;
+
+  /** Username chosen by the user. */
+  username: string;
+
+  /** Email address of the user. */
+  email: string;
+
+  /** Password for the user. */
+  password: string;
+};

package/src/main.ts

@@ -2,6 +2,9 @@ import express, { NextFunction, Request, Response } from "express";
 import fs from "fs";
 import path from "path";
 import config from "./config";
+import { ResponseError } from "./utilities/error-handling";
+import { resolve } from "./utilities/container";
+import { WinstonLoggerService } from "./utilities/logger/winston-logger.service";
 
 /**
  * Recursively loads Express routers from directory
@@ -53,30 +56,39 @@ const app = express();
 app.use(express.json());
 app.use(express.urlencoded({ extended: true }));
 
-//app.use(cors());
-
 // Automatically import all routers from the /src/routers directory
 const routersPath = path.join(__dirname, "/routers");
 loadRouters(routersPath);
 
 // Swagger setup
-if (config.devMode) {
+if (config.swagger) {
   const swaggerJsDoc = require("swagger-jsdoc");
   const swaggerUi = require("swagger-ui-express");
   const swaggerDocs = swaggerJsDoc(config.swaggerOptions);
   app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocs));
 }
 
+const logger = resolve(WinstonLoggerService);
+
 // General error handler
-app.use((err: unknown, req: Request, res: Response, next: NextFunction) => {
-  res.status(500).json(err);
-});
+app.use(
+  (error: ResponseError, req: Request, res: Response, next: NextFunction) => {
+    const status = error.status ?? 500;
+    res.status(status).json(error);
+    if (status < 500) {
+      logger.warn(error.message, "Invalid request", error.details);
+    } else {
+      logger.error(error.message, "Server error", error.details);
+    }
+  }
+);
 
 // Start the server
 app.listen(config.port, () => {
   console.log(`Server is running on http://localhost:${config.port}`);
-  if (config.devMode)
+  if (config.devMode) {
     console.log(
       `Swagger UI is available at http://localhost:${config.port}/api-docs`
     );
+  }
 });

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

@@ -1,33 +1,10 @@
-import { z } from "zod";
+import { ZodOrder } from "@/entities/order.entity";
 
 /**
- * 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
+ * DTO for creating an order.
+ * This is derived from the full Order schema by omitting fields
+ * that are typically generated by the system (id, status, timestamps).
  */
-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,
@@ -36,6 +13,53 @@ export const ZodOrderCreationDto = ZodOrder.omit({
   deliveredAt: true,
 });
 
-export type Order = z.infer<typeof ZodOrder>;
-export type OrderCreationDto = z.infer<typeof ZodOrderCreationDto>;
-export type OrderDto = z.infer<typeof ZodOrder>;
+/**
+ * Data Transfer Object for creating an order.
+ * Represents the minimal data required to create an order.
+ */
+export type OrderCreationDto = {
+  /** ID of the user placing the order. */
+  userId: number;
+
+  /** List of products included in the order with their quantities. */
+  products: {
+    productId: number;
+    quantity: number;
+  }[];
+
+  /** Total price for the order (validated by the server/persistence layer). */
+  total: number;
+};
+
+/**
+ * Data Transfer Object for a full Order view.
+ * Represents the complete order data as returned by the API/service.
+ */
+export type OrderDto = {
+  /** Unique identifier for the order. */
+  id: number;
+
+  /** User ID who placed the order. */
+  userId: number;
+
+  /** List of products in the order with their quantities. */
+  products: {
+    productId: number;
+    quantity: number;
+  }[];
+
+  /** Current status of the order: Processing, Delivered, or Canceled. */
+  status: "Processing" | "Delivered" | "Canceled";
+
+  /** Total price for the order. */
+  total: number;
+
+  /** Timestamp when the order was created. */
+  createdAt: Date;
+
+  /** Optional timestamp when the order was canceled (if canceled). */
+  canceledAt?: Date | undefined;
+
+  /** Optional timestamp when the order was delivered (if delivered). */
+  deliveredAt?: Date | undefined;
+};

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

@@ -1,16 +1,17 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import OrderController from "./order.controller";
+import { resolve } from "@/utilities/container";
 
 const router = Router();
-const orderController = new OrderController();
+const orderController = resolve(OrderController);
 
 /**
  * @swagger
  * /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:
@@ -58,8 +59,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();
   })
 );
 
@@ -99,7 +101,8 @@ router.get(
 router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    const order = await orderController.get(req.params.id);
+    const id = await orderController.validateId(req.params.id);
+    const order = await orderController.get(id);
     res.json(order);
   })
 );
@@ -123,7 +126,8 @@ router.get(
 router.patch(
   "/:id/cancel",
   asyncHandler(async (req: Request, res: Response) => {
-    const order = await orderController.cancel(req.params.id);
+    const id = await orderController.validateId(req.params.id);
+    const order = await orderController.cancel(id);
     res.json(order);
   })
 );
@@ -149,7 +153,8 @@ router.patch(
 router.patch(
   "/:id/deliver",
   asyncHandler(async (req: Request, res: Response) => {
-    const order = await orderController.deliver(req.params.id);
+    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,94 +1,96 @@
 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 { ResponseError } from "@/utilities/error-handling";
+import { convert, stringToInteger } from "@/utilities/conversion";
 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"),
-  },
-];
+import { orders } from "@/db";
+import { Order, ZodOrder } from "@/entities/order.entity";
+import { MapAsyncCache } from "@/utilities/cache/memory-cache";
+import { Injectable } from "@/utilities/container";
 
 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);
+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);
+
+@Injectable()
 /**
  * Controller for handling order-related operations
  * @class OrderController
  * @desc Provides methods for order management including creation, status updates and retrieval
  */
 export default class OrderController {
+  // constructor(private readonly orderService: OrderService) { }
+
+  @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 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,
+      status: "Processing",
+      createdAt: new Date(),
+    };
+  }
+
   @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
+   * @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(@ZodInput(ZodOrderCreationDto) order: OrderCreationDto) {
-    const newOrder = {
-      ...order,
-      id: orders.length + 1,
-      createdAt: new Date(),
-      status: "Processing",
-    } satisfies Order;
-
-    orders.push(newOrder);
-    return newOrder;
+  public async create(order: Order): Promise<void> {
+    orders.push(order);
+    await orderCache.set(order.id.toString(), order as OrderDto);
+    await ordersCache.delete("key");
   }
 
-  @memoizeAsync(config.memoizeTime)
+  @memoizeAsync({
+    cache: ordersCache,
+    keyResolver: () => "key",
+    expirationTimeMs: config.memoizeTime,
+  })
   @timeout(config.timeout)
   @rateLimit({
     timeSpanMs: config.rateLimitTimeSpan,
@@ -100,28 +102,30 @@ export default class OrderController {
    * @returns List of orders
    */
   public async getAll(): Promise<OrderDto[]> {
-    return orders;
+    return orders as OrderDto[];
   }
 
-  @memoizeAsync(config.memoizeTime)
+  @memoizeAsync({
+    cache: orderCache,
+    keyResolver: (id: number) => id.toString(),
+    expirationTimeMs: 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
+   * @param {number} 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;
+  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({
@@ -131,12 +135,12 @@ export default class OrderController {
   })
   /**
    * Cancel an existing order
-   * @param {string} id - Order ID to cancel
+   * @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<OrderDto> {
+  public async cancel(id: number): Promise<OrderDto> {
     let order = await this.get(id);
     if (order.status != "Processing") {
       throw new ResponseError(
@@ -144,10 +148,12 @@ export default class OrderController {
         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({
@@ -157,12 +163,12 @@ export default class OrderController {
   })
   /**
    * Mark an order as delivered
-   * @param {string} id - Order ID to mark as delivered
+   * @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<OrderDto> {
+  public async deliver(id: number): Promise<OrderDto> {
     let order = await this.get(id);
     if (order.status != "Processing") {
       throw new ResponseError(
@@ -170,9 +176,11 @@ export default class OrderController {
         400
       );
     }
-
     order.status = "Delivered";
     order.deliveredAt = new Date();
-    return order satisfies Order;
+
+    await orderCache.set(id.toString(), order);
+    await ordersCache.delete("key");
+    return order;
   }
 }