codeweaver 1.0.15 → 2.0.0

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

@@ -0,0 +1,217 @@
+import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
+import {
+  Product,
+  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 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,
+  },
+];
+
+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);
+}
+
+/**
+ * Controller for handling product-related operations
+ * @class ProductController
+ * @desc Provides methods for product management including CRUD operations
+ */
+export default class ProductController {
+  @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
+   */
+  public async create(
+    @ZodInput(ZodProductCreationDto) product: ProductCreationDto
+  ): Promise<ProductDto> {
+    products.push({
+      ...product,
+      id: products.length + 1,
+    } satisfies Product);
+
+    return product as ProductDto;
+  }
+
+  @memoizeAsync(config.memoizeTime)
+  @timeout(config.timeout)
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Retrieves all products with truncated descriptions
+   * @returns List of products with summarized descriptions
+   */
+  public async getAll(): Promise<ProductDto[]> {
+    return products.map((product) => ({
+      ...product,
+      description: product.description?.substring(0, 50) + "..." || "",
+    }));
+  }
+
+  @memoizeAsync(config.memoizeTime)
+  @onError({
+    func: getProductErrorHandler,
+  })
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Finds a product by its ID
+   * @param 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;
+  }
+
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  @Validate
+  /**
+   * Updates an existing product
+   * @param {string} 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
+  ): Promise<ProductDto> {
+    const product = await this.get(id);
+    if ("id" in product == false) return product satisfies ResponseError;
+
+    if (product) {
+      Object.assign(product, updateData);
+    } else {
+      throw new ResponseError("Product dose not exist.", 404);
+    }
+
+    return product;
+  }
+
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Deletes a product by ID
+   * @param {string} 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);
+    return products.splice(index, 1)[0];
+  }
+}

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

@@ -1,9 +1,23 @@
 import { z } from "zod";
 
-export const CreateUserDto = z.object({
+/**
+ * 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(),
+  email: z.email(),
   password: z.string().min(6),
 });
 
-export type CreateUser = z.infer<typeof CreateUserDto>;
+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>;

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

@@ -0,0 +1,96 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+import UserController from "./user.controller";
+
+const router = Router();
+const userController = new UserController();
+
+/**
+ * @swagger
+ * /users:
+ *   post:
+ *     summary: Create a user
+ *     description: Create a new user.
+ *     consumes:
+ *       - application/json
+ *     produces:
+ *       - application/json
+ *     parameters:
+ *       - in: body
+ *         name: user
+ *         required: true
+ *         schema:
+ *           type: object
+ *           required:
+ *             - username
+ *             - email
+ *             - password
+ *           properties:
+ *             username:
+ *               type: string
+ *               minLength: 3
+ *               example: JessicaSmith
+ *             email:
+ *               type: string
+ *               format: email
+ *               example: user@example.com
+ *             password:
+ *               type: string
+ *               minLength: 6
+ *               example: securePassword123
+ *     responses:
+ *       201:
+ *         description: User created
+ */
+router.post(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const user = await userController.create(req.body);
+    res.status(201).json(user);
+  })
+);
+
+/**
+ * @swagger
+ * /users/{id}:
+ *   get:
+ *     summary: Get a user by ID
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: A user object
+ *       404:
+ *         description: user not found
+ */
+router.get(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const user = await userController.get(req.params.id);
+    res.json(user);
+  })
+);
+
+/**
+ * @swagger
+ * /users:
+ *   get:
+ *     summary: Get users
+ *     description: Returns a list of user objects.
+ *     responses:
+ *       200:
+ *         description: A list of user objects
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.json(await userController.getAll());
+  })
+);
+
+export = router;

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

@@ -1,33 +1,153 @@
-import { Validate, ZodInput } from "ts-zod-decorators";
-import { CreateUserDto, CreateUser } from "./dto/user.dto";
-import { onError, rateLimit, throttle } from "utils-decorators";
+import {
+  User,
+  ZodUserCreationDto,
+  UserCreationDto,
+  UserDto,
+} from "./dto/user.dto";
+import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
+import { Validate, ZodInput } from "ts-zod4-decorators";
+import { ResponseError } from "@/utilities/types";
+import { parseId } from "@/utilities/error-handling";
+import config from "@/config";
+
+// Array to store users (as a mock database)
+const users = [
+  {
+    id: 1,
+    username: "johndoe",
+    email: "johndoe@gmail.com",
+    password: "S3cur3P@ssw0rd",
+  },
+  {
+    id: 2,
+    username: "janesmith",
+    email: "janesmith@yahoo.com",
+    password: "P@ssw0rd2024",
+  },
+  {
+    id: 3,
+    username: "michael89",
+    email: "michael89@hotmail.com",
+    password: "M1chael!2024",
+  },
+  {
+    id: 4,
+    username: "lisa.wong",
+    email: "lisa.wong@example.com",
+    password: "L1saW0ng!2024",
+  },
+  {
+    id: 5,
+    username: "alex_k",
+    email: "alex.k@gmail.com",
+    password: "A1ex#Key2024",
+  },
+  {
+    id: 6,
+    username: "emilyj",
+    email: "emilyj@hotmail.com",
+    password: "Em!ly0101",
+  },
+  {
+    id: 7,
+    username: "davidparker",
+    email: "david.parker@yahoo.com",
+    password: "D@v!d2024",
+  },
+  {
+    id: 8,
+    username: "sophia_m",
+    email: "sophia.m@gmail.com",
+    password: "Sophi@2024",
+  },
+  {
+    id: 9,
+    username: "chrisw",
+    email: "chrisw@outlook.com",
+    password: "Chri$Wong21",
+  },
+  {
+    id: 10,
+    username: "natalie_b",
+    email: "natalie_b@gmail.com",
+    password: "N@talie#B2024",
+  },
+];
 
 function exceedHandler() {
-  throw new Error("Too much call in allowed window");
+  const message = "Too much call in allowed window";
+  throw new ResponseError(message, 429);
 }
 
-function errorHandler(e: Error): void {
-  console.error(e);
+function getUserErrorHandler(e: Error) {
+  const message = "User not found.";
+  throw new ResponseError(message, 404, e.message);
 }
 
+/**
+ * Controller for handling user-related operations
+ * @class UserController
+ * @desc Provides methods for user management including CRUD operations
+ */
 export default class UserController {
-  //constructor(private readonly userService: UserService) { }
+  // constructor(private readonly userService: UserService) { }
 
-  // Throttle the createUser method to 1 request per 200 milliseconds
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
+  @Validate
+  /**
+   * Create a new user
+   * @param {UserCreationDto} user - User 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(ZodUserCreationDto) user: UserCreationDto) {
+    users.push({ ...user, id: users.length + 1 });
+  }
+
+  @memoizeAsync(config.memoizeTime)
   @onError({
-    func: errorHandler,
+    func: getUserErrorHandler,
   })
-  @Validate
-  public async createUser(
-    @ZodInput(CreateUserDto) data: CreateUser
-  ): Promise<string> {
-    // Here you can include logic to save user to database
-    console.log("Creating user:", data);
-    return "User created successfully";
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Get user by ID
+   * @param {string} id - User ID as string
+   * @returns {Promise<User>} User details or error object
+   * @throws {ResponseError} 404 - User not found
+   * @throws {ResponseError} 400 - Invalid ID format
+   */
+  public async get(id: string): Promise<UserDto> {
+    const response = parseId(id);
+    const user = users.find((user) => user.id === response);
+    if (user == null) throw new ResponseError("User dose not exist.", 404);
+    return user satisfies User;
+  }
+
+  @memoizeAsync(config.memoizeTime)
+  @timeout(config.timeout)
+  @rateLimit({
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
+    exceedHandler,
+  })
+  /**
+   * Get all users with masked passwords
+   * @returns {Promise<User[]>} List of users with hidden password fields
+   * @throws {ResponseError} 500 - When rate limit exceeded
+   */
+  public async getAll(): Promise<UserDto[]> {
+    return users.map((user) => ({
+      ...user,
+      password: "?",
+    }));
   }
 }

