codeweaver 1.1.0 → 2.0.0

package/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "cSpell.words": ["microframework"]
+}

package/README.md

@@ -53,34 +53,36 @@ To get started with the project, follow these steps:
 
 **/src**  
 ├── **/routers** `Directory containing all router files`  
-│ ├── **/user** `Routers for user-related endpoints`  
-│ │ ├── user_router1.ts `/user/user_router1`  
-│ │ ├── user_router2.ts `/user/user_router2`  
+│ ├── **/users** `Routers for user-related endpoints`  
+│ │ ├── index.router.ts `/users`  
+│ │ ├── user-router2.router.ts `/users/user-router2`  
 │ │ ├── user.controller.ts  
 │ │ ├── user.service.ts  
 │ │ └── user.dto.ts  
-│ ├── **/product** `Routers for product-related endpoints`  
-│ │ ├── index.ts `/product`  
-│ │ ├── product_test.spec.ts  
+│ ├── **/products** `Routers for product-related endpoints`  
+│ │ ├── index.router.ts `/products`  
 │ │ ├── product.controller.ts  
 │ │ ├── product.service.ts  
-│ │ ├── **/dto**  
+│ │ ├── **/dtos**  
 │ │ │ └── product.dto.ts  
-│ ├── **/order** `Routers for order-related endpoints`  
-│ │ ├── index.ts `/order`  
-│ │ ├── order_test.spec.ts  
+| | │ └── product-types.dto.ts  
+│ ├── **/orders** `Routers for order-related endpoints`  
+│ │ ├── index.router.ts `/orders`  
 │ │ ├── order.controller.ts  
-│ │ └── order.service.ts  
-│ └── index.ts `Home page`  
+│ │ ├── order.controller.spec.ts  
+│ │ ├── order.service.ts  
+│ │ └── order.service.spec.ts  
+│ └── index.router.ts `Home page`  
+│ └── app.controller.ts `Home page`  
 ├── app.ts `Main application file`  
 ├── config.ts `Application configuration file`  
 └── ... `Other files (middleware, models, etc.)`
 
 ### Router Directory
 
-Each router file in the `/routers` directory is organized to handle related endpoints. The `app.ts` file automatically imports all routers and mounts them to the main Express application, making it simple to add new routes without modifying central files.
+Each router file in the `/routers` directory is organized to handle related endpoints. The `app.ts` file automatically imports all routers and mounts them on the main Express application, making it straightforward to add new routes without touching central code.
 
-Files that end with `.controller`, `.service`, `.spec`, `.dto`, `.middleware`, `.error`, `.class`, or `.decorator`, as well as those that start with `_` or `@`, are excluded from the router list and can be utilized for various other purposes within the application.
+Files ending with `.router.ts` or `.router.js` are automatically included in the router list and can be reused for various purposes within the application.
 
 Example of a basic router:
 
@@ -88,7 +90,6 @@ Example of a basic router:
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import UserController from "./user.controller";
-import { sendError } from "@src/utilities";
 
 const router = Router();
 const userController = new UserController();
@@ -160,9 +161,7 @@ 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);
+    res.json(user);
   })
 );
 
@@ -214,14 +213,16 @@ import { z } from "zod";
 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 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>;
 ```
 
 - **Throttling and Rate Limiting**: The `@rateLimit` decorator is applied to safeguard the application's endpoints from abuse by limiting how frequently a particular method can be invoked.
@@ -233,11 +234,17 @@ By using a well-organized controller structure, this project makes it easier to
 Here is a quick reference to the UserController in practice:
 
 ```typescript
