refactors

.vscode/settings.json

@@ -1,5 +1,6 @@
 {
     "cSpell.words": [
+        "IJSON",
         "Routable",
         "tlds"
     ]

src/helpers/serialize.ts

@@ -1,14 +1,33 @@
 import { plainToClass } from "class-transformer";
+import { Document } from "mongoose";
 
+/**
+ * Serializes the given object or array of objects into the specified class type.
+ *
+ * @template T - The class type to serialize the object(s) into.
+ * @param serializable - The object or array of objects to be serialized.
+ * @param serializer - The class constructor function for the target serialization type.
+ * @returns The serialized object(s) of type T or an array of serialized objects of type T.
+ */
 export const serialize = <T>(
-  serializable: Record<string, any> | Record<string, any>[],
+  serializable:
+    | Record<string, any>
+    | Record<string, any>[]
+    | Document
+    | Document[],
   serializer: new () => T
 ): T | T[] => {
+  // If the serializable object is a Document, convert it to a JSON object.
+  if (serializable.hasOwnProperty("toJSON"))
+    serializable = (serializable as Document).toJSON();
+
+  // If the serializable object is an array, serialize each item in the array.
   if (Array.isArray(serializable)) {
     return serializable.map((item) => serialize(item, serializer)) as T[];
   }
 
+  // Serialize the object and return it.
   return plainToClass(serializer, serializable, {
     excludeExtraneousValues: true,
   }) as T;
-};
+};

src/helpers/validation.helper.ts

@@ -1,3 +1,4 @@
+import { JsonResponse } from "@lib/responses/json-response";
 import { NextFunction, Request, Response } from "express";
 import { createValidator } from "express-joi-validation";
 import Joi from "joi";
