refactor: stop using static controllers

src/lib/controllers/controller.base.ts

@@ -1,10 +1,8 @@
 import { Router } from "express";
 
 export abstract class BaseController {
-  public static router: Router = Router();
-  public static prefix: string = "/";
+  public router: Router = Router();
+  public prefix: string = "/";
 
-  public static setRoutes(_router: Router) {
-    throw new Error(`routes not set for ${this.name}`);
-  }
+  public abstract setRoutes(): void;
 }

src/modules/common/decorators/prefix.decorator.ts

@@ -2,6 +2,13 @@ import { BaseController } from "../../../lib/controllers/controller.base";
 
 export const Prefix = (prefix: string) => {
   return (target: typeof BaseController) => {
-    target.prefix = prefix || target.prefix;
+    const originalConstructor = target;
+    const newConstructor: any = function (...args: any[]) {
+      const instance = new (originalConstructor as any)(...args);
+      instance.prefix = prefix || instance.prefix;
+      return instance;
+    };
+    newConstructor.prototype = originalConstructor.prototype;
+    return newConstructor;
   };
 };

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

@@ -10,20 +10,20 @@ import {
 
 @Prefix("/console/admins")
 export class AdminsController extends BaseController {
-  static setRoutes(router: Router) {
-    router.get("/", AdminsController.list);
-    router.get("/:id", paramsValidator("id"), AdminsController.get);
-    router.post("/", bodyValidator(createAdminSchema), AdminsController.create);
-    router.patch(
+  setRoutes() {
+    this.router.get("/", this.list);
+    this.router.get("/:id", paramsValidator("id"), this.get);
+    this.router.post("/", bodyValidator(createAdminSchema), this.create);
+    this.router.patch(
       "/:id",
       paramsValidator("id"),
       bodyValidator(createAdminSchema),
-      AdminsController.update
+      this.update
     );
-    router.delete("/:id", paramsValidator("id"), AdminsController.delete);
+    this.router.delete("/:id", paramsValidator("id"), this.delete);
   }
 
-  static list(_, res: Response) {
+  list(_, res: Response) {
     AdminsService.list({})
       .then((result) => {
         res.status(result.code).json(result);
@@ -33,24 +33,24 @@ export class AdminsController extends BaseController {
       });
   }
 
-  static async get(req: Request, res: Response) {
+  async get(req: Request, res: Response) {
     const data = await AdminsService.get({
       _id: req.params.id,
     });
     res.json(data);
   }
 
-  static async create(req: Request, res: Response) {
+  async create(req: Request, res: Response) {
     const data = await AdminsService.create(req.body);
     res.json(data);
   }
 
-  static async update(req: Request, res: Response) {
+  async update(req: Request, res: Response) {
     const data = await AdminsService.update(req.params.id, req.body);
     res.json(data);
   }
 
-  static async delete(req: Request, res: Response) {
+  async delete(req: Request, res: Response) {
     const data = await AdminsService.remove(req.params.id);
     res.json(data);
   }

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

@@ -8,17 +8,17 @@ import { usersService } from "../services/users.service";
 const allowedRoles = ["superAdmin", "admin"];
 
 @Prefix("/console/users")
-export class adminUsersController extends BaseController {
-  static setRoutes(router) {
-    router.post(
+export class AdminUsersController extends BaseController {
+  setRoutes() {
+    this.router.post(
       "/create",
       jwtHelper.verifyToken(allowedRoles),
       bodyValidator(userRegisterValidation),
-      adminUsersController.create
+      this.create
     );
   }
 
-  static async create(req, res) {
+  async create(req, res) {
     try {
       let result = await usersService.create(req.body);
       return res.status(result.code).json(result);

src/modules/user/auth/controllers/auth.controller.ts

@@ -1,25 +1,23 @@
 import { usersService } from "../services/users.service";
 import { jwtHelper } from "../../../../helpers/jwt.helper";
 import { BaseController } from "../../../../lib/controllers/controller.base";
-import { Router } from "express";
 import { Prefix } from "../../../common/decorators/prefix.decorator";
-import { Env } from "../../../../configs/env";
 import { bodyValidator } from "../../../../helpers/validation.helper";
 import { userRegisterValidation } from "../../../common/users/validation/user.baseValidation";
 import { loginValidation } from "../validation/user.Validation";
 
 @Prefix("/user/auth")
 export class AuthController extends BaseController {
-  static setRoutes(router: Router): void {
-    router.post(
+  setRoutes(): void {
+    this.router.post(
       "/register",
       bodyValidator(userRegisterValidation),
-      AuthController.register
+      this.register
     );
-    router.post("/login", bodyValidator(loginValidation), AuthController.login);
+    this.router.post("/login", bodyValidator(loginValidation), this.login);
   }
 
-  static async register(req, res) {
+  async register(req, res) {
     try {
       let result = await usersService.create(req.body);
       return res.status(result.code).json(result);
@@ -33,7 +31,7 @@ export class AuthController extends BaseController {
     }
   }
 
-  static async login(req, res) {
+  async login(req, res) {
     try {
       const { email, password } = req.body;
       let result: {

src/routes.ts

@@ -43,9 +43,10 @@ const importControllers = async (router: Router) => {
 
   await Promise.all(
     files.map(async (file) => {
-      const controller = await importController(file);
-      if (!controller) return;
-      controller.setRoutes(controller.router);
+      const controllerClass = await importController(file);
+      if (!controllerClass) return;
+      const controller: BaseController = new (controllerClass as any)();
+      controller.setRoutes();
       router.use(controller.prefix, controller.router);
     })
   );
@@ -54,6 +55,7 @@ const importControllers = async (router: Router) => {
 const importController = async (file: string) => {
   const controllers = Object.values(await import(file));
   return controllers.find(
-    (controller: { router?: Router }) => controller.router
+    (controller: { prototype: typeof BaseController }) =>
+      controller.prototype instanceof BaseController
   ) as typeof BaseController;
 };