codeweaver 1.0.15 → 1.1.0

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

@@ -0,0 +1,237 @@
+import { onError, rateLimit, timeout } from "utils-decorators";
+import {
+  Product,
+  ProductCreationDto,
+  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,
+  },
+];
+
+function exceedHandler() {
+  const message = "Too much call in allowed window";
+
+  throw new Error(message, {
+    cause: { status: 500, message } satisfies ResponseError,
+  });
+}
+
+function getProductErrorHandler(e: Error) {
+  const message = "User not found.";
+
+  throw new Error(message, {
+    cause: { status: 404, message, details: e.message } satisfies ResponseError,
+  });
+}
+
+/**
+ * Controller for handling product-related operations
+ * @class ProductController
+ * @desc Provides methods for product management including CRUD operations
+ */
+export default class ProductController {
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    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
+  ) {
+    products.push({
+      ...product,
+      id: products.length + 1,
+    } satisfies Product);
+
+    return product;
+  }
+
+  @timeout(20000)
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    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)
+    );
+  }
+
+  @onError({
+    func: getProductErrorHandler,
+  })
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    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<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;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @Validate
+  /**
+   * Updates an existing product
+   * @param {string} id - Product ID to update
+   * @param {ProductUpdateDto} updateData - Partial product data to update
+   * @returns {Promise<Product | ResponseError>} 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> {
+    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;
+
+    return product;
+  }
+
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Deletes a product by ID
+   * @param {string} id - Product ID to delete
+   * @returns {Promise<Product | ResponseError>} 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;
+  }
+}

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

@@ -1,9 +1,21 @@
 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(),
   password: z.string().min(6),
 });
 
-export type CreateUser = z.infer<typeof CreateUserDto>;
+export const ZodUserCreationDto = ZodUser.omit({ id: true });
+
+export type User = z.infer<typeof ZodUser>;
+export type UserCreationDto = z.infer<typeof ZodUserCreationDto>;

package/src/routers/users/index.ts

@@ -1,6 +1,7 @@
 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();
@@ -11,70 +12,87 @@ const userController = new UserController();
  *   post:
  *     summary: Create a user
  *     description: Create a new user.
- *     requestBody:
- *       required: true
- *       content:
- *         application/json:
- *           schema:
- *             type: object
- *             required:
- *               - username
- *               - email
- *               - password
- *             properties:
- *               username:
- *                 type: string
- *               email:
- *                 type: string
- *               password:
- *                 type: string
- *             example: # Sample object
- *               username: JessicaSmith
- *               email: william.howard.taft@my-own-personal-domain.com
- *               password: password123
+ *     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: product created
+ *         description: User created
  */
 router.post(
   "/",
   asyncHandler(async (req: Request, res: Response) => {
-    const result = await userController.createUser(req.body);
-    res.status(201).json({ message: result });
+    const user = await userController.create(req.body);
+    res.status(201).json(user);
   })
 );
 
 /**
  * @swagger
- * /user:
+ * /users/{id}:
  *   get:
- *     summary: Get user home
- *     description: Returns the user home page.
+ *     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: User home page
+ *         description: A user object
+ *       404:
+ *         description: user not found
  */
 router.get(
-  "/",
+  "/:id",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Home");
+    const user = await userController.get(req.params.id);
+
+    if ("id" in user == false) sendError(res, user);
+    else res.json(user);
   })
 );
 
 /**
  * @swagger
- * /user/profile:
+ * /users:
  *   get:
- *     summary: Get user profile
- *     description: Returns user profile information.
+ *     summary: Get users
+ *     description: Returns a list of user objects.
  *     responses:
  *       200:
- *         description: User profile information
+ *         description: A list of user objects
  */
 router.get(
-  "/profile",
+  "/",
   asyncHandler(async (req: Request, res: Response) => {
-    res.send("User Profile");
+    res.json(await userController.getAll());
   })
 );
 

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

@@ -1,33 +1,161 @@
-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 } from "./dto/user.dto";
+import { onError, rateLimit, timeout } from "utils-decorators";
+import { Validate, ZodInput } from "@pkg/ts-zod-decorators";
+import { ResponseError } from "@/types";
+import { tryParseId } from "@/utilities";
+
+// 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 Error(message, {
+    cause: { status: 500, message } satisfies ResponseError,
+  });
 }
 