@@ -21,11 +22,12 @@ export const validationErrorHandler = (
     console.log(`err`, err.error);
 
     const errors = err.error.details.map((detail) => detail.message);
-    return res.status(422).json({
-      success: false,
-      errors: errors,
-      code: 422,
-    });
+    return JsonResponse.validationError(
+      {
+        errors,
+      },
+      res
+    );
   } else {
     // pass on to another error handler
     next(err);

src/lib/responses/json-response.ts

@@ -1,24 +1,94 @@
-interface JsonResponseProps {
-  status?: number;
-  message?: string;
-  data?: Record<string, any> | Record<string, any>[];
-  meta?: {
-    total: number;
-    page: number;
-    perPage: number;
-  };
-}
+import { Response } from "express";
+import {
+  IJSONSuccessResponse,
+  IJSONErrorResponse,
+  IJSONValidationErrorResponse,
+} from "./json-responses";
+import {
+  IJSONSuccessResponseProps,
+  IJSONErrorResponseProps,
+  IJSONValidationErrorResponseProps,
+} from "./json-responses-params";
+
+/**
+ * Represents a base class for JSON responses.
+ */
+export abstract class JsonResponse {
+  private constructor() {}
+
+  /**
+   * Generates a success response object.
+   *
+   * @param props - The properties for the success response.
+   * @param res - Optional Express response object to send the response.
+   * @returns The success response object or the Express response object if provided.
+   */
+  static success(props: IJSONSuccessResponseProps): IJSONSuccessResponse;
+  static success(
+    props: IJSONSuccessResponseProps,
+    res: Response<IJSONSuccessResponse>
+  ): Response<IJSONSuccessResponse>;
+  static success(
+    props: IJSONSuccessResponseProps,
+    res?: Response<IJSONSuccessResponse>
+  ): IJSONSuccessResponse | Response<IJSONSuccessResponse> {
+    const data = {
+      status: props.status || 200,
+      message: props.message || "Success",
+      data: props.data,
+      meta: props.meta,
+    } satisfies IJSONSuccessResponse;
+
+    return (res && res.status(data.status).json(data)) || data;
+  }
+
+  /**
+   * Creates a JSON error response.
+   * @param props - The properties for the error response.
+   * @param res - Optional response object to send the error response.
+   * @returns The JSON error response object or the response object if provided.
+   */
+  static error(props: IJSONErrorResponseProps): IJSONErrorResponse;
+  static error(
+    props: IJSONErrorResponseProps,
+    res: Response<IJSONErrorResponse>
+  ): Response<IJSONErrorResponse>;
+  static error(
+    props: IJSONErrorResponseProps,
+    res?: Response<IJSONErrorResponse>
+  ): IJSONErrorResponse | Response<IJSONErrorResponse> {
+    const data = {
+      status: props.status || 500,
+      message: props.message || "Something Went Wrong",
+      error: props.error,
+    } satisfies IJSONErrorResponse;
+
+    return (res && res.status(data.status).json(data)) || data;
+  }
 
-export class JsonResponse {
-  public status: JsonResponseProps["status"];
-  public message: JsonResponseProps["message"];
-  public data: JsonResponseProps["data"];
-  public meta?: JsonResponseProps["meta"];
+  /**
+   * Represents a validation error response.
+   * @param props - The properties of the validation error response.
+   * @param res - Optional response object to send the JSON response.
+   * @returns The validation error response object or the response object if provided.
+   */
+  static validationError(
+    props: IJSONValidationErrorResponseProps
+  ): IJSONValidationErrorResponse;
+  static validationError(
+    props: IJSONValidationErrorResponseProps,
+    res: Response<IJSONValidationErrorResponse>
+  ): Response<IJSONValidationErrorResponse>;
+  static validationError(
+    props: IJSONValidationErrorResponseProps,
+    res?: Response<IJSONValidationErrorResponse>
+  ): IJSONValidationErrorResponse | Response<IJSONValidationErrorResponse> {
+    const data = {
+      status: 422,
+      message: "Validation Error",
+      errors: props.errors,
+    } satisfies IJSONValidationErrorResponse;
 
-  constructor(props: JsonResponseProps) {
-    this.status = props.status || 200;
-    this.message = props.message || "Success";
-    this.data = props.data || {};
-    this.meta = props.meta;
+    return (res && res.status(data.status).json(data)) || data;
   }
 }

src/lib/responses/json-responses-params.d.ts

@@ -0,0 +1,20 @@
+export interface IJSONSuccessResponseProps {
+  status?: number;
+  message?: string;
+  data: Record<string, any> | Record<string, any>[];
+  meta?: {
+    total: number;
+    page: number;
+    perPage: number;
+  };
+}
+
+export interface IJSONErrorResponseProps {
+  status?: number;
+  message?: string;
+  error: string;
+}
+
+export interface IJSONValidationErrorResponseProps {
+  errors: Record<string, any>[];
+}

src/lib/responses/json-responses.d.ts

@@ -0,0 +1,23 @@
+interface IJSONResponse {
+  status: number;
+  message: string;
+}
+
+export interface IJSONSuccessResponse extends IJSONResponse {
+  data: Record<string, any> | Record<string, any>[];
+  meta?: {
+    total: number;
+    page: number;
+    perPage: number;
+  };
+}
+
+export interface IJSONErrorResponse extends IJSONResponse {
+  error: string;
+}
+
+export interface IJSONValidationErrorResponse extends IJSONResponse {
+  status: 422;
+  message: "Validation Error";
+  errors: Record<string, any>[];
+}

src/modules/console/modules/admins/controllers/admins.controller.ts

@@ -11,7 +11,7 @@ import { ControllerMiddleware } from "@lib/decorators/controller-middleware.deco
 import { AdminGuardMiddleware } from "modules/console/common/guards/admins.guard";
 import { Role } from "@common/enums/role.enum";
 import { serialize } from "@helpers/serialize";
-import { AdminSerialization } from "modules/console/common/serializers/admin.serializtion";
+import { AdminSerialization } from "modules/console/common/serializers/admin.serialization";
 
 @Prefix("/console/admins")
 @ControllerMiddleware(AdminGuardMiddleware({ roles: [Role.SUPER_ADMIN] }))
@@ -39,39 +39,48 @@ export class AdminsController extends BaseController {
     );
   }
 
-  list = async (req: Request, res: Response) => {
+  list = async (req: Request, res: Response): Promise<Response> => {
     const paginationQuery = parsePaginationQuery(req.query);
     const { docs, paginationData } = await this.adminsService.list(
       {},
       paginationQuery
     );
 
-    const response = new JsonResponse({
-      data: serialize(docs, AdminSerialization),
-      meta: paginationData,
-    });
-    return res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(docs, AdminSerialization),
+        meta: paginationData,
+      },
+      res
+    );
   };
 
-  get = async (req: Request, res: Response) => {
+  get = async (req: Request, res: Response): Promise<Response> => {
     const data = await this.adminsService.findOneOrFail({
       _id: req.params.id,
     });
-    const response = new JsonResponse({
-      data: serialize(data.toJSON(), AdminSerialization),
-    });
-    res.json(response);
+
+    return JsonResponse.success(
+      {
+        data: serialize(data, AdminSerialization),
+      },
+      res
+    );
   };
 
-  create = async (req: Request, res: Response) => {
+  create = async (req: Request, res: Response): Promise<Response> => {
     const admin = await this.adminsService.create(req.body);
-    const response = new JsonResponse({
-      data: serialize(admin.toJSON(), AdminSerialization),
-    });
-    res.json(response);
+
+    return JsonResponse.success(
+      {
+        status: 201,
+        data: serialize(admin, AdminSerialization),
+      },
+      res
+    );
   };
 
-  update = async (req: Request, res: Response) => {
+  update = async (req: Request, res: Response): Promise<Response> => {
     const admin = await this.adminsService.update(
       {
         _id: req.params.id,
@@ -79,22 +88,24 @@ export class AdminsController extends BaseController {
       req.body
     );
 
-    const response = new JsonResponse({
-      data: serialize(admin.toJSON(), AdminSerialization),
-    });
-
-    res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(admin, AdminSerialization),
+      },
+      res
+    );
   };
 
-  delete = async (req: Request, res: Response) => {
+  delete = async (req: Request, res: Response): Promise<Response> => {
     const admin = await this.adminsService.delete({
       _id: req.params.id,
     });
 
-    const response = new JsonResponse({
-      data: serialize(admin.toJSON(), AdminSerialization),
-    });
-
-    res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(admin, AdminSerialization),
+      },
+      res
+    );
   };
 }

src/modules/console/modules/users/controllers/users.controller.ts

@@ -1,31 +1,29 @@
-import { userRegisterSchema } from "@common/validations/user-register.validation";
 import { UsersService } from "../services/users.service";
 import { JsonResponse } from "@lib/responses/json-response";
 import { Request, Response } from "express";
 import { asyncHandler } from "@helpers/async-handler";
-import { bodyValidator } from "@helpers/validation.helper";
 import { BaseController } from "@lib/controllers/controller.base";
 import { Prefix } from "@lib/decorators/prefix.decorator";
 import { serialize } from "@helpers/serialize";
-import { UserSerialization } from "@common/serializers/user.serializtion";
-
+import { UserSerialization } from "@common/serializers/user.serialization";
 
 @Prefix("/console/users")
 export class AdminUsersController extends BaseController {
   private usersService: UsersService = new UsersService();
 
   setRoutes() {
-    this.router.post(
-      "/create",
-      asyncHandler(this.create)
-    );
+    this.router.post("/create", asyncHandler(this.create));
   }
 
-  create = async (req: Request, res: Response) => {
+  create = async (req: Request, res: Response): Promise<Response> => {
     let user = await this.usersService.create(req.body);
-    const response = new JsonResponse({
-      data: serialize(user.toJSON(), UserSerialization),
-    });
-    return res.json(response);
+
+    return JsonResponse.success(
+      {
+        status: 201,
+        data: serialize(user, UserSerialization),
+      },
+      res
+    );
   };
 }

src/modules/users/{auth → modules/auth}/controllers/auth.controller.ts

@@ -2,13 +2,16 @@ import { UsersAuthService } from "../services/users.service";
 import { loginValidationSchema } from "../validation/login.validation";
 import { Request, Response } from "express";
 import { JsonResponse } from "@lib/responses/json-response";
-import { userRegisterSchema, IUserRegister } from "@common/validations/user-register.validation";
+import {
+  userRegisterSchema,
+  IUserRegister,
+} from "@common/validations/user-register.validation";
 import { asyncHandler } from "@helpers/async-handler";
 import { bodyValidator } from "@helpers/validation.helper";
 import { BaseController } from "@lib/controllers/controller.base";
 import { Prefix } from "@lib/decorators/prefix.decorator";
 import { serialize } from "@helpers/serialize";
-import { UserSerialization } from "@common/serializers/user.serializtion";
+import { UserSerialization } from "@common/serializers/user.serialization";
 
 @Prefix("/users/auth")
 export class UsersAuthController extends BaseController {
@@ -30,17 +33,22 @@ export class UsersAuthController extends BaseController {
   register = async (req: Request, res: Response) => {
     const user = await this.authService.register(req.body as IUserRegister);
 
-    const response = new JsonResponse({
-      data: serialize(user.toJSON(), UserSerialization),
-    });
-    return res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(user, UserSerialization),
+      },
+      res
+    );
   };
 
-  login = async (req: Request, res: Response) => {
+  login = async (req: Request, res: Response): Promise<Response> => {
     const { user, token } = await this.authService.login(req.body);
-    const response = new JsonResponse({
-      data: { user: serialize(user.toJSON(), UserSerialization), token },
-    });
-    return res.json(response);
+
+    return JsonResponse.success(
+      {
+        data: { user: serialize(user, UserSerialization), token },
+      },
+      res
+    );
   };
 }

src/modules/users/{exercises → modules/exercises}/controllers/exercises.controller.ts

@@ -11,7 +11,6 @@ import { ExerciseSerialization } from "@common/serializers/exercise.serializtion
 import { ControllerMiddleware } from "@lib/decorators/controller-middleware.decorator";
 import { UsersGuardMiddleware } from "modules/users/common/guards/users.guard";
 
-
 @Prefix("/users/exercises")
 @ControllerMiddleware(UsersGuardMiddleware())
 export class ExerciseController extends BaseController {
@@ -22,27 +21,32 @@ export class ExerciseController extends BaseController {
     this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
   }
 
-  list = async (req: Request, res: Response) => {
+  list = async (req: Request, res: Response): Promise<Response> => {
     const paginationQuery = parsePaginationQuery(req.query);
     const { docs, paginationData } = await this.exercisesService.list(
       {},
       paginationQuery
     );
 
-    const response = new JsonResponse({
-      data: serialize(docs, ExerciseSerialization),
-      meta: paginationData,
-    });
-    return res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(docs, ExerciseSerialization),
+        meta: paginationData,
+      },
+      res
+    );
   };
 
-  get = async (req: Request, res: Response) => {
+  get = async (req: Request, res: Response): Promise<Response> => {
     const data = await this.exercisesService.findOneOrFail({
       _id: req.params.id,
     });
-    const response = new JsonResponse({
-      data: serialize(data.toJSON(), ExerciseSerialization),
-    });
-    res.json(response);
+
+    return JsonResponse.success(
+      {
+        data: serialize(data, ExerciseSerialization),
+      },
+      res
+    );
   };
 }

src/modules/users/{workouts → modules/workouts}/controllers/workouts.controller.ts

@@ -21,27 +21,32 @@ export class WorkoutController extends BaseController {
     this.router.get("/:id", paramsValidator("id"), asyncHandler(this.get));
   }
 
-  list = async (req: Request, res: Response) => {
+  list = async (req: Request, res: Response): Promise<Response> => {
     const paginationQuery = parsePaginationQuery(req.query);
     const { docs, paginationData } = await this.workoutsService.list(
       {},
       paginationQuery
     );
 
-    const response = new JsonResponse({
-      data: serialize(docs, WorkoutSerialization),
-      meta: paginationData,
-    });
-    return res.json(response);
+    return JsonResponse.success(
+      {
+        data: serialize(docs, WorkoutSerialization),
+        meta: paginationData,
+      },
+      res
+    );
   };
 
-  get = async (req: Request, res: Response) => {
+  get = async (req: Request, res: Response): Promise<Response> => {
     const data = await this.workoutsService.findOneOrFail({
       _id: req.params.id,
     });
-    const response = new JsonResponse({
-      data: serialize(data.toJSON(), WorkoutSerialization),
-    });
-    res.json(response);
+
+    return JsonResponse.success(
+      {
+        data: serialize(data, WorkoutSerialization),
+      },
+      res
+    );
   };
 }

src/routes.ts

@@ -4,7 +4,13 @@ import * as glob from "glob";
 import path from "path";
 import { BaseController } from "./lib/controllers/controller.base";
 import { validationErrorHandler } from "./helpers/validation.helper";
+import { JsonResponse } from "@lib/responses/json-response";
 
+/**
+ * Sets the routes for the Express app.
+ *
+ * @param app - The Express app.
+ */
 export const setAppRoutes = async (app: Express) => {
   const mainRouter = Router();
 
@@ -16,46 +22,77 @@ export const setAppRoutes = async (app: Express) => {
 
 /* custom routes */
 
+/**
+ * Sets custom routes for the router.
+ *
+ * @param router - The router object to set the routes on.
+ */
 const setCustomRoutes = (router: Router) => {
+  // Health check route
   router.get("/health", (_req: any, res: any) => {
-    res
-      .status(200)
-      .json({ success: true, message: "Server is up!", code: 200 });
+    JsonResponse.success(
+      {
+        message: "Server is up!",
+        data: { success: true },
+      },
+      res
+    );
   });
 
+  // Validation error handler
   router.use(validationErrorHandler);
 
+  // Invalid URL handler
   router.all("*", (_req: any, res: any) => {
-    res
-      .status(404)
-      .json({ success: false, message: "Invalid URL!", code: 404 });
+    JsonResponse.error(
+      {
+        error: "Invalid URL!",
+        status: 404,
+      },
+      res
+    );
   });
+
+  // Error handler
   router.use((err, req, res, next) => {
     try {
       err.message = JSON.parse(err.message);
-    } catch (error) { }
+    } catch (error) {}
 
-    res.status(err.status || 500).json({
-      status: err.status || 500,
-      message: err.message || "Internal Server Error",
-    });
+    JsonResponse.error(
+      {
+        error: err.message || "Internal Server Error",
+        status: err.status || 500,
+      },
+      res
+    );
 
     console.error(err.message, err.stack);
   });
-
 };
 
 /* importing all controllers */
 
+/**
+ * Finds all controller files in the project.
+ * @returns An array of strings representing the absolute paths of the controller files.
+ */
 const findControllerFiles = (): string[] => {
-  const controllersPath = path.relative(process.cwd(), path.join(__dirname, "**/*.controller.{ts,js}")).replace(/\\/g, "/")
+  const controllersPath = path
+    .relative(process.cwd(), path.join(__dirname, "**/*.controller.{ts,js}"))
+    .replace(/\\/g, "/");
 
   return glob.sync(controllersPath, {}).map((file) => {
     return path.resolve(file);
   });
 };
 
-
+/**
+ * Imports controller classes from files, sets up routes for each controller,
+ * and adds them to the provided router.
+ *
+ * @param router - The router to add the routes to.
+ */
 const importControllers = async (router: Router) => {
   const files = findControllerFiles();
 
@@ -71,6 +108,11 @@ const importControllers = async (router: Router) => {
   );
 };
 
+/**
+ * Imports a module from a file and returns the first controller that extends BaseController.
+ * @param file - The path to the file containing the module.
+ * @returns The first controller that extends BaseController.
+ */
 const importController = async (file: string) => {
   const controllers = Object.values(await import(file));
   return controllers.find(