codeweaver 1.1.0 → 2.1.0

package/src/config.ts

@@ -1,48 +1,14 @@
-/**
- * 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
- */
-interface SwaggerOptions {
-  swaggerDefinition: SwaggerDefinition;
-  apis: string[];
-}
+import {
+  memoizeTime,
+  productionEnvironment,
+  rateLimitTimeSpan,
+  rateLimitAllowedCalls,
+  timeout,
+  portNumber,
+  cacheSize,
+} from "./constants";
+import { SwaggerOptions } from "./swagger-options";
+import { stringToBoolean } from "./utilities/conversion";
 
 /**
  * Main application configuration
@@ -53,14 +19,22 @@ interface SwaggerOptions {
  */
 interface Config {
   devMode: boolean;
-  port: string;
+  port: number;
+  swagger: boolean;
   swaggerOptions: SwaggerOptions;
+  timeout: number;
+  rateLimitTimeSpan: number;
+  rateLimitAllowedCalls: number;
+  memoizeTime: number;
+  cacheSize: number;
 }
 
-const port = process.env.PORT || "3000";
-const config: Config = {
-  devMode: process.env.NODE_ENV !== "production",
+const port = Number(process.env.PORT) || portNumber;
+
+let config: Config = {
+  devMode: process.env.NODE_ENV !== productionEnvironment,
   port,
+  swagger: stringToBoolean(process.env.SWAGGER || "true"),
   swaggerOptions: {
     swaggerDefinition: {
       openApi: "3.0.0",
@@ -76,23 +50,18 @@ const config: Config = {
       ],
     },
     apis: [
-      "./src/routers/index.ts",
-      "./src/routers/**/*.ts",
-      "./src/routers/index.js",
-      "./src/routers/**/*.js",
+      "./src/routers/index.router.ts",
+      "./src/routers/**/*.router.ts",
+      "./src/routers/index.router.js",
+      "./src/routers/**/*.router.js",
     ], // Path to the API docs
   },
+  timeout: Number(process.env.TIMEOUT) || timeout,
+  rateLimitTimeSpan: Number(process.env.RATE_LIMIT) || rateLimitTimeSpan,
+  rateLimitAllowedCalls:
+    Number(process.env.RATE_LIMIT) || rateLimitAllowedCalls,
+  memoizeTime: Number(process.env.MEMOIZE_TIME) || memoizeTime,
+  cacheSize: Number(process.env.CACHE_SIZE) || cacheSize,
 };
 
-// Other configurations:
-//
-// config.jwt_key = config.devMode ? "" : "";
-// config.jwt_expiration = config.devMode ? 360000 : 360000;
-// config.dbConnectionString = config.devMode ? `mongoDb url` : `mongoDb url`;
-// config.mongoDebug = config.devMode;
-// config.port = config.devMode ? 3000 : 3000;
-// config.host = config.devMode ? "localhost" : "localhost";
-// config.env = config.devMode ? "development" : "production";
-// config.mongoUrl = config.devMode ? "mongodb://localhost:27017/test" : "mongodb://localhost:27017/test";
-
 export default config;

package/src/constants.ts

@@ -0,0 +1,7 @@
+export const timeout = 20000;
+export const rateLimitTimeSpan = 60000;
+export const rateLimitAllowedCalls = 300;
+export const memoizeTime = 1000 * 60 * 60;
+export const cacheSize = 1000;
+export const productionEnvironment = "production";
+export const portNumber = 3000;

package/src/db.ts

@@ -0,0 +1,183 @@
+import { Order } from "@/entities/order.entity";
+import { Product } from "@/entities/product.entity";
+import { User } from "@/entities/user.entity";
+
+// Array to store users (as a mock database)
+export const users: User[] = [
+  {
+    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",
+  },
+];
+
+// Array to store products (as a mock database)
+export 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,
+  },
+];
+
+// Array to store orders (as a mock database)
+export 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"),
+  },
+];

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

@@ -0,0 +1,85 @@
+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";
+require("./app");
+
+/**
+ * Recursively loads Express routers from directory
+ * @param {string} routerPath - Directory path to scan
+ * @param {string} [basePath=""] - Base route path
+ */
+function loadRouters(routerPath: string, basePath: string = "") {
+  // Read entries with their type info
+  const entries = fs.readdirSync(routerPath, { withFileTypes: true });
+
+  for (const entry of entries) {
+    const fullPath = path.join(routerPath, entry.name);
+
+    if (entry.isDirectory()) {
+      // Recurse into subdirectories
+      const subRoutePath = path
+        .join(basePath, entry.name)
+        .replace(/\\/g, "/")
+        .replace(/\/?index$/g, "");
+      loadRouters(fullPath, subRoutePath);
+      continue;
+    }
+
+    // Only handle router files
+    if (
+      !entry.name.endsWith(".router.ts") &&
+      !entry.name.endsWith(".router.js")
+    ) {
+      continue;
+    }
+
+    // Build route path safely
+    const routePath = path
+      .join(basePath, entry.name.replace(/\.router\.[tj]s$/, ""))
+      .replace(/\\/g, "/")
+      .replace(/\/?index$/g, "");
+
+    // Optional: skip if the target path would be empty (maps to /)
+    const mountPath = "/" + (routePath || "");
+
+    // Import and mount
+    const router = require(fullPath);
+    app.use(mountPath, router);
+    console.log(`Mounted ${entry.name} at ${mountPath}`);
+  }
+}
+
+const app = express();
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Automatically import all routers from the /src/routers directory
+const routersPath = path.join(__dirname, "/routers");
+loadRouters(routersPath);
+
+// Swagger setup
+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));
+}
+
+// General error handler
+app.use(
+  (err: ResponseError, req: Request, res: Response, next: NextFunction) => {
+    res.status(err.status ?? 500).json(err);
+  }
+);
+
+// Start the server
+app.listen(config.port, () => {
+  console.log(`Server is running on http://localhost:${config.port}`);
+  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,5 +13,53 @@ export const ZodOrderCreationDto = ZodOrder.omit({
   deliveredAt: true,
 });
 
-export type Order = z.infer<typeof ZodOrder>;
-export type OrderCreationDto = z.infer<typeof ZodOrderCreationDto>;
+/**
+ * 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;
+};