package/src/swagger-options.ts

@@ -0,0 +1,54 @@
+import {
+  memoizeTime,
+  productionEnvironment,
+  rateLimitTimeSpan,
+  rateLimitAllowedCalls,
+  timeout,
+  portNumber,
+} from "./constants";
+
+/**
+ * Server configuration interface
+ * @interface
+ * @property {string} url - Base server URL
+ */
+interface Server {
+  url: string;
+}
+
+/**
+ * API information structure
+ * @interface
+ * @property {string} title - API title
+ * @property {string} version - API version
+ * @property {string} description - API description
+ */
+interface Info {
+  title: string;
+  version: string;
+  description: string;
+}
+
+/**
+ * Swagger definition structure
+ * @interface
+ * @property {string} openApi - OpenAPI specification version
+ * @property {Info} info - API information
+ * @property {Server[]} servers - List of server configurations
+ */
+interface SwaggerDefinition {
+  openApi: string;
+  info: Info;
+  servers: Server[];
+}
+
+/**
+ * Swagger configuration options
+ * @interface
+ * @property {SwaggerDefinition} swaggerDefinition - Swagger definition object
+ * @property {string[]} apis - Paths to API documentation files
+ */
+export interface SwaggerOptions {
+  swaggerDefinition: SwaggerDefinition;
+  apis: string[];
+}

