Refactor routers to be class based

Server/routes/authRoute.js

@@ -5,34 +5,56 @@ import { isAllowed } from "../middleware/isAllowed.js";
 import multer from "multer";
 import User from "../db/models/User.js";
 
-const router = Router();
 const upload = multer();
 
-import {
-	registerUser,
-	loginUser,
-  refreshAuthToken,
-	editUser,
-	requestRecovery,
-	validateRecovery,
-	resetPassword,
-	checkSuperadminExists,
-	getAllUsers,
-	deleteUser,
-} from "../controllers/authController.js";
+class AuthRoutes {
+	constructor(authController) {
+		this.router = Router();
+		this.authController = authController;
+		this.initRoutes();
+	}
 
-//Auth routes
-router.post("/register", upload.single("profileImage"), registerUser);
-router.post("/login", loginUser);
-router.post("/refresh", refreshAuthToken);
-router.put("/user/:userId", upload.single("profileImage"), verifyJWT, editUser);
-router.get("/users/superadmin", checkSuperadminExists);
-router.get("/users", verifyJWT, isAllowed(["admin", "superadmin"]), getAllUsers);
-router.delete("/user/:userId", verifyJWT, verifyOwnership(User, "userId"), deleteUser);
+	initRoutes() {
+		this.router.post(
+			"/register",
+			upload.single("profileImage"),
+			this.authController.registerUser
+		);
+		this.router.post("/login", this.authController.loginUser);
+		this.router.post("/refresh", this.authController.refreshAuthToken);
 
-//Recovery routes
-router.post("/recovery/request", requestRecovery);
-router.post("/recovery/validate", validateRecovery);
-router.post("/recovery/reset/", resetPassword);
+		this.router.put(
+			"/user/:userId",
+			upload.single("profileImage"),
+			verifyJWT,
+			this.authController.editUser
+		);
 
-export default router;
+		this.router.get("/users/superadmin", this.authController.checkSuperadminExists);
+
+		this.router.get(
+			"/users",
+			verifyJWT,
+			isAllowed(["admin", "superadmin"]),
+			this.authController.getAllUsers
+		);
+
+		this.router.delete(
+			"/user/:userId",
+			verifyJWT,
+			verifyOwnership(User, "userId"),
+			this.authController.deleteUser
+		);
+
+		// Recovery routes
+		this.router.post("/recovery/request", this.authController.requestRecovery);
+		this.router.post("/recovery/validate", this.authController.validateRecovery);
+		this.router.post("/recovery/reset/", this.authController.resetPassword);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default AuthRoutes;

Server/routes/checkRoute.js

@@ -1,26 +1,46 @@
 import { Router } from "express";
-import {
-	createCheck,
-	getChecks,
-	deleteChecks,
-	getTeamChecks,
-	deleteChecksByTeamId,
-	updateChecksTTL,
-} from "../controllers/checkController.js";
 import { verifyOwnership } from "../middleware/verifyOwnership.js";
 import { isAllowed } from "../middleware/isAllowed.js";
 import Monitor from "../db/models/Monitor.js";
 
-const router = Router();
+class CheckRoutes {
+	constructor(checkController) {
+		this.router = Router();
+		this.checkController = checkController;
+		this.initRoutes();
+	}
 
-router.get("/:monitorId", getChecks);
-router.post("/:monitorId", verifyOwnership(Monitor, "monitorId"), createCheck);
-router.delete("/:monitorId", verifyOwnership(Monitor, "monitorId"), deleteChecks);
+	initRoutes() {
+		this.router.get("/:monitorId", this.checkController.getChecks);
+		this.router.post(
+			"/:monitorId",
+			verifyOwnership(Monitor, "monitorId"),
+			this.checkController.createCheck
+		);
+		this.router.delete(
+			"/:monitorId",
+			verifyOwnership(Monitor, "monitorId"),
+			this.checkController.deleteChecks
+		);
 
-router.get("/team/:teamId", getTeamChecks);
+		this.router.get("/team/:teamId", this.checkController.getTeamChecks);
 
-router.delete("/team/:teamId", isAllowed(["admin", "superadmin"]), deleteChecksByTeamId);
+		this.router.delete(
+			"/team/:teamId",
+			isAllowed(["admin", "superadmin"]),
+			this.checkController.deleteChecksByTeamId
+		);
 
-router.put("/team/ttl", isAllowed(["admin", "superadmin"]), updateChecksTTL);
+		this.router.put(
+			"/team/ttl",
+			isAllowed(["admin", "superadmin"]),
+			this.checkController.updateChecksTTL
+		);
+	}
 
-export default router;
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default CheckRoutes;

Server/routes/inviteRoute.js

@@ -1,14 +1,27 @@
 import { Router } from "express";
 import { verifyJWT } from "../middleware/verifyJWT.js";
 import { isAllowed } from "../middleware/isAllowed.js";
-import {
-	issueInvitation,
-	inviteVerifyController,
-} from "../controllers/inviteController.js";
 
-const router = Router();
+class InviteRoutes {
+	constructor(inviteController) {
+		this.router = Router();
+		this.inviteController = inviteController;
+		this.initRoutes();
+	}
 
-router.post("/", isAllowed(["admin", "superadmin"]), verifyJWT, issueInvitation);
-router.post("/verify", inviteVerifyController);
+	initRoutes() {
+		this.router.post(
+			"/",
+			isAllowed(["admin", "superadmin"]),
+			verifyJWT,
+			this.inviteController.issueInvitation
+		);
+		this.router.post("/verify", this.inviteController.inviteVerifyController);
+	}
 
-export default router;
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default InviteRoutes;

Server/routes/maintenanceWindowRoute.js

@@ -1,31 +1,37 @@
 import { Router } from "express";
-import {
-	createMaintenanceWindows,
-	getMaintenanceWindowById,
-	getMaintenanceWindowsByTeamId,
-	getMaintenanceWindowsByMonitorId,
-	deleteMaintenanceWindow,
-	editMaintenanceWindow,
-} from "../controllers/maintenanceWindowController.js";
 import { verifyOwnership } from "../middleware/verifyOwnership.js";
 import Monitor from "../db/models/Monitor.js";
 
-const router = Router();
+class MaintenanceWindowRoutes {
+	constructor(maintenanceWindowController) {
+		this.router = Router();
+		this.maintenanceWindowController = maintenanceWindowController;
+		this.initRoutes();
+	}
+	initRoutes() {
+		this.router.post("/", this.maintenanceWindowController.createMaintenanceWindows);
 
-router.post("/", createMaintenanceWindows);
+		this.router.get(
+			"/monitor/:monitorId",
+			verifyOwnership(Monitor, "monitorId"),
+			this.maintenanceWindowController.getMaintenanceWindowsByMonitorId
+		);
 
-router.get(
-	"/monitor/:monitorId",
-	verifyOwnership(Monitor, "monitorId"),
-	getMaintenanceWindowsByMonitorId
-);
+		this.router.get(
+			"/team/",
+			this.maintenanceWindowController.getMaintenanceWindowsByTeamId
+		);
 
-router.get("/team/", getMaintenanceWindowsByTeamId);
+		this.router.get("/:id", this.maintenanceWindowController.getMaintenanceWindowById);
 
-router.get("/:id", getMaintenanceWindowById);
+		this.router.put("/:id", this.maintenanceWindowController.editMaintenanceWindow);
 
-router.put("/:id", editMaintenanceWindow);
+		this.router.delete("/:id", this.maintenanceWindowController.deleteMaintenanceWindow);
+	}
 
-router.delete("/:id", deleteMaintenanceWindow);
+	getRouter() {
+		return this.router;
+	}
+}
 
-export default router;
+export default MaintenanceWindowRoutes;

Server/routes/monitorRoute.js

@@ -1,51 +1,79 @@
 import { Router } from "express";
-import {
-	getAllMonitors,
-	getAllMonitorsWithUptimeStats,
-	getMonitorStatsById,
-	getMonitorCertificate,
-	getMonitorById,
-	getMonitorsAndSummaryByTeamId,
-	getMonitorsByTeamId,
-	createMonitor,
-	checkEndpointResolution,
-	deleteMonitor,
-	deleteAllMonitors,
-	editMonitor,
-	pauseMonitor,
-	addDemoMonitors,
-} from "../controllers/monitorController.js";
 import { isAllowed } from "../middleware/isAllowed.js";
 import { fetchMonitorCertificate } from "../controllers/controllerUtils.js";
 
-const router = Router();
+class MonitorRoutes {
+	constructor(monitorController) {
+		this.router = Router();
+		this.monitorController = monitorController;
+		this.initRoutes();
+	}
 
-router.get("/", getAllMonitors);
-router.get("/uptime", getAllMonitorsWithUptimeStats);
-router.get("/stats/:monitorId", getMonitorStatsById);
-router.get("/certificate/:monitorId", (req, res, next) => {
-	getMonitorCertificate(req, res, next, fetchMonitorCertificate);
-});
-router.get("/:monitorId", getMonitorById);
-router.get("/team/summary/:teamId", getMonitorsAndSummaryByTeamId);
-router.get("/team/:teamId", getMonitorsByTeamId);
+	initRoutes() {
+		this.router.get("/", this.monitorController.getAllMonitors);
+		this.router.get("/uptime", this.monitorController.getAllMonitorsWithUptimeStats);
+		this.router.get("/stats/:monitorId", this.monitorController.getMonitorStatsById);
+		this.router.get("/certificate/:monitorId", (req, res, next) => {
+			this.monitorController.getMonitorCertificate(
+				req,
+				res,
+				next,
+				fetchMonitorCertificate
+			);
+		});
+		this.router.get("/:monitorId", this.monitorController.getMonitorById);
+		this.router.get(
+			"/team/summary/:teamId",
+			this.monitorController.getMonitorsAndSummaryByTeamId
+		);
+		this.router.get("/team/:teamId", this.monitorController.getMonitorsByTeamId);
 
-router.get(
-	"/resolution/url",
-	isAllowed(["admin", "superadmin"]),
-	checkEndpointResolution
-);
+		this.router.get(
+			"/resolution/url",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.checkEndpointResolution
+		);
 
-router.delete("/:monitorId", isAllowed(["admin", "superadmin"]), deleteMonitor);
+		this.router.delete(
+			"/:monitorId",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.deleteMonitor
+		);
 
-router.post("/", isAllowed(["admin", "superadmin"]), createMonitor);
+		this.router.post(
+			"/",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.createMonitor
+		);
 
-router.put("/:monitorId", isAllowed(["admin", "superadmin"]), editMonitor);
+		this.router.put(
+			"/:monitorId",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.editMonitor
+		);
 
-router.delete("/", isAllowed(["superadmin"]), deleteAllMonitors);
+		this.router.delete(
+			"/",
+			isAllowed(["superadmin"]),
+			this.monitorController.deleteAllMonitors
+		);
 
-router.post("/pause/:monitorId", isAllowed(["admin", "superadmin"]), pauseMonitor);
+		this.router.post(
+			"/pause/:monitorId",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.pauseMonitor
+		);
 
-router.post("/demo", isAllowed(["admin", "superadmin"]), addDemoMonitors);
+		this.router.post(
+			"/demo",
+			isAllowed(["admin", "superadmin"]),
+			this.monitorController.addDemoMonitors
+		);
+	}
 
-export default router;
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default MonitorRoutes;

Server/routes/queueRoute.js

@@ -1,21 +1,21 @@
 import { Router } from "express";
-import {
-	getMetrics,
-	getJobs,
-	addJob,
-	obliterateQueue,
-} from "../controllers/queueController.js";
 
-const router = Router();
-router.get("/metrics", getMetrics);
+class QueueRoutes {
+	constructor(queueController) {
+		this.router = Router();
+		this.queueController = queueController;
+		this.initRoutes();
+	}
+	initRoutes() {
+		this.router.get("/metrics", this.queueController.getMetrics);
+		this.router.get("/jobs", this.queueController.getJobs);
+		this.router.post("/jobs", this.queueController.addJob);
+		this.router.post("/obliterate", this.queueController.obliterateQueue);
+	}
 
-// Get Jobs
-router.get("/jobs", getJobs);
+	getRouter() {
+		return this.router;
+	}
+}
 
-// Add Job
-router.post("/jobs", addJob);
-
-// Obliterate Queue
-router.post("/obliterate", obliterateQueue);
-
-export default router;
+export default QueueRoutes;

Server/routes/settingsRoute.js

@@ -1,10 +1,25 @@
 import { Router } from "express";
-import { getAppSettings, updateAppSettings } from "../controllers/settingsController.js";
 import { isAllowed } from "../middleware/isAllowed.js";
 
-const router = Router();
+class SettingsRoutes {
+	constructor(settingsController) {
+		this.router = Router();
+		this.settingsController = settingsController;
+		this.initRoutes();
+	}
 
-router.get("/", getAppSettings);
-router.put("/", isAllowed(["superadmin"]), updateAppSettings);
+	initRoutes() {
+		this.router.get("/", this.settingsController.getAppSettings);
+		this.router.put(
+			"/",
+			isAllowed(["superadmin"]),
+			this.settingsController.updateAppSettings
+		);
+	}
 
-export default router;
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default SettingsRoutes;

Server/routes/statusPageRoute.js

@@ -1,11 +1,22 @@
-import express from "express";
-import { verifyJWT } from "../middleware/verifyJWT.js";
-import {
-	createStatusPage,
-	getStatusPageByUrl,
-} from "../controllers/statusPageController.js";
-const router = express.Router();
+import { Router } from "express";
 
-router.get("/:url", getStatusPageByUrl);
-router.post("/:url", verifyJWT, createStatusPage);
-export default router;
+import { verifyJWT } from "../middleware/verifyJWT.js";
+
+class StatusPageRoutes {
+	constructor(statusPageController) {
+		this.router = Router();
+		this.statusPageController = statusPageController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		this.router.get("/:url", this.statusPageController.getStatusPageByUrl);
+		this.router.post("/:url", verifyJWT, this.statusPageController.createStatusPage);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default StatusPageRoutes;