-function errorHandler(e: Error): void {
-  console.error(e);
+function getUserErrorHandler(e: Error) {
+  const message = "User not found.";
+
+  throw new Error(message, {
+    cause: { status: 404, message, details: e.message } satisfies ResponseError,
+  });
 }
 
+/**
+ * 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,
     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 } satisfies User);
+  }
+
   @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: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  /**
+   * Get user by ID
+   * @param {string} id - User ID as string
+   * @returns {Promise<User | ResponseError>} User details or error object
+   * @throws {ResponseError} 404 - User not found
+   * @throws {ResponseError} 400 - Invalid ID format
+   */
+  public async get(id: string): Promise<User | ResponseError> {
+    const userId = tryParseId(id);
+    if (typeof userId != "number") return userId satisfies ResponseError;
+    const user = users.find((user) => user.id === userId);
+
+    if (!user)
+      return {
+        status: 404,
+        message: "User dose not exist.",
+      } satisfies ResponseError;
+
+    return user satisfies User;
+  }
+
+  @timeout(20000)
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    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<User[]> {
+    return users.map(
+      (user) =>
+        ({
+          ...user,
+          password: "?",
+        } satisfies User)
+    );
   }
 }

package/src/types.ts

@@ -0,0 +1,16 @@
+/**
+ * Represents a standardized error response structure for API endpoints
+ * @interface
+ * @property {number} status - HTTP status code
+ * @property {string} [name] - Error name/type
+ * @property {string} message - Human-readable error message
+ * @property {string} [stack] - Error stack trace (development only)
+ * @property {string} [details] - Additional error details
+ */
+export interface ResponseError {
+  status: number;
+  name?: string;
+  message: string;
+  stack?: string;
+  details?: string;
+}

package/src/utilities.ts

@@ -0,0 +1,47 @@
+import { Response } from "express";
+import { ResponseError } from "./types";
+
+/**
+ * Sends a standardized error response
+ * @param {Response} res - Express response object
+ * @param {ResponseError} error - Error details object
+ */
+export function sendError(res: Response, error: ResponseError): void {
+  res.status(error.status).json(error);
+}
+
+/**
+ * Parses and validates ID parameter from string to number
+ * @param {string} input - Input string to parse
+ * @returns {number|ResponseError} Parsed number or error object
+ */
+export function tryParseId(input: string): number | ResponseError {
+  try {
+    return parseInt(input) satisfies number;
+  } catch {
+    return {
+      status: 400,
+      message: "wrong input",
+      details: "The id parameter must be an integer number.",
+    } satisfies ResponseError;
+  }
+}
+
+/**
+ * Checks if the provided object is a ResponseError.
+ *
+ * A ResponseError is an object that contains at least the properties:
+ * - message: string
+ * - status: number
+ *
+ * @param obj - The object to check.
+ * @returns true if the object is a ResponseError, false otherwise.
+ */
+export function isResponseError(obj: unknown): boolean {
+  return (
+    obj != null &&
+    typeof obj === "object" &&
+    "message" in obj &&
+    "status" in obj
+  );
+}

package/tsconfig.json

@@ -1,6 +1,6 @@
 {
   "compilerOptions": {
-    "target": "ESNext",
+    "target": "ES2023",
     "module": "commonjs",
     "outDir": "./dist",
     "strict": true,
@@ -8,8 +8,14 @@
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "emitDecoratorMetadata": true,
+    "baseUrl": ".",
+    "paths": {
+      "@pkg/*": ["src/packages/*"],
+      "@r/*": ["src/routers/*"],
+      "@/*": ["src/*"]
+    }
   },
-  "include": ["src/**/*.ts", "src/**/*.js", "command.js"],
+  "include": ["**/*.ts", "**/*.js"],
   "exclude": ["node_modules"]
 }

package/tsconfig.paths.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "baseUrl": ".",
+    "paths": {
+      "@pkg/*": ["dist/packages/*"],
+      "@r/*": ["dist/routers/*"],
+      "@/*": ["dist/*"]
+    }
+  }
+}