package/src/utilities/assign.ts

@@ -0,0 +1,81 @@
+import { z, ZodRawShape } from "zod";
+import { ResponseError } from "./types";
+
+/**
+ * Strictly convert obj (type T1) to T2 using a Zod schema.
+ *
+ * - Throws if obj has extra fields beyond those defined in the schema.
+ * - Validates fields with the schema; on failure, throws with a descriptive message.
+ * - Returns an object typed as T2 (inferred from the schema).
+ *
+ * @param obj - Source object of type T1
+ * @param schema - Zod schema describing the target type T2
+ * @returns T2 inferred from the provided schema
+ */
+export function assignStrictlyFromSchema<T1 extends object, T2 extends object>(
+  obj: T1,
+  schema: z.ZodObject<any>
+): T2 {
+  // 1) Derive the runtime keys from the schema's shape
+  const shape = (schema as any)._def?.shape as ZodRawShape | undefined;
+  if (!shape) {
+    throw new ResponseError(
+      "assignStrictlyFromSchema: provided schema has no shape.",
+      500
+    );
+  }
+
+  const keysSchema = Object.keys(shape) as Array<keyof any>;
+
+  // 2) Extra keys check
+  const objKeys = Object.keys(obj) as Array<keyof T1>;
+  const extraKeys = objKeys.filter((k) => !keysSchema.includes(k as any));
+  if (extraKeys.length > 0) {
+    throw new ResponseError(
+      `assignStrictlyFromSchema: source object contains extra field(s) not present on target: ${extraKeys.join(
+        ", "
+      )}`,
+      500
+    );
+  }
+
+  // 3) Required-field check for T2 (all keys in schema must be present and non-undefined)
+  const missingOrUndefined = keysSchema.filter((k) => {
+    const v = (obj as any)[k];
+    return v === undefined || v === null;
+  });
+  if (missingOrUndefined.length > 0) {
+    throw new ResponseError(
+      `assignStrictlyFromSchema: missing required field(s): ${missingOrUndefined.join(
+        ", "
+      )}`,
+      500
+    );
+  }
+
+  // 4) Build a plain object to pass through Zod for validation
+  const candidate: any = {};
+  for (const k of keysSchema) {
+    if (k in (obj as any)) {
+      candidate[k] = (obj as any)[k];
+    }
+  }
+
+  // 5) Validate against the schema
+  const result = schema.safeParse(candidate);
+  if (!result.success) {
+    // Modern, non-format error reporting
+    const issues = result.error.issues.map((i) => ({
+      path: i.path, // where the issue occurred
+      message: i.message, // human-friendly message
+      code: i.code, // e.g., "too_small", "invalid_type"
+    }));
+    // You can log issues or throw a structured error
+    throw new Error(
+      `assignStrictlyFromSchema: validation failed: ${JSON.stringify(issues)}`
+    );
+  }
+
+  // 6) Return the validated data typed as T2
+  return result.data as T2;
+}