-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 "@src/types";
-import { tryParseId } from "@src/utilities";
+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 "@/types";
+import { parseId } from "@/utilities/error-handling";
+import config from "@/config";
 
 // Array to store users (as a mock database)
 const users = [
@@ -305,18 +312,12 @@ const users = [
 
 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 getUserErrorHandler(e: Error) {
   const message = "User not found.";
-
-  throw new Error(message, {
-    cause: { status: 404, message, details: e.message } satisfies ResponseError,
-  });
+  throw new ResponseError(message, 404, e.message);
 }
 
 /**
@@ -328,8 +329,8 @@ export default class UserController {
   // constructor(private readonly userService: UserService) { }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   @Validate
@@ -341,57 +342,49 @@ export default class UserController {
    * @throws {ResponseError} 400 - Invalid input data
    */
   public async create(@ZodInput(ZodUserCreationDto) user: UserCreationDto) {
-    users.push({ ...user, id: users.length + 1 } satisfies User);
+    users.push({ ...user, id: users.length + 1 });
   }
 
+  @memoizeAsync(config.memoizeTime)
   @onError({
     func: getUserErrorHandler,
   })
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Get user by ID
    * @param {string} id - User ID as string
-   * @returns {Promise<User | ResponseError>} User details or error object
+   * @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<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;
-
+  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;
   }
 
-  @timeout(20000)
+  @memoizeAsync(config.memoizeTime)
+  @timeout(config.timeout)
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Get all users with masked passwords
-   * @returns {Promise<User[]>} List of users with hidden password fields
+   * @returns {Promise<UserDto[]>} 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)
-    );
+  public async getAll(): Promise<UserDto[]> {
+    return users.map((user) => ({
+      ...user,
+      password: "?",
+    }));
   }
 }
 ```

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "codeweaver",
-  "version": "1.1.0",
-  "main": "src/app.ts",
+  "version": "2.0.0",
+  "main": "src/main.ts",
   "bin": {
     "create-codeweaver-app": "./command.js"
   },
   "scripts": {
-    "start": "nodemon -r tsconfig-paths/register src/app.ts",
-    "dev": "nodemon -r tsconfig-paths/register src/app.ts",
+    "start": "nodemon -r tsconfig-paths/register src/main.ts",
+    "dev": "nodemon -r tsconfig-paths/register src/main.ts",
     "build": "tsc && tsc-alias && copyfiles -u 1 \"src/**/*.{json,env,sqlite,db,sql,yaml,yml,xml,txt,md}\" dist",
-    "serve": "cross-env TSCONFIG_PATH=tsconfig.paths.json node -r tsconfig-paths/register dist/app.js"
+    "serve": "cross-env TSCONFIG_PATH=tsconfig.paths.json node -r tsconfig-paths/register dist/main.js"
   },
   "keywords": [
     "codeweaver",
@@ -32,8 +32,11 @@
   "license": "MIT",
   "description": "A lightweight framework built on top of Express and TypeScript",
   "dependencies": {
+    "dotenv": "^17.2.3",
     "express": "^5.1.0",
     "express-async-handler": "^1.2.0",
+    "swagger-jsdoc": "^3.7.0",
+    "ts-zod4-decorators": "^1.0.0",
     "utils-decorators": "^2.10.0",
     "zod": "^4.0.14"
   },
@@ -43,7 +46,6 @@
     "copyfiles": "^2.4.1",
     "cross-env": "^10.0.0",
     "nodemon": "^3.1.10",
-    "swagger-jsdoc": "^6.2.8",
     "swagger-ui-express": "^5.0.1",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.16",

package/src/config.ts

@@ -1,3 +1,12 @@
+import {
+  memoizeTime,
+  productionEnvironment,
+  rateLimitTimeSpan,
+  rateLimitAllowedCalls,
+  timeout,
+  portNumber,
+} from "./constants";
+
 /**
  * Server configuration interface
  * @interface
@@ -53,13 +62,18 @@ interface SwaggerOptions {
  */
 interface Config {
   devMode: boolean;
-  port: string;
+  port: number;
   swaggerOptions: SwaggerOptions;
+  timeout: number;
+  rateLimitTimeSpan: number;
+  rateLimitAllowedCalls: number;
+  memoizeTime: 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,
   swaggerOptions: {
     swaggerDefinition: {
@@ -82,17 +96,11 @@ const config: Config = {
       "./src/routers/**/*.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,
 };
 
-// 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,6 @@
+export const timeout = 20000;
+export const rateLimitTimeSpan = 60000;
+export const rateLimitAllowedCalls = 300;
+export const memoizeTime = 1000 * 60 * 60;
+export const productionEnvironment = "production";
+export const portNumber = 3000;

package/src/main.ts

@@ -0,0 +1,82 @@
+import express, { NextFunction, Request, Response } from "express";
+import fs from "fs";
+import path from "path";
+import config from "./config";
+
+/**
+ * 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 }));
+
+//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) {
+  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: unknown, req: Request, res: Response, next: NextFunction) => {
+  res.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

@@ -38,3 +38,4 @@ export const ZodOrderCreationDto = ZodOrder.omit({
 
 export type Order = z.infer<typeof ZodOrder>;
 export type OrderCreationDto = z.infer<typeof ZodOrderCreationDto>;
+export type OrderDto = z.infer<typeof ZodOrder>;

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

@@ -1,7 +1,6 @@
 import { Router, Request, Response } from "express";
 import asyncHandler from "express-async-handler";
 import OrderController from "./order.controller";
-import { sendError } from "@/utilities";
 
 const router = Router();
 const orderController = new OrderController();
@@ -101,8 +100,7 @@ router.get(
   "/:id",
   asyncHandler(async (req: Request, res: Response) => {
     const order = await orderController.get(req.params.id);
-    if ("id" in order == false) sendError(res, order);
-    else res.json(order);
+    res.json(order);
   })
 );
 
@@ -126,8 +124,7 @@ router.patch(
   "/:id/cancel",
   asyncHandler(async (req: Request, res: Response) => {
     const order = await orderController.cancel(req.params.id);
-    if ("id" in order == false) sendError(res, order);
-    else res.json(order);
+    res.json(order);
   })
 );
 
@@ -153,8 +150,7 @@ router.patch(
   "/:id/deliver",
   asyncHandler(async (req: Request, res: Response) => {
     const order = await orderController.deliver(req.params.id);
-    if ("id" in order == false) sendError(res, order);
-    else res.json(order);
+    res.json(order);
   })
 );
 

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

@@ -1,12 +1,14 @@
-import { onError, rateLimit, timeout } from "utils-decorators";
+import { memoizeAsync, onError, rateLimit, timeout } from "utils-decorators";
 import {
   Order,
+  OrderDto,
   OrderCreationDto,
   ZodOrderCreationDto,
 } from "./dto/order.dto";
-import { Validate, ZodInput } from "@pkg/ts-zod-decorators";
-import { ResponseError } from "@/types";
-import { tryParseId } from "@/utilities";
+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 orders (as a mock database)
 const orders: Order[] = [
@@ -49,18 +51,12 @@ const orders: Order[] = [
 
 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 getOrderErrorHandler(e: Error) {
   const message = "Order not found.";
-
-  throw new Error(message, {
-    cause: { status: 404, message, details: e.message } satisfies ResponseError,
-  });
+  throw new ResponseError(message, 404, e.message);
 }
 
 /**
@@ -70,8 +66,8 @@ function getOrderErrorHandler(e: Error) {
  */
 export default class OrderController {
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   @Validate
@@ -92,23 +88,25 @@ export default class OrderController {
     return newOrder;
   }
 
-  @timeout(20000)
+  @memoizeAsync(config.memoizeTime)
+  @timeout(config.timeout)
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Retrieves all orders
    * @returns List of orders
    */
-  public async getAll(): Promise<Order[]> {
+  public async getAll(): Promise<OrderDto[]> {
     return orders;
   }
 
+  @memoizeAsync(config.memoizeTime)
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   @onError({
@@ -119,42 +117,33 @@ export default class OrderController {
    * @param id - Order ID as string
    * @returns Order details or error object if not found
    */
-  public async get(id: string): Promise<Order | ResponseError> {
-    const orderId = tryParseId(id);
-    if (typeof orderId != "number") return orderId satisfies ResponseError;
+  public async get(id: string): Promise<OrderDto> {
+    const orderId = parseId(id);
     const order = orders.find((order) => order.id === orderId);
-
-    if (!order)
-      return {
-        status: 404,
-        message: "Order dose not exist.",
-      } satisfies ResponseError;
-
+    if (order == null) throw new ResponseError("User dose not exist.", 404);
     return order satisfies Order;
   }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Cancel an existing order
    * @param {string} id - Order ID to cancel
-   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @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<Order | ResponseError> {
+  public async cancel(id: string): Promise<OrderDto> {
     let order = await this.get(id);
-    if ("id" in order == false) return order satisfies ResponseError;
-
-    if (order.status != "Processing")
-      return {
-        status: 400,
-        message:
-          "Cancellation is not available unless the order is in processing status.",
-      } satisfies ResponseError;
+    if (order.status != "Processing") {
+      throw new ResponseError(
+        "Cancellation is not available unless the order is in processing status.",
+        400
+      );
+    }
 
     order.status = "Canceled";
     order.deliveredAt = new Date();
@@ -162,27 +151,25 @@ export default class OrderController {
   }
 
   @rateLimit({
-    timeSpanMs: 60000,
-    allowedCalls: 300,
+    timeSpanMs: config.rateLimitTimeSpan,
+    allowedCalls: config.rateLimitAllowedCalls,
     exceedHandler,
   })
   /**
    * Mark an order as delivered
    * @param {string} id - Order ID to mark as delivered
-   * @returns {Promise<Order | ResponseError>} Updated order or error object
+   * @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<Order | ResponseError> {
+  public async deliver(id: string): Promise<OrderDto> {
     let order = await this.get(id);
-    if ("id" in order == false) return order satisfies ResponseError;
-
-    if (order.status != "Processing")
-      return {
-        status: 400,
-        message:
-          "Delivery is only available when the order is in processing status.",
-      } satisfies ResponseError;
+    if (order.status != "Processing") {
+      throw new ResponseError(
+        "Delivery is only available when the order is in processing status.",
+        400
+      );
+    }
 
     order.status = "Delivered";
     order.deliveredAt = new Date();

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

@@ -34,3 +34,4 @@ export const ZodProductUpdateDto = ZodProductCreationDto.partial();
 export type Product = z.infer<typeof ZodProduct>;
 export type ProductCreationDto = z.infer<typeof ZodProductCreationDto>;
 export type ProductUpdateDto = z.infer<typeof ZodProductUpdateDto>;
+export type ProductDto = z.infer<typeof ZodProduct>;