move to src

server/src/app.js

@@ -0,0 +1,73 @@
+import express from "express";
+import path from "path";
+import { responseHandler } from "./middleware/responseHandler.js";
+import cors from "cors";
+import helmet from "helmet";
+import compression from "compression";
+import languageMiddleware from "./middleware/languageMiddleware.js";
+import swaggerUi from "swagger-ui-express";
+import { handleErrors } from "./middleware/handleErrors.js";
+import { setupRoutes } from "./config/routes.js";
+export const createApp = ({ services, controllers, appSettings, frontendPath, openApiSpec }) => {
+	const allowedOrigin = appSettings.clientHost;
+
+	const app = express();
+
+	// Static files
+	app.use(express.static(frontendPath));
+
+	// Response handler
+	app.use(responseHandler);
+
+	app.use(
+		cors({
+			origin: allowedOrigin,
+			methods: "GET,HEAD,PUT,PATCH,POST,DELETE,OPTIONS",
+			allowedHeaders: "*",
+			credentials: true,
+		})
+	);
+	app.use(express.json());
+	app.use(
+		helmet({
+			hsts: false,
+			contentSecurityPolicy: {
+				useDefaults: true,
+				directives: {
+					upgradeInsecureRequests: null,
+				},
+			},
+		})
+	);
+	app.use(
+		compression({
+			level: 6,
+			threshold: 1024,
+			filter: (req, res) => {
+				if (req.headers["x-no-compression"]) {
+					return false;
+				}
+				return compression.filter(req, res);
+			},
+		})
+	);
+	app.use(languageMiddleware(services.stringService, services.translationService, services.settingsService));
+	// Swagger UI
+	app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(openApiSpec));
+
+	app.use("/api/v1/health", (req, res) => {
+		res.json({
+			status: "OK",
+		});
+	});
+
+	// Main app routes
+	setupRoutes(app, controllers);
+
+	// FE routes
+	app.get("*", (req, res) => {
+		res.sendFile(path.join(frontendPath, "index.html"));
+	});
+	app.use(handleErrors);
+	return app;
+};

server/src/config/controllers.js

@@ -0,0 +1,66 @@
+import { createCommonDependencies } from "../controllers/baseController.js";
+
+// Services
+
+// Controllers
+import MonitorController from "../controllers/monitorController.js";
+import AuthController from "../controllers/authController.js";
+import SettingsController from "../controllers/settingsController.js";
+import CheckController from "../controllers/checkController.js";
+import InviteController from "../controllers/inviteController.js";
+import MaintenanceWindowController from "../controllers/maintenanceWindowController.js";
+import QueueController from "../controllers/queueController.js";
+import LogController from "../controllers/logController.js";
+import StatusPageController from "../controllers/statusPageController.js";
+import NotificationController from "../controllers/notificationController.js";
+import DiagnosticController from "../controllers/diagnosticController.js";
+
+export const initializeControllers = (services) => {
+	const controllers = {};
+	const commonDependencies = createCommonDependencies(services.db, services.logger, services.errorService, services.stringService);
+
+	controllers.authController = new AuthController(commonDependencies, {
+		settingsService: services.settingsService,
+		emailService: services.emailService,
+		jobQueue: services.jobQueue,
+		userService: services.userService,
+	});
+
+	controllers.monitorController = new MonitorController(commonDependencies, {
+		settingsService: services.settingsService,
+		jobQueue: services.jobQueue,
+		emailService: services.emailService,
+		monitorService: services.monitorService,
+	});
+
+	controllers.settingsController = new SettingsController(commonDependencies, {
+		settingsService: services.settingsService,
+		emailService: services.emailService,
+	});
+	controllers.checkController = new CheckController(commonDependencies, {
+		settingsService: services.settingsService,
+		checkService: services.checkService,
+	});
+	controllers.inviteController = new InviteController(commonDependencies, {
+		inviteService: services.inviteService,
+	});
+
+	controllers.maintenanceWindowController = new MaintenanceWindowController(commonDependencies, {
+		settingsService: services.settingsService,
+		maintenanceWindowService: services.maintenanceWindowService,
+	});
+	controllers.queueController = new QueueController(commonDependencies, {
+		jobQueue: services.jobQueue,
+	});
+	controllers.logController = new LogController(commonDependencies);
+	controllers.statusPageController = new StatusPageController(commonDependencies);
+	controllers.notificationController = new NotificationController(commonDependencies, {
+		notificationService: services.notificationService,
+		statusService: services.statusService,
+	});
+	controllers.diagnosticController = new DiagnosticController(commonDependencies, {
+		diagnosticService: services.diagnosticService,
+	});
+
+	return controllers;
+};

server/src/config/routes.js

@@ -0,0 +1,39 @@
+import { verifyJWT } from "../middleware/verifyJWT.js";
+
+import AuthRoutes from "../routes/authRoute.js";
+import InviteRoutes from "../routes/inviteRoute.js";
+import MonitorRoutes from "../routes/monitorRoute.js";
+import CheckRoutes from "../routes/checkRoute.js";
+import SettingsRoutes from "../routes/settingsRoute.js";
+import MaintenanceWindowRoutes from "../routes/maintenanceWindowRoute.js";
+import StatusPageRoutes from "../routes/statusPageRoute.js";
+import QueueRoutes from "../routes/queueRoute.js";
+import LogRoutes from "../routes/logRoutes.js";
+import DiagnosticRoutes from "../routes/diagnosticRoute.js";
+import NotificationRoutes from "../routes/notificationRoute.js";
+
+export const setupRoutes = (app, controllers) => {
+	const authRoutes = new AuthRoutes(controllers.authController);
+	const monitorRoutes = new MonitorRoutes(controllers.monitorController);
+	const settingsRoutes = new SettingsRoutes(controllers.settingsController);
+	const checkRoutes = new CheckRoutes(controllers.checkController);
+	const inviteRoutes = new InviteRoutes(controllers.inviteController);
+	const maintenanceWindowRoutes = new MaintenanceWindowRoutes(controllers.maintenanceWindowController);
+	const queueRoutes = new QueueRoutes(controllers.queueController);
+	const logRoutes = new LogRoutes(controllers.logController);
+	const statusPageRoutes = new StatusPageRoutes(controllers.statusPageController);
+	const notificationRoutes = new NotificationRoutes(controllers.notificationController);
+	const diagnosticRoutes = new DiagnosticRoutes(controllers.diagnosticController);
+
+	app.use("/api/v1/auth", authRoutes.getRouter());
+	app.use("/api/v1/monitors", verifyJWT, monitorRoutes.getRouter());
+	app.use("/api/v1/settings", verifyJWT, settingsRoutes.getRouter());
+	app.use("/api/v1/checks", verifyJWT, checkRoutes.getRouter());
+	app.use("/api/v1/invite", inviteRoutes.getRouter());
+	app.use("/api/v1/maintenance-window", verifyJWT, maintenanceWindowRoutes.getRouter());
+	app.use("/api/v1/queue", verifyJWT, queueRoutes.getRouter());
+	app.use("/api/v1/logs", verifyJWT, logRoutes.getRouter());
+	app.use("/api/v1/status-page", statusPageRoutes.getRouter());
+	app.use("/api/v1/notifications", verifyJWT, notificationRoutes.getRouter());
+	app.use("/api/v1/diagnostic", verifyJWT, diagnosticRoutes.getRouter());
+};

server/src/config/services.js

@@ -0,0 +1,152 @@
+import ServiceRegistry from "../service/system/serviceRegistry.js";
+import logger from "../utils/logger.js";
+import TranslationService from "../service/system/translationService.js";
+import StringService from "../service/system/stringService.js";
+import MongoDB from "../db/mongo/MongoDB.js";
+import NetworkService from "../service/infrastructure/networkService.js";
+import EmailService from "../service/infrastructure/emailService.js";
+import BufferService from "../service/infrastructure/bufferService.js";
+import StatusService from "../service/infrastructure/statusService.js";
+import NotificationUtils from "../service/infrastructure/notificationUtils.js";
+import NotificationService from "../service/infrastructure/notificationService.js";
+import RedisService from "../service/data/redisService.js";
+import ErrorService from "../service/infrastructure/errorService.js";
+import SuperSimpleQueueHelper from "../service/infrastructure/SuperSimpleQueue/SuperSimpleQueueHelper.js";
+import SuperSimpleQueue from "../service/infrastructure/SuperSimpleQueue/SuperSimpleQueue.js";
+import UserService from "../service/business/userService.js";
+import CheckService from "../service/business/checkService.js";
+import DiagnosticService from "../service/business/diagnosticService.js";
+import InviteService from "../service/business/inviteService.js";
+import MaintenanceWindowService from "../service/business/maintenanceWindowService.js";
+import MonitorService from "../service/business/monitorService.js";
+import IORedis from "ioredis";
+import papaparse from "papaparse";
+import axios from "axios";
+import ping from "ping";
+import http from "http";
+import Docker from "dockerode";
+import net from "net";
+import fs from "fs";
+import path from "path";
+import nodemailer from "nodemailer";
+import pkg from "handlebars";
+const { compile } = pkg;
+import mjml2html from "mjml";
+import jwt from "jsonwebtoken";
+
+export const initializeServices = async (appSettings, settingsService) => {
+	const translationService = new TranslationService(logger);
+	await translationService.initialize();
+
+	const stringService = new StringService(translationService);
+
+	// Create DB
+	const db = new MongoDB({ appSettings });
+	await db.connect();
+
+	const networkService = new NetworkService(axios, ping, logger, http, Docker, net, stringService, settingsService);
+	const emailService = new EmailService(settingsService, fs, path, compile, mjml2html, nodemailer, logger);
+	const bufferService = new BufferService({ db, logger });
+	const statusService = new StatusService({ db, logger, buffer: bufferService });
+
+	const notificationUtils = new NotificationUtils({
+		stringService,
+		emailService,
+	});
+
+	const notificationService = new NotificationService({
+		emailService,
+		db,
+		logger,
+		networkService,
+		stringService,
+		notificationUtils,
+	});
+
+	const redisService = new RedisService({ Redis: IORedis, logger });
+	const errorService = new ErrorService();
+
+	const superSimpleQueueHelper = new SuperSimpleQueueHelper({
+		db,
+		logger,
+		networkService,
+		statusService,
+		notificationService,
+	});
+
+	const superSimpleQueue = await SuperSimpleQueue.create({
+		appSettings,
+		db,
+		logger,
+		helper: superSimpleQueueHelper,
+	});
+
+	// Business services
+	const userService = new UserService({
+		db,
+		emailService,
+		settingsService,
+		logger,
+		stringService,
+		jwt,
+		errorService,
+	});
+	const checkService = new CheckService({
+		db,
+		settingsService,
+		stringService,
+		errorService,
+	});
+	const diagnosticService = new DiagnosticService();
+	const inviteService = new InviteService({
+		db,
+		settingsService,
+		emailService,
+		stringService,
+		errorService,
+	});
+	const maintenanceWindowService = new MaintenanceWindowService({
+		db,
+		settingsService,
+		stringService,
+		errorService,
+	});
+	const monitorService = new MonitorService({
+		db,
+		settingsService,
+		jobQueue: superSimpleQueue,
+		stringService,
+		emailService,
+		papaparse,
+		logger,
+		errorService,
+	});
+
+	const services = {
+		settingsService,
+		translationService,
+		stringService,
+		db,
+		networkService,
+		emailService,
+		bufferService,
+		statusService,
+		notificationService,
+		redisService,
+		jobQueue: superSimpleQueue,
+		userService,
+		checkService,
+		diagnosticService,
+		inviteService,
+		maintenanceWindowService,
+		monitorService,
+		errorService,
+		logger,
+	};
+
+	Object.values(services).forEach((service) => {
+		ServiceRegistry.register(service.serviceName, service);
+	});
+
+	return services;
+};

server/src/controllers/announcementsController.js

@@ -0,0 +1,77 @@
+import { createAnnouncementValidation } from "../validation/joi.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "announcementController";
+
+/**
+ * Controller for managing announcements in the system.
+ * This class handles the creation of new announcements.
+ *
+ * @class AnnouncementController
+ */
+
+class AnnouncementController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies) {
+		super(commonDependencies);
+		this.createAnnouncement = this.createAnnouncement.bind(this);
+		this.getAnnouncement = this.getAnnouncement.bind(this);
+	}
+
+	get serviceName() {
+		return AnnouncementController.SERVICE_NAME;
+	}
+
+	/**
+	 * Handles the creation of a new announcement.
+	 *
+	 * @async
+	 * @param {Object} req - The request object, containing the announcement data in the body.
+	 * @param {Object} res - The response object used to send the result back to the client.
+	 * @param {Function} next - The next middleware function in the stack for error handling.
+	 *
+	 * @returns {Promise<void>} A promise that resolves once the response is sent.
+	 */
+	createAnnouncement = asyncHandler(
+		async (req, res, next) => {
+			await createAnnouncementValidation.validateAsync(req.body);
+			const { title, message } = req.body;
+			const announcementData = {
+				title: title.trim(),
+				message: message.trim(),
+				userId: req.user._id,
+			};
+
+			const newAnnouncement = await this.db.createAnnouncement(announcementData);
+			return res.success({
+				msg: this.stringService.createAnnouncement,
+				data: newAnnouncement,
+			});
+		},
+		SERVICE_NAME,
+		"createAnnouncement"
+	);
+
+	/**
+	 * Handles retrieving announcements with pagination.
+	 *
+	 * @async
+	 * @param {Object} res - The response object used to send the result back to the client.
+	 *  - `data`: The list of announcements to be sent back to the client.
+	 *  - `msg`: A message about the success of the request.
+	 * @param {Function} next - The next middleware function in the stack for error handling.
+	 */
+	getAnnouncement = asyncHandler(
+		async (req, res, next) => {
+			const allAnnouncements = await this.db.getAnnouncements();
+			return res.success({
+				msg: this.stringService.getAnnouncement,
+				data: allAnnouncements,
+			});
+		},
+		SERVICE_NAME,
+		"getAnnouncement"
+	);
+}
+
+export default AnnouncementController;

server/src/controllers/authController.js

@@ -0,0 +1,461 @@
+import BaseController from "./baseController.js";
+import {
+	registrationBodyValidation,
+	loginValidation,
+	editUserBodyValidation,
+	recoveryValidation,
+	recoveryTokenBodyValidation,
+	newPasswordValidation,
+	getUserByIdParamValidation,
+	editUserByIdParamValidation,
+	editUserByIdBodyValidation,
+	editSuperadminUserByIdBodyValidation,
+} from "../validation/joi.js";
+
+const SERVICE_NAME = "authController";
+
+/**
+ * Authentication Controller
+ *
+ * Handles all authentication-related HTTP requests including user registration,
+ * login, password recovery, and user management operations.
+ *
+ * @class AuthController
+ * @description Manages user authentication and authorization operations
+ */
+class AuthController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	/**
+	 * Creates an instance of AuthController.
+	 *
+	 * @param {Object} commonDependencies - Common dependencies injected into the controller
+	 * @param {Object} dependencies - The dependencies required by the controller
+	 * @param {Object} dependencies.settingsService - Service for application settings
+	 * @param {Object} dependencies.emailService - Service for email operations
+	 * @param {Object} dependencies.jobQueue - Service for job queue operations
+	 * @param {Object} dependencies.userService - User business logic service
+	 */
+	constructor(commonDependencies, { settingsService, emailService, jobQueue, userService }) {
+		super(commonDependencies);
+		this.settingsService = settingsService;
+		this.emailService = emailService;
+		this.jobQueue = jobQueue;
+		this.userService = userService;
+	}
+
+	get serviceName() {
+		return AuthController.SERVICE_NAME;
+	}
+
+	/**
+	 * Registers a new user in the system.
+	 *
+	 * @async
+	 * @function registerUser
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing user registration data
+	 * @param {string} req.body.firstName - User's first name
+	 * @param {string} req.body.lastName - User's last name
+	 * @param {string} req.body.email - User's email address (will be converted to lowercase)
+	 * @param {string} req.body.password - User's password
+	 * @param {string} [req.body.inviteToken] - Invite token for registration (required if superadmin exists)
+	 * @param {string} [req.body.teamId] - Team ID (auto-assigned if superadmin)
+	 * @param {Array<string>} [req.body.role] - User roles (auto-assigned if superadmin)
+	 * @param {Object} [req.file] - Profile image file uploaded via multer
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with user data and JWT token
+	 * @throws {Error} 422 - Validation error if request body is invalid
+	 * @throws {Error} 409 - Conflict if user already exists
+	 * @example
+	 * // Register first user (becomes superadmin)
+	 * POST /auth/register
+	 * {
+	 *   "firstName": "John",
+	 *   "lastName": "Doe",
+	 *   "email": "john@example.com",
+	 *   "password": "SecurePass123!"
+	 * }
+	 *
+	 * // Register subsequent user (requires invite token)
+	 * POST /auth/register
+	 * {
+	 *   "firstName": "Jane",
+	 *   "lastName": "Smith",
+	 *   "email": "jane@example.com",
+	 *   "password": "SecurePass123!",
+	 *   "inviteToken": "abc123..."
+	 * }
+	 */
+	registerUser = this.asyncHandler(
+		async (req, res) => {
+			if (req.body?.email) {
+				req.body.email = req.body.email?.toLowerCase();
+			}
+			await registrationBodyValidation.validateAsync(req.body);
+			const { user, token } = await this.userService.registerUser(req.body, req.file);
+			res.success({
+				msg: this.stringService.authCreateUser,
+				data: { user, token },
+			});
+		},
+		SERVICE_NAME,
+		"registerUser"
+	);
+
+	/**
+	 * Authenticates a user and returns a JWT token.
+	 *
+	 * @async
+	 * @function loginUser
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing login credentials
+	 * @param {string} req.body.email - User's email address (will be converted to lowercase)
+	 * @param {string} req.body.password - User's password
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with user data and JWT token
+	 * @throws {Error} 422 - Validation error if request body is invalid
+	 * @throws {Error} 401 - Unauthorized if credentials are incorrect
+	 * @example
+	 * POST /auth/login
+	 * {
+	 *   "email": "john@example.com",
+	 *   "password": "SecurePass123!"
+	 * }
+	 */
+	loginUser = this.asyncHandler(
+		async (req, res) => {
+			if (req.body?.email) {
+				req.body.email = req.body.email?.toLowerCase();
+			}
+			await loginValidation.validateAsync(req.body);
+			const { user, token } = await this.userService.loginUser(req.body.email, req.body.password);
+
+			return res.success({
+				msg: this.stringService.authLoginUser,
+				data: {
+					user,
+					token,
+				},
+			});
+		},
+		SERVICE_NAME,
+		"loginUser"
+	);
+
+	/**
+	 * Updates the current user's profile information.
+	 *
+	 * @async
+	 * @function editUser
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing user update data
+	 * @param {string} [req.body.firstName] - Updated first name
+	 * @param {string} [req.body.lastName] - Updated last name
+	 * @param {string} [req.body.password] - Current password (required for password change)
+	 * @param {string} [req.body.newPassword] - New password (required for password change)
+	 * @param {boolean} [req.body.deleteProfileImage] - Flag to delete profile image
+	 * @param {Object} [req.file] - New profile image file
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with updated user data
+	 * @throws {Error} 422 - Validation error if request body is invalid
+	 * @throws {Error} 403 - Forbidden if current password is incorrect
+	 * @example
+	 * PUT /auth/user
+	 * {
+	 *   "firstName": "John Updated",
+	 *   "lastName": "Doe Updated"
+	 * }
+	 *
+	 * // Change password
+	 * PUT /auth/user
+	 * {
+	 *   "password": "OldPass123!",
+	 *   "newPassword": "NewPass123!"
+	 * }
+	 */
+	editUser = this.asyncHandler(
+		async (req, res) => {
+			await editUserBodyValidation.validateAsync(req.body);
+
+			const updatedUser = await this.userService.editUser(req.body, req.file, req.user);
+
+			res.success({
+				msg: this.stringService.authUpdateUser,
+				data: updatedUser,
+			});
+		},
+		SERVICE_NAME,
+		"editUser"
+	);
+
+	/**
+	 * Checks if a superadmin account exists in the system.
+	 *
+	 * @async
+	 * @function checkSuperadminExists
+	 * @param {Object} req - Express request object
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with boolean indicating superadmin existence
+	 * @example
+	 * GET /auth/users/superadmin
+	 * // Response: { "data": true } or { "data": false }
+	 */
+	checkSuperadminExists = this.asyncHandler(
+		async (req, res) => {
+			const superAdminExists = await this.userService.checkSuperadminExists();
+			return res.success({
+				msg: this.stringService.authAdminExists,
+				data: superAdminExists,
+			});
+		},
+		SERVICE_NAME,
+		"checkSuperadminExists"
+	);
+
+	/**
+	 * Initiates password recovery process by sending a recovery email.
+	 *
+	 * @async
+	 * @function requestRecovery
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing email
+	 * @param {string} req.body.email - Email address for password recovery
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with message ID
+	 * @throws {Error} 422 - Validation error if email is invalid
+	 * @throws {Error} 404 - Not found if user doesn't exist
+	 * @example
+	 * POST /auth/recovery/request
+	 * {
+	 *   "email": "john@example.com"
+	 * }
+	 */
+	requestRecovery = this.asyncHandler(
+		async (req, res) => {
+			await recoveryValidation.validateAsync(req.body);
+			const email = req?.body?.email;
+			const msgId = await this.userService.requestRecovery(email);
+			return res.success({
+				msg: this.stringService.authCreateRecoveryToken,
+				data: msgId,
+			});
+		},
+		SERVICE_NAME,
+		"requestRecovery"
+	);
+
+	/**
+	 * Validates a password recovery token.
+	 *
+	 * @async
+	 * @function validateRecovery
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing recovery token
+	 * @param {string} req.body.recoveryToken - Recovery token to validate
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response if token is valid
+	 * @throws {Error} 422 - Validation error if token format is invalid
+	 * @throws {Error} 400 - Bad request if token is invalid or expired
+	 * @example
+	 * POST /auth/recovery/validate
+	 * {
+	 *   "recoveryToken": "abc123..."
+	 * }
+	 */
+	validateRecovery = this.asyncHandler(
+		async (req, res) => {
+			await recoveryTokenBodyValidation.validateAsync(req.body);
+			await this.userService.validateRecovery(req.body.recoveryToken);
+			return res.success({
+				msg: this.stringService.authVerifyRecoveryToken,
+			});
+		},
+		SERVICE_NAME,
+		"validateRecovery"
+	);
+
+	/**
+	 * Resets user password using a valid recovery token.
+	 *
+	 * @async
+	 * @function resetPassword
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing new password and recovery token
+	 * @param {string} req.body.password - New password
+	 * @param {string} req.body.recoveryToken - Valid recovery token
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with user data and JWT token
+	 * @throws {Error} 422 - Validation error if password format is invalid
+	 * @throws {Error} 400 - Bad request if token is invalid or expired
+	 * @example
+	 * POST /auth/recovery/reset
+	 * {
+	 *   "password": "NewSecurePass123!",
+	 *   "recoveryToken": "abc123..."
+	 * }
+	 */
+	resetPassword = this.asyncHandler(
+		async (req, res) => {
+			await newPasswordValidation.validateAsync(req.body);
+			const { user, token } = await this.userService.resetPassword(req.body.password, req.body.recoveryToken);
+			return res.success({
+				msg: this.stringService.authResetPassword,
+				data: { user, token },
+			});
+		},
+		SERVICE_NAME,
+		"resetPassword"
+	);
+
+	/**
+	 * Deletes the current user's account and associated data.
+	 *
+	 * @async
+	 * @function deleteUser
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user._id - User ID
+	 * @param {string} req.user.email - User email
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Array<string>} req.user.role - User roles
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response confirming user deletion
+	 * @throws {Error} 400 - Bad request if user is demo user
+	 * @throws {Error} 404 - Not found if user doesn't exist
+	 * @example
+	 * DELETE /auth/user
+	 * // Requires JWT authentication
+	 */
+	deleteUser = this.asyncHandler(
+		async (req, res) => {
+			await this.userService.deleteUser(req.user);
+			return res.success({
+				msg: this.stringService.authDeleteUser,
+			});
+		},
+		SERVICE_NAME,
+		"deleteUser"
+	);
+
+	/**
+	 * Retrieves all users in the system (admin/superadmin only).
+	 *
+	 * @async
+	 * @function getAllUsers
+	 * @param {Object} req - Express request object
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with array of users
+	 * @throws {Error} 403 - Forbidden if user doesn't have admin/superadmin role
+	 * @example
+	 * GET /auth/users
+	 * // Requires JWT authentication with admin/superadmin role
+	 */
+	getAllUsers = this.asyncHandler(
+		async (req, res) => {
+			const allUsers = await this.userService.getAllUsers();
+			return res.success({
+				msg: this.stringService.authGetAllUsers,
+				data: allUsers,
+			});
+		},
+		SERVICE_NAME,
+		"getAllUsers"
+	);
+
+	/**
+	 * Retrieves a specific user by ID (superadmin only).
+	 *
+	 * @async
+	 * @function getUserById
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.userId - ID of the user to retrieve
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {Array<string>} req.user.role - Current user's roles
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with user data
+	 * @throws {Error} 422 - Validation error if userId is invalid
+	 * @throws {Error} 403 - Forbidden if user doesn't have superadmin role
+	 * @throws {Error} 404 - Not found if user doesn't exist
+	 * @example
+	 * GET /auth/users/507f1f77bcf86cd799439011
+	 * // Requires JWT authentication with superadmin role
+	 */
+	getUserById = this.asyncHandler(
+		async (req, res) => {
+			await getUserByIdParamValidation.validateAsync(req.params);
+			const userId = req?.params?.userId;
+			const roles = req?.user?.role;
+
+			if (!userId) {
+				throw new Error("No user ID in request");
+			}
+
+			if (!roles || roles.length === 0) {
+				throw new Error("No roles in request");
+			}
+
+			const user = await this.userService.getUserById(roles, userId);
+
+			return res.success({ msg: "ok", data: user });
+		},
+		SERVICE_NAME,
+		"getUserById"
+	);
+
+	/**
+	 * Updates a specific user by ID (superadmin only).
+	 *
+	 * @async
+	 * @function editUserById
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.userId - ID of the user to update
+	 * @param {Object} req.body - Request body containing user update data
+	 * @param {string} [req.body.firstName] - Updated first name
+	 * @param {string} [req.body.lastName] - Updated last name
+	 * @param {Array<string>} [req.body.role] - Updated user roles
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user._id - Current user's ID
+	 * @param {Array<string>} req.user.role - Current user's roles
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response confirming user update
+	 * @throws {Error} 422 - Validation error if parameters or body are invalid
+	 * @throws {Error} 403 - Forbidden if user doesn't have superadmin role
+	 * @throws {Error} 404 - Not found if user doesn't exist
+	 * @example
+	 * PUT /auth/users/507f1f77bcf86cd799439011
+	 * {
+	 *   "firstName": "Updated Name",
+	 *   "role": ["admin"]
+	 * }
+	 * // Requires JWT authentication with superadmin role
+	 */
+	editUserById = this.asyncHandler(
+		async (req, res) => {
+			const roles = req?.user?.role;
+			if (!roles.includes("superadmin")) {
+				throw createError("Unauthorized", 403);
+			}
+
+			const userId = req.params.userId;
+			const user = { ...req.body };
+
+			await editUserByIdParamValidation.validateAsync(req.params);
+			// If this is superadmin self edit, allow "superadmin" role
+			if (userId === req.user._id) {
+				await editSuperadminUserByIdBodyValidation.validateAsync(req.body);
+			} else {
+				await editUserByIdBodyValidation.validateAsync(req.body);
+			}
+
+			await this.userService.editUserById(userId, user);
+			return res.success({ msg: "ok" });
+		},
+		SERVICE_NAME,
+		"editUserById"
+	);
+}
+
+export default AuthController;

server/src/controllers/baseController.js

@@ -0,0 +1,83 @@
+import { AppError } from "../service/infrastructure/errorService.js";
+
+export const createCommonDependencies = (db, errorService, logger, stringService) => {
+	return {
+		db,
+		errorService,
+		logger,
+		stringService,
+	};
+};
+
+class BaseController {
+	constructor({ db, logger, errorService, ...additionalDependencies }) {
+		this.db = db;
+		this.logger = logger;
+		this.errorService = errorService;
+		Object.assign(this, additionalDependencies);
+
+		this.asyncHandler = (fn, serviceName, methodName) => {
+			return async (req, res, next) => {
+				try {
+					await fn(req, res, next);
+				} catch (error) {
+					// Handle validation errors
+					if (error.isJoi) {
+						const validationError = this.errorService.createValidationError(error.message, error.details, serviceName, methodName);
+						return next(validationError);
+					}
+
+					if (error.name === "ValidationError") {
+						const validationError = this.errorService.createValidationError("Database validation failed", error.errors, serviceName, methodName);
+						return next(validationError);
+					}
+
+					if (error.name === "CastError") {
+						const notFoundError = this.errorService.createNotFoundError(
+							"Invalid resource identifier",
+							{ field: error.path, value: error.value },
+							serviceName,
+							methodName
+						);
+						return next(notFoundError);
+					}
+
+					if (error.code === "11000") {
+						const conflictError = this.errorService.createConflictError("Resource already exists", {
+							originalError: error.message,
+							code: error.code,
+						});
+						conflictError.service = serviceName;
+						conflictError.method = methodName;
+						return next(conflictError);
+					}
+
+					if (error instanceof AppError) {
+						error.service = error.service || serviceName;
+						error.method = error.method || methodName;
+						return next(error);
+					}
+
+					if (error.status) {
+						const appError = this.errorService.createError(error.message, error.status, serviceName, methodName, {
+							originalError: error.message,
+							stack: error.stack,
+						});
+						return next(appError);
+					}
+
+					// For unknown errors, create a server error
+					const appError = this.errorService.createServerError(error.message || "An unexpected error occurred", {
+						originalError: error.message,
+						stack: error.stack,
+					});
+					appError.service = serviceName;
+					appError.method = methodName;
+					appError.stack = error.stack; // Preserve original stack
+					return next(appError);
+				}
+			};
+		};
+	}
+}
+export default BaseController;

server/src/controllers/checkController.js

@@ -0,0 +1,360 @@
+import BaseController from "./baseController.js";
+import {
+	getChecksParamValidation,
+	getChecksQueryValidation,
+	getTeamChecksQueryValidation,
+	deleteChecksParamValidation,
+	deleteChecksByTeamIdParamValidation,
+	updateChecksTTLBodyValidation,
+	ackCheckBodyValidation,
+	ackAllChecksParamValidation,
+	ackAllChecksBodyValidation,
+} from "../validation/joi.js";
+
+const SERVICE_NAME = "checkController";
+
+/**
+ * Check Controller
+ *
+ * Handles all check-related HTTP requests including retrieving checks,
+ * acknowledging checks, deleting checks, and managing check TTL settings.
+ *
+ * @class CheckController
+ * @description Manages check operations and monitoring data
+ */
+class CheckController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	/**
+	 * Creates an instance of CheckController.
+	 *
+	 * @param {Object} commonDependencies - Common dependencies injected into the controller
+	 * @param {Object} dependencies - The dependencies required by the controller
+	 * @param {Object} dependencies.settingsService - Service for application settings
+	 * @param {Object} dependencies.checkService - Check business logic service
+	 */
+	constructor(commonDependencies, { settingsService, checkService }) {
+		super(commonDependencies);
+		this.settingsService = settingsService;
+		this.checkService = checkService;
+	}
+
+	get serviceName() {
+		return CheckController.SERVICE_NAME;
+	}
+
+	/**
+	 * Retrieves checks for a specific monitor with filtering and pagination.
+	 *
+	 * @async
+	 * @function getChecksByMonitor
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.monitorId - ID of the monitor to get checks for
+	 * @param {Object} req.query - Query parameters for filtering and pagination
+	 * @param {string} [req.query.type] - Type of checks to filter by
+	 * @param {string} [req.query.sortOrder] - Sort order (asc/desc)
+	 * @param {string} [req.query.dateRange] - Date range filter
+	 * @param {string} [req.query.filter] - General filter string
+	 * @param {boolean} [req.query.ack] - Filter by acknowledgment status
+	 * @param {number} [req.query.page] - Page number for pagination
+	 * @param {number} [req.query.rowsPerPage] - Number of rows per page
+	 * @param {string} [req.query.status] - Filter by check status
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with checks data
+	 * @throws {Error} 422 - Validation error if parameters are invalid
+	 * @throws {Error} 404 - Not found if monitor doesn't exist
+	 * @throws {Error} 403 - Forbidden if user doesn't have access to monitor
+	 * @example
+	 * GET /checks/monitor/507f1f77bcf86cd799439011?page=1&rowsPerPage=10&status=down
+	 * // Requires JWT authentication
+	 */
+	getChecksByMonitor = this.asyncHandler(
+		async (req, res) => {
+			await getChecksParamValidation.validateAsync(req.params);
+			await getChecksQueryValidation.validateAsync(req.query);
+
+			const result = await this.checkService.getChecksByMonitor({
+				monitorId: req?.params?.monitorId,
+				query: req?.query,
+				teamId: req?.user?.teamId,
+			});
+
+			return res.success({
+				msg: this.stringService.checkGet,
+				data: result,
+			});
+		},
+		SERVICE_NAME,
+		"getChecksByMonitor"
+	);
+
+	/**
+	 * Retrieves all checks for the current user's team with filtering and pagination.
+	 *
+	 * @async
+	 * @function getChecksByTeam
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.query - Query parameters for filtering and pagination
+	 * @param {string} [req.query.sortOrder] - Sort order (asc/desc)
+	 * @param {string} [req.query.dateRange] - Date range filter
+	 * @param {string} [req.query.filter] - General filter string
+	 * @param {boolean} [req.query.ack] - Filter by acknowledgment status
+	 * @param {number} [req.query.page] - Page number for pagination
+	 * @param {number} [req.query.rowsPerPage] - Number of rows per page
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with checks data
+	 * @throws {Error} 422 - Validation error if query parameters are invalid
+	 * @example
+	 * GET /checks/team?page=1&rowsPerPage=20&status=down&ack=false
+	 * // Requires JWT authentication
+	 */
+	getChecksByTeam = this.asyncHandler(
+		async (req, res) => {
+			await getTeamChecksQueryValidation.validateAsync(req.query);
+			const checkData = await this.checkService.getChecksByTeam({
+				teamId: req?.user?.teamId,
+				query: req?.query,
+			});
+			return res.success({
+				msg: this.stringService.checkGet,
+				data: checkData,
+			});
+		},
+		SERVICE_NAME,
+		"getChecksByTeam"
+	);
+
+	/**
+	 * Retrieves a summary of checks for the current user's team.
+	 *
+	 * @async
+	 * @function getChecksSummaryByTeamId
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with checks summary
+	 * @example
+	 * GET /checks/summary
+	 * // Requires JWT authentication
+	 * // Response includes counts by status, time ranges, etc.
+	 */
+	getChecksSummaryByTeamId = this.asyncHandler(
+		async (req, res) => {
+			const summary = await this.checkService.getChecksSummaryByTeamId({ teamId: req?.user?.teamId });
+			return res.success({
+				msg: this.stringService.checkGetSummary,
+				data: summary,
+			});
+		},
+		SERVICE_NAME,
+		"getChecksSummaryByTeamId"
+	);
+
+	/**
+	 * Acknowledges a specific check by ID.
+	 *
+	 * @async
+	 * @function ackCheck
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.checkId - ID of the check to acknowledge
+	 * @param {Object} req.body - Request body containing acknowledgment data
+	 * @param {boolean} req.body.ack - Acknowledgment status (true/false)
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with updated check data
+	 * @throws {Error} 422 - Validation error if request body is invalid
+	 * @throws {Error} 404 - Not found if check doesn't exist
+	 * @throws {Error} 403 - Forbidden if user doesn't have access to check
+	 * @example
+	 * PUT /checks/507f1f77bcf86cd799439011/ack
+	 * {
+	 *   "ack": true
+	 * }
+	 * // Requires JWT authentication
+	 */
+	ackCheck = this.asyncHandler(
+		async (req, res) => {
+			await ackCheckBodyValidation.validateAsync(req.body);
+
+			const updatedCheck = await this.checkService.ackCheck({
+				checkId: req?.params?.checkId,
+				teamId: req?.user?.teamId,
+				ack: req?.body?.ack,
+			});
+
+			return res.success({
+				msg: this.stringService.checkUpdateStatus,
+				data: updatedCheck,
+			});
+		},
+		SERVICE_NAME,
+		"ackCheck"
+	);
+
+	/**
+	 * Acknowledges all checks for a specific monitor or path.
+	 *
+	 * @async
+	 * @function ackAllChecks
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.monitorId - ID of the monitor
+	 * @param {string} req.params.path - Path for acknowledgment (e.g., "monitor")
+	 * @param {Object} req.body - Request body containing acknowledgment data
+	 * @param {boolean} req.body.ack - Acknowledgment status (true/false)
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with updated checks data
+	 * @throws {Error} 422 - Validation error if parameters or body are invalid
+	 * @throws {Error} 404 - Not found if monitor doesn't exist
+	 * @throws {Error} 403 - Forbidden if user doesn't have access to monitor
+	 * @example
+	 * PUT /checks/monitor/507f1f77bcf86cd799439011/ack
+	 * {
+	 *   "ack": true
+	 * }
+	 * // Requires JWT authentication
+	 */
+	ackAllChecks = this.asyncHandler(
+		async (req, res) => {
+			await ackAllChecksParamValidation.validateAsync(req.params);
+			await ackAllChecksBodyValidation.validateAsync(req.body);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new Error("No team ID in request");
+			}
+
+			const updatedChecks = await this.checkService.ackAllChecks({
+				monitorId: req?.params?.monitorId,
+				path: req?.params?.path,
+				teamId: req?.user?.teamId,
+				ack: req?.body?.ack,
+			});
+
+			return res.success({
+				msg: this.stringService.checkUpdateStatus,
+				data: updatedChecks,
+			});
+		},
+		SERVICE_NAME,
+		"ackAllChecks"
+	);
+
+	/**
+	 * Deletes all checks for a specific monitor.
+	 *
+	 * @async
+	 * @function deleteChecks
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.params - URL parameters
+	 * @param {string} req.params.monitorId - ID of the monitor whose checks to delete
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with deletion count
+	 * @throws {Error} 422 - Validation error if monitorId is invalid
+	 * @throws {Error} 404 - Not found if monitor doesn't exist
+	 * @throws {Error} 403 - Forbidden if user doesn't have access to monitor
+	 * @example
+	 * DELETE /checks/monitor/507f1f77bcf86cd799439011
+	 * // Requires JWT authentication
+	 * // Response: { "data": { "deletedCount": 150 } }
+	 */
+	deleteChecks = this.asyncHandler(
+		async (req, res) => {
+			await deleteChecksParamValidation.validateAsync(req.params);
+
+			const deletedCount = await this.checkService.deleteChecks({
+				monitorId: req.params.monitorId,
+				teamId: req?.user?.teamId,
+			});
+
+			return res.success({
+				msg: this.stringService.checkDelete,
+				data: { deletedCount },
+			});
+		},
+		SERVICE_NAME,
+		"deleteChecks"
+	);
+
+	/**
+	 * Deletes all checks for the current user's team.
+	 *
+	 * @async
+	 * @function deleteChecksByTeamId
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with deletion count
+	 * @throws {Error} 422 - Validation error if parameters are invalid
+	 * @example
+	 * DELETE /checks/team
+	 * // Requires JWT authentication
+	 * // Response: { "data": { "deletedCount": 1250 } }
+	 */
+	deleteChecksByTeamId = this.asyncHandler(
+		async (req, res) => {
+			await deleteChecksByTeamIdParamValidation.validateAsync(req.params);
+
+			const deletedCount = await this.checkService.deleteChecksByTeamId({ teamId: req?.user?.teamId });
+
+			return res.success({
+				msg: this.stringService.checkDelete,
+				data: { deletedCount },
+			});
+		},
+		SERVICE_NAME,
+		"deleteChecksByTeamId"
+	);
+
+	/**
+	 * Updates the TTL (Time To Live) setting for checks in the current user's team.
+	 *
+	 * @async
+	 * @function updateChecksTTL
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing TTL data
+	 * @param {number} req.body.ttl - TTL value in days
+	 * @param {Object} req.user - Current authenticated user (from JWT)
+	 * @param {string} req.user.teamId - User's team ID
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response confirming TTL update
+	 * @throws {Error} 422 - Validation error if TTL value is invalid
+	 * @example
+	 * PUT /checks/ttl
+	 * {
+	 *   "ttl": 30
+	 * }
+	 * // Requires JWT authentication
+	 * // Sets check TTL to 30 days
+	 */
+	updateChecksTTL = this.asyncHandler(
+		async (req, res) => {
+			await updateChecksTTLBodyValidation.validateAsync(req.body);
+
+			await this.checkService.updateChecksTTL({
+				teamId: req?.user?.teamId,
+				ttl: req?.body?.ttl,
+			});
+
+			return res.success({
+				msg: this.stringService.checkUpdateTTL,
+			});
+		},
+		SERVICE_NAME,
+		"updateChecksTtl"
+	);
+}
+
+export default CheckController;

server/src/controllers/controllerUtils.js

@@ -0,0 +1,12 @@
+const fetchMonitorCertificate = async (sslChecker, monitor) => {
+	const monitorUrl = new URL(monitor.url);
+	const hostname = monitorUrl.hostname;
+	const cert = await sslChecker(hostname);
+	// Throw an error if no cert or if cert.validTo is not present
+	if (cert?.validTo === null || cert?.validTo === undefined) {
+		throw new Error("Certificate not found");
+	}
+	return cert;
+};
+
+export { fetchMonitorCertificate };

server/src/controllers/diagnosticController.js

@@ -0,0 +1,61 @@
+const SERVICE_NAME = "diagnosticController";
+import BaseController from "./baseController.js";
+/**
+ * Diagnostic Controller
+ *
+ * Handles system diagnostic and monitoring requests including system statistics,
+ * performance metrics, and health checks.
+ *
+ * @class DiagnosticController
+ * @description Manages system diagnostics and performance monitoring
+ */
+class DiagnosticController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	/**
+	 * Creates an instance of DiagnosticController.
+	 * @param {Object} commonDependencies - Common dependencies injected into the controller
+	 * @param {Object} dependencies - The dependencies required by the controller
+	 * @param {Object} dependencies.diagnosticService - Service for system diagnostics and monitoring
+	 */
+	constructor(commonDependencies, { diagnosticService }) {
+		super(commonDependencies);
+		this.diagnosticService = diagnosticService;
+	}
+
+	get serviceName() {
+		return DiagnosticController.SERVICE_NAME;
+	}
+	/**
+	 * Retrieves comprehensive system statistics and performance metrics.
+	 *
+	 * @async
+	 * @function getSystemStats
+	 * @param {Object} req - Express request object
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Success response with system diagnostics data
+	 * @description Returns system performance metrics, memory usage, CPU statistics,
+	 * and other diagnostic information useful for monitoring system health.
+	 * @example
+	 * GET /diagnostics/stats
+	 * // Response includes:
+	 * // - Memory usage (heap, external, arrayBuffers)
+	 * // - CPU usage statistics
+	 * // - System uptime
+	 * // - Performance metrics
+	 * // - Database connection status
+	 * // - Active processes/connections
+	 */
+	getSystemStats = this.asyncHandler(
+		async (req, res) => {
+			const diagnostics = await this.diagnosticService.getSystemStats();
+			return res.success({
+				msg: "OK",
+				data: diagnostics,
+			});
+		},
+		SERVICE_NAME,
+		"getSystemStats"
+	);
+}
+
+export default DiagnosticController;

server/src/controllers/inviteController.js

@@ -0,0 +1,101 @@
+import { inviteBodyValidation, inviteVerificationBodyValidation } from "../validation/joi.js";
+import BaseController from "./baseController.js";
+const SERVICE_NAME = "inviteController";
+
+/**
+ * Controller for handling user invitation operations
+ * Manages invite token generation, email sending, and token verification
+ */
+class InviteController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	/**
+	 * Creates a new InviteController instance
+	 * @param {Object} commonDependencies - Common dependencies injected into the controller
+	 * @param {Object} dependencies.inviteService - Service for invite-related operations
+	 */
+	constructor(commonDependencies, { inviteService }) {
+		super(commonDependencies);
+		this.inviteService = inviteService;
+	}
+
+	get serviceName() {
+		return InviteController.SERVICE_NAME;
+	}
+
+	/**
+	 * Generates an invite token for a user invitation
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing invite details
+	 * @param {Object} req.user - Authenticated user object
+	 * @param {string} req.user.teamId - Team ID of the authenticated user
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Response with invite token data
+	 */
+	getInviteToken = this.asyncHandler(
+		async (req, res) => {
+			const invite = req.body;
+			const teamId = req?.user?.teamId;
+			invite.teamId = teamId;
+			await inviteBodyValidation.validateAsync(invite);
+			const inviteToken = await this.inviteService.getInviteToken({ invite, teamId });
+			return res.success({
+				msg: this.stringService.inviteIssued,
+				data: inviteToken,
+			});
+		},
+		SERVICE_NAME,
+		"getInviteToken"
+	);
+
+	/**
+	 * Sends an invitation email to a user
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing invite details
+	 * @param {Object} req.user - Authenticated user object
+	 * @param {string} req.user.teamId - Team ID of the authenticated user
+	 * @param {string} req.user.firstName - First name of the authenticated user
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Response with invite token data
+	 */
+	sendInviteEmail = this.asyncHandler(
+		async (req, res) => {
+			const inviteRequest = req.body;
+			inviteRequest.teamId = req?.user?.teamId;
+			await inviteBodyValidation.validateAsync(inviteRequest);
+
+			const inviteToken = await this.inviteService.sendInviteEmail({
+				inviteRequest,
+				firstName: req?.user?.firstName,
+			});
+			return res.success({
+				msg: this.stringService.inviteIssued,
+				data: inviteToken,
+			});
+		},
+		SERVICE_NAME,
+		"sendInviteEmail"
+	);
+
+	/**
+	 * Verifies an invite token and returns invite details
+	 * @param {Object} req - Express request object
+	 * @param {Object} req.body - Request body containing the invite token
+	 * @param {string} req.body.token - The invite token to verify
+	 * @param {Object} res - Express response object
+	 * @returns {Promise<Object>} Response with verified invite data
+	 */
+	verifyInviteToken = this.asyncHandler(
+		async (req, res) => {
+			await inviteVerificationBodyValidation.validateAsync(req.body);
+			const invite = await this.inviteService.verifyInviteToken({ inviteToken: req?.body?.token });
+			return res.success({
+				msg: this.stringService.inviteVerified,
+				data: invite,
+			});
+		},
+		SERVICE_NAME,
+		"verifyInviteToken"
+	);
+}
+
+export default InviteController;

server/src/controllers/logController.js

@@ -0,0 +1,26 @@
+import BaseController from "./baseController.js";
+const SERVICE_NAME = "LogController";
+
+class LogController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies) {
+		super(commonDependencies);
+	}
+
+	get serviceName() {
+		return LogController.SERVICE_NAME;
+	}
+
+	getLogs = this.asyncHandler(
+		async (req, res) => {
+			const logs = await this.logger.getLogs();
+			res.success({
+				msg: "Logs fetched successfully",
+				data: logs,
+			});
+		},
+		SERVICE_NAME,
+		"getLogs"
+	);
+}
+export default LogController;

server/src/controllers/maintenanceWindowController.js

@@ -0,0 +1,146 @@
+import {
+	createMaintenanceWindowBodyValidation,
+	editMaintenanceWindowByIdParamValidation,
+	editMaintenanceByIdWindowBodyValidation,
+	getMaintenanceWindowByIdParamValidation,
+	getMaintenanceWindowsByMonitorIdParamValidation,
+	getMaintenanceWindowsByTeamIdQueryValidation,
+	deleteMaintenanceWindowByIdParamValidation,
+} from "../validation/joi.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "maintenanceWindowController";
+
+class MaintenanceWindowController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies, { settingsService, maintenanceWindowService }) {
+		super(commonDependencies);
+		this.settingsService = settingsService;
+		this.maintenanceWindowService = maintenanceWindowService;
+	}
+
+	get serviceName() {
+		return MaintenanceWindowController.SERVICE_NAME;
+	}
+
+	createMaintenanceWindows = this.asyncHandler(
+		async (req, res) => {
+			await createMaintenanceWindowBodyValidation.validateAsync(req.body);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			await this.maintenanceWindowService.createMaintenanceWindow({ teamId, body: req.body });
+
+			return res.success({
+				msg: this.stringService.maintenanceWindowCreate,
+			});
+		},
+		SERVICE_NAME,
+		"createMaintenanceWindows"
+	);
+
+	getMaintenanceWindowById = this.asyncHandler(
+		async (req, res) => {
+			await getMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+
+			const teamId = req.user.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const maintenanceWindow = await this.maintenanceWindowService.getMaintenanceWindowById({ id: req.params.id, teamId });
+
+			return res.success({
+				msg: this.stringService.maintenanceWindowGetById,
+				data: maintenanceWindow,
+			});
+		},
+		SERVICE_NAME,
+		"getMaintenanceWindowById"
+	);
+
+	getMaintenanceWindowsByTeamId = this.asyncHandler(
+		async (req, res) => {
+			await getMaintenanceWindowsByTeamIdQueryValidation.validateAsync(req.query);
+
+			const teamId = req?.user?.teamId;
+
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const maintenanceWindows = await this.maintenanceWindowService.getMaintenanceWindowsByTeamId({ teamId, query: req.query });
+
+			return res.success({
+				msg: this.stringService.maintenanceWindowGetByTeam,
+				data: maintenanceWindows,
+			});
+		},
+		SERVICE_NAME,
+		"getMaintenanceWindowsByTeamId"
+	);
+
+	getMaintenanceWindowsByMonitorId = this.asyncHandler(
+		async (req, res) => {
+			await getMaintenanceWindowsByMonitorIdParamValidation.validateAsync(req.params);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const maintenanceWindows = await this.maintenanceWindowService.getMaintenanceWindowsByMonitorId({ monitorId: req.params.monitorId, teamId });
+
+			return res.success({
+				msg: this.stringService.maintenanceWindowGetByUser,
+				data: maintenanceWindows,
+			});
+		},
+		SERVICE_NAME,
+		"getMaintenanceWindowsByMonitorId"
+	);
+
+	deleteMaintenanceWindow = this.asyncHandler(
+		async (req, res) => {
+			await deleteMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			await this.maintenanceWindowService.deleteMaintenanceWindow({ id: req.params.id, teamId });
+
+			return res.success({
+				msg: this.stringService.maintenanceWindowDelete,
+			});
+		},
+		SERVICE_NAME,
+		"deleteMaintenanceWindow"
+	);
+
+	editMaintenanceWindow = this.asyncHandler(
+		async (req, res) => {
+			await editMaintenanceWindowByIdParamValidation.validateAsync(req.params);
+			await editMaintenanceByIdWindowBodyValidation.validateAsync(req.body);
+
+			const teamId = req.user.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const editedMaintenanceWindow = await this.maintenanceWindowService.editMaintenanceWindow({ id: req.params.id, body: req.body, teamId });
+			return res.success({
+				msg: this.stringService.maintenanceWindowEdit,
+				data: editedMaintenanceWindow,
+			});
+		},
+		SERVICE_NAME,
+		"editMaintenanceWindow"
+	);
+}
+
+export default MaintenanceWindowController;

server/src/controllers/monitorController.js

@@ -0,0 +1,446 @@
+import {
+	getMonitorByIdParamValidation,
+	getMonitorByIdQueryValidation,
+	getMonitorsByTeamIdParamValidation,
+	getMonitorsByTeamIdQueryValidation,
+	createMonitorBodyValidation,
+	editMonitorBodyValidation,
+	pauseMonitorParamValidation,
+	getMonitorStatsByIdParamValidation,
+	getMonitorStatsByIdQueryValidation,
+	getCertificateParamValidation,
+	getHardwareDetailsByIdParamValidation,
+	getHardwareDetailsByIdQueryValidation,
+} from "../validation/joi.js";
+import sslChecker from "ssl-checker";
+import { fetchMonitorCertificate } from "./controllerUtils.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "monitorController";
+class MonitorController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies, { settingsService, jobQueue, emailService, monitorService }) {
+		super(commonDependencies);
+		this.settingsService = settingsService;
+		this.jobQueue = jobQueue;
+		this.emailService = emailService;
+		this.monitorService = monitorService;
+	}
+
+	get serviceName() {
+		return MonitorController.SERVICE_NAME;
+	}
+
+	async verifyTeamAccess(teamId, monitorId) {
+		const monitor = await this.db.getMonitorById(monitorId);
+		if (!monitor.teamId.equals(teamId)) {
+			throw this.errorService.createAuthorizationError();
+		}
+	}
+
+	getAllMonitors = this.asyncHandler(
+		async (req, res) => {
+			const monitors = await this.monitorService.getAllMonitors();
+			return res.success({
+				msg: this.stringService.monitorGetAll,
+				data: monitors,
+			});
+		},
+		SERVICE_NAME,
+		"getAllMonitors"
+	);
+
+	getUptimeDetailsById = this.asyncHandler(
+		async (req, res) => {
+			const monitorId = req?.params?.monitorId;
+			const dateRange = req?.query?.dateRange;
+			const normalize = req?.query?.normalize;
+
+			const teamId = req?.user?.teamId;
+
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const data = await this.monitorService.getUptimeDetailsById({
+				teamId,
+				monitorId,
+				dateRange,
+				normalize,
+			});
+			return res.success({
+				msg: this.stringService.monitorGetByIdSuccess,
+				data: data,
+			});
+		},
+		SERVICE_NAME,
+		"getUptimeDetailsById"
+	);
+
+	getMonitorStatsById = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorStatsByIdParamValidation.validateAsync(req.params);
+			await getMonitorStatsByIdQueryValidation.validateAsync(req.query);
+
+			let { limit, sortOrder, dateRange, numToDisplay, normalize } = req.query;
+			const monitorId = req?.params?.monitorId;
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitorStats = await this.monitorService.getMonitorStatsById({
+				teamId,
+				monitorId,
+				limit,
+				sortOrder,
+				dateRange,
+				numToDisplay,
+				normalize,
+			});
+
+			return res.success({
+				msg: this.stringService.monitorStatsById,
+				data: monitorStats,
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorStatsById"
+	);
+
+	/**
+	 * Get hardware details for a specific monitor by ID
+	 * @async
+	 * @param {Express.Request} req - Express request object containing monitorId in params
+	 * @param {Express.Response} res - Express response object
+	 * @param {Express.NextFunction} next - Express next middleware function
+	 * @returns {Promise<Express.Response>}
+	 * @throws {Error} - Throws error if monitor not found or other database errors
+	 */
+	getHardwareDetailsById = this.asyncHandler(
+		async (req, res) => {
+			await getHardwareDetailsByIdParamValidation.validateAsync(req.params);
+			await getHardwareDetailsByIdQueryValidation.validateAsync(req.query);
+
+			const monitorId = req?.params?.monitorId;
+			const dateRange = req?.query?.dateRange;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitor = await this.monitorService.getHardwareDetailsById({
+				teamId,
+				monitorId,
+				dateRange,
+			});
+
+			return res.success({
+				msg: this.stringService.monitorGetByIdSuccess,
+				data: monitor,
+			});
+		},
+		SERVICE_NAME,
+		"getHardwareDetailsById"
+	);
+
+	getMonitorCertificate = this.asyncHandler(
+		async (req, res) => {
+			await getCertificateParamValidation.validateAsync(req.params);
+
+			const { monitorId } = req.params;
+			const monitor = await this.db.getMonitorById(monitorId);
+			const certificate = await fetchMonitorCertificate(sslChecker, monitor);
+
+			return res.success({
+				msg: this.stringService.monitorCertificate,
+				data: {
+					certificateDate: new Date(certificate.validTo),
+				},
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorCertificate"
+	);
+
+	getMonitorById = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorByIdParamValidation.validateAsync(req.params);
+			await getMonitorByIdQueryValidation.validateAsync(req.query);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitor = await this.monitorService.getMonitorById({ teamId, monitorId: req?.params?.monitorId });
+
+			return res.success({
+				msg: this.stringService.monitorGetByIdSuccess,
+				data: monitor,
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorById"
+	);
+
+	createMonitor = this.asyncHandler(
+		async (req, res) => {
+			await createMonitorBodyValidation.validateAsync(req.body);
+
+			const userId = req?.user?._id;
+			const teamId = req?.user?.teamId;
+
+			const monitor = await this.monitorService.createMonitor({ teamId, userId, body: req.body });
+
+			return res.success({
+				msg: this.stringService.monitorCreate,
+				data: monitor,
+			});
+		},
+		SERVICE_NAME,
+		"createMonitor"
+	);
+
+	createBulkMonitors = this.asyncHandler(
+		async (req, res) => {
+			if (!req.file) {
+				throw this.errorService.createBadRequestError("No file uploaded");
+			}
+
+			if (!req.file.mimetype.includes("csv")) {
+				throw this.errorService.createBadRequestError("File is not a CSV");
+			}
+
+			if (req.file.size === 0) {
+				throw this.errorService.createBadRequestError("File is empty");
+			}
+
+			const userId = req?.user?._id;
+			const teamId = req?.user?.teamId;
+
+			if (!userId || !teamId) {
+				throw this.errorService.createBadRequestError("Missing userId or teamId");
+			}
+
+			const fileData = req?.file?.buffer?.toString("utf-8");
+			if (!fileData) {
+				throw this.errorService.createBadRequestError("Cannot get file from buffer");
+			}
+
+			const monitors = await this.monitorService.createBulkMonitors({ fileData, userId, teamId });
+
+			return res.success({
+				msg: this.stringService.bulkMonitorsCreate,
+				data: monitors,
+			});
+		},
+		SERVICE_NAME,
+		"createBulkMonitors"
+	);
+
+	deleteMonitor = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorByIdParamValidation.validateAsync(req.params);
+			const monitorId = req.params.monitorId;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const deletedMonitor = await this.monitorService.deleteMonitor({ teamId, monitorId });
+
+			return res.success({ msg: this.stringService.monitorDelete, data: deletedMonitor });
+		},
+		SERVICE_NAME,
+		"deleteMonitor"
+	);
+
+	deleteAllMonitors = this.asyncHandler(
+		async (req, res) => {
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const deletedCount = await this.monitorService.deleteAllMonitors({ teamId });
+
+			return res.success({ msg: `Deleted ${deletedCount} monitors` });
+		},
+		SERVICE_NAME,
+		"deleteAllMonitors"
+	);
+
+	editMonitor = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorByIdParamValidation.validateAsync(req.params);
+			await editMonitorBodyValidation.validateAsync(req.body);
+			const monitorId = req?.params?.monitorId;
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const editedMonitor = await this.monitorService.editMonitor({ teamId, monitorId, body: req.body });
+
+			return res.success({
+				msg: this.stringService.monitorEdit,
+				data: editedMonitor,
+			});
+		},
+		SERVICE_NAME,
+		"editMonitor"
+	);
+
+	pauseMonitor = this.asyncHandler(
+		async (req, res) => {
+			await pauseMonitorParamValidation.validateAsync(req.params);
+
+			const monitorId = req.params.monitorId;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitor = await this.monitorService.pauseMonitor({ teamId, monitorId });
+
+			return res.success({
+				msg: monitor.isActive ? this.stringService.monitorResume : this.stringService.monitorPause,
+				data: monitor,
+			});
+		},
+		SERVICE_NAME,
+		"pauseMonitor"
+	);
+
+	addDemoMonitors = this.asyncHandler(
+		async (req, res) => {
+			const { _id, teamId } = req.user;
+			const demoMonitors = await this.monitorService.addDemoMonitors({ userId: _id, teamId });
+
+			return res.success({
+				msg: this.stringService.monitorDemoAdded,
+				data: demoMonitors?.length ?? 0,
+			});
+		},
+		SERVICE_NAME,
+		"addDemoMonitors"
+	);
+
+	sendTestEmail = this.asyncHandler(
+		async (req, res) => {
+			const { to } = req.body;
+			if (!to || typeof to !== "string") {
+				throw this.errorService.createBadRequestError(this.stringService.errorForValidEmailAddress);
+			}
+
+			const messageId = await this.monitorService.sendTestEmail({ to });
+			return res.success({
+				msg: this.stringService.sendTestEmail,
+				data: { messageId },
+			});
+		},
+		SERVICE_NAME,
+		"sendTestEmail"
+	);
+
+	getMonitorsByTeamId = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorsByTeamIdParamValidation.validateAsync(req.params);
+			await getMonitorsByTeamIdQueryValidation.validateAsync(req.query);
+
+			let { limit, type, page, rowsPerPage, filter, field, order } = req.query;
+			const teamId = req?.user?.teamId;
+
+			const monitors = await this.monitorService.getMonitorsByTeamId({ teamId, limit, type, page, rowsPerPage, filter, field, order });
+
+			return res.success({
+				msg: this.stringService.monitorGetByTeamId,
+				data: monitors,
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorsByTeamId"
+	);
+
+	getMonitorsAndSummaryByTeamId = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorsByTeamIdParamValidation.validateAsync(req.params);
+			await getMonitorsByTeamIdQueryValidation.validateAsync(req.query);
+
+			const explain = req?.query?.explain;
+			const type = req?.query?.type;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const result = await this.monitorService.getMonitorsAndSummaryByTeamId({ teamId, type, explain });
+
+			return res.success({
+				msg: "OK", // TODO
+				data: result,
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorsAndSummaryByTeamId"
+	);
+
+	getMonitorsWithChecksByTeamId = this.asyncHandler(
+		async (req, res) => {
+			await getMonitorsByTeamIdParamValidation.validateAsync(req.params);
+			await getMonitorsByTeamIdQueryValidation.validateAsync(req.query);
+
+			const explain = req?.query?.explain;
+			let { limit, type, page, rowsPerPage, filter, field, order } = req.query;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitors = await this.monitorService.getMonitorsWithChecksByTeamId({
+				teamId,
+				limit,
+				type,
+				page,
+				rowsPerPage,
+				filter,
+				field,
+				order,
+				explain,
+			});
+
+			return res.success({
+				msg: "OK",
+				data: monitors,
+			});
+		},
+		SERVICE_NAME,
+		"getMonitorsWithChecksByTeamId"
+	);
+
+	exportMonitorsToCSV = this.asyncHandler(
+		async (req, res) => {
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const csv = await this.monitorService.exportMonitorsToCSV({ teamId });
+
+			return res.file({
+				data: csv,
+				headers: {
+					"Content-Type": "text/csv",
+					"Content-Disposition": "attachment; filename=monitors.csv",
+				},
+			});
+		},
+		SERVICE_NAME,
+		"exportMonitorsToCSV"
+	);
+}
+
+export default MonitorController;

server/src/controllers/notificationController.js

@@ -0,0 +1,180 @@
+import { createNotificationBodyValidation } from "../validation/joi.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "NotificationController";
+
+class NotificationController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies, { notificationService, statusService }) {
+		super(commonDependencies);
+		this.notificationService = notificationService;
+		this.statusService = statusService;
+	}
+
+	get serviceName() {
+		return NotificationController.SERVICE_NAME;
+	}
+
+	testNotification = this.asyncHandler(
+		async (req, res) => {
+			const notification = req.body;
+
+			const success = await this.notificationService.sendTestNotification(notification);
+
+			if (!success) {
+				throw this.errorService.createServerError("Sending notification failed");
+			}
+
+			return res.success({
+				msg: "Notification sent successfully",
+			});
+		},
+		SERVICE_NAME,
+		"testNotification"
+	);
+
+	createNotification = this.asyncHandler(
+		async (req, res) => {
+			await createNotificationBodyValidation.validateAsync(req.body, {
+				abortEarly: false,
+			});
+
+			const body = req.body;
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const userId = req?.user?._id;
+			if (!userId) {
+				throw this.errorService.createBadRequestError("User ID is required");
+			}
+			body.userId = userId;
+			body.teamId = teamId;
+
+			const notification = await this.db.createNotification(body);
+			return res.success({
+				msg: "Notification created successfully",
+				data: notification,
+			});
+		},
+		SERVICE_NAME,
+		"createNotification"
+	);
+
+	getNotificationsByTeamId = this.asyncHandler(
+		async (req, res) => {
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const notifications = await this.db.getNotificationsByTeamId(teamId);
+
+			return res.success({
+				msg: "Notifications fetched successfully",
+				data: notifications,
+			});
+		},
+		SERVICE_NAME,
+		"getNotificationsByTeamId"
+	);
+
+	deleteNotification = this.asyncHandler(
+		async (req, res) => {
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const notification = await this.db.getNotificationById(req.params.id);
+			if (!notification.teamId.equals(teamId)) {
+				throw this.errorService.createAuthorizationError();
+			}
+
+			await this.db.deleteNotificationById(req.params.id);
+			return res.success({
+				msg: "Notification deleted successfully",
+			});
+		},
+		SERVICE_NAME,
+		"deleteNotification"
+	);
+
+	getNotificationById = this.asyncHandler(
+		async (req, res) => {
+			const notification = await this.db.getNotificationById(req.params.id);
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			if (!notification.teamId.equals(teamId)) {
+				throw this.errorService.createAuthorizationError();
+			}
+			return res.success({
+				msg: "Notification fetched successfully",
+				data: notification,
+			});
+		},
+		SERVICE_NAME,
+		"getNotificationById"
+	);
+
+	editNotification = this.asyncHandler(
+		async (req, res) => {
+			await createNotificationBodyValidation.validateAsync(req.body, {
+				abortEarly: false,
+			});
+
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const notification = await this.db.getNotificationById(req.params.id);
+
+			if (!notification.teamId.equals(teamId)) {
+				throw this.errorService.createAuthorizationError();
+			}
+
+			const editedNotification = await this.db.editNotification(req.params.id, req.body);
+			return res.success({
+				msg: "Notification updated successfully",
+				data: editedNotification,
+			});
+		},
+		SERVICE_NAME,
+		"editNotification"
+	);
+
+	testAllNotifications = this.asyncHandler(
+		async (req, res) => {
+			const monitorId = req.body.monitorId;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw this.errorService.createBadRequestError("Team ID is required");
+			}
+
+			const monitor = await this.db.getMonitorById(monitorId);
+
+			if (!monitor.teamId.equals(teamId)) {
+				throw this.errorService.createAuthorizationError();
+			}
+
+			const notifications = monitor.notifications;
+			if (notifications.length === 0) throw this.errorService.createBadRequestError("No notifications");
+			const result = await this.notificationService.testAllNotifications(notifications);
+			if (!result) throw this.errorService.createServerError("Failed to send all notifications");
+			return res.success({
+				msg: "All notifications sent successfully",
+			});
+		},
+		SERVICE_NAME,
+		"testAllNotifications"
+	);
+}
+
+export default NotificationController;

server/src/controllers/queueController.js

@@ -0,0 +1,87 @@
+import BaseController from "./baseController.js";
+const SERVICE_NAME = "JobQueueController";
+
+class JobQueueController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies, { jobQueue }) {
+		super(commonDependencies);
+		this.jobQueue = jobQueue;
+	}
+
+	get serviceName() {
+		return JobQueueController.SERVICE_NAME;
+	}
+
+	getMetrics = this.asyncHandler(
+		async (req, res) => {
+			const metrics = await this.jobQueue.getMetrics();
+			res.success({
+				msg: this.stringService.queueGetMetrics,
+				data: metrics,
+			});
+		},
+		SERVICE_NAME,
+		"getMetrics"
+	);
+
+	getJobs = this.asyncHandler(
+		async (req, res) => {
+			const jobs = await this.jobQueue.getJobs();
+			return res.success({
+				msg: this.stringService.queueGetJobs,
+				data: jobs,
+			});
+		},
+		SERVICE_NAME,
+		"getJobs"
+	);
+
+	getAllMetrics = this.asyncHandler(
+		async (req, res) => {
+			const jobs = await this.jobQueue.getJobs();
+			const metrics = await this.jobQueue.getMetrics();
+			return res.success({
+				msg: this.stringService.queueGetAllMetrics,
+				data: { jobs, metrics },
+			});
+		},
+		SERVICE_NAME,
+		"getAllMetrics"
+	);
+
+	addJob = this.asyncHandler(
+		async (req, res) => {
+			await this.jobQueue.addJob(Math.random().toString(36).substring(7));
+			return res.success({
+				msg: this.stringService.queueAddJob,
+			});
+		},
+		SERVICE_NAME,
+		"addJob"
+	);
+
+	flushQueue = this.asyncHandler(
+		async (req, res) => {
+			const result = await this.jobQueue.flushQueues();
+			return res.success({
+				msg: this.stringService.jobQueueFlush,
+				data: result,
+			});
+		},
+		SERVICE_NAME,
+		"flushQueue"
+	);
+
+	checkQueueHealth = this.asyncHandler(
+		async (req, res) => {
+			const stuckQueues = await this.jobQueue.checkQueueHealth();
+			return res.success({
+				msg: this.stringService.queueHealthCheck,
+				data: stuckQueues,
+			});
+		},
+		SERVICE_NAME,
+		"checkQueueHealth"
+	);
+}
+export default JobQueueController;

server/src/controllers/settingsController.js

@@ -0,0 +1,122 @@
+import { updateAppSettingsBodyValidation } from "../validation/joi.js";
+import { sendTestEmailBodyValidation } from "../validation/joi.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "SettingsController";
+
+class SettingsController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies, { settingsService, emailService }) {
+		super(commonDependencies);
+		this.settingsService = settingsService;
+		this.emailService = emailService;
+	}
+
+	get serviceName() {
+		return SettingsController.SERVICE_NAME;
+	}
+
+	buildAppSettings = (dbSettings) => {
+		const sanitizedSettings = { ...dbSettings };
+		delete sanitizedSettings.version;
+
+		const returnSettings = {
+			pagespeedKeySet: false,
+			emailPasswordSet: false,
+		};
+
+		if (typeof sanitizedSettings.pagespeedApiKey !== "undefined") {
+			returnSettings.pagespeedKeySet = true;
+			delete sanitizedSettings.pagespeedApiKey;
+		}
+		if (typeof sanitizedSettings.systemEmailPassword !== "undefined") {
+			returnSettings.emailPasswordSet = true;
+			delete sanitizedSettings.systemEmailPassword;
+		}
+		returnSettings.settings = sanitizedSettings;
+		return returnSettings;
+	};
+
+	getAppSettings = this.asyncHandler(
+		async (req, res) => {
+			const dbSettings = await this.settingsService.getDBSettings();
+
+			const returnSettings = this.buildAppSettings(dbSettings);
+			return res.success({
+				msg: this.stringService.getAppSettings,
+				data: returnSettings,
+			});
+		},
+		SERVICE_NAME,
+		"getAppSettings"
+	);
+
+	updateAppSettings = this.asyncHandler(
+		async (req, res) => {
+			await updateAppSettingsBodyValidation.validateAsync(req.body);
+
+			const updatedSettings = await this.db.updateAppSettings(req.body);
+			const returnSettings = this.buildAppSettings(updatedSettings);
+			return res.success({
+				msg: this.stringService.updateAppSettings,
+				data: returnSettings,
+			});
+		},
+		SERVICE_NAME,
+		"updateAppSettings"
+	);
+
+	sendTestEmail = this.asyncHandler(
+		async (req, res) => {
+			await sendTestEmailBodyValidation.validateAsync(req.body);
+
+			const {
+				to,
+				systemEmailHost,
+				systemEmailPort,
+				systemEmailAddress,
+				systemEmailPassword,
+				systemEmailUser,
+				systemEmailConnectionHost,
+				systemEmailSecure,
+				systemEmailPool,
+				systemEmailIgnoreTLS,
+				systemEmailRequireTLS,
+				systemEmailRejectUnauthorized,
+				systemEmailTLSServername,
+			} = req.body;
+
+			const subject = this.stringService.testEmailSubject;
+			const context = { testName: "Monitoring System" };
+
+			const html = await this.emailService.buildEmail("testEmailTemplate", context);
+			const messageId = await this.emailService.sendEmail(to, subject, html, {
+				systemEmailHost,
+				systemEmailPort,
+				systemEmailUser,
+				systemEmailAddress,
+				systemEmailPassword,
+				systemEmailConnectionHost,
+				systemEmailSecure,
+				systemEmailPool,
+				systemEmailIgnoreTLS,
+				systemEmailRequireTLS,
+				systemEmailRejectUnauthorized,
+				systemEmailTLSServername,
+			});
+
+			if (!messageId) {
+				throw this.errorService.createServerError("Failed to send test email.");
+			}
+
+			return res.success({
+				msg: this.stringService.sendTestEmail,
+				data: { messageId },
+			});
+		},
+		SERVICE_NAME,
+		"sendTestEmail"
+	);
+}
+
+export default SettingsController;

server/src/controllers/statusPageController.js

@@ -0,0 +1,108 @@
+import { createStatusPageBodyValidation, getStatusPageParamValidation, getStatusPageQueryValidation, imageValidation } from "../validation/joi.js";
+import BaseController from "./baseController.js";
+
+const SERVICE_NAME = "statusPageController";
+
+class StatusPageController extends BaseController {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor(commonDependencies) {
+		super(commonDependencies);
+	}
+
+	get serviceName() {
+		return StatusPageController.SERVICE_NAME;
+	}
+
+	createStatusPage = this.asyncHandler(
+		async (req, res) => {
+			await createStatusPageBodyValidation.validateAsync(req.body);
+			await imageValidation.validateAsync(req.file);
+
+			const { _id, teamId } = req.user;
+			const statusPage = await this.db.createStatusPage({
+				statusPageData: req.body,
+				image: req.file,
+				userId: _id,
+				teamId,
+			});
+			return res.success({
+				msg: this.stringService.statusPageCreate,
+				data: statusPage,
+			});
+		},
+		SERVICE_NAME,
+		"createStatusPage"
+	);
+
+	updateStatusPage = this.asyncHandler(
+		async (req, res) => {
+			await createStatusPageBodyValidation.validateAsync(req.body);
+			await imageValidation.validateAsync(req.file);
+
+			const statusPage = await this.db.updateStatusPage(req.body, req.file);
+			if (statusPage === null) {
+				throw this.errorService.createNotFoundError(this.stringService.statusPageNotFound);
+			}
+			return res.success({
+				msg: this.stringService.statusPageUpdate,
+				data: statusPage,
+			});
+		},
+		SERVICE_NAME,
+		"updateStatusPage"
+	);
+
+	getStatusPage = this.asyncHandler(
+		async (req, res) => {
+			const statusPage = await this.db.getStatusPage();
+			return res.success({
+				msg: this.stringService.statusPageByUrl,
+				data: statusPage,
+			});
+		},
+		SERVICE_NAME,
+		"getStatusPage"
+	);
+
+	getStatusPageByUrl = this.asyncHandler(
+		async (req, res) => {
+			await getStatusPageParamValidation.validateAsync(req.params);
+			await getStatusPageQueryValidation.validateAsync(req.query);
+
+			const statusPage = await this.db.getStatusPageByUrl(req.params.url, req.query.type);
+			return res.success({
+				msg: this.stringService.statusPageByUrl,
+				data: statusPage,
+			});
+		},
+		SERVICE_NAME,
+		"getStatusPageByUrl"
+	);
+
+	getStatusPagesByTeamId = this.asyncHandler(
+		async (req, res) => {
+			const teamId = req.user.teamId;
+			const statusPages = await this.db.getStatusPagesByTeamId(teamId);
+
+			return res.success({
+				msg: this.stringService.statusPageByTeamId,
+				data: statusPages,
+			});
+		},
+		SERVICE_NAME,
+		"getStatusPagesByTeamId"
+	);
+
+	deleteStatusPage = this.asyncHandler(
+		async (req, res) => {
+			await this.db.deleteStatusPage(req.params.url);
+			return res.success({
+				msg: this.stringService.statusPageDelete,
+			});
+		},
+		SERVICE_NAME,
+		"deleteStatusPage"
+	);
+}
+
+export default StatusPageController;

server/src/db/models/AppSettings.js

@@ -0,0 +1,74 @@
+import mongoose from "mongoose";
+
+const AppSettingsSchema = mongoose.Schema(
+	{
+		checkTTL: {
+			type: Number,
+			default: 30,
+		},
+		language: {
+			type: String,
+			default: "gb",
+		},
+		pagespeedApiKey: {
+			type: String,
+		},
+		systemEmailHost: {
+			type: String,
+		},
+		systemEmailPort: {
+			type: Number,
+		},
+		systemEmailAddress: {
+			type: String,
+		},
+		systemEmailPassword: {
+			type: String,
+		},
+		systemEmailUser: {
+			type: String,
+		},
+		systemEmailConnectionHost: {
+			type: String,
+			default: "localhost",
+		},
+		systemEmailTLSServername: {
+			type: String,
+		},
+		systemEmailSecure: {
+			type: Boolean,
+			default: false,
+		},
+		systemEmailPool: {
+			type: Boolean,
+			default: false,
+		},
+		systemEmailIgnoreTLS: {
+			type: Boolean,
+			default: false,
+		},
+		systemEmailRequireTLS: {
+			type: Boolean,
+			default: false,
+		},
+		systemEmailRejectUnauthorized: {
+			type: Boolean,
+			default: true,
+		},
+		singleton: {
+			type: Boolean,
+			required: true,
+			unique: true,
+			default: true,
+		},
+		version: {
+			type: Number,
+			default: 1,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+export default mongoose.model("AppSettings", AppSettingsSchema);

server/src/db/models/Check.js

@@ -0,0 +1,99 @@
+import mongoose from "mongoose";
+
+const BaseCheckSchema = mongoose.Schema({
+	/**
+	 * Reference to the associated Monitor document.
+	 *
+	 * @type {mongoose.Schema.Types.ObjectId}
+	 */
+	monitorId: {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: "Monitor",
+		immutable: true,
+		index: true,
+	},
+
+	teamId: {
+		type: mongoose.Schema.Types.ObjectId,
+		ref: "Team",
+		immutable: true,
+		index: true,
+	},
+	/**
+	 * Status of the check (true for up, false for down).
+	 *
+	 * @type {Boolean}
+	 */
+	status: {
+		type: Boolean,
+		index: true,
+	},
+	/**
+	 * Response time of the check in milliseconds.
+	 *
+	 * @type {Number}
+	 */
+	responseTime: {
+		type: Number,
+	},
+	/**
+	 * HTTP status code received during the check.
+	 *
+	 * @type {Number}
+	 */
+	statusCode: {
+		type: Number,
+		index: true,
+	},
+	/**
+	 * Message or description of the check result.
+	 *
+	 * @type {String}
+	 */
+	message: {
+		type: String,
+	},
+	/**
+	 * Expiry date of the check, auto-calculated to expire after 30 days.
+	 *
+	 * @type {Date}
+	 */
+
+	expiry: {
+		type: Date,
+		default: Date.now,
+		expires: 60 * 60 * 24 * 30, // 30 days
+	},
+	/**
+	 * Acknowledgment of the check.
+	 *
+	 * @type {Boolean}
+	 */
+	ack: {
+		type: Boolean,
+		default: false,
+	},
+	/**
+	 * Resolution date of the check (when the check was resolved).
+	 *
+	 * @type {Date}
+	 */
+	ackAt: {
+		type: Date,
+	},
+});
+
+/**
+ * Check Schema for MongoDB collection.
+ *
+ * Represents a check associated with a monitor, storing information
+ * about the status and response of a particular check event.
+ */
+const CheckSchema = mongoose.Schema({ ...BaseCheckSchema.obj }, { timestamps: true });
+CheckSchema.index({ updatedAt: 1 });
+CheckSchema.index({ monitorId: 1, updatedAt: 1 });
+CheckSchema.index({ monitorId: 1, updatedAt: -1 });
+CheckSchema.index({ teamId: 1, updatedAt: -1 });
+
+export default mongoose.model("Check", CheckSchema);
+export { BaseCheckSchema };

server/src/db/models/HardwareCheck.js

@@ -0,0 +1,80 @@
+import mongoose from "mongoose";
+import { BaseCheckSchema } from "./Check.js";
+const cpuSchema = mongoose.Schema({
+	physical_core: { type: Number, default: 0 },
+	logical_core: { type: Number, default: 0 },
+	frequency: { type: Number, default: 0 },
+	temperature: { type: [Number], default: [] },
+	free_percent: { type: Number, default: 0 },
+	usage_percent: { type: Number, default: 0 },
+});
+
+const memorySchema = mongoose.Schema({
+	total_bytes: { type: Number, default: 0 },
+	available_bytes: { type: Number, default: 0 },
+	used_bytes: { type: Number, default: 0 },
+	usage_percent: { type: Number, default: 0 },
+});
+
+const diskSchema = mongoose.Schema({
+	read_speed_bytes: { type: Number, default: 0 },
+	write_speed_bytes: { type: Number, default: 0 },
+	total_bytes: { type: Number, default: 0 },
+	free_bytes: { type: Number, default: 0 },
+	usage_percent: { type: Number, default: 0 },
+});
+
+const hostSchema = mongoose.Schema({
+	os: { type: String, default: "" },
+	platform: { type: String, default: "" },
+	kernel_version: { type: String, default: "" },
+});
+
+const errorSchema = mongoose.Schema({
+	metric: { type: [String], default: [] },
+	err: { type: String, default: "" },
+});
+
+const captureSchema = mongoose.Schema({
+	version: { type: String, default: "" },
+	mode: { type: String, default: "" },
+});
+
+const HardwareCheckSchema = mongoose.Schema(
+	{
+		...BaseCheckSchema.obj,
+		cpu: {
+			type: cpuSchema,
+			default: () => ({}),
+		},
+		memory: {
+			type: memorySchema,
+			default: () => ({}),
+		},
+		disk: {
+			type: [diskSchema],
+			default: () => [],
+		},
+		host: {
+			type: hostSchema,
+			default: () => ({}),
+		},
+
+		errors: {
+			type: [errorSchema],
+			default: () => [],
+		},
+
+		capture: {
+			type: captureSchema,
+			default: () => ({}),
+		},
+	},
+	{ timestamps: true }
+);
+
+HardwareCheckSchema.index({ createdAt: 1 });
+HardwareCheckSchema.index({ monitorId: 1, createdAt: 1 });
+HardwareCheckSchema.index({ monitorId: 1, createdAt: -1 });
+
+export default mongoose.model("HardwareCheck", HardwareCheckSchema);

server/src/db/models/InviteToken.js

@@ -0,0 +1,35 @@
+import mongoose from "mongoose";
+const InviteTokenSchema = mongoose.Schema(
+	{
+		email: {
+			type: String,
+			required: true,
+			unique: true,
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+			required: true,
+		},
+		role: {
+			type: Array,
+			required: true,
+			default: ["user"],
+		},
+		token: {
+			type: String,
+			required: true,
+		},
+		expiry: {
+			type: Date,
+			default: Date.now,
+			expires: 3600,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+export default mongoose.model("InviteToken", InviteTokenSchema);

server/src/db/models/MaintenanceWindow.js

@@ -0,0 +1,68 @@
+import mongoose from "mongoose";
+/**
+ * MaintenanceWindow Schema
+ * @module MaintenanceWindow
+ * @typedef {Object} MaintenanceWindow
+ * @property {mongoose.Schema.Types.ObjectId} monitorId - The ID of the monitor. This is a reference to the Monitor model and is immutable.
+ * @property {Boolean} active - Indicates whether the maintenance window is active.
+ * @property {Number} repeat - Indicates how often this maintenance window should repeat.
+ * @property {Date} start - The start date and time of the maintenance window.
+ * @property {Date} end - The end date and time of the maintenance window.
+ * @property {Date} expiry - The expiry date and time of the maintenance window. This is used for MongoDB's TTL index to automatically delete the document at this time. This field is set to the same value as `end` when `oneTime` is `true`.
+ *
+ * @example
+ *
+ * let maintenanceWindow = new MaintenanceWindow({
+ *   monitorId: monitorId,
+ *   active: active,
+ *   repeat: repeat,
+ *   start: start,
+ *   end: end,
+ * });
+ *
+ * if (repeat === 0) {
+ *   maintenanceWindow.expiry = end;
+ * }
+ *
+ */
+
+const MaintenanceWindow = mongoose.Schema(
+	{
+		monitorId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Monitor",
+			immutable: true,
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+		},
+		active: {
+			type: Boolean,
+			default: true,
+		},
+		name: {
+			type: String,
+		},
+		repeat: {
+			type: Number,
+		},
+		start: {
+			type: Date,
+		},
+		end: {
+			type: Date,
+		},
+		expiry: {
+			type: Date,
+			index: { expires: "0s" },
+		},
+	},
+
+	{
+		timestamps: true,
+	}
+);
+
+export default mongoose.model("MaintenanceWindow", MaintenanceWindow);

server/src/db/models/Monitor.js

@@ -0,0 +1,198 @@
+import mongoose from "mongoose";
+import HardwareCheck from "./HardwareCheck.js";
+import PageSpeedCheck from "./PageSpeedCheck.js";
+import Check from "./Check.js";
+import MonitorStats from "./MonitorStats.js";
+import StatusPage from "./StatusPage.js";
+
+const MonitorSchema = mongoose.Schema(
+	{
+		userId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "User",
+			immutable: true,
+			required: true,
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+			required: true,
+		},
+		name: {
+			type: String,
+			required: true,
+		},
+		description: {
+			type: String,
+		},
+		status: {
+			type: Boolean,
+			default: undefined,
+		},
+		type: {
+			type: String,
+			required: true,
+			enum: ["http", "ping", "pagespeed", "hardware", "docker", "port"],
+		},
+		ignoreTlsErrors: {
+			type: Boolean,
+			default: false,
+		},
+		jsonPath: {
+			type: String,
+		},
+		expectedValue: {
+			type: String,
+		},
+		matchMethod: {
+			type: String,
+			enum: ["equal", "include", "regex", ""],
+		},
+		url: {
+			type: String,
+			required: true,
+		},
+		port: {
+			type: Number,
+		},
+		isActive: {
+			type: Boolean,
+			default: true,
+		},
+		interval: {
+			// in milliseconds
+			type: Number,
+			default: 60000,
+		},
+		uptimePercentage: {
+			type: Number,
+			default: undefined,
+		},
+		notifications: [
+			{
+				type: mongoose.Schema.Types.ObjectId,
+				ref: "Notification",
+			},
+		],
+		secret: {
+			type: String,
+		},
+		thresholds: {
+			type: {
+				usage_cpu: { type: Number },
+				usage_memory: { type: Number },
+				usage_disk: { type: Number },
+				usage_temperature: { type: Number },
+			},
+			_id: false,
+		},
+		alertThreshold: {
+			type: Number,
+			default: 5,
+		},
+		cpuAlertThreshold: {
+			type: Number,
+			default: function () {
+				return this.alertThreshold;
+			},
+		},
+		memoryAlertThreshold: {
+			type: Number,
+			default: function () {
+				return this.alertThreshold;
+			},
+		},
+		diskAlertThreshold: {
+			type: Number,
+			default: function () {
+				return this.alertThreshold;
+			},
+		},
+		tempAlertThreshold: {
+			type: Number,
+			default: function () {
+				return this.alertThreshold;
+			},
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+MonitorSchema.pre("findOneAndDelete", async function (next) {
+	// Delete checks and stats
+	try {
+		const doc = await this.model.findOne(this.getFilter());
+
+		if (!doc) {
+			throw new Error("Monitor not found");
+		}
+
+		if (doc?.type === "pagespeed") {
+			await PageSpeedCheck.deleteMany({ monitorId: doc._id });
+		} else if (doc?.type === "hardware") {
+			await HardwareCheck.deleteMany({ monitorId: doc._id });
+		} else {
+			await Check.deleteMany({ monitorId: doc._id });
+		}
+
+		// Deal with status pages
+		await StatusPage.updateMany({ monitors: doc?._id }, { $pull: { monitors: doc?._id } });
+
+		await MonitorStats.deleteMany({ monitorId: doc?._id.toString() });
+		next();
+	} catch (error) {
+		next(error);
+	}
+});
+
+MonitorSchema.pre("deleteMany", async function (next) {
+	const filter = this.getFilter();
+	const monitors = await this.model.find(filter).select(["_id", "type"]).lean();
+
+	for (const monitor of monitors) {
+		if (monitor.type === "pagespeed") {
+			await PageSpeedCheck.deleteMany({ monitorId: monitor._id });
+		} else if (monitor.type === "hardware") {
+			await HardwareCheck.deleteMany({ monitorId: monitor._id });
+		} else {
+			await Check.deleteMany({ monitorId: monitor._id });
+		}
+		await StatusPage.updateMany({ monitors: monitor._id }, { $pull: { monitors: monitor._id } });
+		await MonitorStats.deleteMany({ monitorId: monitor._id.toString() });
+	}
+	next();
+});
+
+MonitorSchema.pre("save", function (next) {
+	if (!this.cpuAlertThreshold || this.isModified("alertThreshold")) {
+		this.cpuAlertThreshold = this.alertThreshold;
+	}
+	if (!this.memoryAlertThreshold || this.isModified("alertThreshold")) {
+		this.memoryAlertThreshold = this.alertThreshold;
+	}
+	if (!this.diskAlertThreshold || this.isModified("alertThreshold")) {
+		this.diskAlertThreshold = this.alertThreshold;
+	}
+	if (!this.tempAlertThreshold || this.isModified("alertThreshold")) {
+		this.tempAlertThreshold = this.alertThreshold;
+	}
+	next();
+});
+
+MonitorSchema.pre("findOneAndUpdate", function (next) {
+	const update = this.getUpdate();
+	if (update.alertThreshold) {
+		update.cpuAlertThreshold = update.alertThreshold;
+		update.memoryAlertThreshold = update.alertThreshold;
+		update.diskAlertThreshold = update.alertThreshold;
+		update.tempAlertThreshold = update.alertThreshold;
+	}
+	next();
+});
+
+MonitorSchema.index({ teamId: 1, type: 1 });
+
+export default mongoose.model("Monitor", MonitorSchema);

server/src/db/models/MonitorStats.js

@@ -0,0 +1,53 @@
+import mongoose from "mongoose";
+
+const MonitorStatsSchema = new mongoose.Schema(
+	{
+		monitorId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Monitor",
+			immutable: true,
+			index: true,
+		},
+		avgResponseTime: {
+			type: Number,
+			default: 0,
+		},
+		totalChecks: {
+			type: Number,
+			default: 0,
+		},
+		totalUpChecks: {
+			type: Number,
+			default: 0,
+		},
+		totalDownChecks: {
+			type: Number,
+			default: 0,
+		},
+		uptimePercentage: {
+			type: Number,
+			default: 0,
+		},
+		lastCheckTimestamp: {
+			type: Number,
+			default: 0,
+		},
+		lastResponseTime: {
+			type: Number,
+			default: 0,
+		},
+		timeOfLastFailure: {
+			type: Number,
+			default: 0,
+		},
+		uptBurnt: {
+			type: mongoose.Schema.Types.Decimal128,
+			required: false,
+		},
+	},
+	{ timestamps: true }
+);
+
+const MonitorStats = mongoose.model("MonitorStats", MonitorStatsSchema);
+
+export default MonitorStats;

server/src/db/models/NetworkCheck.js

@@ -0,0 +1,46 @@
+import mongoose from "mongoose";
+import { BaseCheckSchema } from "./Check.js";
+
+const networkInterfaceSchema = mongoose.Schema({
+	name: { type: String, required: true },
+	bytes_sent: { type: Number, default: 0 },
+	bytes_recv: { type: Number, default: 0 },
+	packets_sent: { type: Number, default: 0 },
+	packets_recv: { type: Number, default: 0 },
+	err_in: { type: Number, default: 0 },
+	err_out: { type: Number, default: 0 },
+	drop_in: { type: Number, default: 0 },
+	drop_out: { type: Number, default: 0 },
+	fifo_in: { type: Number, default: 0 },
+	fifo_out: { type: Number, default: 0 },
+});
+
+const captureSchema = mongoose.Schema({
+	version: { type: String, default: "" },
+	mode: { type: String, default: "" },
+});
+
+const NetworkCheckSchema = mongoose.Schema(
+	{
+		...BaseCheckSchema.obj,
+		data: {
+			type: [networkInterfaceSchema],
+			default: () => [],
+		},
+		capture: {
+			type: captureSchema,
+			default: () => ({}),
+		},
+		errors: {
+			type: mongoose.Schema.Types.Mixed,
+			default: null,
+		},
+	},
+	{ timestamps: true }
+);
+
+NetworkCheckSchema.index({ createdAt: 1 });
+NetworkCheckSchema.index({ monitorId: 1, createdAt: 1 });
+NetworkCheckSchema.index({ monitorId: 1, createdAt: -1 });
+
+export default mongoose.model("NetworkCheck", NetworkCheckSchema);

server/src/db/models/Notification.js

@@ -0,0 +1,64 @@
+import mongoose from "mongoose";
+
+const NotificationSchema = mongoose.Schema(
+	{
+		userId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "User",
+			immutable: true,
+			required: true,
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+			required: true,
+		},
+		type: {
+			type: String,
+			enum: ["email", "slack", "discord", "webhook", "pager_duty"],
+		},
+		notificationName: {
+			type: String,
+			required: true,
+		},
+		address: {
+			type: String,
+		},
+		phone: {
+			type: String,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+NotificationSchema.pre("save", function (next) {
+	if (!this.cpuAlertThreshold || this.isModified("alertThreshold")) {
+		this.cpuAlertThreshold = this.alertThreshold;
+	}
+	if (!this.memoryAlertThreshold || this.isModified("alertThreshold")) {
+		this.memoryAlertThreshold = this.alertThreshold;
+	}
+	if (!this.diskAlertThreshold || this.isModified("alertThreshold")) {
+		this.diskAlertThreshold = this.alertThreshold;
+	}
+	if (!this.tempAlertThreshold || this.isModified("alertThreshold")) {
+		this.tempAlertThreshold = this.alertThreshold;
+	}
+	next();
+});
+
+NotificationSchema.pre("findOneAndUpdate", function (next) {
+	const update = this.getUpdate();
+	if (update.alertThreshold) {
+		update.cpuAlertThreshold = update.alertThreshold;
+		update.memoryAlertThreshold = update.alertThreshold;
+		update.diskAlertThreshold = update.alertThreshold;
+		update.tempAlertThreshold = update.alertThreshold;
+	}
+	next();
+});
+
+export default mongoose.model("Notification", NotificationSchema);

server/src/db/models/PageSpeedCheck.js

@@ -0,0 +1,83 @@
+import mongoose from "mongoose";
+import { BaseCheckSchema } from "./Check.js";
+const AuditSchema = mongoose.Schema({
+	id: { type: String, required: true },
+	title: { type: String, required: true },
+	description: { type: String, required: true },
+	score: { type: Number, required: true },
+	scoreDisplayMode: { type: String, required: true },
+	displayValue: { type: String, required: true },
+	numericValue: { type: Number, required: true },
+	numericUnit: { type: String, required: true },
+});
+
+const AuditsSchema = mongoose.Schema({
+	cls: {
+		type: AuditSchema,
+		required: true,
+	},
+	si: {
+		type: AuditSchema,
+		required: true,
+	},
+	fcp: {
+		type: AuditSchema,
+		required: true,
+	},
+	lcp: {
+		type: AuditSchema,
+		required: true,
+	},
+	tbt: {
+		type: AuditSchema,
+		required: true,
+	},
+});
+
+/**
+ * Mongoose schema for storing metrics from Google Lighthouse.
+ * @typedef {Object} PageSpeedCheck
+ * @property {mongoose.Schema.Types.ObjectId} monitorId - Reference to the Monitor model.
+ * @property {number} accessibility - Accessibility score.
+ * @property {number} bestPractices - Best practices score.
+ * @property {number} seo - SEO score.
+ * @property {number} performance - Performance score.
+ */
+
+const PageSpeedCheck = mongoose.Schema(
+	{
+		...BaseCheckSchema.obj,
+		accessibility: {
+			type: Number,
+			required: true,
+		},
+		bestPractices: {
+			type: Number,
+			required: true,
+		},
+		seo: {
+			type: Number,
+			required: true,
+		},
+		performance: {
+			type: Number,
+			required: true,
+		},
+		audits: {
+			type: AuditsSchema,
+			required: true,
+		},
+	},
+	{ timestamps: true }
+);
+
+/**
+ * Mongoose model for storing metrics from Google Lighthouse.
+ * @typedef {mongoose.Model<PageSpeedCheck>} LighthouseMetricsModel
+ */
+
+PageSpeedCheck.index({ createdAt: 1 });
+PageSpeedCheck.index({ monitorId: 1, createdAt: 1 });
+PageSpeedCheck.index({ monitorId: 1, createdAt: -1 });
+
+export default mongoose.model("PageSpeedCheck", PageSpeedCheck);

server/src/db/models/RecoveryToken.js

@@ -0,0 +1,25 @@
+import mongoose from "mongoose";
+
+const RecoveryTokenSchema = mongoose.Schema(
+	{
+		email: {
+			type: String,
+			required: true,
+			unique: true,
+		},
+		token: {
+			type: String,
+			required: true,
+		},
+		expiry: {
+			type: Date,
+			default: Date.now,
+			expires: 600,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+export default mongoose.model("RecoveryToken", RecoveryTokenSchema);

server/src/db/models/StatusPage.js

@@ -0,0 +1,81 @@
+import mongoose from "mongoose";
+
+const StatusPageSchema = mongoose.Schema(
+	{
+		userId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "User",
+			immutable: true,
+			required: true,
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+			required: true,
+		},
+		type: {
+			type: String,
+			required: true,
+			default: "uptime",
+			enum: ["uptime"],
+		},
+		companyName: {
+			type: String,
+			required: true,
+			default: "",
+		},
+		url: {
+			type: String,
+			unique: true,
+			required: true,
+			default: "",
+		},
+		timezone: {
+			type: String,
+			required: false,
+		},
+		color: {
+			type: String,
+			required: false,
+			default: "#4169E1",
+		},
+		monitors: [
+			{
+				type: mongoose.Schema.Types.ObjectId,
+				ref: "Monitor",
+				required: true,
+			},
+		],
+		subMonitors: [
+			{
+				type: mongoose.Schema.Types.ObjectId,
+				ref: "Monitor",
+				required: true,
+			},
+		],
+		logo: {
+			data: Buffer,
+			contentType: String,
+		},
+		isPublished: {
+			type: Boolean,
+			default: false,
+		},
+		showCharts: {
+			type: Boolean,
+			default: true,
+		},
+		showUptimePercentage: {
+			type: Boolean,
+			default: true,
+		},
+		showAdminLoginLink: {
+			type: Boolean,
+			default: false,
+		},
+	},
+	{ timestamps: true }
+);
+
+export default mongoose.model("StatusPage", StatusPageSchema);

server/src/db/models/Team.js

@@ -0,0 +1,14 @@
+import mongoose from "mongoose";
+const TeamSchema = mongoose.Schema(
+	{
+		email: {
+			type: String,
+			required: true,
+			unique: true,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+export default mongoose.model("Team", TeamSchema);

server/src/db/models/User.js

@@ -0,0 +1,114 @@
+import mongoose from "mongoose";
+import bcrypt from "bcryptjs";
+import logger from "../../utils/logger.js";
+import Monitor from "./Monitor.js";
+import Team from "./Team.js";
+import Notification from "./Notification.js";
+
+const UserSchema = mongoose.Schema(
+	{
+		firstName: {
+			type: String,
+			required: true,
+		},
+		lastName: {
+			type: String,
+			required: true,
+		},
+		email: {
+			type: String,
+			required: true,
+			unique: true,
+		},
+		password: {
+			type: String,
+			required: true,
+		},
+		avatarImage: {
+			type: String,
+		},
+		profileImage: {
+			data: Buffer,
+			contentType: String,
+		},
+		isActive: {
+			type: Boolean,
+			default: true,
+		},
+		isVerified: {
+			type: Boolean,
+			default: false,
+		},
+		role: {
+			type: [String],
+			default: "user",
+			enum: ["user", "admin", "superadmin", "demo"],
+		},
+		teamId: {
+			type: mongoose.Schema.Types.ObjectId,
+			ref: "Team",
+			immutable: true,
+		},
+		checkTTL: {
+			type: Number,
+		},
+	},
+	{
+		timestamps: true,
+	}
+);
+
+UserSchema.pre("save", function (next) {
+	if (!this.isModified("password")) {
+		return next();
+	}
+	const salt = bcrypt.genSaltSync(10);
+	this.password = bcrypt.hashSync(this.password, salt);
+	next();
+});
+
+UserSchema.pre("findOneAndUpdate", function (next) {
+	const update = this.getUpdate();
+	if ("password" in update) {
+		const salt = bcrypt.genSaltSync(10);
+		update.password = bcrypt.hashSync(update.password, salt);
+	}
+
+	next();
+});
+
+UserSchema.pre("findOneAndDelete", async function (next) {
+	try {
+		const userToDelete = await this.model.findOne(this.getFilter());
+		if (!userToDelete) return next();
+		if (userToDelete.role.includes("superadmin")) {
+			await Team.deleteOne({ _id: userToDelete.teamId });
+			await Monitor.deleteMany({ userId: userToDelete._id });
+			await this.model.deleteMany({
+				teamId: userToDelete.teamId,
+				_id: { $ne: userToDelete._id },
+			});
+			await Notification.deleteMany({ teamId: userToDelete.teamId });
+		}
+		next();
+	} catch (error) {
+		next(error);
+	}
+});
+
+UserSchema.methods.comparePassword = async function (submittedPassword) {
+	const res = await bcrypt.compare(submittedPassword, this.password);
+	return res;
+};
+
+const User = mongoose.model("User", UserSchema);
+
+User.init().then(() => {
+	logger.info({
+		message: "User model initialized",
+		service: "UserModel",
+		method: "init",
+	});
+});
+
+export default User;

server/src/db/mongo/MongoDB.js

@@ -0,0 +1,146 @@
+import mongoose from "mongoose";
+import AppSettings from "../models/AppSettings.js";
+import logger from "../../utils/logger.js";
+
+//****************************************
+// User Operations
+//****************************************
+
+import * as userModule from "./modules/userModule.js";
+
+//****************************************
+// Invite Token Operations
+//****************************************
+
+import * as inviteModule from "./modules/inviteModule.js";
+
+//****************************************
+// Recovery Operations
+//****************************************
+import * as recoveryModule from "./modules/recoveryModule.js";
+
+//****************************************
+//  Monitors
+//****************************************
+
+import * as monitorModule from "./modules/monitorModule.js";
+
+//****************************************
+// Page Speed Checks
+//****************************************
+
+import * as pageSpeedCheckModule from "./modules/pageSpeedCheckModule.js";
+
+//****************************************
+// Hardware Checks
+//****************************************
+import * as hardwareCheckModule from "./modules/hardwareCheckModule.js";
+
+//****************************************
+// Checks
+//****************************************
+
+import * as checkModule from "./modules/checkModule.js";
+
+//****************************************
+// Maintenance Window
+//****************************************
+import * as maintenanceWindowModule from "./modules/maintenanceWindowModule.js";
+
+//****************************************
+// Notifications
+//****************************************
+import * as notificationModule from "./modules/notificationModule.js";
+
+//****************************************
+// AppSettings
+//****************************************
+import * as settingsModule from "./modules/settingsModule.js";
+
+//****************************************
+// Status Page
+//****************************************
+import * as statusPageModule from "./modules/statusPageModule.js";
+
+//****************************************
+// Diagnostic
+//****************************************
+import * as diagnosticModule from "./modules/diagnosticModule.js";
+
+class MongoDB {
+	static SERVICE_NAME = "MongoDB";
+
+	constructor({ appSettings }) {
+		this.appSettings = appSettings;
+		Object.assign(this, userModule);
+		Object.assign(this, inviteModule);
+		Object.assign(this, recoveryModule);
+		Object.assign(this, monitorModule);
+		Object.assign(this, pageSpeedCheckModule);
+		Object.assign(this, hardwareCheckModule);
+		Object.assign(this, checkModule);
+		Object.assign(this, maintenanceWindowModule);
+		Object.assign(this, notificationModule);
+		Object.assign(this, settingsModule);
+		Object.assign(this, statusPageModule);
+		Object.assign(this, diagnosticModule);
+	}
+
+	get serviceName() {
+		return MongoDB.SERVICE_NAME;
+	}
+
+	connect = async () => {
+		try {
+			const connectionString = this.appSettings.dbConnectionString || "mongodb://localhost:27017/uptime_db";
+			await mongoose.connect(connectionString);
+			// If there are no AppSettings, create one
+			await AppSettings.findOneAndUpdate(
+				{}, // empty filter to match any document
+				{}, // empty update
+				{
+					new: true,
+					setDefaultsOnInsert: true,
+				}
+			);
+			// Sync indexes
+			const models = mongoose.modelNames();
+			for (const modelName of models) {
+				const model = mongoose.model(modelName);
+				await model.syncIndexes();
+			}
+
+			logger.info({
+				message: "Connected to MongoDB",
+				service: this.SERVICE_NAME,
+				method: "connect",
+			});
+		} catch (error) {
+			logger.error({
+				message: error.message,
+				service: this.SERVICE_NAME,
+				method: "connect",
+				stack: error.stack,
+			});
+			throw error;
+		}
+	};
+
+	disconnect = async () => {
+		try {
+			logger.info({ message: "Disconnecting from MongoDB" });
+			await mongoose.disconnect();
+			logger.info({ message: "Disconnected from MongoDB" });
+			return;
+		} catch (error) {
+			logger.error({
+				message: error.message,
+				service: this.SERVICE_NAME,
+				method: "disconnect",
+				stack: error.stack,
+			});
+		}
+	};
+}
+
+export default MongoDB;

server/src/db/mongo/modules/checkModule.js

@@ -0,0 +1,385 @@
+import Check from "../../models/Check.js";
+import Monitor from "../../models/Monitor.js";
+import HardwareCheck from "../../models/HardwareCheck.js";
+import PageSpeedCheck from "../../models/PageSpeedCheck.js";
+import User from "../../models/User.js";
+import logger from "../../../utils/logger.js";
+import { ObjectId } from "mongodb";
+import { buildChecksSummaryByTeamIdPipeline } from "./checkModuleQueries.js";
+
+const SERVICE_NAME = "checkModule";
+const dateRangeLookup = {
+	recent: new Date(new Date().setDate(new Date().getDate() - 2)),
+	hour: new Date(new Date().setHours(new Date().getHours() - 1)),
+	day: new Date(new Date().setDate(new Date().getDate() - 1)),
+	week: new Date(new Date().setDate(new Date().getDate() - 7)),
+	month: new Date(new Date().setMonth(new Date().getMonth() - 1)),
+	all: undefined,
+};
+
+/**
+ * Create a check for a monitor
+ * @async
+ * @param {Object} checkData
+ * @param {string} checkData.monitorId
+ * @param {boolean} checkData.status
+ * @param {number} checkData.responseTime
+ * @param {number} checkData.statusCode
+ * @param {string} checkData.message
+ * @returns {Promise<Check>}
+ * @throws {Error}
+ */
+
+const createCheck = async (checkData) => {
+	try {
+		const check = await new Check({ ...checkData }).save();
+		return check;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createCheck";
+		throw error;
+	}
+};
+
+const createChecks = async (checks) => {
+	try {
+		await Check.insertMany(checks, { ordered: false });
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createCheck";
+		throw error;
+	}
+};
+
+/**
+ * Get all checks for a monitor
+ * @async
+ * @param {string} monitorId
+ * @returns {Promise<Array<Check>>}
+ * @throws {Error}
+ */
+const getChecksByMonitor = async ({ monitorId, type, sortOrder, dateRange, filter, ack, page, rowsPerPage, status }) => {
+	try {
+		status = status === "true" ? true : status === "false" ? false : undefined;
+		page = parseInt(page);
+		rowsPerPage = parseInt(rowsPerPage);
+
+		const ackStage = ack === "true" ? { ack: true } : { $or: [{ ack: false }, { ack: { $exists: false } }] };
+
+		// Match
+		const matchStage = {
+			monitorId: new ObjectId(monitorId),
+			...(typeof status !== "undefined" && { status }),
+			...(typeof ack !== "undefined" && ackStage),
+			...(dateRangeLookup[dateRange] && {
+				createdAt: {
+					$gte: dateRangeLookup[dateRange],
+				},
+			}),
+		};
+
+		if (filter !== undefined) {
+			switch (filter) {
+				case "all":
+					break;
+				case "down":
+					break;
+				case "resolve":
+					matchStage.statusCode = 5000;
+					break;
+				default:
+					logger.warn({
+						message: "invalid filter",
+						service: SERVICE_NAME,
+						method: "getChecks",
+					});
+					break;
+			}
+		}
+
+		//Sort
+		sortOrder = sortOrder === "asc" ? 1 : -1;
+
+		// Pagination
+		let skip = 0;
+		if (page && rowsPerPage) {
+			skip = page * rowsPerPage;
+		}
+
+		const checkModels = {
+			http: Check,
+			ping: Check,
+			docker: Check,
+			port: Check,
+			pagespeed: PageSpeedCheck,
+			hardware: HardwareCheck,
+		};
+
+		const Model = checkModels[type];
+
+		const checks = await Model.aggregate([
+			{ $match: matchStage },
+			{ $sort: { createdAt: sortOrder } },
+			{
+				$facet: {
+					summary: [{ $count: "checksCount" }],
+					checks: [{ $skip: skip }, { $limit: rowsPerPage }],
+				},
+			},
+			{
+				$project: {
+					checksCount: {
+						$ifNull: [{ $arrayElemAt: ["$summary.checksCount", 0] }, 0],
+					},
+					checks: {
+						$ifNull: ["$checks", []],
+					},
+				},
+			},
+		]);
+		return checks[0];
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getChecks";
+		throw error;
+	}
+};
+
+const getChecksByTeam = async ({ sortOrder, dateRange, filter, ack, page, rowsPerPage, teamId }) => {
+	try {
+		page = parseInt(page);
+		rowsPerPage = parseInt(rowsPerPage);
+
+		const ackStage = ack === "true" ? { ack: true } : { $or: [{ ack: false }, { ack: { $exists: false } }] };
+
+		const matchStage = {
+			teamId: new ObjectId(teamId),
+			status: false,
+			...(typeof ack !== "undefined" && ackStage),
+			...(dateRangeLookup[dateRange] && {
+				createdAt: {
+					$gte: dateRangeLookup[dateRange],
+				},
+			}),
+		};
+		// Add filter to match stage
+		if (filter !== undefined) {
+			switch (filter) {
+				case "all":
+					break;
+				case "down":
+					break;
+				case "resolve":
+					matchStage.statusCode = 5000;
+					break;
+				default:
+					logger.warn({
+						message: "invalid filter",
+						service: SERVICE_NAME,
+						method: "getChecksByTeam",
+					});
+					break;
+			}
+		}
+
+		sortOrder = sortOrder === "asc" ? 1 : -1;
+
+		// pagination
+		let skip = 0;
+		if (page && rowsPerPage) {
+			skip = page * rowsPerPage;
+		}
+
+		const aggregatePipeline = [
+			{ $match: matchStage },
+			{
+				$unionWith: {
+					coll: "hardwarechecks",
+					pipeline: [{ $match: matchStage }],
+				},
+			},
+			{
+				$unionWith: {
+					coll: "pagespeedchecks",
+					pipeline: [{ $match: matchStage }],
+				},
+			},
+
+			{ $sort: { createdAt: sortOrder } },
+			{
+				$facet: {
+					summary: [{ $count: "checksCount" }],
+					checks: [{ $skip: skip }, { $limit: rowsPerPage }],
+				},
+			},
+			{
+				$project: {
+					checksCount: { $arrayElemAt: ["$summary.checksCount", 0] },
+					checks: "$checks",
+				},
+			},
+		];
+
+		const checks = await Check.aggregate(aggregatePipeline);
+		return checks[0];
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getChecksByTeam";
+		throw error;
+	}
+};
+
+/**
+ * Update the acknowledgment status of a check
+ * @async
+ * @param {string} checkId - The ID of the check to update
+ * @param {string} teamId - The ID of the team
+ * @param {boolean} ack - The acknowledgment status to set
+ * @returns {Promise<Check>}
+ * @throws {Error}
+ */
+const ackCheck = async (checkId, teamId, ack) => {
+	try {
+		const updatedCheck = await Check.findOneAndUpdate({ _id: checkId, teamId: teamId }, { $set: { ack, ackAt: new Date() } }, { new: true });
+
+		if (!updatedCheck) {
+			throw new Error("Check not found");
+		}
+
+		return updatedCheck;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "ackCheck";
+		throw error;
+	}
+};
+
+/**
+ * Update the acknowledgment status of all checks for a monitor or team
+ * @async
+ * @param {string} id - The monitor ID or team ID
+ * @param {boolean} ack - The acknowledgment status to set
+ * @param {string} path - The path type ('monitor' or 'team')
+ * @returns {Promise<number>}
+ * @throws {Error}
+ */
+const ackAllChecks = async (monitorId, teamId, ack, path) => {
+	try {
+		const updatedChecks = await Check.updateMany(path === "monitor" ? { monitorId } : { teamId }, { $set: { ack, ackAt: new Date() } });
+		return updatedChecks.modifiedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "ackAllChecks";
+		throw error;
+	}
+};
+
+/**
+ * Get checks and summary by team ID
+ * @async
+ * @param {string} teamId
+ * @returns {Promise<Object>}
+ * @throws {Error}
+ */
+const getChecksSummaryByTeamId = async ({ teamId }) => {
+	try {
+		const matchStage = {
+			teamId: new ObjectId(teamId),
+		};
+		const checks = await Check.aggregate(buildChecksSummaryByTeamIdPipeline({ matchStage }));
+		return checks[0].summary;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getChecksSummaryByTeamId";
+		throw error;
+	}
+};
+
+/**
+ * Delete all checks for a monitor
+ * @async
+ * @param {string} monitorId
+ * @returns {number}
+ * @throws {Error}
+ */
+
+const deleteChecks = async (monitorId) => {
+	try {
+		const result = await Check.deleteMany({ monitorId });
+		return result.deletedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteChecks";
+		throw error;
+	}
+};
+
+/**
+ * Delete all checks for a team
+ * @async
+ * @param {string} monitorId
+ * @returns {number}
+ * @throws {Error}
+ */
+
+const deleteChecksByTeamId = async (teamId) => {
+	try {
+		// Find all monitor IDs for this team (only get _id field for efficiency)
+		const teamMonitors = await Monitor.find({ teamId }, { _id: 1 });
+		const monitorIds = teamMonitors.map((monitor) => monitor._id);
+
+		// Delete all checks for these monitors in one operation
+		const deleteResult = await Check.deleteMany({ monitorId: { $in: monitorIds } });
+
+		return deleteResult.deletedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteChecksByTeamId";
+		throw error;
+	}
+};
+
+const updateChecksTTL = async (teamId, ttl) => {
+	try {
+		await Check.collection.dropIndex("expiry_1");
+	} catch (error) {
+		logger.error({
+			message: error.message,
+			service: SERVICE_NAME,
+			method: "updateChecksTTL",
+			stack: error.stack,
+		});
+	}
+
+	try {
+		await Check.collection.createIndex(
+			{ expiry: 1 },
+			{ expireAfterSeconds: ttl } // TTL in seconds, adjust as necessary
+		);
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "updateChecksTTL";
+		throw error;
+	}
+	// Update user
+	try {
+		await User.updateMany({ teamId: teamId }, { checkTTL: ttl });
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "updateChecksTTL";
+		throw error;
+	}
+};
+
+export {
+	createCheck,
+	createChecks,
+	getChecksByMonitor,
+	getChecksByTeam,
+	ackCheck,
+	ackAllChecks,
+	getChecksSummaryByTeamId,
+	deleteChecks,
+	deleteChecksByTeamId,
+	updateChecksTTL,
+};

server/src/db/mongo/modules/checkModuleQueries.js

@@ -0,0 +1,44 @@
+const buildChecksSummaryByTeamIdPipeline = ({ matchStage }) => {
+	return [
+		{ $match: matchStage },
+		{
+			$facet: {
+				summary: [
+					{
+						$group: {
+							_id: null,
+							totalChecks: { $sum: { $cond: [{ $eq: ["$status", false] }, 1, 0] } },
+							resolvedChecks: {
+								$sum: {
+									$cond: [{ $and: [{ $eq: ["$ack", true] }, { $eq: ["$status", false] }] }, 1, 0],
+								},
+							},
+							downChecks: {
+								$sum: {
+									$cond: [{ $and: [{ $eq: ["$ack", false] }, { $eq: ["$status", false] }] }, 1, 0],
+								},
+							},
+							cannotResolveChecks: {
+								$sum: {
+									$cond: [{ $eq: ["$statusCode", 5000] }, 1, 0],
+								},
+							},
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+						},
+					},
+				],
+			},
+		},
+		{
+			$project: {
+				summary: { $arrayElemAt: ["$summary", 0] },
+			},
+		},
+	];
+};
+
+export { buildChecksSummaryByTeamIdPipeline };

server/src/db/mongo/modules/diagnosticModule.js

@@ -0,0 +1,48 @@
+import Monitor from "../../models/Monitor.js";
+import { ObjectId } from "mongodb";
+
+const SERVICE_NAME = "diagnosticModule";
+import { buildMonitorSummaryByTeamIdPipeline, buildMonitorsByTeamIdPipeline, buildFilteredMonitorsByTeamIdPipeline } from "./monitorModuleQueries.js";
+
+const getMonitorsByTeamIdExecutionStats = async (req) => {
+	try {
+		let { limit, type, page, rowsPerPage, filter, field, order } = req.query;
+		limit = parseInt(limit);
+		page = parseInt(page);
+		rowsPerPage = parseInt(rowsPerPage);
+		if (field === undefined) {
+			field = "name";
+			order = "asc";
+		}
+		// Build match stage
+		const matchStage = { teamId: new ObjectId(req.params.teamId) };
+		if (type !== undefined) {
+			matchStage.type = Array.isArray(type) ? { $in: type } : type;
+		}
+
+		const summary = await Monitor.aggregate(buildMonitorSummaryByTeamIdPipeline({ matchStage })).explain("executionStats");
+
+		const monitors = await Monitor.aggregate(buildMonitorsByTeamIdPipeline({ matchStage, field, order })).explain("executionStats");
+
+		const filteredMonitors = await Monitor.aggregate(
+			buildFilteredMonitorsByTeamIdPipeline({
+				matchStage,
+				filter,
+				page,
+				rowsPerPage,
+				field,
+				order,
+				limit,
+				type,
+			})
+		).explain("executionStats");
+
+		return { summary, monitors, filteredMonitors };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorSummaryByTeamIdExecutionStats";
+		throw error;
+	}
+};
+
+export { getMonitorsByTeamIdExecutionStats };

server/src/db/mongo/modules/hardwareCheckModule.js

@@ -0,0 +1,70 @@
+import HardwareCheck from "../../models/HardwareCheck.js";
+import Monitor from "../../models/Monitor.js";
+import logger from "../../../utils/logger.js";
+
+const SERVICE_NAME = "hardwareCheckModule";
+const createHardwareCheck = async (hardwareCheckData) => {
+	try {
+		const { monitorId, status } = hardwareCheckData;
+		const n = (await HardwareCheck.countDocuments({ monitorId })) + 1;
+		const monitor = await Monitor.findById(monitorId);
+
+		if (!monitor) {
+			logger.error({
+				message: "Monitor not found",
+				service: SERVICE_NAME,
+				method: "createHardwareCheck",
+				details: `monitor ID: ${monitorId}`,
+			});
+			return null;
+		}
+
+		let newUptimePercentage;
+		if (monitor.uptimePercentage === undefined) {
+			newUptimePercentage = status === true ? 1 : 0;
+		} else {
+			newUptimePercentage = (monitor.uptimePercentage * (n - 1) + (status === true ? 1 : 0)) / n;
+		}
+
+		await Monitor.findOneAndUpdate({ _id: monitorId }, { uptimePercentage: newUptimePercentage });
+
+		const hardwareCheck = await new HardwareCheck({
+			...hardwareCheckData,
+		}).save();
+		return hardwareCheck;
+	} catch (error) {
+		logger.error({
+			message: "Error creating hardware check",
+			service: SERVICE_NAME,
+			method: "createHardwareCheck",
+			stack: error.stack,
+		});
+		error.service = SERVICE_NAME;
+		error.method = "createHardwareCheck";
+		throw error;
+	}
+};
+
+const createHardwareChecks = async (hardwareChecks) => {
+	try {
+		await HardwareCheck.insertMany(hardwareChecks, { ordered: false });
+		return true;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createHardwareChecks";
+		throw error;
+	}
+};
+
+const deleteHardwareChecksByMonitorId = async (monitorId) => {
+	try {
+		const result = await HardwareCheck.deleteMany({ monitorId });
+		return result.deletedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteHardwareChecksByMonitorId";
+		throw error;
+	}
+};
+
+export { createHardwareCheck, createHardwareChecks, deleteHardwareChecksByMonitorId };

server/src/db/mongo/modules/inviteModule.js

@@ -0,0 +1,89 @@
+import InviteToken from "../../models/InviteToken.js";
+import crypto from "crypto";
+import ServiceRegistry from "../../../service/system/serviceRegistry.js";
+import StringService from "../../../service/system/stringService.js";
+
+const SERVICE_NAME = "inviteModule";
+/**
+ * Request an invite token for a user.
+ *
+ * This function deletes any existing invite tokens for the user's email,
+ * generates a new token, saves it, and then returns the new token.
+ *
+ * @param {Object} userData - The user data.
+ * @param {string} userData.email - The user's email.
+ * @param {mongoose.Schema.Types.ObjectId} userData.teamId - The ID of the team.
+ * @param {Array} userData.role - The user's role(s).
+ * @param {Date} [userData.expiry=Date.now] - The expiry date of the token. Defaults to the current date and time.
+ * @returns {Promise<InviteToken>} The invite token.
+ * @throws {Error} If there is an error.
+ */
+const requestInviteToken = async (userData) => {
+	try {
+		await InviteToken.deleteMany({ email: userData.email });
+		userData.token = crypto.randomBytes(32).toString("hex");
+		let inviteToken = new InviteToken(userData);
+		await inviteToken.save();
+		return inviteToken;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "requestInviteToken";
+		throw error;
+	}
+};
+
+/**
+ * Retrieves an invite token
+ *
+ * This function searches for an invite token in the database and deletes it.
+ * If the invite token is not found, it throws an error.
+ *
+ * @param {string} token - The invite token to search for.
+ * @returns {Promise<InviteToken>} The invite token data.
+ * @throws {Error} If the invite token is not found or there is another error.
+ */
+const getInviteToken = async (token) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const invite = await InviteToken.findOne({
+			token,
+		});
+		if (invite === null) {
+			throw new Error(stringService.authInviteNotFound);
+		}
+		return invite;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getInviteToken";
+		throw error;
+	}
+};
+
+/**
+ * Retrieves and deletes an invite token
+ *
+ * This function searches for an invite token in the database and deletes it.
+ * If the invite token is not found, it throws an error.
+ *
+ * @param {string} token - The invite token to search for.
+ * @returns {Promise<InviteToken>} The invite token data.
+ * @throws {Error} If the invite token is not found or there is another error.
+ */
+const getInviteTokenAndDelete = async (token) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const invite = await InviteToken.findOneAndDelete({
+			token,
+		});
+		if (invite === null) {
+			throw new Error(stringService.authInviteNotFound);
+		}
+		return invite;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getInviteTokenAndDelete";
+		throw error;
+	}
+};
+
+export { requestInviteToken, getInviteToken, getInviteTokenAndDelete };

server/src/db/mongo/modules/maintenanceWindowModule.js

@@ -0,0 +1,192 @@
+import MaintenanceWindow from "../../models/MaintenanceWindow.js";
+const SERVICE_NAME = "maintenanceWindowModule";
+
+/**
+ * Asynchronously creates a new MaintenanceWindow document and saves it to the database.
+ * If the maintenance window is a one-time event, the expiry field is set to the same value as the end field.
+ * @async
+ * @function createMaintenanceWindow
+ * @param {Object} maintenanceWindowData - The data for the new MaintenanceWindow document.
+ * @param {mongoose.Schema.Types.ObjectId} maintenanceWindowData.monitorId - The ID of the monitor.
+ * @param {Boolean} maintenanceWindowData.active - Indicates whether the maintenance window is active.
+ * @param {Boolean} maintenanceWindowData.oneTime - Indicates whether the maintenance window is a one-time event.
+ * @param {Date} maintenanceWindowData.start - The start date and time of the maintenance window.
+ * @param {Date} maintenanceWindowData.end - The end date and time of the maintenance window.
+ * @returns {Promise<MaintenanceWindow>} The saved MaintenanceWindow document.
+ * @throws {Error} If there is an error saving the document.
+ */
+const createMaintenanceWindow = async (maintenanceWindowData) => {
+	try {
+		const maintenanceWindow = new MaintenanceWindow({
+			...maintenanceWindowData,
+		});
+
+		// If the maintenance window is a one time window, set the expiry to the end date
+		if (maintenanceWindowData.oneTime) {
+			maintenanceWindow.expiry = maintenanceWindowData.end;
+		}
+		const result = await maintenanceWindow.save();
+		return result;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createMaintenanceWindow";
+		throw error;
+	}
+};
+
+const getMaintenanceWindowById = async ({ id, teamId }) => {
+	try {
+		const maintenanceWindow = await MaintenanceWindow.findOne({
+			_id: id,
+			teamId: teamId,
+		});
+		return maintenanceWindow;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMaintenanceWindowById";
+		throw error;
+	}
+};
+
+/**
+ * Asynchronously retrieves all MaintenanceWindow documents associated with a specific team ID.
+ * @async
+ * @function getMaintenanceWindowByUserId
+ * @param {String} teamId - The ID of the team.
+ * @param {Object} query - The request body.
+ * @returns {Promise<Array<MaintenanceWindow>>} An array of MaintenanceWindow documents.
+ * @throws {Error} If there is an error retrieving the documents.
+ */
+const getMaintenanceWindowsByTeamId = async (teamId, query) => {
+	try {
+		let { active, page, rowsPerPage, field, order } = query || {};
+		const maintenanceQuery = { teamId };
+
+		if (active !== undefined) maintenanceQuery.active = active;
+
+		const maintenanceWindowCount = await MaintenanceWindow.countDocuments(maintenanceQuery);
+
+		// Pagination
+		let skip = 0;
+		if (page && rowsPerPage) {
+			skip = page * rowsPerPage;
+		}
+
+		// Sorting
+		let sort = {};
+		if (field !== undefined && order !== undefined) {
+			sort[field] = order === "asc" ? 1 : -1;
+		}
+
+		const maintenanceWindows = await MaintenanceWindow.find(maintenanceQuery).skip(skip).limit(rowsPerPage).sort(sort);
+
+		return { maintenanceWindows, maintenanceWindowCount };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMaintenanceWindowByUserId";
+		throw error;
+	}
+};
+
+/**
+ * Asynchronously retrieves all MaintenanceWindow documents associated with a specific monitor ID.
+ * @async
+ * @function getMaintenanceWindowsByMonitorId
+ * @param {mongoose.Schema.Types.ObjectId} monitorId - The ID of the monitor.
+ * @returns {Promise<Array<MaintenanceWindow>>} An array of MaintenanceWindow documents.
+ * @throws {Error} If there is an error retrieving the documents.
+ */
+const getMaintenanceWindowsByMonitorId = async ({ monitorId, teamId }) => {
+	try {
+		const maintenanceWindows = await MaintenanceWindow.find({
+			monitorId: monitorId,
+			teamId: teamId,
+		});
+		return maintenanceWindows;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMaintenanceWindowsByMonitorId";
+		throw error;
+	}
+};
+
+/**
+ * Asynchronously deletes a MaintenanceWindow document by its ID.
+ * @async
+ * @function deleteMaintenanceWindowById
+ * @param {mongoose.Schema.Types.ObjectId} maintenanceWindowId - The ID of the MaintenanceWindow document to delete.
+ * @returns {Promise<MaintenanceWindow>} The deleted MaintenanceWindow document.
+ * @throws {Error} If there is an error deleting the document.
+ */
+const deleteMaintenanceWindowById = async ({ id, teamId }) => {
+	try {
+		const maintenanceWindow = await MaintenanceWindow.findOneAndDelete({ _id: id, teamId });
+		return maintenanceWindow;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteMaintenanceWindowById";
+		throw error;
+	}
+};
+
+/**
+ * Asynchronously deletes all MaintenanceWindow documents associated with a specific monitor ID.
+ * @async
+ * @function deleteMaintenanceWindowByMonitorId
+ * @param {mongoose.Schema.Types.ObjectId} monitorId - The ID of the monitor.
+ * @returns {Promise<Object>} The result of the delete operation. This object contains information about the operation, such as the number of documents deleted.
+ * @throws {Error} If there is an error deleting the documents.
+ * @example
+ */
+const deleteMaintenanceWindowByMonitorId = async (monitorId) => {
+	try {
+		const result = await MaintenanceWindow.deleteMany({ monitorId: monitorId });
+		return result;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteMaintenanceWindowByMonitorId";
+		throw error;
+	}
+};
+
+/**
+ * Asynchronously deletes all MaintenanceWindow documents associated with a specific user ID.
+ * @async
+ * @function deleteMaintenanceWindowByUserId
+ * @param {String} userId - The ID of the user.
+ * @returns {Promise<Object>} The result of the delete operation. This object contains information about the operation, such as the number of documents deleted.
+ * @throws {Error} If there is an error deleting the documents.
+ * @example
+ */
+const deleteMaintenanceWindowByUserId = async (userId) => {
+	try {
+		const result = await MaintenanceWindow.deleteMany({ userId: userId });
+		return result;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteMaintenanceWindowByUserId";
+		throw error;
+	}
+};
+
+const editMaintenanceWindowById = async ({ id, body, teamId }) => {
+	try {
+		const editedMaintenanceWindow = await MaintenanceWindow.findByIdAndUpdate(id, body, { new: true });
+		return editedMaintenanceWindow;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "editMaintenanceWindowById";
+		throw error;
+	}
+};
+
+export {
+	createMaintenanceWindow,
+	getMaintenanceWindowById,
+	getMaintenanceWindowsByTeamId,
+	getMaintenanceWindowsByMonitorId,
+	deleteMaintenanceWindowById,
+	deleteMaintenanceWindowByMonitorId,
+	deleteMaintenanceWindowByUserId,
+	editMaintenanceWindowById,
+};

server/src/db/mongo/modules/monitorModule.js

@@ -0,0 +1,766 @@
+import Monitor from "../../models/Monitor.js";
+import MonitorStats from "../../models/MonitorStats.js";
+import Check from "../../models/Check.js";
+import PageSpeedCheck from "../../models/PageSpeedCheck.js";
+import HardwareCheck from "../../models/HardwareCheck.js";
+import { NormalizeData, NormalizeDataUptimeDetails } from "../../../utils/dataUtils.js";
+import ServiceRegistry from "../../../service/system/serviceRegistry.js";
+import StringService from "../../../service/system/stringService.js";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { ObjectId } from "mongodb";
+
+import {
+	buildUptimeDetailsPipeline,
+	buildHardwareDetailsPipeline,
+	buildMonitorSummaryByTeamIdPipeline,
+	buildMonitorsByTeamIdPipeline,
+	buildMonitorsAndSummaryByTeamIdPipeline,
+	buildMonitorsWithChecksByTeamIdPipeline,
+	buildFilteredMonitorsByTeamIdPipeline,
+} from "./monitorModuleQueries.js";
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const demoMonitorsPath = path.resolve(__dirname, "../../../utils/demoMonitors.json");
+const demoMonitors = JSON.parse(fs.readFileSync(demoMonitorsPath, "utf8"));
+
+const SERVICE_NAME = "monitorModule";
+
+const CHECK_MODEL_LOOKUP = {
+	http: Check,
+	ping: Check,
+	docker: Check,
+	port: Check,
+	pagespeed: PageSpeedCheck,
+	hardware: HardwareCheck,
+};
+
+/**
+ * Get all monitors
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Array<Monitor>>}
+ * @throws {Error}
+ */
+const getAllMonitors = async (req, res) => {
+	try {
+		const monitors = await Monitor.find();
+		return monitors;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getAllMonitors";
+		throw error;
+	}
+};
+
+/**
+ * Function to calculate uptime duration based on the most recent check.
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Uptime duration in ms.
+ */
+const calculateUptimeDuration = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0;
+	}
+	const latestCheck = new Date(checks[0].createdAt);
+	let latestDownCheck = 0;
+
+	for (let i = checks.length - 1; i >= 0; i--) {
+		if (checks[i].status === false) {
+			latestDownCheck = new Date(checks[i].createdAt);
+			break;
+		}
+	}
+
+	// If no down check is found, uptime is from the last check to now
+	if (latestDownCheck === 0) {
+		return Date.now() - new Date(checks[checks.length - 1].createdAt);
+	}
+
+	// Otherwise the uptime is from the last check to the last down check
+	return latestCheck - latestDownCheck;
+};
+
+/**
+ * Helper function to get duration since last check
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Timestamp of the most recent check.
+ */
+const getLastChecked = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0; // Handle case when no checks are available
+	}
+	// Data is sorted newest->oldest, so last check is the most recent
+	return new Date() - new Date(checks[0].createdAt);
+};
+
+/**
+ * Helper function to get latestResponseTime
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Timestamp of the most recent check.
+ */
+const getLatestResponseTime = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0;
+	}
+
+	return checks[0]?.responseTime ?? 0;
+};
+
+/**
+ * Helper function to get average response time
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Timestamp of the most recent check.
+ */
+const getAverageResponseTime = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0;
+	}
+
+	const validChecks = checks.filter((check) => typeof check.responseTime === "number");
+	if (validChecks.length === 0) {
+		return 0;
+	}
+	const aggResponseTime = validChecks.reduce((sum, check) => {
+		return sum + check.responseTime;
+	}, 0);
+	return aggResponseTime / validChecks.length;
+};
+
+/**
+ * Helper function to get percentage 24h uptime
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Timestamp of the most recent check.
+ */
+
+const getUptimePercentage = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0;
+	}
+	const upCount = checks.reduce((count, check) => {
+		return check.status === true ? count + 1 : count;
+	}, 0);
+	return (upCount / checks.length) * 100;
+};
+
+/**
+ * Helper function to get all incidents
+ * @param {Array} checks Array of check objects.
+ * @returns {number} Timestamp of the most recent check.
+ */
+
+const getIncidents = (checks) => {
+	if (!checks || checks.length === 0) {
+		return 0; // Handle case when no checks are available
+	}
+	return checks.reduce((acc, check) => {
+		return check.status === false ? (acc += 1) : acc;
+	}, 0);
+};
+
+/**
+ * Get date range parameters
+ * @param {string} dateRange - 'day' | 'week' | 'month' | 'all'
+ * @returns {Object} Start and end dates
+ */
+const getDateRange = (dateRange) => {
+	const startDates = {
+		recent: new Date(new Date().setHours(new Date().getHours() - 2)),
+		day: new Date(new Date().setDate(new Date().getDate() - 1)),
+		week: new Date(new Date().setDate(new Date().getDate() - 7)),
+		month: new Date(new Date().setMonth(new Date().getMonth() - 1)),
+		all: new Date(0),
+	};
+	return {
+		start: startDates[dateRange],
+		end: new Date(),
+	};
+};
+
+/**
+ * Get checks for a monitor
+ * @param {string} monitorId - Monitor ID
+ * @param {Object} model - Check model to use
+ * @param {Object} dateRange - Date range parameters
+ * @param {number} sortOrder - Sort order (1 for ascending, -1 for descending)
+ * @returns {Promise<Object>} All checks and date-ranged checks
+ */
+const getMonitorChecks = async (monitorId, model, dateRange, sortOrder) => {
+	const indexSpec = {
+		monitorId: 1,
+		createdAt: sortOrder, // This will be 1 or -1
+	};
+
+	const [checksAll, checksForDateRange] = await Promise.all([
+		model.find({ monitorId }).sort({ createdAt: sortOrder }).hint(indexSpec).lean(),
+		model
+			.find({
+				monitorId,
+				createdAt: { $gte: dateRange.start, $lte: dateRange.end },
+			})
+			.hint(indexSpec)
+			.lean(),
+	]);
+
+	return { checksAll, checksForDateRange };
+};
+
+/**
+ * Process checks for display
+ * @param {Array} checks - Checks to process
+ * @param {number} numToDisplay - Number of checks to display
+ * @param {boolean} normalize - Whether to normalize the data
+ * @returns {Array} Processed checks
+ */
+const processChecksForDisplay = (normalizeData, checks, numToDisplay, normalize) => {
+	let processedChecks = checks;
+	if (numToDisplay && checks.length > numToDisplay) {
+		const n = Math.ceil(checks.length / numToDisplay);
+		processedChecks = checks.filter((_, index) => index % n === 0);
+	}
+	return normalize ? normalizeData(processedChecks, 1, 100) : processedChecks;
+};
+
+/**
+ * Get time-grouped checks based on date range
+ * @param {Array} checks Array of check objects
+ * @param {string} dateRange 'day' | 'week' | 'month'
+ * @returns {Object} Grouped checks by time period
+ */
+const groupChecksByTime = (checks, dateRange) => {
+	return checks.reduce((acc, check) => {
+		// Validate the date
+		const checkDate = new Date(check.createdAt);
+		if (Number.isNaN(checkDate.getTime()) || checkDate.getTime() === 0) {
+			return acc;
+		}
+
+		const time = dateRange === "day" ? checkDate.setMinutes(0, 0, 0) : checkDate.toISOString().split("T")[0];
+
+		if (!acc[time]) {
+			acc[time] = { time, checks: [] };
+		}
+		acc[time].checks.push(check);
+		return acc;
+	}, {});
+};
+
+/**
+ * Calculate aggregate stats for a group of checks
+ * @param {Object} group Group of checks
+ * @returns {Object} Stats for the group
+ */
+const calculateGroupStats = (group) => {
+	const totalChecks = group.checks.length;
+
+	const checksWithResponseTime = group.checks.filter((check) => typeof check.responseTime === "number" && !Number.isNaN(check.responseTime));
+
+	return {
+		time: group.time,
+		uptimePercentage: getUptimePercentage(group.checks),
+		totalChecks,
+		totalIncidents: group.checks.filter((check) => !check.status).length,
+		avgResponseTime:
+			checksWithResponseTime.length > 0
+				? checksWithResponseTime.reduce((sum, check) => sum + check.responseTime, 0) / checksWithResponseTime.length
+				: 0,
+	};
+};
+
+/**
+ * Get uptime details by monitor ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const getUptimeDetailsById = async ({ monitorId, dateRange, normalize }) => {
+	try {
+		const dates = getDateRange(dateRange);
+		const formatLookup = {
+			recent: "%Y-%m-%dT%H:%M:00Z",
+			day: "%Y-%m-%dT%H:00:00Z",
+			week: "%Y-%m-%dT%H:00:00Z",
+			month: "%Y-%m-%dT00:00:00Z",
+		};
+
+		const dateString = formatLookup[dateRange];
+
+		const results = await Check.aggregate(buildUptimeDetailsPipeline(monitorId, dates, dateString));
+
+		const monitorData = results[0];
+
+		monitorData.groupedUpChecks = NormalizeDataUptimeDetails(monitorData.groupedUpChecks, 10, 100);
+
+		monitorData.groupedDownChecks = NormalizeDataUptimeDetails(monitorData.groupedDownChecks, 10, 100);
+
+		const normalizedGroupChecks = NormalizeDataUptimeDetails(monitorData.groupedChecks, 10, 100);
+
+		monitorData.groupedChecks = normalizedGroupChecks;
+		const monitorStats = await MonitorStats.findOne({ monitorId });
+		return { monitorData, monitorStats };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getUptimeDetailsById";
+		throw error;
+	}
+};
+
+/**
+ * Get stats by monitor ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const getMonitorStatsById = async ({ monitorId, limit, sortOrder, dateRange, numToDisplay, normalize }) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		// Get monitor, if we can't find it, abort with error
+		const monitor = await Monitor.findById(monitorId);
+		if (monitor === null || monitor === undefined) {
+			throw new Error(stringService.getDbFindMonitorById(monitorId));
+		}
+
+		// Get query params
+		const sort = sortOrder === "asc" ? 1 : -1;
+
+		// Get Checks for monitor in date range requested
+		const model = CHECK_MODEL_LOOKUP[monitor.type];
+		const dates = getDateRange(dateRange);
+		const { checksAll, checksForDateRange } = await getMonitorChecks(monitorId, model, dates, sort);
+
+		// Build monitor stats
+		const monitorStats = {
+			...monitor.toObject(),
+			uptimeDuration: calculateUptimeDuration(checksAll),
+			lastChecked: getLastChecked(checksAll),
+			latestResponseTime: getLatestResponseTime(checksAll),
+			periodIncidents: getIncidents(checksForDateRange),
+			periodTotalChecks: checksForDateRange.length,
+			checks: processChecksForDisplay(NormalizeData, checksForDateRange, numToDisplay, normalize),
+		};
+
+		if (monitor.type === "http" || monitor.type === "ping" || monitor.type === "docker" || monitor.type === "port") {
+			// HTTP/PING Specific stats
+			monitorStats.periodAvgResponseTime = getAverageResponseTime(checksForDateRange);
+			monitorStats.periodUptime = getUptimePercentage(checksForDateRange);
+			const groupedChecks = groupChecksByTime(checksForDateRange, dateRange);
+			monitorStats.aggregateData = Object.values(groupedChecks).map(calculateGroupStats);
+		}
+
+		return monitorStats;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorStatsById";
+		throw error;
+	}
+};
+
+const getHardwareDetailsById = async ({ monitorId, dateRange }) => {
+	try {
+		const monitor = await Monitor.findById(monitorId);
+		const dates = getDateRange(dateRange);
+		const formatLookup = {
+			recent: "%Y-%m-%dT%H:%M:00Z",
+			day: "%Y-%m-%dT%H:00:00Z",
+			week: "%Y-%m-%dT%H:00:00Z",
+			month: "%Y-%m-%dT00:00:00Z",
+		};
+		const dateString = formatLookup[dateRange];
+		const hardwareStats = await HardwareCheck.aggregate(buildHardwareDetailsPipeline(monitor, dates, dateString));
+
+		const monitorStats = {
+			...monitor.toObject(),
+			stats: hardwareStats[0],
+		};
+		return monitorStats;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getHardwareDetailsById";
+		throw error;
+	}
+};
+
+/**
+ * Get a monitor by ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const getMonitorById = async (monitorId) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const monitor = await Monitor.findById(monitorId);
+		if (monitor === null || monitor === undefined) {
+			const error = new Error(stringService.getDbFindMonitorById(monitorId));
+			error.status = 404;
+			throw error;
+		}
+
+		return monitor;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorById";
+		throw error;
+	}
+};
+
+const getMonitorsByIds = async (monitorIds) => {
+	try {
+		const objectIds = monitorIds.map((id) => new ObjectId(id));
+		return await Monitor.find({ _id: { $in: objectIds } }, { _id: 1, teamId: 1 }).lean();
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorsByIds";
+		throw error;
+	}
+};
+
+const getMonitorsByTeamId = async ({ limit, type, page, rowsPerPage, filter, field, order, teamId }) => {
+	limit = parseInt(limit);
+	page = parseInt(page);
+	rowsPerPage = parseInt(rowsPerPage);
+	if (field === undefined) {
+		field = "name";
+		order = "asc";
+	}
+	// Build match stage
+	const matchStage = { teamId: new ObjectId(teamId) };
+	if (type !== undefined) {
+		matchStage.type = Array.isArray(type) ? { $in: type } : type;
+	}
+
+	const summaryResult = await Monitor.aggregate(buildMonitorSummaryByTeamIdPipeline({ matchStage }));
+	const summary = summaryResult[0];
+
+	const monitors = await Monitor.aggregate(buildMonitorsByTeamIdPipeline({ matchStage, field, order }));
+
+	const filteredMonitors = await Monitor.aggregate(
+		buildFilteredMonitorsByTeamIdPipeline({
+			matchStage,
+			filter,
+			page,
+			rowsPerPage,
+			field,
+			order,
+			limit,
+			type,
+		})
+	);
+
+	const normalizedFilteredMonitors = filteredMonitors.map((monitor) => {
+		if (!monitor.checks) {
+			return monitor;
+		}
+		monitor.checks = NormalizeData(monitor.checks, 10, 100);
+		return monitor;
+	});
+
+	return { summary, monitors, filteredMonitors: normalizedFilteredMonitors };
+};
+
+const getMonitorsAndSummaryByTeamId = async ({ type, explain, teamId }) => {
+	try {
+		const matchStage = { teamId: new ObjectId(teamId) };
+		if (type !== undefined) {
+			matchStage.type = Array.isArray(type) ? { $in: type } : type;
+		}
+
+		if (explain === true) {
+			return Monitor.aggregate(buildMonitorsAndSummaryByTeamIdPipeline({ matchStage })).explain("executionStats");
+		}
+
+		const queryResult = await Monitor.aggregate(buildMonitorsAndSummaryByTeamIdPipeline({ matchStage }));
+		const { monitors, summary } = queryResult?.[0] ?? {};
+		return { monitors, summary };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorsAndSummaryByTeamId";
+		throw error;
+	}
+};
+
+const getMonitorsWithChecksByTeamId = async ({ limit, type, page, rowsPerPage, filter, field, order, teamId, explain }) => {
+	try {
+		limit = parseInt(limit);
+		page = parseInt(page);
+		rowsPerPage = parseInt(rowsPerPage);
+		if (field === undefined) {
+			field = "name";
+			order = "asc";
+		}
+		// Build match stage
+		const matchStage = { teamId: new ObjectId(teamId) };
+		if (type !== undefined) {
+			matchStage.type = Array.isArray(type) ? { $in: type } : type;
+		}
+
+		if (explain === true) {
+			return Monitor.aggregate(
+				buildMonitorsWithChecksByTeamIdPipeline({
+					matchStage,
+					filter,
+					page,
+					rowsPerPage,
+					field,
+					order,
+					limit,
+					type,
+				})
+			).explain("executionStats");
+		}
+
+		const queryResult = await Monitor.aggregate(
+			buildMonitorsWithChecksByTeamIdPipeline({
+				matchStage,
+				filter,
+				page,
+				rowsPerPage,
+				field,
+				order,
+				limit,
+				type,
+			})
+		);
+		const monitors = queryResult[0]?.monitors;
+		const count = queryResult[0]?.count;
+		const normalizedFilteredMonitors = monitors.map((monitor) => {
+			if (!monitor.checks) {
+				return monitor;
+			}
+			monitor.checks = NormalizeData(monitor.checks, 10, 100);
+			return monitor;
+		});
+		return { count, monitors: normalizedFilteredMonitors };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getMonitorsWithChecksByTeamId";
+		throw error;
+	}
+};
+
+/**
+ * Create a monitor
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const createMonitor = async ({ body, teamId, userId }) => {
+	try {
+		const monitor = new Monitor({ ...body, teamId, userId });
+		const saved = await monitor.save();
+		return saved;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createMonitor";
+		throw error;
+	}
+};
+
+/**
+ * Create bulk monitors
+ * @async
+ * @param {Express.Request} req
+ * @returns {Promise<Monitors>}
+ * @throws {Error}
+ */
+const createBulkMonitors = async (req) => {
+	try {
+		const monitors = req.map((item) => new Monitor({ ...item, notifications: undefined }));
+		await Monitor.bulkSave(monitors);
+		return monitors;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createBulkMonitors";
+		throw error;
+	}
+};
+
+/**
+ * Delete a monitor by ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const deleteMonitor = async ({ teamId, monitorId }) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const deletedMonitor = await Monitor.findOneAndDelete({ _id: monitorId, teamId });
+
+		if (!deletedMonitor) {
+			throw new Error(stringService.getDbFindMonitorById(monitorId));
+		}
+
+		return deletedMonitor;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteMonitor";
+		throw error;
+	}
+};
+
+/**
+ * DELETE ALL MONITORS (TEMP)
+ */
+
+const deleteAllMonitors = async (teamId) => {
+	try {
+		const monitors = await Monitor.find({ teamId });
+		const { deletedCount } = await Monitor.deleteMany({ teamId });
+
+		return { monitors, deletedCount };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteAllMonitors";
+		throw error;
+	}
+};
+
+/**
+ * Delete all monitors associated with a user ID
+ * @async
+ * @param {string} userId - The ID of the user whose monitors are to be deleted.
+ * @returns {Promise} A promise that resolves when the operation is complete.
+ */
+const deleteMonitorsByUserId = async (userId) => {
+	try {
+		const result = await Monitor.deleteMany({ userId: userId });
+		return result;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteMonitorsByUserId";
+		throw error;
+	}
+};
+
+/**
+ * Edit a monitor by ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<Monitor>}
+ * @throws {Error}
+ */
+const editMonitor = async ({ monitorId, body }) => {
+	try {
+		const editedMonitor = await Monitor.findByIdAndUpdate(monitorId, body, {
+			new: true,
+		});
+		return editedMonitor;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "editMonitor";
+		throw error;
+	}
+};
+
+const addDemoMonitors = async (userId, teamId) => {
+	try {
+		const demoMonitorsToInsert = demoMonitors.map((monitor) => {
+			return {
+				userId,
+				teamId,
+				name: monitor.name,
+				description: monitor.name,
+				type: "http",
+				url: monitor.url,
+				interval: 60000,
+			};
+		});
+		const insertedMonitors = await Monitor.insertMany(demoMonitorsToInsert);
+		return insertedMonitors;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "addDemoMonitors";
+		throw error;
+	}
+};
+
+const pauseMonitor = async ({ monitorId }) => {
+	try {
+		const monitor = await Monitor.findOneAndUpdate(
+			{ _id: monitorId },
+			[
+				{
+					$set: {
+						isActive: { $not: "$isActive" },
+						status: "$$REMOVE",
+					},
+				},
+			],
+			{ new: true }
+		);
+
+		return monitor;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "pauseMonitor";
+		throw error;
+	}
+};
+
+export {
+	getAllMonitors,
+	getMonitorStatsById,
+	getMonitorById,
+	getMonitorsByIds,
+	getMonitorsByTeamId,
+	getMonitorsAndSummaryByTeamId,
+	getMonitorsWithChecksByTeamId,
+	getUptimeDetailsById,
+	createMonitor,
+	createBulkMonitors,
+	deleteMonitor,
+	deleteAllMonitors,
+	deleteMonitorsByUserId,
+	editMonitor,
+	addDemoMonitors,
+	getHardwareDetailsById,
+	pauseMonitor,
+};
+
+// Helper functions
+export {
+	calculateUptimeDuration,
+	getLastChecked,
+	getLatestResponseTime,
+	getAverageResponseTime,
+	getUptimePercentage,
+	getIncidents,
+	getDateRange,
+	getMonitorChecks,
+	processChecksForDisplay,
+	groupChecksByTime,
+	calculateGroupStats,
+};
+
+// limit 25
+// page 1
+// rowsPerPage 25
+// filter undefined
+// field name
+// order asc
+// skip 25
+// sort { name: 1 }
+// filteredMonitors []
+
+// limit 25
+// page NaN
+// rowsPerPage 25
+// filter undefined
+// field name
+// order asc
+// skip 0
+// sort { name: 1 }

server/src/db/mongo/modules/monitorModuleQueries.js

@@ -0,0 +1,869 @@
+import { ObjectId } from "mongodb";
+
+const buildUptimeDetailsPipeline = (monitorId, dates, dateString) => {
+	return [
+		{
+			$match: {
+				monitorId: new ObjectId(monitorId),
+				createdAt: { $gte: dates.start, $lte: dates.end },
+			},
+		},
+		{
+			$sort: {
+				createdAt: 1,
+			},
+		},
+		{
+			$facet: {
+				// For the response time chart, should return checks for date window
+				// Grouped by: {day: hour}, {week: day}, {month: day}
+				uptimePercentage: [
+					{
+						$group: {
+							_id: null,
+							upChecks: {
+								$sum: { $cond: [{ $eq: ["$status", true] }, 1, 0] },
+							},
+							totalChecks: { $sum: 1 },
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+							percentage: {
+								$cond: [{ $eq: ["$totalChecks", 0] }, 0, { $divide: ["$upChecks", "$totalChecks"] }],
+							},
+						},
+					},
+				],
+				groupedAvgResponseTime: [
+					{
+						$group: {
+							_id: null,
+							avgResponseTime: {
+								$avg: "$responseTime",
+							},
+						},
+					},
+				],
+				groupedChecks: [
+					{
+						$group: {
+							_id: {
+								$dateToString: {
+									format: dateString,
+									date: "$createdAt",
+								},
+							},
+							avgResponseTime: {
+								$avg: "$responseTime",
+							},
+							totalChecks: {
+								$sum: 1,
+							},
+						},
+					},
+					{
+						$sort: {
+							_id: 1,
+						},
+					},
+				],
+				// Up checks grouped by: {day: hour}, {week: day}, {month: day}
+				groupedUpChecks: [
+					{
+						$match: {
+							status: true,
+						},
+					},
+					{
+						$group: {
+							_id: {
+								$dateToString: {
+									format: dateString,
+									date: "$createdAt",
+								},
+							},
+							totalChecks: {
+								$sum: 1,
+							},
+							avgResponseTime: {
+								$avg: "$responseTime",
+							},
+						},
+					},
+					{
+						$sort: { _id: 1 },
+					},
+				],
+				// Down checks grouped by: {day: hour}, {week: day}, {month: day} for the date window
+				groupedDownChecks: [
+					{
+						$match: {
+							status: false,
+						},
+					},
+					{
+						$group: {
+							_id: {
+								$dateToString: {
+									format: dateString,
+									date: "$createdAt",
+								},
+							},
+							totalChecks: {
+								$sum: 1,
+							},
+							avgResponseTime: {
+								$avg: "$responseTime",
+							},
+						},
+					},
+					{
+						$sort: { _id: 1 },
+					},
+				],
+			},
+		},
+		{
+			$lookup: {
+				from: "monitors",
+				let: { monitor_id: { $toObjectId: monitorId } },
+				pipeline: [
+					{
+						$match: {
+							$expr: { $eq: ["$_id", "$$monitor_id"] },
+						},
+					},
+					{
+						$project: {
+							_id: 1,
+							teamId: 1,
+							name: 1,
+							status: 1,
+							interval: 1,
+							type: 1,
+							url: 1,
+							isActive: 1,
+							notifications: 1,
+						},
+					},
+				],
+				as: "monitor",
+			},
+		},
+		{
+			$project: {
+				groupedAvgResponseTime: {
+					$arrayElemAt: ["$groupedAvgResponseTime.avgResponseTime", 0],
+				},
+
+				groupedChecks: "$groupedChecks",
+				groupedUpChecks: "$groupedUpChecks",
+				groupedDownChecks: "$groupedDownChecks",
+				groupedUptimePercentage: { $arrayElemAt: ["$uptimePercentage.percentage", 0] },
+				monitor: { $arrayElemAt: ["$monitor", 0] },
+			},
+		},
+	];
+};
+
+const buildHardwareDetailsPipeline = (monitor, dates, dateString) => {
+	return [
+		{
+			$match: {
+				monitorId: monitor._id,
+				createdAt: { $gte: dates.start, $lte: dates.end },
+			},
+		},
+		{
+			$sort: {
+				createdAt: 1,
+			},
+		},
+		{
+			$facet: {
+				aggregateData: [
+					{
+						$group: {
+							_id: null,
+							latestCheck: {
+								$last: "$$ROOT",
+							},
+							totalChecks: {
+								$sum: 1,
+							},
+						},
+					},
+				],
+				upChecks: [
+					{
+						$match: {
+							status: true,
+						},
+					},
+					{
+						$group: {
+							_id: null,
+							totalChecks: {
+								$sum: 1,
+							},
+						},
+					},
+				],
+				checks: [
+					{
+						$limit: 1,
+					},
+					{
+						$project: {
+							diskCount: {
+								$size: "$disk",
+							},
+						},
+					},
+					{
+						$lookup: {
+							from: "hardwarechecks",
+							let: {
+								diskCount: "$diskCount",
+							},
+							pipeline: [
+								{
+									$match: {
+										$expr: {
+											$and: [{ $eq: ["$monitorId", monitor._id] }, { $gte: ["$createdAt", dates.start] }, { $lte: ["$createdAt", dates.end] }],
+										},
+									},
+								},
+								{
+									$group: {
+										_id: {
+											$dateToString: {
+												format: dateString,
+												date: "$createdAt",
+											},
+										},
+										avgCpuUsage: {
+											$avg: "$cpu.usage_percent",
+										},
+										avgMemoryUsage: {
+											$avg: "$memory.usage_percent",
+										},
+										avgTemperatures: {
+											$push: {
+												$ifNull: ["$cpu.temperature", [0]],
+											},
+										},
+										disks: {
+											$push: "$disk",
+										},
+									},
+								},
+								{
+									$project: {
+										_id: 1,
+										avgCpuUsage: 1,
+										avgMemoryUsage: 1,
+										avgTemperature: {
+											$map: {
+												input: {
+													$range: [
+														0,
+														{
+															$size: {
+																// Handle null temperatures array
+																$ifNull: [
+																	{ $arrayElemAt: ["$avgTemperatures", 0] },
+																	[0], // Default to single-element array if null
+																],
+															},
+														},
+													],
+												},
+												as: "index",
+												in: {
+													$avg: {
+														$map: {
+															input: "$avgTemperatures",
+															as: "tempArray",
+															in: {
+																$ifNull: [
+																	{ $arrayElemAt: ["$$tempArray", "$$index"] },
+																	0, // Default to 0 if element is null
+																],
+															},
+														},
+													},
+												},
+											},
+										},
+										disks: {
+											$map: {
+												input: {
+													$range: [0, "$$diskCount"],
+												},
+												as: "diskIndex",
+												in: {
+													name: {
+														$concat: [
+															"disk",
+															{
+																$toString: "$$diskIndex",
+															},
+														],
+													},
+													readSpeed: {
+														$avg: {
+															$map: {
+																input: "$disks",
+																as: "diskArray",
+																in: {
+																	$arrayElemAt: ["$$diskArray.read_speed_bytes", "$$diskIndex"],
+																},
+															},
+														},
+													},
+													writeSpeed: {
+														$avg: {
+															$map: {
+																input: "$disks",
+																as: "diskArray",
+																in: {
+																	$arrayElemAt: ["$$diskArray.write_speed_bytes", "$$diskIndex"],
+																},
+															},
+														},
+													},
+													totalBytes: {
+														$avg: {
+															$map: {
+																input: "$disks",
+																as: "diskArray",
+																in: {
+																	$arrayElemAt: ["$$diskArray.total_bytes", "$$diskIndex"],
+																},
+															},
+														},
+													},
+													freeBytes: {
+														$avg: {
+															$map: {
+																input: "$disks",
+																as: "diskArray",
+																in: {
+																	$arrayElemAt: ["$$diskArray.free_bytes", "$$diskIndex"],
+																},
+															},
+														},
+													},
+													usagePercent: {
+														$avg: {
+															$map: {
+																input: "$disks",
+																as: "diskArray",
+																in: {
+																	$arrayElemAt: ["$$diskArray.usage_percent", "$$diskIndex"],
+																},
+															},
+														},
+													},
+												},
+											},
+										},
+									},
+								},
+							],
+							as: "hourlyStats",
+						},
+					},
+					{
+						$unwind: "$hourlyStats",
+					},
+					{
+						$replaceRoot: {
+							newRoot: "$hourlyStats",
+						},
+					},
+				],
+			},
+		},
+		{ $unwind: "$checks" },
+		{ $sort: { "checks._id": 1 } },
+		{
+			$group: {
+				_id: "$_id",
+				checks: { $push: "$checks" },
+				aggregateData: { $first: "$aggregateData" },
+				upChecks: { $first: "$upChecks" },
+			},
+		},
+		{
+			$project: {
+				aggregateData: {
+					$arrayElemAt: ["$aggregateData", 0],
+				},
+				upChecks: {
+					$arrayElemAt: ["$upChecks", 0],
+				},
+				checks: 1,
+			},
+		},
+	];
+};
+
+const buildMonitorStatsPipeline = (monitor) => {
+	return [
+		{
+			$match: {
+				monitorId: monitor._id,
+			},
+		},
+		{
+			$project: {
+				avgResponseTime: 1,
+				uptimePercentage: 1,
+				totalChecks: 1,
+				timeSinceLastCheck: {
+					$subtract: [Date.now(), "$lastCheckTimestamp"],
+				},
+				lastCheckTimestamp: 1,
+				uptBurnt: { $toString: "$uptBurnt" },
+			},
+		},
+	];
+};
+
+const buildMonitorSummaryByTeamIdPipeline = ({ matchStage }) => {
+	return [
+		{ $match: matchStage },
+		{
+			$group: {
+				_id: null,
+				totalMonitors: { $sum: 1 },
+				upMonitors: {
+					$sum: {
+						$cond: [{ $eq: ["$status", true] }, 1, 0],
+					},
+				},
+				downMonitors: {
+					$sum: {
+						$cond: [{ $eq: ["$status", false] }, 1, 0],
+					},
+				},
+				pausedMonitors: {
+					$sum: {
+						$cond: [{ $eq: ["$isActive", false] }, 1, 0],
+					},
+				},
+			},
+		},
+		{
+			$project: {
+				_id: 0,
+			},
+		},
+	];
+};
+
+const buildMonitorsByTeamIdPipeline = ({ matchStage, field, order }) => {
+	const sort = { [field]: order === "asc" ? 1 : -1 };
+
+	return [
+		{ $match: matchStage },
+		{ $sort: sort },
+		{
+			$project: {
+				_id: 1,
+				name: 1,
+				type: 1,
+				port: 1,
+			},
+		},
+	];
+};
+
+const buildMonitorsAndSummaryByTeamIdPipeline = ({ matchStage }) => {
+	return [
+		{ $match: matchStage },
+		{
+			$facet: {
+				summary: [
+					{
+						$group: {
+							_id: null,
+							totalMonitors: { $sum: 1 },
+							upMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$status", true] }, 1, 0],
+								},
+							},
+							downMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$status", false] }, 1, 0],
+								},
+							},
+							pausedMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$isActive", false] }, 1, 0],
+								},
+							},
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+						},
+					},
+				],
+				monitors: [
+					{ $sort: { name: 1 } },
+					{
+						$project: {
+							_id: 1,
+							name: 1,
+							type: 1,
+						},
+					},
+				],
+			},
+		},
+		{
+			$project: {
+				summary: { $arrayElemAt: ["$summary", 0] },
+				monitors: 1,
+			},
+		},
+	];
+};
+
+const buildMonitorsWithChecksByTeamIdPipeline = ({ matchStage, filter, page, rowsPerPage, field, order, limit, type }) => {
+	const skip = page && rowsPerPage ? page * rowsPerPage : 0;
+	const sort = { [field]: order === "asc" ? 1 : -1 };
+	const limitStage = rowsPerPage ? [{ $limit: rowsPerPage }] : [];
+
+	// Match name
+	if (typeof filter !== "undefined" && field === "name") {
+		matchStage.$or = [{ name: { $regex: filter, $options: "i" } }, { url: { $regex: filter, $options: "i" } }];
+	}
+
+	// Match isActive
+	if (typeof filter !== "undefined" && field === "isActive") {
+		matchStage.isActive = filter === "true" ? true : false;
+	}
+
+	if (typeof filter !== "undefined" && field === "status") {
+		matchStage.status = filter === "true" ? true : false;
+	}
+
+	// Match type
+	if (typeof filter !== "undefined" && field === "type") {
+		matchStage.type = filter;
+	}
+
+	const monitorsPipeline = [
+		{ $sort: sort },
+		{ $skip: skip },
+		...limitStage,
+		{
+			$project: {
+				_id: 1,
+				name: 1,
+				description: 1,
+				type: 1,
+				url: 1,
+				isActive: 1,
+				createdAt: 1,
+				updatedAt: 1,
+				uptimePercentage: 1,
+				status: 1,
+			},
+		},
+	];
+
+	// Add checks
+	if (limit) {
+		let checksCollection = "checks";
+		if (type === "pagespeed") {
+			checksCollection = "pagespeedchecks";
+		} else if (type === "hardware") {
+			checksCollection = "hardwarechecks";
+		}
+		monitorsPipeline.push({
+			$lookup: {
+				from: checksCollection,
+				let: { monitorId: "$_id" },
+				pipeline: [
+					{
+						$match: {
+							$expr: { $eq: ["$monitorId", "$$monitorId"] },
+						},
+					},
+					{ $sort: { updatedAt: -1 } },
+					{ $limit: limit },
+					{
+						$project: {
+							_id: 1,
+							status: 1,
+							responseTime: 1,
+							statusCode: 1,
+							createdAt: 1,
+							updatedAt: 1,
+							originalResponseTime: 1,
+						},
+					},
+				],
+				as: "checks",
+			},
+		});
+	}
+
+	const pipeline = [
+		{ $match: matchStage },
+		{
+			$facet: {
+				count: [{ $count: "monitorsCount" }],
+				monitors: monitorsPipeline,
+			},
+		},
+		{
+			$project: {
+				count: { $arrayElemAt: ["$count", 0] },
+				monitors: 1,
+			},
+		},
+	];
+	return pipeline;
+};
+
+const buildFilteredMonitorsByTeamIdPipeline = ({ matchStage, filter, page, rowsPerPage, field, order, limit, type }) => {
+	const skip = page && rowsPerPage ? page * rowsPerPage : 0;
+	const sort = { [field]: order === "asc" ? 1 : -1 };
+	const limitStage = rowsPerPage ? [{ $limit: rowsPerPage }] : [];
+
+	if (typeof filter !== "undefined" && field === "name") {
+		matchStage.$or = [{ name: { $regex: filter, $options: "i" } }, { url: { $regex: filter, $options: "i" } }];
+	}
+
+	if (typeof filter !== "undefined" && field === "status") {
+		matchStage.status = filter === "true";
+	}
+
+	const pipeline = [{ $match: matchStage }, { $sort: sort }, { $skip: skip }, ...limitStage];
+
+	// Add checks
+	if (limit) {
+		let checksCollection = "checks";
+		if (type === "pagespeed") {
+			checksCollection = "pagespeedchecks";
+		} else if (type === "hardware") {
+			checksCollection = "hardwarechecks";
+		}
+		pipeline.push({
+			$lookup: {
+				from: checksCollection,
+				let: { monitorId: "$_id" },
+				pipeline: [
+					{
+						$match: {
+							$expr: { $eq: ["$monitorId", "$$monitorId"] },
+						},
+					},
+					{ $sort: { createdAt: -1 } },
+					{ $limit: limit },
+				],
+				as: "checks",
+			},
+		});
+	}
+
+	return pipeline;
+};
+
+const buildGetMonitorsByTeamIdPipeline = (req) => {
+	let { limit, type, page, rowsPerPage, filter, field, order } = req.query;
+
+	limit = parseInt(limit);
+	page = parseInt(page);
+	rowsPerPage = parseInt(rowsPerPage);
+	if (field === undefined) {
+		field = "name";
+		order = "asc";
+	}
+	// Build the match stage
+	const matchStage = { teamId: new ObjectId(req.params.teamId) };
+	if (type !== undefined) {
+		matchStage.type = Array.isArray(type) ? { $in: type } : type;
+	}
+
+	const skip = page && rowsPerPage ? page * rowsPerPage : 0;
+	const sort = { [field]: order === "asc" ? 1 : -1 };
+	return [
+		{ $match: matchStage },
+		{
+			$facet: {
+				summary: [
+					{
+						$group: {
+							_id: null,
+							totalMonitors: { $sum: 1 },
+							upMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$status", true] }, 1, 0],
+								},
+							},
+							downMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$status", false] }, 1, 0],
+								},
+							},
+							pausedMonitors: {
+								$sum: {
+									$cond: [{ $eq: ["$isActive", false] }, 1, 0],
+								},
+							},
+						},
+					},
+					{
+						$project: {
+							_id: 0,
+						},
+					},
+				],
+				monitors: [
+					{ $sort: sort },
+					{
+						$project: {
+							_id: 1,
+							name: 1,
+						},
+					},
+				],
+				filteredMonitors: [
+					...(filter !== undefined
+						? [
+								{
+									$match: {
+										$or: [{ name: { $regex: filter, $options: "i" } }, { url: { $regex: filter, $options: "i" } }],
+									},
+								},
+							]
+						: []),
+					{ $sort: sort },
+					{ $skip: skip },
+					...(rowsPerPage ? [{ $limit: rowsPerPage }] : []),
+					...(limit
+						? [
+								{
+									$lookup: {
+										from: "checks",
+										let: { monitorId: "$_id" },
+										pipeline: [
+											{
+												$match: {
+													$expr: { $eq: ["$monitorId", "$$monitorId"] },
+												},
+											},
+											{ $sort: { createdAt: -1 } },
+											...(limit ? [{ $limit: limit }] : []),
+										],
+										as: "standardchecks",
+									},
+								},
+							]
+						: []),
+					...(limit
+						? [
+								{
+									$lookup: {
+										from: "pagespeedchecks",
+										let: { monitorId: "$_id" },
+										pipeline: [
+											{
+												$match: {
+													$expr: { $eq: ["$monitorId", "$$monitorId"] },
+												},
+											},
+											{ $sort: { createdAt: -1 } },
+											...(limit ? [{ $limit: limit }] : []),
+										],
+										as: "pagespeedchecks",
+									},
+								},
+							]
+						: []),
+					...(limit
+						? [
+								{
+									$lookup: {
+										from: "hardwarechecks",
+										let: { monitorId: "$_id" },
+										pipeline: [
+											{
+												$match: {
+													$expr: { $eq: ["$monitorId", "$$monitorId"] },
+												},
+											},
+											{ $sort: { createdAt: -1 } },
+											...(limit ? [{ $limit: limit }] : []),
+										],
+										as: "hardwarechecks",
+									},
+								},
+							]
+						: []),
+
+					{
+						$addFields: {
+							checks: {
+								$switch: {
+									branches: [
+										{
+											case: { $in: ["$type", ["http", "ping", "docker", "port"]] },
+											then: "$standardchecks",
+										},
+										{
+											case: { $eq: ["$type", "pagespeed"] },
+											then: "$pagespeedchecks",
+										},
+										{
+											case: { $eq: ["$type", "hardware"] },
+											then: "$hardwarechecks",
+										},
+									],
+									default: [],
+								},
+							},
+						},
+					},
+					{
+						$project: {
+							standardchecks: 0,
+							pagespeedchecks: 0,
+							hardwarechecks: 0,
+						},
+					},
+				],
+			},
+		},
+		{
+			$project: {
+				summary: { $arrayElemAt: ["$summary", 0] },
+				filteredMonitors: 1,
+				monitors: 1,
+			},
+		},
+	];
+};
+
+export {
+	buildUptimeDetailsPipeline,
+	buildHardwareDetailsPipeline,
+	buildMonitorStatsPipeline,
+	buildGetMonitorsByTeamIdPipeline,
+	buildMonitorSummaryByTeamIdPipeline,
+	buildMonitorsByTeamIdPipeline,
+	buildMonitorsAndSummaryByTeamIdPipeline,
+	buildMonitorsWithChecksByTeamIdPipeline,
+	buildFilteredMonitorsByTeamIdPipeline,
+};

server/src/db/mongo/modules/networkCheckModule.js

@@ -0,0 +1,44 @@
+import NetworkCheck from "../../models/NetworkCheck.js";
+
+const SERVICE_NAME = "networkCheckModule";
+
+/**
+ * Creates and saves a new network check document to the database.
+ * @async
+ * @param {object} networkCheckData - The data for the new network check. This should conform to the NetworkCheckSchema.
+ * @param {string} networkCheckData.monitorId - The ID of the monitor associated with this check.
+ * @returns {Promise<object>} A promise that resolves to the newly created network check document.
+ * @throws {Error} Throws an error if the database operation fails.
+ */
+const createNetworkCheck = async (networkCheckData) => {
+	try {
+		const networkCheck = await new NetworkCheck(networkCheckData);
+		await networkCheck.save();
+		return networkCheck;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createNetworkCheck";
+		throw error;
+	}
+};
+
+/**
+ * Retrieves a list of network checks for a specific monitor, sorted by most recent.
+ * @async
+ * @param {string} monitorId - The ID of the monitor to retrieve checks for.
+ * @param {number} [limit=100] - The maximum number of checks to return. Defaults to 100.
+ * @returns {Promise<Array<object>>} A promise that resolves to an array of network check documents.
+ * @throws {Error} Throws an error if the database operation fails.
+ */
+const getNetworkChecksByMonitorId = async (monitorId, limit = 100) => {
+	try {
+		const networkChecks = await NetworkCheck.find({ monitorId }).sort({ createdAt: -1 }).limit(limit);
+		return networkChecks;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getNetworkChecksByMonitorId";
+		throw error;
+	}
+};
+
+export { createNetworkCheck, getNetworkChecksByMonitorId };

server/src/db/mongo/modules/notificationModule.js

@@ -0,0 +1,125 @@
+import Notification from "../../models/Notification.js";
+import Monitor from "../../models/Monitor.js";
+const SERVICE_NAME = "notificationModule";
+/**
+ * Creates a new notification.
+ * @param {Object} notificationData - The data for the new notification.
+ * @param {mongoose.Types.ObjectId} notificationData.monitorId - The ID of the monitor.
+ * @param {string} notificationData.type - The type of the notification (e.g., "email", "sms").
+ * @param {string} [notificationData.address] - The address for the notification (if applicable).
+ * @param {string} [notificationData.phone] - The phone number for the notification (if applicable).
+ * @returns {Promise<Object>} The created notification.
+ * @throws Will throw an error if the notification cannot be created.
+ */
+const createNotification = async (notificationData) => {
+	try {
+		const notification = await new Notification({ ...notificationData }).save();
+		return notification;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createNotification";
+		throw error;
+	}
+};
+
+const getNotificationsByTeamId = async (teamId) => {
+	try {
+		const notifications = await Notification.find({ teamId });
+		return notifications;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getNotificationsByTeamId";
+		throw error;
+	}
+};
+
+const getNotificationsByIds = async (notificationIds) => {
+	try {
+		const notifications = await Notification.find({ _id: { $in: notificationIds } });
+		return notifications;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getNotificationsByIds";
+		throw error;
+	}
+};
+
+/**
+ * Retrieves notifications by monitor ID.
+ * @param {mongoose.Types.ObjectId} monitorId - The ID of the monitor.
+ * @returns {Promise<Array<Object>>} An array of notifications.
+ * @throws Will throw an error if the notifications cannot be retrieved.
+ */
+const getNotificationsByMonitorId = async (monitorId) => {
+	try {
+		const notifications = await Notification.find({ monitorId });
+		return notifications;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getNotificationsByMonitorId";
+		throw error;
+	}
+};
+
+const deleteNotificationsByMonitorId = async (monitorId) => {
+	try {
+		const result = await Notification.deleteMany({ monitorId });
+		return result.deletedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteNotificationsByMonitorId";
+		throw error;
+	}
+};
+
+const deleteNotificationById = async (id) => {
+	try {
+		const notification = await Notification.findById(id);
+		if (!notification) {
+			throw new Error("Notification not found");
+		}
+
+		const result = await Notification.findByIdAndDelete(id);
+		await Monitor.updateMany({ notifications: id }, { $pull: { notifications: id } });
+		return result;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteNotificationById";
+		throw error;
+	}
+};
+
+const getNotificationById = async (id) => {
+	try {
+		const notification = await Notification.findById(id);
+		return notification;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getNotificationById";
+		throw error;
+	}
+};
+
+const editNotification = async (id, notificationData) => {
+	try {
+		const notification = await Notification.findByIdAndUpdate(id, notificationData, {
+			new: true,
+		});
+		return notification;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "editNotification";
+		throw error;
+	}
+};
+
+export {
+	createNotification,
+	getNotificationsByTeamId,
+	getNotificationsByIds,
+	getNotificationsByMonitorId,
+	deleteNotificationsByMonitorId,
+	deleteNotificationById,
+	getNotificationById,
+	editNotification,
+};

server/src/db/mongo/modules/pageSpeedCheckModule.js

@@ -0,0 +1,57 @@
+import PageSpeedCheck from "../../models/PageSpeedCheck.js";
+const SERVICE_NAME = "pageSpeedCheckModule";
+/**
+ * Create a PageSpeed check for a monitor
+ * @async
+ * @param {Object} pageSpeedCheckData
+ * @param {string} pageSpeedCheckData.monitorId
+ * @param {number} pageSpeedCheckData.accessibility
+ * @param {number} pageSpeedCheckData.bestPractices
+ * @param {number} pageSpeedCheckData.seo
+ * @param {number} pageSpeedCheckData.performance
+ * @returns {Promise<PageSpeedCheck>}
+ * @throws {Error}
+ */
+const createPageSpeedCheck = async (pageSpeedCheckData) => {
+	try {
+		const pageSpeedCheck = await new PageSpeedCheck({
+			...pageSpeedCheckData,
+		}).save();
+		return pageSpeedCheck;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createPageSpeedCheck";
+		throw error;
+	}
+};
+const createPageSpeedChecks = async (pageSpeedChecks) => {
+	try {
+		await PageSpeedCheck.insertMany(pageSpeedChecks, { ordered: false });
+		return true;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "createPageSpeedCheck";
+		throw error;
+	}
+};
+
+/**
+ * Delete all PageSpeed checks for a monitor
+ * @async
+ * @param {string} monitorId
+ * @returns {number}
+ * @throws {Error}
+ */
+
+const deletePageSpeedChecksByMonitorId = async (monitorId) => {
+	try {
+		const result = await PageSpeedCheck.deleteMany({ monitorId });
+		return result.deletedCount;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deletePageSpeedChecksByMonitorId";
+		throw error;
+	}
+};
+
+export { createPageSpeedCheck, createPageSpeedChecks, deletePageSpeedChecksByMonitorId };

server/src/db/mongo/modules/recoveryModule.js

@@ -0,0 +1,86 @@
+import UserModel from "../../models/User.js";
+import RecoveryToken from "../../models/RecoveryToken.js";
+import crypto from "crypto";
+import serviceRegistry from "../../../service/system/serviceRegistry.js";
+import StringService from "../../../service/system/stringService.js";
+
+const SERVICE_NAME = "recoveryModule";
+
+/**
+ * Request a recovery token
+ * @async
+ * @param {string} email
+ * @returns {Promise<UserModel>}
+ * @throws {Error}
+ */
+const requestRecoveryToken = async (email) => {
+	try {
+		// Delete any existing tokens
+		await RecoveryToken.deleteMany({ email });
+		let recoveryToken = new RecoveryToken({
+			email,
+			token: crypto.randomBytes(32).toString("hex"),
+		});
+		await recoveryToken.save();
+		return recoveryToken;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "requestRecoveryToken";
+		throw error;
+	}
+};
+
+const validateRecoveryToken = async (candidateToken) => {
+	const stringService = serviceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const recoveryToken = await RecoveryToken.findOne({
+			token: candidateToken,
+		});
+		if (recoveryToken !== null) {
+			return recoveryToken;
+		} else {
+			throw new Error(stringService.dbTokenNotFound);
+		}
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "validateRecoveryToken";
+		throw error;
+	}
+};
+
+const resetPassword = async (password, candidateToken) => {
+	const stringService = serviceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		const newPassword = password;
+
+		// Validate token again
+		const recoveryToken = await validateRecoveryToken(candidateToken);
+		const user = await UserModel.findOne({ email: recoveryToken.email });
+
+		if (user === null) {
+			throw new Error(stringService.dbUserNotFound);
+		}
+
+		const match = await user.comparePassword(newPassword);
+		if (match === true) {
+			throw new Error(stringService.dbResetPasswordBadMatch);
+		}
+
+		user.password = newPassword;
+		await user.save();
+		await RecoveryToken.deleteMany({ email: recoveryToken.email });
+		// Fetch the user again without the password
+		const userWithoutPassword = await UserModel.findOne({
+			email: recoveryToken.email,
+		})
+			.select("-password")
+			.select("-profileImage");
+		return userWithoutPassword;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "resetPassword";
+		throw error;
+	}
+};
+
+export { requestRecoveryToken, validateRecoveryToken, resetPassword };

server/src/db/mongo/modules/settingsModule.js

@@ -0,0 +1,41 @@
+import AppSettings from "../../models/AppSettings.js";
+const SERVICE_NAME = "SettingsModule";
+
+const getAppSettings = async () => {
+	try {
+		const settings = AppSettings.findOne();
+		return settings;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getSettings";
+		throw error;
+	}
+};
+
+const updateAppSettings = async (newSettings) => {
+	try {
+		const update = { $set: { ...newSettings } };
+
+		if (newSettings.pagespeedApiKey === "") {
+			update.$unset = { pagespeedApiKey: "" };
+			delete update.$set.pagespeedApiKey;
+		}
+
+		if (newSettings.systemEmailPassword === "") {
+			update.$unset = { systemEmailPassword: "" };
+			delete update.$set.systemEmailPassword;
+		}
+
+		await AppSettings.findOneAndUpdate({}, update, {
+			upsert: true,
+		});
+		const settings = await AppSettings.findOne().select("-__v -_id -createdAt -updatedAt -singleton").lean();
+		return settings;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "updateAppSettings";
+		throw error;
+	}
+};
+
+export { getAppSettings, updateAppSettings };

server/src/db/mongo/modules/statusPageModule.js

@@ -0,0 +1,241 @@
+import StatusPage from "../../models/StatusPage.js";
+import { NormalizeData } from "../../../utils/dataUtils.js";
+import ServiceRegistry from "../../../service/system/serviceRegistry.js";
+import StringService from "../../../service/system/stringService.js";
+
+const SERVICE_NAME = "statusPageModule";
+
+const createStatusPage = async ({ statusPageData, image, userId, teamId }) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+
+	try {
+		const statusPage = new StatusPage({
+			...statusPageData,
+			userId,
+			teamId,
+		});
+		if (image) {
+			statusPage.logo = {
+				data: image.buffer,
+				contentType: image.mimetype,
+			};
+		}
+		await statusPage.save();
+		return statusPage;
+	} catch (error) {
+		if (error?.code === 11000) {
+			// Handle duplicate URL errors
+			error.status = 400;
+			error.message = stringService.statusPageUrlNotUnique;
+		}
+		error.service = SERVICE_NAME;
+		error.method = "createStatusPage";
+		throw error;
+	}
+};
+
+const updateStatusPage = async (statusPageData, image) => {
+	try {
+		if (image) {
+			statusPageData.logo = {
+				data: image.buffer,
+				contentType: image.mimetype,
+			};
+		} else {
+			statusPageData.logo = null;
+		}
+
+		if (statusPageData.deleteSubmonitors === "true") {
+			statusPageData.subMonitors = [];
+		}
+		const statusPage = await StatusPage.findOneAndUpdate({ url: statusPageData.url }, statusPageData, {
+			new: true,
+		});
+
+		return statusPage;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "updateStatusPage";
+		throw error;
+	}
+};
+
+const getStatusPageByUrl = async (url, type) => {
+	// TODO This is deprecated, can remove and have controller call getStatusPage
+	try {
+		return getStatusPage(url);
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getStatusPageByUrl";
+		throw error;
+	}
+};
+
+const getStatusPagesByTeamId = async (teamId) => {
+	try {
+		const statusPages = await StatusPage.find({ teamId });
+		return statusPages;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getStatusPagesByTeamId";
+		throw error;
+	}
+};
+
+const getStatusPage = async (url) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+
+	try {
+		const preliminaryStatusPage = await StatusPage.findOne({ url });
+		if (!preliminaryStatusPage) {
+			const error = new Error(stringService.statusPageNotFound);
+			error.status = 404;
+			throw error;
+		}
+
+		if (!preliminaryStatusPage.monitors || preliminaryStatusPage.monitors.length === 0) {
+			const { _id, color, companyName, isPublished, logo, originalMonitors, showCharts, showUptimePercentage, timezone, showAdminLoginLink, url } =
+				preliminaryStatusPage;
+			return {
+				statusPage: {
+					_id,
+					color,
+					companyName,
+					isPublished,
+					logo,
+					originalMonitors,
+					showCharts,
+					showUptimePercentage,
+					timezone,
+					showAdminLoginLink,
+					url,
+				},
+				monitors: [],
+			};
+		}
+
+		const statusPageQuery = await StatusPage.aggregate([
+			{ $match: { url: url } },
+			{
+				$set: {
+					originalMonitors: "$monitors",
+				},
+			},
+			{
+				$lookup: {
+					from: "monitors",
+					localField: "monitors",
+					foreignField: "_id",
+					as: "monitors",
+				},
+			},
+			{
+				$unwind: {
+					path: "$monitors",
+					preserveNullAndEmptyArrays: true,
+				},
+			},
+			{
+				$lookup: {
+					from: "checks",
+					let: { monitorId: "$monitors._id" },
+					pipeline: [
+						{
+							$match: {
+								$expr: { $eq: ["$monitorId", "$$monitorId"] },
+							},
+						},
+						{ $sort: { createdAt: -1 } },
+						{ $limit: 25 },
+					],
+					as: "monitors.checks",
+				},
+			},
+			{
+				$addFields: {
+					"monitors.orderIndex": {
+						$indexOfArray: ["$originalMonitors", "$monitors._id"],
+					},
+				},
+			},
+			{ $match: { "monitors.orderIndex": { $ne: -1 } } },
+			{ $sort: { "monitors.orderIndex": 1 } },
+
+			{
+				$group: {
+					_id: "$_id",
+					statusPage: { $first: "$$ROOT" },
+					monitors: { $push: "$monitors" },
+				},
+			},
+			{
+				$project: {
+					statusPage: {
+						_id: 1,
+						color: 1,
+						companyName: 1,
+						isPublished: 1,
+						logo: 1,
+						originalMonitors: 1,
+						showCharts: 1,
+						showUptimePercentage: 1,
+						timezone: 1,
+						showAdminLoginLink: 1,
+						url: 1,
+					},
+					monitors: 1,
+				},
+			},
+		]);
+		if (!statusPageQuery.length) {
+			const error = new Error(stringService.statusPageNotFound);
+			error.status = 404;
+			throw error;
+		}
+
+		const { statusPage, monitors } = statusPageQuery[0];
+
+		const normalizedMonitors = monitors.map((monitor) => {
+			return {
+				...monitor,
+				checks: NormalizeData(monitor.checks, 10, 100),
+			};
+		});
+
+		return { statusPage, monitors: normalizedMonitors };
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getStatusPageByUrl";
+		throw error;
+	}
+};
+
+const deleteStatusPage = async (url) => {
+	try {
+		await StatusPage.deleteOne({ url });
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteStatusPage";
+		throw error;
+	}
+};
+
+const deleteStatusPagesByMonitorId = async (monitorId) => {
+	try {
+		await StatusPage.deleteMany({ monitors: { $in: [monitorId] } });
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteStatusPageByMonitorId";
+		throw error;
+	}
+};
+
+export {
+	createStatusPage,
+	updateStatusPage,
+	getStatusPagesByTeamId,
+	getStatusPage,
+	getStatusPageByUrl,
+	deleteStatusPage,
+	deleteStatusPagesByMonitorId,
+};

server/src/db/mongo/modules/userModule.js

@@ -0,0 +1,261 @@
+import UserModel from "../../models/User.js";
+import TeamModel from "../../models/Team.js";
+import { GenerateAvatarImage } from "../../../utils/imageProcessing.js";
+
+const DUPLICATE_KEY_CODE = 11000; // MongoDB error code for duplicate key
+import { ParseBoolean } from "../../../utils/utils.js";
+import ServiceRegistry from "../../../service/system/serviceRegistry.js";
+import StringService from "../../../service/system/stringService.js";
+const SERVICE_NAME = "userModule";
+
+const checkSuperadmin = async () => {
+	const superAdmin = await UserModel.findOne({ role: "superadmin" });
+	if (superAdmin !== null) {
+		return true;
+	}
+	return false;
+};
+
+/**
+ * Insert a User
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<UserModel>}
+ * @throws {Error}
+ */
+const insertUser = async (userData, imageFile, generateAvatarImage = GenerateAvatarImage) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	try {
+		if (imageFile) {
+			// 1.  Save the full size image
+			userData.profileImage = {
+				data: imageFile.buffer,
+				contentType: imageFile.mimetype,
+			};
+
+			// 2.  Get the avatar sized image
+			const avatar = await generateAvatarImage(imageFile);
+			userData.avatarImage = avatar;
+		}
+
+		//  Handle creating team if superadmin
+		if (userData.role.includes("superadmin")) {
+			const team = new TeamModel({
+				email: userData.email,
+			});
+			userData.teamId = team._id;
+			userData.checkTTL = 60 * 60 * 24 * 30;
+			await team.save();
+		}
+
+		const newUser = new UserModel(userData);
+		await newUser.save();
+		return await UserModel.findOne({ _id: newUser._id }).select("-password").select("-profileImage"); // .select() doesn't work with create, need to save then find
+	} catch (error) {
+		if (error.code === DUPLICATE_KEY_CODE) {
+			error.message = stringService.dbUserExists;
+		}
+		error.service = SERVICE_NAME;
+		error.method = "insertUser";
+		throw error;
+	}
+};
+
+/**
+ * Get User by Email
+ * Gets a user by Email.  Not sure if we'll ever need this except for login.
+ * If not needed except for login, we can move password comparison here
+ * Throws error if user not found
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<UserModel>}
+ * @throws {Error}
+ */
+const getUserByEmail = async (email) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+
+	try {
+		// Need the password to be able to compare, removed .select()
+		// We can strip the hash before returning the user
+		const user = await UserModel.findOne({ email: email }).select("-profileImage");
+		if (!user) {
+			throw new Error(stringService.dbUserNotFound);
+		}
+		return user;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getUserByEmail";
+		throw error;
+	}
+};
+
+/**
+ * Update a user by ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<UserModel>}
+ * @throws {Error}
+ */
+
+const updateUser = async ({ userId, user, file }) => {
+	if (!userId) {
+		throw new Error("No user in request");
+	}
+
+	try {
+		const candidateUser = { ...user };
+
+		if (ParseBoolean(candidateUser.deleteProfileImage) === true) {
+			candidateUser.profileImage = null;
+			candidateUser.avatarImage = null;
+		} else if (file) {
+			// 1.  Save the full size image
+			candidateUser.profileImage = {
+				data: file.buffer,
+				contentType: file.mimetype,
+			};
+
+			// 2.  Get the avatar sized image
+			const avatar = await GenerateAvatarImage(file);
+			candidateUser.avatarImage = avatar;
+		}
+
+		// ******************************************
+		// End handling profile image
+		// ******************************************
+
+		const updatedUser = await UserModel.findByIdAndUpdate(
+			userId,
+			candidateUser,
+			{ new: true } // Returns updated user instead of pre-update user
+		)
+			.select("-password")
+			.select("-profileImage");
+		return updatedUser;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "updateUser";
+		throw error;
+	}
+};
+
+/**
+ * Delete a user by ID
+ * @async
+ * @param {Express.Request} req
+ * @param {Express.Response} res
+ * @returns {Promise<UserModel>}
+ * @throws {Error}
+ */
+const deleteUser = async (userId) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+
+	try {
+		const deletedUser = await UserModel.findByIdAndDelete(userId);
+		if (!deletedUser) {
+			throw new Error(stringService.dbUserNotFound);
+		}
+		return deletedUser;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteUser";
+		throw error;
+	}
+};
+
+/**
+ * Delete a user by ID
+ * @async
+ * @param {string} teamId
+ * @returns {void}
+ * @throws {Error}
+ */
+const deleteTeam = async (teamId) => {
+	try {
+		await TeamModel.findByIdAndDelete(teamId);
+		return true;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteTeam";
+		throw error;
+	}
+};
+
+const deleteAllOtherUsers = async () => {
+	try {
+		await UserModel.deleteMany({ role: { $ne: "superadmin" } });
+		return true;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "deleteAllOtherUsers";
+		throw error;
+	}
+};
+
+const getAllUsers = async () => {
+	try {
+		const users = await UserModel.find().select("-password").select("-profileImage");
+		return users;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getAllUsers";
+		throw error;
+	}
+};
+
+const logoutUser = async (userId) => {
+	try {
+		await UserModel.updateOne({ _id: userId }, { $unset: { authToken: null } });
+		return true;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "logoutUser";
+		throw error;
+	}
+};
+
+const getUserById = async (roles, userId) => {
+	try {
+		if (!roles.includes("superadmin")) {
+			throw new Error("User is not a superadmin");
+		}
+
+		const user = await UserModel.findById(userId).select("-password").select("-profileImage");
+		if (!user) {
+			throw new Error("User not found");
+		}
+
+		return user;
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "getUserById";
+		throw error;
+	}
+};
+
+const editUserById = async (userId, user) => {
+	try {
+		await UserModel.findByIdAndUpdate(userId, user, { new: true }).select("-password").select("-profileImage");
+	} catch (error) {
+		error.service = SERVICE_NAME;
+		error.method = "editUserById";
+		throw error;
+	}
+};
+
+export {
+	checkSuperadmin,
+	insertUser,
+	getUserByEmail,
+	updateUser,
+	deleteUser,
+	deleteTeam,
+	deleteAllOtherUsers,
+	getAllUsers,
+	logoutUser,
+	getUserById,
+	editUserById,
+};

server/src/db/mongo/utils/seedDb.js

@@ -0,0 +1,75 @@
+import Monitor from "../../models/Monitor.js";
+import Check from "../../models/Check.js";
+import logger from "../../../utils/logger.js";
+
+const generateRandomUrl = () => {
+	const domains = ["example.com", "test.org", "demo.net", "sample.io", "mock.dev"];
+	const paths = ["api", "status", "health", "ping", "check"];
+	return `https://${domains[Math.floor(Math.random() * domains.length)]}/${paths[Math.floor(Math.random() * paths.length)]}`;
+};
+
+const generateChecks = (monitorId, teamId, count) => {
+	const checks = [];
+	const endTime = new Date(Date.now() - 10 * 60 * 1000); // 10 minutes ago
+	const startTime = new Date(endTime - count * 60 * 1000); // count minutes before endTime
+
+	for (let i = 0; i < count; i++) {
+		const timestamp = new Date(startTime.getTime() + i * 60 * 1000);
+		const status = Math.random() > 0.05; // 95% chance of being up
+
+		checks.push({
+			monitorId,
+			teamId,
+			status,
+			responseTime: Math.floor(Math.random() * 1000), // Random response time between 0-1000ms
+			createdAt: timestamp,
+			updatedAt: timestamp,
+		});
+	}
+
+	return checks;
+};
+
+const seedDb = async (userId, teamId) => {
+	try {
+		logger.info({
+			message: "Deleting all monitors and checks",
+			service: "seedDb",
+			method: "seedDb",
+		});
+		await Monitor.deleteMany({});
+		await Check.deleteMany({});
+		logger.info({
+			message: "Adding monitors",
+			service: "DB",
+			method: "seedDb",
+		});
+		for (let i = 0; i < 300; i++) {
+			const monitor = await Monitor.create({
+				name: `Monitor ${i}`,
+				url: generateRandomUrl(),
+				type: "http",
+				userId,
+				teamId,
+				interval: 60000,
+				active: false,
+			});
+			logger.info({
+				message: `Adding monitor and checks for monitor ${i}`,
+				service: "DB",
+				method: "seedDb",
+			});
+			const checks = generateChecks(monitor._id, teamId, 10000);
+			await Check.insertMany(checks);
+		}
+	} catch (error) {
+		logger.error({
+			message: "Error seeding DB",
+			service: "DB",
+			method: "seedDb",
+			stack: error.stack,
+		});
+	}
+};
+
+export default seedDb;

server/src/index.js

@@ -0,0 +1,55 @@
+import { initializeServices } from "./config/services.js";
+import { initializeControllers } from "./config/controllers.js";
+import { createApp } from "./app.js";
+import { initShutdownListener } from "./shutdown.js";
+import logger from "./utils/logger.js";
+import { fileURLToPath } from "url";
+import path from "path";
+import fs from "fs";
+
+import SettingsService from "./service/system/settingsService.js";
+import AppSettings from "./db/models/AppSettings.js";
+
+const SERVICE_NAME = "Server";
+
+const startApp = async () => {
+	// FE path
+	const __filename = fileURLToPath(import.meta.url);
+	const __dirname = path.dirname(__filename);
+	const openApiSpec = JSON.parse(fs.readFileSync(path.join(__dirname, "../openapi.json"), "utf8"));
+	const frontendPath = path.join(__dirname, "public");
+	// Create services
+	const settingsService = new SettingsService(AppSettings);
+	const appSettings = settingsService.loadSettings();
+
+	// Initialize services
+	const services = await initializeServices(appSettings, settingsService);
+
+	// Initialize controllers
+	const controllers = initializeControllers(services);
+
+	const app = createApp({
+		services,
+		controllers,
+		appSettings,
+		frontendPath,
+		openApiSpec,
+	});
+
+	const port = appSettings.port || 52345;
+	const server = app.listen(port, () => {
+		logger.info({ message: `Server started on port:${port}` });
+	});
+
+	initShutdownListener(server, services);
+};
+
+startApp().catch((error) => {
+	logger.error({
+		message: error.message,
+		service: SERVICE_NAME,
+		method: "startApp",
+		stack: error.stack,
+	});
+	process.exit(1);
+});

server/src/locales/en.json

@@ -0,0 +1,166 @@
+{
+	"dontHaveAccount": "Don't have account",
+	"email": "E-mail",
+	"forgotPassword": "Forgot Password",
+	"password": "password",
+	"signUp": "Sign up",
+	"submit": "Submit",
+	"title": "Title",
+	"continue": "Continue",
+	"enterEmail": "Enter your email",
+	"authLoginTitle": "Log In",
+	"authLoginEnterPassword": "Enter your password",
+	"commonPassword": "Password",
+	"commonBack": "Back",
+	"authForgotPasswordTitle": "Forgot password?",
+	"authForgotPasswordResetPassword": "Reset password",
+	"createPassword": "Create your password",
+	"createAPassword": "Create a password",
+	"authRegisterAlreadyHaveAccount": "Already have an account?",
+	"commonAppName": "BlueWave Uptime",
+	"authLoginEnterEmail": "Enter your email",
+	"authRegisterTitle": "Create an account",
+	"authRegisterStepOneTitle": "Create your account",
+	"authRegisterStepOneDescription": "Enter your details to get started",
+	"authRegisterStepTwoTitle": "Set up your profile",
+	"authRegisterStepTwoDescription": "Tell us more about yourself",
+	"authRegisterStepThreeTitle": "Almost done!",
+	"authRegisterStepThreeDescription": "Review your information",
+	"authForgotPasswordDescription": "No worries, we'll send you reset instructions.",
+	"authForgotPasswordSendInstructions": "Send instructions",
+	"authForgotPasswordBackTo": "Back to",
+	"authCheckEmailTitle": "Check your email",
+	"authCheckEmailDescription": "We sent a password reset link to {{email}}",
+	"authCheckEmailResendEmail": "Resend email",
+	"authCheckEmailBackTo": "Back to",
+	"goBackTo": "Go back to",
+	"authCheckEmailDidntReceiveEmail": "Didn't receive the email?",
+	"authCheckEmailClickToResend": "Click to resend",
+	"authSetNewPasswordTitle": "Set new password",
+	"authSetNewPasswordDescription": "Your new password must be different from previously used passwords.",
+	"authSetNewPasswordNewPassword": "New password",
+	"authSetNewPasswordConfirmPassword": "Confirm password",
+	"confirmPassword": "Confirm your password",
+	"authSetNewPasswordResetPassword": "Reset password",
+	"authSetNewPasswordBackTo": "Back to",
+	"authPasswordMustBeAtLeast": "Must be at least",
+	"authPasswordCharactersLong": "8 characters long",
+	"authPasswordMustContainAtLeast": "Must contain at least",
+	"authPasswordSpecialCharacter": "one special character",
+	"authPasswordOneNumber": "one number",
+	"authPasswordUpperCharacter": "one upper character",
+	"authPasswordLowerCharacter": "one lower character",
+	"authPasswordConfirmAndPassword": "Confirm password and password",
+	"authPasswordMustMatch": "must match",
+	"friendlyError": "Something went wrong...",
+	"unknownError": "An unknown error occurred",
+	"unauthorized": "Unauthorized access",
+	"authAdminExists": "Admin already exists",
+	"authInviteNotFound": "Invite not found",
+	"unknownService": "Unknown service",
+	"noAuthToken": "No auth token provided",
+	"invalidAuthToken": "Invalid auth token",
+	"expiredAuthToken": "Token expired",
+	"noRefreshToken": "No refresh token provided",
+	"invalidRefreshToken": "Invalid refresh token",
+	"expiredRefreshToken": "Refresh token expired",
+	"requestNewAccessToken": "Request new access token",
+	"invalidPayload": "Invalid payload",
+	"verifyOwnerNotFound": "Document not found",
+	"verifyOwnerUnauthorized": "Unauthorized access",
+	"insufficientPermissions": "Insufficient permissions",
+	"dbUserExists": "User already exists",
+	"dbUserNotFound": "User not found",
+	"dbTokenNotFound": "Token not found",
+	"dbResetPasswordBadMatch": "New password must be different from old password",
+	"dbFindMonitorById": "Monitor with id ${monitorId} not found",
+	"dbDeleteChecks": "No checks found for monitor with id ${monitorId}",
+	"authIncorrectPassword": "Incorrect password",
+	"authUnauthorized": "Unauthorized access",
+	"monitorGetById": "Monitor not found",
+	"monitorGetByUserId": "No monitors found for user",
+	"jobQueueWorkerClose": "Error closing worker",
+	"jobQueueDeleteJob": "Job not found in queue",
+	"jobQueueObliterate": "Error obliterating queue",
+	"pingCannotResolve": "No response",
+	"statusPageNotFound": "Status page not found",
+	"statusPageUrlNotUnique": "Status page url must be unique",
+	"dockerFail": "Failed to fetch Docker container information",
+	"dockerNotFound": "Docker container not found",
+	"portFail": "Failed to connect to port",
+	"alertCreate": "Alert created successfully",
+	"alertGetByUser": "Got alerts successfully",
+	"alertGetByMonitor": "Got alerts by Monitor successfully",
+	"alertGetById": "Got alert by Id successfully",
+	"alertEdit": "Alert edited successfully",
+	"alertDelete": "Alert deleted successfully",
+	"authCreateUser": "User created successfully",
+	"authLoginUser": "User logged in successfully",
+	"authLogoutUser": "User logged out successfully",
+	"authUpdateUser": "User updated successfully",
+	"authCreateRecoveryToken": "Recovery token created successfully",
+	"authVerifyRecoveryToken": "Recovery token verified successfully",
+	"authResetPassword": "Password reset successfully",
+	"authAdminCheck": "Admin check completed successfully",
+	"authDeleteUser": "User deleted successfully",
+	"authTokenRefreshed": "Auth token is refreshed",
+	"authGetAllUsers": "Got all users successfully",
+	"inviteIssued": "Invite sent successfully",
+	"inviteVerified": "Invite verified successfully",
+	"checkCreate": "Check created successfully",
+	"checkGet": "Got checks successfully",
+	"checkDelete": "Checks deleted successfully",
+	"checkUpdateTtl": "Checks TTL updated successfully",
+	"monitorGetAll": "Got all monitors successfully",
+	"monitorStatsById": "Got monitor stats by Id successfully",
+	"monitorGetByIdSuccess": "Got monitor by Id successfully",
+	"monitorGetByTeamId": "Got monitors by Team Id successfully",
+	"monitorGetByUserIdSuccess": "Got monitor for ${userId} successfully",
+	"monitorCreate": "Monitor created successfully",
+	"bulkMonitorsCreate": "Monitors created successfully",
+	"monitorDelete": "Monitor deleted successfully",
+	"monitorEdit": "Monitor edited successfully",
+	"monitorCertificate": "Got monitor certificate successfully",
+	"monitorDemoAdded": "Successfully added demo monitors",
+	"queueGetMetrics": "Got metrics successfully",
+	"queueGetJobs": "Got jobs successfully",
+	"queueAddJob": "Job added successfully",
+	"queueObliterate": "Queue obliterated",
+	"jobQueueDeleteJobSuccess": "Job removed successfully",
+	"jobQueuePauseJob": "Job paused successfully",
+	"jobQueueResumeJob": "Job resumed successfully",
+	"maintenanceWindowGetById": "Got Maintenance Window by Id successfully",
+	"maintenanceWindowCreate": "Maintenance Window created successfully",
+	"maintenanceWindowGetByTeam": "Got Maintenance Windows by Team successfully",
+	"maintenanceWindowDelete": "Maintenance Window deleted successfully",
+	"maintenanceWindowEdit": "Maintenance Window edited successfully",
+	"pingSuccess": "Success",
+	"getAppSettings": "Got app settings successfully",
+	"updateAppSettings": "Updated app settings successfully",
+	"statusPageByUrl": "Got status page by url successfully",
+	"statusPageCreate": "Status page created successfully",
+	"newTermsAdded": "New terms added to POEditor",
+	"dockerSuccess": "Docker container status fetched successfully",
+	"portSuccess": "Port connected successfully",
+	"monitorPause": "Monitor paused successfully",
+	"monitorResume": "Monitor resumed successfully",
+	"statusPageDelete": "Status page deleted successfully",
+	"statusPageUpdate": "Status page updated successfully",
+	"statusPageByTeamId": "Got status pages by team id successfully",
+	"httpNetworkError": "Network error",
+	"httpNotJson": "Response data is not json",
+	"httpJsonPathError": "Failed to parse json data",
+	"httpEmptyResult": "Result is empty",
+	"httpMatchSuccess": "Response data match successfully",
+	"httpMatchFail": "Failed to match response data",
+	"webhookSendSuccess": "Webhook notification sent successfully",
+	"telegramRequiresBotTokenAndChatId": "Telegram notifications require both botToken and chatId",
+	"webhookUrlRequired": "Webhook URL is required",
+	"platformRequired": "Platform is required",
+	"testNotificationFailed": "Failed to send test notification",
+	"monitorUpAlert": "Uptime Alert: One of your monitors is back online.\n📌 Monitor: {monitorName}\n📅 Time: {time}\n⚠️ Status: UP\n📟 Status Code: {code}\n\u200B\n",
+	"monitorDownAlert": "Downtime Alert: One of your monitors went offline.\n📌 Monitor: {monitorName}\n📅 Time: {time}\n⚠️ Status: DOWN\n📟 Status Code: {code}\n\u200B\n",
+	"sendTestEmail": "Test email sent successfully",
+	"errorForValidEmailAddress": "A valid recipient email address is required.",
+	"testEmailSubject": "Test E-mail from Checkmate"
+}

server/src/locales/en.json.bak

@@ -0,0 +1,147 @@
+{
+	"dontHaveAccount": "Don't have account",
+	"email": "E-mail",
+	"forgotPassword": "Forgot Password",
+	"password": "password",
+	"signUp": "Sign up",
+	"submit": "Submit",
+	"title": "Title",
+	"continue": "Continue",
+	"enterEmail": "Enter your email",
+	"authLoginTitle": "Log In",
+	"authLoginEnterPassword": "Enter your password",
+	"commonPassword": "Password",
+	"commonBack": "Back",
+	"authForgotPasswordTitle": "Forgot password?",
+	"authForgotPasswordResetPassword": "Reset password",
+	"createPassword": "Create your password",
+	"createAPassword": "Create a password",
+	"authRegisterAlreadyHaveAccount": "Already have an account?",
+	"commonAppName": "BlueWave Uptime",
+	"authLoginEnterEmail": "Enter your email",
+	"authRegisterTitle": "Create an account",
+	"authRegisterStepOneTitle": "Create your account",
+	"authRegisterStepOneDescription": "Enter your details to get started",
+	"authRegisterStepTwoTitle": "Set up your profile",
+	"authRegisterStepTwoDescription": "Tell us more about yourself",
+	"authRegisterStepThreeTitle": "Almost done!",
+	"authRegisterStepThreeDescription": "Review your information",
+	"authForgotPasswordDescription": "No worries, we'll send you reset instructions.",
+	"authForgotPasswordSendInstructions": "Send instructions",
+	"authForgotPasswordBackTo": "Back to",
+	"authCheckEmailTitle": "Check your email",
+	"authCheckEmailDescription": "We sent a password reset link to {{email}}",
+	"authCheckEmailResendEmail": "Resend email",
+	"authCheckEmailBackTo": "Back to",
+	"goBackTo": "Go back to",
+	"authCheckEmailDidntReceiveEmail": "Didn't receive the email?",
+	"authCheckEmailClickToResend": "Click to resend",
+	"authSetNewPasswordTitle": "Set new password",
+	"authSetNewPasswordDescription": "Your new password must be different from previously used passwords.",
+	"authSetNewPasswordNewPassword": "New password",
+	"authSetNewPasswordConfirmPassword": "Confirm password",
+	"confirmPassword": "Confirm your password",
+	"authSetNewPasswordResetPassword": "Reset password",
+	"authSetNewPasswordBackTo": "Back to",
+	"authPasswordMustBeAtLeast": "Must be at least",
+	"authPasswordCharactersLong": "8 characters long",
+	"authPasswordMustContainAtLeast": "Must contain at least",
+	"authPasswordSpecialCharacter": "one special character",
+	"authPasswordOneNumber": "one number",
+	"authPasswordUpperCharacter": "one upper character",
+	"authPasswordLowerCharacter": "one lower character",
+	"authPasswordConfirmAndPassword": "Confirm password and password",
+	"authPasswordMustMatch": "must match",
+	"friendlyError": "Something went wrong...",
+	"unknownError": "An unknown error occurred",
+	"unauthorized": "Unauthorized access",
+	"authAdminExists": "Admin already exists",
+	"authInviteNotFound": "Invite not found",
+	"unknownService": "Unknown service",
+	"noAuthToken": "No auth token provided",
+	"invalidAuthToken": "Invalid auth token",
+	"expiredAuthToken": "Token expired",
+	"noRefreshToken": "No refresh token provided",
+	"invalidRefreshToken": "Invalid refresh token",
+	"expiredRefreshToken": "Refresh token expired",
+	"requestNewAccessToken": "Request new access token",
+	"invalidPayload": "Invalid payload",
+	"verifyOwnerNotFound": "Document not found",
+	"verifyOwnerUnauthorized": "Unauthorized access",
+	"insufficientPermissions": "Insufficient permissions",
+	"dbUserExists": "User already exists",
+	"dbUserNotFound": "User not found",
+	"dbTokenNotFound": "Token not found",
+	"dbResetPasswordBadMatch": "New password must be different from old password",
+	"dbFindMonitorById": "Monitor with id ${monitorId} not found",
+	"dbDeleteChecks": "No checks found for monitor with id ${monitorId}",
+	"authIncorrectPassword": "Incorrect password",
+	"authUnauthorized": "Unauthorized access",
+	"monitorGetById": "Monitor not found",
+	"monitorGetByUserId": "No monitors found for user",
+	"jobQueueWorkerClose": "Error closing worker",
+	"jobQueueDeleteJob": "Job not found in queue",
+	"jobQueueObliterate": "Error obliterating queue",
+	"pingCannotResolve": "No response",
+	"statusPageNotFound": "Status page not found",
+	"statusPageUrlNotUnique": "Status page url must be unique",
+	"dockerFail": "Failed to fetch Docker container information",
+	"dockerNotFound": "Docker container not found",
+	"portFail": "Failed to connect to port",
+	"alertCreate": "Alert created successfully",
+	"alertGetByUser": "Got alerts successfully",
+	"alertGetByMonitor": "Got alerts by Monitor successfully",
+	"alertGetById": "Got alert by Id successfully",
+	"alertEdit": "Alert edited successfully",
+	"alertDelete": "Alert deleted successfully",
+	"authCreateUser": "User created successfully",
+	"authLoginUser": "User logged in successfully",
+	"authLogoutUser": "User logged out successfully",
+	"authUpdateUser": "User updated successfully",
+	"authCreateRecoveryToken": "Recovery token created successfully",
+	"authVerifyRecoveryToken": "Recovery token verified successfully",
+	"authResetPassword": "Password reset successfully",
+	"authAdminCheck": "Admin check completed successfully",
+	"authDeleteUser": "User deleted successfully",
+	"authTokenRefreshed": "Auth token is refreshed",
+	"authGetAllUsers": "Got all users successfully",
+	"inviteIssued": "Invite sent successfully",
+	"inviteVerified": "Invite verified successfully",
+	"checkCreate": "Check created successfully",
+	"checkGet": "Got checks successfully",
+	"checkDelete": "Checks deleted successfully",
+	"checkUpdateTtl": "Checks TTL updated successfully",
+	"monitorGetAll": "Got all monitors successfully",
+	"monitorStatsById": "Got monitor stats by Id successfully",
+	"monitorGetByIdSuccess": "Got monitor by Id successfully",
+	"monitorGetByTeamId": "Got monitors by Team Id successfully",
+	"monitorGetByUserIdSuccess": "Got monitor for ${userId} successfully",
+	"monitorCreate": "Monitor created successfully",
+	"monitorDelete": "Monitor deleted successfully",
+	"monitorEdit": "Monitor edited successfully",
+	"monitorCertificate": "Got monitor certificate successfully",
+	"monitorDemoAdded": "Successfully added demo monitors",
+	"queueGetMetrics": "Got metrics successfully",
+	"queueAddJob": "Job added successfully",
+	"queueObliterate": "Queue obliterated",
+	"jobQueueDeleteJobSuccess": "Job removed successfully",
+	"jobQueuePauseJob": "Job paused successfully",
+	"jobQueueResumeJob": "Job resumed successfully",
+	"maintenanceWindowGetById": "Got Maintenance Window by Id successfully",
+	"maintenanceWindowCreate": "Maintenance Window created successfully",
+	"maintenanceWindowGetByTeam": "Got Maintenance Windows by Team successfully",
+	"maintenanceWindowDelete": "Maintenance Window deleted successfully",
+	"maintenanceWindowEdit": "Maintenance Window edited successfully",
+	"pingSuccess": "Success",
+	"getAppSettings": "Got app settings successfully",
+	"updateAppSettings": "Updated app settings successfully",
+	"statusPageByUrl": "Got status page by url successfully",
+	"statusPageCreate": "Status page created successfully",
+	"newTermsAdded": "New terms added to POEditor",
+	"dockerSuccess": "Docker container status fetched successfully",
+	"portSuccess": "Port connected successfully",
+	"monitorPause": "Monitor paused successfully",
+	"monitorResume": "Monitor resumed successfully",
+	"statusPageDelete": "Status page deleted successfully",
+	"statusPageUpdate": "Status page updated successfully"
+}

server/src/locales/tr.json

@@ -0,0 +1,146 @@
+{
+	"dontHaveAccount": "Hesabınız yok mu",
+	"email": "E-posta",
+	"forgotPassword": "Parolamı Unuttum",
+	"password": "Parola",
+	"signUp": "Kayıt ol",
+	"submit": "Gönder",
+	"title": "Başlık",
+	"continue": "Devam et",
+	"enterEmail": "E-posta adresinizi girin",
+	"authLoginTitle": "Giriş Yap",
+	"authLoginEnterPassword": "Parolanızı girin",
+	"commonPassword": "Parola",
+	"commonBack": "Geri",
+	"authForgotPasswordTitle": "Parolanı mi unuttun?",
+	"authForgotPasswordResetPassword": "Parola sıfırla",
+	"createPassword": "Parolanızı oluşturun",
+	"createAPassword": "Bir parola oluşturun",
+	"authRegisterAlreadyHaveAccount": "Zaten hesabınız var mı?",
+	"commonAppName": "BlueWave Uptime",
+	"authLoginEnterEmail": "E-posta adresinizi girin",
+	"authRegisterTitle": "Hesap oluştur",
+	"authRegisterStepOneTitle": "Hesabınızı oluşturun",
+	"authRegisterStepOneDescription": "Başlamak için bilgilerinizi girin",
+	"authRegisterStepTwoTitle": "Profilinizi ayarlayın",
+	"authRegisterStepTwoDescription": "Kendiniz hakkında daha fazla bilgi verin",
+	"authRegisterStepThreeTitle": "Neredeyse bitti!",
+	"authRegisterStepThreeDescription": "Bilgilerinizi gözden geçirin",
+	"authForgotPasswordDescription": "Endişelenmeyin, size sıfırlama talimatlarını göndereceğiz.",
+	"authForgotPasswordSendInstructions": "Talimatları gönder",
+	"authForgotPasswordBackTo": "Geri dön",
+	"authCheckEmailTitle": "E-postanızı kontrol edin",
+	"authCheckEmailDescription": "{{email}} adresine bir şifre sıfırlama bağlantısı gönderdik",
+	"authCheckEmailResendEmail": "E-postayı yeniden gönder",
+	"authCheckEmailBackTo": "Geri dön",
+	"goBackTo": "Geri dön",
+	"authCheckEmailDidntReceiveEmail": "E-postayı almadınız mı?",
+	"authCheckEmailClickToResend": "Yeniden göndermek için tıklayın",
+	"authSetNewPasswordTitle": "Yeni şifre belirleyin",
+	"authSetNewPasswordDescription": "Yeni şifreniz, daha önce kullanılan şifrelerden farklı olmalıdır.",
+	"authSetNewPasswordNewPassword": "Yeni şifre",
+	"authSetNewPasswordConfirmPassword": "Parolayı onayla",
+	"confirmPassword": "Parolanızı onaylayın",
+	"authSetNewPasswordResetPassword": "Parolayı sıfırla",
+	"authSetNewPasswordBackTo": "Geri dön",
+	"authPasswordMustBeAtLeast": "En az",
+	"authPasswordCharactersLong": "8 karakter uzunluğunda olmalı",
+	"authPasswordMustContainAtLeast": "En az içermeli",
+	"authPasswordSpecialCharacter": "bir özel karakter",
+	"authPasswordOneNumber": "bir rakam",
+	"authPasswordUpperCharacter": "bir büyük harf",
+	"authPasswordLowerCharacter": "bir küçük harf",
+	"authPasswordConfirmAndPassword": "Onay şifresi ve şifre",
+	"authPasswordMustMatch": "eşleşmelidir",
+	"friendlyError": "Bir şeyler yanlış gitti...",
+	"unknownError": "Bilinmeyen bir hata oluştu",
+	"unauthorized": "Yetkisiz erişim",
+	"authAdminExists": "Yönetici zaten mevcut",
+	"authInviteNotFound": "Davet bulunamadı",
+	"unknownService": "Bilinmeyen servis",
+	"noAuthToken": "Kimlik doğrulama belirteci sağlanmadı",
+	"invalidAuthToken": "Geçersiz kimlik doğrulama belirteci",
+	"expiredAuthToken": "Belirteç süresi doldu",
+	"noRefreshToken": "Yenileme belirteci sağlanmadı",
+	"invalidRefreshToken": "Geçersiz yenileme belirteci",
+	"expiredRefreshToken": "Yenileme belirteci süresi doldu",
+	"requestNewAccessToken": "Yeni erişim belirteci isteyin",
+	"invalidPayload": "Geçersiz veri",
+	"verifyOwnerNotFound": "Belge bulunamadı",
+	"verifyOwnerUnauthorized": "Yetkisiz erişim",
+	"insufficientPermissions": "Yetersiz izinler",
+	"dbUserExists": "Kullanıcı zaten mevcut",
+	"dbUserNotFound": "Kullanıcı bulunamadı",
+	"dbTokenNotFound": "Belirteç bulunamadı",
+	"dbResetPasswordBadMatch": "Yeni şifre eski şifreden farklı olmalıdır",
+	"dbFindMonitorById": "${monitorId} kimlikli monitör bulunamadı",
+	"dbDeleteChecks": "${monitorId} kimlikli monitör için kontrol bulunamadı",
+	"authIncorrectPassword": "Geçersiz parola",
+	"authUnauthorized": "Yetkisiz erişim",
+	"monitorGetById": "Monitör bulunamadı",
+	"monitorGetByUserId": "Kullanıcı için monitör bulunamadı",
+	"jobQueueWorkerClose": "İşçi kapatılırken hata oluştu",
+	"jobQueueDeleteJob": "İş kuyrukta bulunamadı",
+	"jobQueueObliterate": "Kuyruk yok edilirken hata oluştu",
+	"pingCannotResolve": "Yanıt yok",
+	"statusPageNotFound": "Durum sayfası bulunamadı",
+	"statusPageUrlNotUnique": "Durum sayfası URL'si benzersiz olmalıdır",
+	"dockerFail": "Docker konteyner bilgisi alınamadı",
+	"dockerNotFound": "Docker konteyner bulunamadı",
+	"portFail": "Porta bağlanılamadı",
+	"alertCreate": "Uyarı başarıyla oluşturuldu",
+	"alertGetByUser": "Uyarılar başarıyla alındı",
+	"alertGetByMonitor": "Monitöre göre uyarılar başarıyla alındı",
+	"alertGetById": "Kimliğe göre uyarı başarıyla alındı",
+	"alertEdit": "Uyarı başarıyla düzenlendi",
+	"alertDelete": "Uyarı başarıyla silindi",
+	"authCreateUser": "Kullanıcı başarıyla oluşturuldu",
+	"authLoginUser": "Kullanıcı başarıyla giriş yaptı",
+	"authLogoutUser": "Kullanıcı başarıyla çıkış yaptı",
+	"authUpdateUser": "Kullanıcı başarıyla güncellendi",
+	"authCreateRecoveryToken": "Kurtarma belirteci başarıyla oluşturuldu",
+	"authVerifyRecoveryToken": "Kurtarma belirteci başarıyla doğrulandı",
+	"authResetPassword": "Şifre başarıyla sıfırlandı",
+	"authAdminCheck": "Yönetici kontrolü başarıyla tamamlandı",
+	"authDeleteUser": "Kullanıcı başarıyla silindi",
+	"authTokenRefreshed": "Kimlik doğrulama belirteci yenilendi",
+	"authGetAllUsers": "Tüm kullanıcılar başarıyla alındı",
+	"inviteIssued": "Davet başarıyla gönderildi",
+	"inviteVerified": "Davet başarıyla doğrulandı",
+	"checkCreate": "Kontrol başarıyla oluşturuldu",
+	"checkGet": "Kontroller başarıyla alındı",
+	"checkDelete": "Kontroller başarıyla silindi",
+	"checkUpdateTtl": "Kontrol TTL başarıyla güncellendi",
+	"monitorGetAll": "Tüm monitörler başarıyla alındı",
+	"monitorStatsById": "Kimliğe göre monitör istatistikleri başarıyla alındı",
+	"monitorGetByIdSuccess": "Kimliğe göre monitör başarıyla alındı",
+	"monitorGetByTeamId": "Takım kimliğine göre monitörler başarıyla alındı",
+	"monitorGetByUserIdSuccess": "${userId} için monitör başarıyla alındı",
+	"monitorCreate": "Monitör başarıyla oluşturuldu",
+	"monitorDelete": "Monitör başarıyla silindi",
+	"monitorEdit": "Monitör başarıyla düzenlendi",
+	"monitorCertificate": "Monitör sertifikası başarıyla alındı",
+	"monitorDemoAdded": "Demo monitörler başarıyla eklendi",
+	"queueGetMetrics": "Metrikler başarıyla alındı",
+	"queueAddJob": "İş başarıyla eklendi",
+	"queueObliterate": "Kuyruk yok edildi",
+	"jobQueueDeleteJobSuccess": "İş başarıyla kaldırıldı",
+	"jobQueuePauseJob": "İş başarıyla duraklatıldı",
+	"jobQueueResumeJob": "İş başarıyla devam ettirildi",
+	"maintenanceWindowGetById": "Kimliğe göre bakım penceresi başarıyla alındı",
+	"maintenanceWindowCreate": "Bakım penceresi başarıyla oluşturuldu",
+	"maintenanceWindowGetByTeam": "Takıma göre bakım pencereleri başarıyla alındı",
+	"maintenanceWindowDelete": "Bakım penceresi başarıyla silindi",
+	"maintenanceWindowEdit": "Bakım penceresi başarıyla düzenlendi",
+	"pingSuccess": "Başarılı",
+	"getAppSettings": "Uygulama ayarları başarıyla alındı",
+	"updateAppSettings": "Uygulama ayarları başarıyla güncellendi",
+	"statusPageByUrl": "URL'ye göre durum sayfası başarıyla alındı",
+	"statusPageCreate": "Durum sayfası başarıyla oluşturuldu",
+	"dockerSuccess": "Docker konteyner durumu başarıyla alındı",
+	"portSuccess": "Porta başarıyla bağlanıldı",
+	"newTermsAdded": "POEditor'a yeni terimler eklendi",
+	"monitorPause": "Monitör başarıyla duraklatıldı",
+	"monitorResume": "Monitör başarıyla devam ettirildi",
+	"monitorDelete2": ""
+}

server/src/middleware/handleErrors.js

@@ -0,0 +1,22 @@
+import logger from "../utils/logger.js";
+import ServiceRegistry from "../service/system/serviceRegistry.js";
+import StringService from "../service/system/stringService.js";
+
+const handleErrors = (error, req, res, next) => {
+	const status = error.status || 500;
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	const message = error.message || stringService.authIncorrectPassword;
+	const service = error.service || stringService.unknownService;
+	logger.error({
+		message: message,
+		service: service,
+		method: error.method,
+		stack: error.stack,
+	});
+	res.error({
+		status,
+		msg: message,
+	});
+};
+
+export { handleErrors };

server/src/middleware/isAllowed.js

@@ -0,0 +1,57 @@
+import jwt from "jsonwebtoken";
+const TOKEN_PREFIX = "Bearer ";
+const SERVICE_NAME = "allowedRoles";
+import ServiceRegistry from "../service/system/serviceRegistry.js";
+import StringService from "../service/system/stringService.js";
+import SettingsService from "../service/system/settingsService.js";
+
+const isAllowed = (allowedRoles) => {
+	return (req, res, next) => {
+		const token = req.headers["authorization"];
+		const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+		// If no token is pressent, return an error
+		if (!token) {
+			const error = new Error(stringService.noAuthToken);
+			error.status = 401;
+			error.service = SERVICE_NAME;
+			next(error);
+			return;
+		}
+
+		// If the token is improperly formatted, return an error
+		if (!token.startsWith(TOKEN_PREFIX)) {
+			const error = new Error(stringService.invalidAuthToken);
+			error.status = 400;
+			error.service = SERVICE_NAME;
+			next(error);
+			return;
+		}
+		// Parse the token
+		try {
+			const parsedToken = token.slice(TOKEN_PREFIX.length, token.length);
+			const { jwtSecret } = ServiceRegistry.get(SettingsService.SERVICE_NAME).getSettings();
+			var decoded = jwt.verify(parsedToken, jwtSecret);
+			const userRoles = decoded.role;
+
+			// Check if the user has the required role
+			if (userRoles.some((role) => allowedRoles.includes(role))) {
+				next();
+				return;
+			} else {
+				const error = new Error(stringService.insufficientPermissions);
+				error.status = 403;
+				error.service = SERVICE_NAME;
+				next(error);
+				return;
+			}
+		} catch (error) {
+			error.status = 401;
+			error.method = "isAllowed";
+			error.service = SERVICE_NAME;
+			next(error);
+			return;
+		}
+	};
+};
+
+export { isAllowed };

server/src/middleware/languageMiddleware.js

@@ -0,0 +1,27 @@
+import logger from "../utils/logger.js";
+
+const languageMiddleware = (stringService, translationService) => async (req, res, next) => {
+	try {
+		const acceptLanguage = req.headers["accept-language"] || "en";
+		const language = acceptLanguage.split(",")[0].slice(0, 2).toLowerCase();
+
+		translationService.setLanguage(language);
+		stringService.setLanguage(language);
+
+		next();
+	} catch (error) {
+		logger.error({
+			message: error.message,
+			service: "languageMiddleware",
+		});
+		const acceptLanguage = req.headers["accept-language"] || "en";
+		const language = acceptLanguage.split(",")[0].slice(0, 2).toLowerCase();
+
+		translationService.setLanguage(language);
+		stringService.setLanguage(language);
+
+		next();
+	}
+};
+
+export default languageMiddleware;

server/src/middleware/responseHandler.js

@@ -0,0 +1,66 @@
+/**
+ * Middleware that adds standardized response methods to the Express response object.
+ * This allows for consistent API responses throughout the application.
+ *
+ * @param {import('express').Request} req - Express request object
+ * @param {import('express').Response} res - Express response object
+ * @param {import('express').NextFunction} next - Express next middleware function
+ */
+const responseHandler = (req, res, next) => {
+	/**
+	 * Sends a standardized success response
+	 *
+	 * @param {Object} options - Success response options
+	 * @param {number} [options.status=200] - HTTP status code
+	 * @param {string} [options.msg="OK"] - Success message
+	 * @param {*} [options.data=null] - Response data payload
+	 * @returns {Object} Express response object
+	 */
+	res.success = ({ status = 200, msg = "OK", data = null, headers = {} }) => {
+		// Set custom headers if provided
+		Object.entries(headers).forEach(([key, value]) => {
+			res.set(key, value);
+		});
+
+		return res.status(status).json({
+			success: true,
+			msg: msg,
+			data: data,
+		});
+	};
+
+	/**
+	 * Sends a standardized error response
+	 *
+	 * @param {Object} options - Error response options
+	 * @param {number} [options.status=500] - HTTP status code
+	 * @param {string} [options.msg="Internal server error"] - Error message
+	 * @param {*} [options.data=null] - Additional error data (if any)
+	 * @returns {Object} Express response object
+	 */
+	res.error = ({ status = 500, msg = "Internal server error", data = null }) => {
+		return res.status(status).json({
+			success: false,
+			msg,
+			data,
+		});
+	};
+
+	/**
+	 * Sends a raw file response (for CSV, PDF, etc.)
+	 * @param {Object} options
+	 * @param {Buffer|string} options.data - The file content
+	 * @param {Object} options.headers - Headers to set (e.g. Content-Type, Content-Disposition)
+	 * @param {number} [options.status=200] - HTTP status code
+	 */
+	res.file = ({ data, headers = {}, status = 200 }) => {
+		Object.entries(headers).forEach(([key, value]) => {
+			res.setHeader(key, value);
+		});
+		return res.status(status).send(data);
+	};
+
+	next();
+};
+
+export { responseHandler };

server/src/middleware/verifyJWT.js

@@ -0,0 +1,57 @@
+import jwt from "jsonwebtoken";
+import ServiceRegistry from "../service/system/serviceRegistry.js";
+import SettingsService from "../service/system/settingsService.js";
+import StringService from "../service/system/stringService.js";
+const SERVICE_NAME = "verifyJWT";
+const TOKEN_PREFIX = "Bearer ";
+
+/**
+ * Verifies the JWT token
+ * @function
+ * @param {express.Request} req
+ * @param {express.Response} res
+ * @param {express.NextFunction} next
+ * @returns {express.Response}
+ */
+const verifyJWT = (req, res, next) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	const token = req.headers["authorization"];
+	// Make sure a token is provided
+	if (!token) {
+		const error = new Error(stringService.noAuthToken);
+		error.status = 401;
+		error.service = SERVICE_NAME;
+		next(error);
+		return;
+	}
+	// Make sure it is properly formatted
+	if (!token.startsWith(TOKEN_PREFIX)) {
+		const error = new Error(stringService.invalidAuthToken); // Instantiate a new Error object for improperly formatted token
+		error.status = 401;
+		error.service = SERVICE_NAME;
+		error.method = "verifyJWT";
+		next(error);
+		return;
+	}
+
+	const parsedToken = token.slice(TOKEN_PREFIX.length, token.length);
+	// Verify the token's authenticity
+	const { jwtSecret } = ServiceRegistry.get(SettingsService.SERVICE_NAME).getSettings();
+	jwt.verify(parsedToken, jwtSecret, (err, decoded) => {
+		if (err) {
+			const errorMessage = err.name === "TokenExpiredError" ? stringService.expiredAuthToken : stringService.invalidAuthToken;
+			err.details = { msg: errorMessage };
+			err.status = 401;
+			err.service = SERVICE_NAME;
+			err.method = "verifyJWT";
+			next(err);
+			return;
+		} else {
+			// Token is valid, carry on
+			req.user = decoded;
+			next();
+		}
+	});
+};
+
+export { verifyJWT };

server/src/middleware/verifyOwnership.js

@@ -0,0 +1,59 @@
+import logger from "../utils/logger.js";
+import ServiceRegistry from "../service/system/serviceRegistry.js";
+import StringService from "../service/system/stringService.js";
+import { ObjectId } from "mongodb";
+
+const SERVICE_NAME = "verifyOwnership";
+
+const verifyOwnership = (Model, paramName) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	return async (req, res, next) => {
+		const userId = req.user._id;
+		let documentId = req.params[paramName];
+
+		try {
+			if (typeof documentId === "string") {
+				documentId = ObjectId.createFromHexString(documentId);
+			}
+			const doc = await Model.findById(documentId);
+			//If the document is not found, return a 404 error
+			if (!doc) {
+				logger.error({
+					message: stringService.verifyOwnerNotFound,
+					service: SERVICE_NAME,
+					method: "verifyOwnership",
+				});
+				const error = new Error(stringService.verifyOwnerNotFound);
+				error.status = 404;
+				throw error;
+			}
+
+			// Special case for User model, as it will not have a `userId` field as other docs will
+			if (Model.modelName === "User") {
+				if (userId.toString() !== doc._id.toString()) {
+					const error = new Error(stringService.verifyOwnerUnauthorized);
+					error.status = 403;
+					throw error;
+				}
+				next();
+				return;
+			}
+
+			// If the userID does not match the document's userID, return a 403 error
+			if (userId.toString() !== doc.userId.toString()) {
+				const error = new Error("Unauthorized");
+				error.status = 403;
+				throw error;
+			}
+			next();
+			return;
+		} catch (error) {
+			error.service = SERVICE_NAME;
+			error.method = "verifyOwnership";
+			next(error);
+			return;
+		}
+	};
+};
+
+export { verifyOwnership };

server/src/middleware/verifySuperAdmin.js

@@ -0,0 +1,66 @@
+const jwt = require("jsonwebtoken");
+const logger = require("../utils/logger");
+const SERVICE_NAME = "verifyAdmin";
+const TOKEN_PREFIX = "Bearer ";
+import ServiceRegistry from "../service/serviceRegistry.js";
+import SettingsService from "../service/settingsService.js";
+import StringService from "../service/stringService.js";
+/**
+ * Verifies the JWT token
+ * @function
+ * @param {express.Request} req
+ * @param {express.Response} res
+ * @param {express.NextFunction} next
+ * @returns {express.Response}
+ */
+const verifySuperAdmin = (req, res, next) => {
+	const stringService = ServiceRegistry.get(StringService.SERVICE_NAME);
+	const token = req.headers["authorization"];
+	// Make sure a token is provided
+	if (!token) {
+		const error = new Error(stringService.noAuthToken);
+		error.status = 401;
+		error.service = SERVICE_NAME;
+		next(error);
+		return;
+	}
+	// Make sure it is properly formatted
+	if (!token.startsWith(TOKEN_PREFIX)) {
+		const error = new Error(stringService.invalidAuthToken); // Instantiate a new Error object for improperly formatted token
+		error.status = 400;
+		error.service = SERVICE_NAME;
+		error.method = "verifySuperAdmin";
+		next(error);
+		return;
+	}
+
+	const parsedToken = token.slice(TOKEN_PREFIX.length, token.length);
+	// verify admin role is present
+	const { jwtSecret } = ServiceRegistry.get(SettingsService.SERVICE_NAME).getSettings();
+
+	jwt.verify(parsedToken, jwtSecret, (err, decoded) => {
+		if (err) {
+			logger.error({
+				message: err.message,
+				service: SERVICE_NAME,
+				method: "verifySuperAdmin",
+				stack: err.stack,
+				details: stringService.invalidAuthToken,
+			});
+			return res.status(401).json({ success: false, msg: stringService.invalidAuthToken });
+		}
+
+		if (decoded.role.includes("superadmin") === false) {
+			logger.error({
+				message: stringService.invalidAuthToken,
+				service: SERVICE_NAME,
+				method: "verifySuperAdmin",
+				stack: err.stack,
+			});
+			return res.status(401).json({ success: false, msg: stringService.unauthorized });
+		}
+		next();
+	});
+};
+
+module.exports = { verifySuperAdmin };

server/src/middleware/verifyTeamAccess.js

@@ -0,0 +1,38 @@
+const SERVICE_NAME = "verifyTeamAccess";
+
+const verifyTeamAccess = (Model, paramName) => {
+	return async (req, res, next) => {
+		try {
+			const documentId = req.params[paramName];
+			const doc = await Model.findById(documentId);
+
+			if (!doc) {
+				const error = new Error("Document not found");
+				error.status = 404;
+				throw error;
+			}
+
+			if (!req?.user?.teamId || !doc.teamId) {
+				const error = new Error("Missing team information");
+				error.status = 400;
+				throw error;
+			}
+
+			if (req.user.teamId.toString() === doc.teamId.toString()) {
+				next();
+				return;
+			}
+
+			const error = new Error("Unauthorized");
+			error.status = 403;
+			throw error;
+		} catch (error) {
+			error.service = SERVICE_NAME;
+			error.method = "verifyTeamAccess";
+			next(error);
+			return;
+		}
+	};
+};
+
+export { verifyTeamAccess };

server/src/routes/announcementsRoute.js

@@ -0,0 +1,33 @@
+import { Router } from "express";
+import { verifyJWT } from "../middleware/verifyJWT.js";
+import { isAllowed } from "../middleware/isAllowed.js";
+
+class AnnouncementRoutes {
+	constructor(controller) {
+		this.router = Router();
+		this.announcementController = controller;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		/**
+		 * @route   POST /
+		 * @desc    Create a new announcement
+		 * @access  Private (Requires JWT verification)
+		 */
+		this.router.post("/", verifyJWT, isAllowed(["admin", "superadmin"]), this.announcementController.createAnnouncement);
+
+		/**
+		 * @route   GET /
+		 * @desc    Get announcements
+		 * @access  Public
+		 */
+		this.router.get("/", this.announcementController.getAnnouncement);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default AnnouncementRoutes;

server/src/routes/authRoute.js

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

server/src/routes/checkRoute.js

@@ -0,0 +1,34 @@
+import { Router } from "express";
+import { verifyOwnership } from "../middleware/verifyOwnership.js";
+import { verifyTeamAccess } from "../middleware/verifyTeamAccess.js";
+import { isAllowed } from "../middleware/isAllowed.js";
+import Monitor from "../db/models/Monitor.js";
+import Check from "../db/models/Check.js";
+
+class CheckRoutes {
+	constructor(checkController) {
+		this.router = Router();
+		this.checkController = checkController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		this.router.get("/team/summary", this.checkController.getChecksSummaryByTeamId);
+		this.router.get("/team", this.checkController.getChecksByTeam);
+		this.router.put("/team/ttl", isAllowed(["admin", "superadmin"]), this.checkController.updateChecksTTL);
+		this.router.delete("/team", isAllowed(["admin", "superadmin"]), this.checkController.deleteChecksByTeamId);
+
+		this.router.put("/check/:checkId", this.checkController.ackCheck);
+
+		this.router.get("/:monitorId", this.checkController.getChecksByMonitor);
+		this.router.delete("/:monitorId", this.checkController.deleteChecks);
+
+		this.router.put("/:path/:monitorId?", this.checkController.ackAllChecks);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default CheckRoutes;

server/src/routes/diagnosticRoute.js

@@ -0,0 +1,20 @@
+import { Router } from "express";
+import { verifyJWT } from "../middleware/verifyJWT.js";
+import { isAllowed } from "../middleware/isAllowed.js";
+
+class DiagnosticRoutes {
+	constructor(diagnosticController) {
+		this.router = Router();
+		this.diagnosticController = diagnosticController;
+		this.initRoutes();
+	}
+	initRoutes() {
+		this.router.get("/system", verifyJWT, isAllowed(["admin", "superadmin"]), this.diagnosticController.getSystemStats);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default DiagnosticRoutes;

server/src/routes/inviteRoute.js

@@ -0,0 +1,23 @@
+import { Router } from "express";
+import { verifyJWT } from "../middleware/verifyJWT.js";
+import { isAllowed } from "../middleware/isAllowed.js";
+
+class InviteRoutes {
+	constructor(inviteController) {
+		this.router = Router();
+		this.inviteController = inviteController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		this.router.post("/send", verifyJWT, isAllowed(["admin", "superadmin"]), this.inviteController.sendInviteEmail);
+		this.router.post("/verify", this.inviteController.verifyInviteToken);
+		this.router.post("/", verifyJWT, isAllowed(["admin", "superadmin"]), this.inviteController.getInviteToken);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default InviteRoutes;

server/src/routes/logRoutes.js

@@ -0,0 +1,18 @@
+import { Router } from "express";
+import { isAllowed } from "../middleware/isAllowed.js";
+class LogRoutes {
+	constructor(logController) {
+		this.router = Router();
+		this.logController = logController;
+		this.initRoutes();
+	}
+	initRoutes() {
+		this.router.get("/", isAllowed(["admin", "superadmin"]), this.logController.getLogs);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default LogRoutes;

server/src/routes/maintenanceWindowRoute.js

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

server/src/routes/monitorRoute.js

@@ -0,0 +1,59 @@
+import { Router } from "express";
+import { isAllowed } from "../middleware/isAllowed.js";
+import multer from "multer";
+import { fetchMonitorCertificate } from "../controllers/controllerUtils.js";
+const upload = multer({
+	storage: multer.memoryStorage(), // Store file in memory as Buffer
+});
+
+class MonitorRoutes {
+	constructor(monitorController) {
+		this.router = Router();
+		this.monitorController = monitorController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		// Team routes
+		this.router.get("/team", this.monitorController.getMonitorsByTeamId);
+		this.router.get("/team/with-checks", this.monitorController.getMonitorsWithChecksByTeamId);
+		this.router.get("/team/summary", this.monitorController.getMonitorsAndSummaryByTeamId);
+
+		// Uptime routes
+		this.router.get("/uptime/details/:monitorId", this.monitorController.getUptimeDetailsById);
+
+		// Hardware routes
+		this.router.get("/hardware/details/:monitorId", this.monitorController.getHardwareDetailsById);
+
+		// General monitor routes
+		this.router.post("/pause/:monitorId", isAllowed(["admin", "superadmin"]), this.monitorController.pauseMonitor);
+		this.router.get("/stats/:monitorId", this.monitorController.getMonitorStatsById);
+
+		// Util routes
+		this.router.get("/certificate/:monitorId", (req, res, next) => {
+			this.monitorController.getMonitorCertificate(req, res, next, fetchMonitorCertificate);
+		});
+
+		// General monitor CRUD routes
+		this.router.get("/", this.monitorController.getAllMonitors);
+		this.router.post("/", isAllowed(["admin", "superadmin"]), this.monitorController.createMonitor);
+		this.router.delete("/", isAllowed(["superadmin"]), this.monitorController.deleteAllMonitors);
+
+		// Other static routes
+		this.router.post("/demo", isAllowed(["admin", "superadmin"]), this.monitorController.addDemoMonitors);
+		this.router.get("/export", isAllowed(["admin", "superadmin"]), this.monitorController.exportMonitorsToCSV);
+		this.router.post("/bulk", isAllowed(["admin", "superadmin"]), upload.single("csvFile"), this.monitorController.createBulkMonitors);
+		this.router.post("/test-email", isAllowed(["admin", "superadmin"]), this.monitorController.sendTestEmail);
+
+		// Individual monitor CRUD routes
+		this.router.get("/:monitorId", this.monitorController.getMonitorById);
+		this.router.put("/:monitorId", isAllowed(["admin", "superadmin"]), this.monitorController.editMonitor);
+		this.router.delete("/:monitorId", isAllowed(["admin", "superadmin"]), this.monitorController.deleteMonitor);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default MonitorRoutes;

server/src/routes/notificationRoute.js

@@ -0,0 +1,27 @@
+import { Router } from "express";
+class NotificationRoutes {
+	constructor(notificationController) {
+		this.router = Router();
+		this.notificationController = notificationController;
+		this.initializeRoutes();
+	}
+
+	initializeRoutes() {
+		this.router.post("/", this.notificationController.createNotification);
+
+		this.router.post("/test/all", this.notificationController.testAllNotifications);
+		this.router.post("/test", this.notificationController.testNotification);
+
+		this.router.get("/team", this.notificationController.getNotificationsByTeamId);
+
+		this.router.get("/:id", this.notificationController.getNotificationById);
+		this.router.delete("/:id", this.notificationController.deleteNotification);
+		this.router.put("/:id", this.notificationController.editNotification);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default NotificationRoutes;

server/src/routes/queueRoute.js

@@ -0,0 +1,24 @@
+import { Router } from "express";
+import { isAllowed } from "../middleware/isAllowed.js";
+class QueueRoutes {
+	constructor(queueController) {
+		this.router = Router();
+		this.queueController = queueController;
+		this.initRoutes();
+	}
+	initRoutes() {
+		this.router.get("/jobs", isAllowed(["admin", "superadmin"]), this.queueController.getJobs);
+		this.router.post("/jobs", isAllowed(["admin", "superadmin"]), this.queueController.addJob);
+
+		this.router.get("/metrics", isAllowed(["admin", "superadmin"]), this.queueController.getMetrics);
+		this.router.get("/health", isAllowed(["admin", "superadmin"]), this.queueController.checkQueueHealth);
+		this.router.get("/all-metrics", isAllowed(["admin", "superadmin"]), this.queueController.getAllMetrics);
+		this.router.post("/flush", isAllowed(["admin", "superadmin"]), this.queueController.flushQueue);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default QueueRoutes;

server/src/routes/settingsRoute.js

@@ -0,0 +1,22 @@
+import { Router } from "express";
+import { isAllowed } from "../middleware/isAllowed.js";
+
+class SettingsRoutes {
+	constructor(settingsController) {
+		this.router = Router();
+		this.settingsController = settingsController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		this.router.get("/", this.settingsController.getAppSettings);
+		this.router.put("/", isAllowed(["admin", "superadmin"]), this.settingsController.updateAppSettings);
+		this.router.post("/test-email", isAllowed(["admin", "superadmin"]), this.settingsController.sendTestEmail);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default SettingsRoutes;

server/src/routes/statusPageRoute.js

@@ -0,0 +1,29 @@
+import { Router } from "express";
+import { verifyJWT } from "../middleware/verifyJWT.js";
+import multer from "multer";
+const upload = multer();
+
+class StatusPageRoutes {
+	constructor(statusPageController) {
+		this.router = Router();
+		this.statusPageController = statusPageController;
+		this.initRoutes();
+	}
+
+	initRoutes() {
+		this.router.get("/", this.statusPageController.getStatusPage);
+		this.router.get("/team", verifyJWT, this.statusPageController.getStatusPagesByTeamId);
+
+		this.router.post("/", upload.single("logo"), verifyJWT, this.statusPageController.createStatusPage);
+		this.router.put("/", upload.single("logo"), verifyJWT, this.statusPageController.updateStatusPage);
+
+		this.router.get("/:url", this.statusPageController.getStatusPageByUrl);
+		this.router.delete("/:url(*)", verifyJWT, this.statusPageController.deleteStatusPage);
+	}
+
+	getRouter() {
+		return this.router;
+	}
+}
+
+export default StatusPageRoutes;

server/src/service/business/checkService.js

@@ -0,0 +1,150 @@
+const SERVICE_NAME = "checkService";
+
+class CheckService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, settingsService, stringService, errorService }) {
+		this.db = db;
+		this.settingsService = settingsService;
+		this.stringService = stringService;
+		this.errorService = errorService;
+	}
+
+	get serviceName() {
+		return CheckService.SERVICE_NAME;
+	}
+
+	getChecksByMonitor = async ({ monitorId, query, teamId }) => {
+		if (!monitorId) {
+			throw this.errorService.createBadRequestError("No monitor ID in request");
+		}
+
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const monitor = await this.db.getMonitorById(monitorId);
+
+		if (!monitor) {
+			throw this.errorService.createNotFoundError("Monitor not found");
+		}
+
+		if (!monitor.teamId.equals(teamId)) {
+			throw this.errorService.createAuthorizationError();
+		}
+
+		let { type, sortOrder, dateRange, filter, ack, page, rowsPerPage, status } = query;
+		const result = await this.db.getChecksByMonitor({
+			monitorId,
+			type,
+			sortOrder,
+			dateRange,
+			filter,
+			ack,
+			page,
+			rowsPerPage,
+			status,
+		});
+		return result;
+	};
+
+	getChecksByTeam = async ({ teamId, query }) => {
+		let { sortOrder, dateRange, filter, ack, page, rowsPerPage } = query;
+
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const checkData = await this.db.getChecksByTeam({
+			sortOrder,
+			dateRange,
+			filter,
+			ack,
+			page,
+			rowsPerPage,
+			teamId,
+		});
+		return checkData;
+	};
+
+	getChecksSummaryByTeamId = async ({ teamId }) => {
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const summary = await this.db.getChecksSummaryByTeamId({ teamId });
+		return summary;
+	};
+
+	ackCheck = async ({ checkId, teamId, ack }) => {
+		if (!checkId) {
+			throw this.errorService.createBadRequestError("No check ID in request");
+		}
+
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const updatedCheck = await this.db.ackCheck(checkId, teamId, ack);
+		return updatedCheck;
+	};
+
+	ackAllChecks = async ({ monitorId, path, teamId, ack }) => {
+		if (path === "monitor") {
+			if (!monitorId) {
+				throw this.errorService.createBadRequestError("No monitor ID in request");
+			}
+
+			const monitor = await this.db.getMonitorById(monitorId);
+			if (!monitor) {
+				throw this.errorService.createNotFoundError("Monitor not found");
+			}
+
+			if (!monitor.teamId.equals(teamId)) {
+				throw this.errorService.createAuthorizationError();
+			}
+		}
+
+		const updatedChecks = await this.db.ackAllChecks(monitorId, teamId, ack, path);
+		return updatedChecks;
+	};
+
+	deleteChecks = async ({ monitorId, teamId }) => {
+		if (!monitorId) {
+			throw this.errorService.createBadRequestError("No monitor ID in request");
+		}
+
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const monitor = await this.db.getMonitorById(monitorId);
+
+		if (!monitor) {
+			throw this.errorService.createNotFoundError("Monitor not found");
+		}
+
+		if (!monitor.teamId.equals(teamId)) {
+			throw this.errorService.createAuthorizationError();
+		}
+
+		const deletedCount = await this.db.deleteChecks(monitorId);
+		return deletedCount;
+	};
+	deleteChecksByTeamId = async ({ teamId }) => {
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		const deletedCount = await this.db.deleteChecksByTeamId(teamId);
+		return deletedCount;
+	};
+
+	updateChecksTTL = async ({ teamId, ttl }) => {
+		const SECONDS_PER_DAY = 86400;
+		const newTTL = parseInt(ttl, 10) * SECONDS_PER_DAY;
+		await this.db.updateChecksTTL(teamId, newTTL);
+	};
+}
+
+export default CheckService;

server/src/service/business/diagnosticService.js

@@ -0,0 +1,94 @@
+import v8 from "v8";
+import os from "os";
+
+const SERVICE_NAME = "diagnosticService";
+
+class DiagnosticService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor() {
+		/**
+		 * Performance Observer for monitoring system performance metrics.
+		 * Clears performance marks after each measurement to prevent memory leaks.
+		 */
+		const obs = new PerformanceObserver((items) => {
+			// Get the first entry but we don't need to store it
+			items.getEntries()[0];
+			performance.clearMarks();
+		});
+		obs.observe({ entryTypes: ["measure"] });
+	}
+
+	get serviceName() {
+		return DiagnosticService.SERVICE_NAME;
+	}
+
+	getCPUUsage = async () => {
+		const startUsage = process.cpuUsage();
+		const timingPeriod = 1000; // measured in ms
+		await new Promise((resolve) => setTimeout(resolve, timingPeriod));
+		const endUsage = process.cpuUsage(startUsage);
+		const cpuUsage = {
+			userUsageMs: endUsage.user / 1000,
+			systemUsageMs: endUsage.system / 1000,
+			usagePercentage: ((endUsage.user + endUsage.system) / 1000 / timingPeriod) * 100,
+		};
+		return cpuUsage;
+	};
+
+	getSystemStats = async () => {
+		// Memory Usage
+		const totalMemory = os.totalmem();
+		const freeMemory = os.freemem();
+
+		const osStats = {
+			freeMemoryBytes: freeMemory, // bytes
+			totalMemoryBytes: totalMemory, // bytes
+		};
+
+		const used = process.memoryUsage();
+		const memoryUsage = {};
+		for (let key in used) {
+			memoryUsage[`${key}Mb`] = Math.round((used[key] / 1024 / 1024) * 100) / 100; // MB
+		}
+
+		// CPU Usage
+		const cpuMetrics = await this.getCPUUsage();
+
+		// V8 Heap Statistics
+		const heapStats = v8.getHeapStatistics();
+		const v8Metrics = {
+			totalHeapSizeBytes: heapStats.total_heap_size, // bytes
+			usedHeapSizeBytes: heapStats.used_heap_size, // bytes
+			heapSizeLimitBytes: heapStats.heap_size_limit, // bytes
+		};
+
+		// Event Loop Delay
+		let eventLoopDelay = 0;
+		performance.mark("start");
+		await new Promise((resolve) => setTimeout(resolve, 0));
+		performance.mark("end");
+		performance.measure("eventLoopDelay", "start", "end");
+		const entries = performance.getEntriesByName("eventLoopDelay");
+		if (entries.length > 0) {
+			eventLoopDelay = entries[0].duration;
+		}
+
+		// Uptime
+		const uptimeMs = process.uptime() * 1000; // ms
+
+		// Combine Metrics
+		const diagnostics = {
+			osStats,
+			memoryUsage,
+			cpuUsage: cpuMetrics,
+			v8HeapStats: v8Metrics,
+			eventLoopDelayMs: eventLoopDelay,
+			uptimeMs,
+		};
+
+		return diagnostics;
+	};
+}
+
+export default DiagnosticService;

server/src/service/business/inviteService.js

@@ -0,0 +1,44 @@
+const SERVICE_NAME = "inviteService";
+
+class InviteService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, settingsService, emailService, stringService, errorService }) {
+		this.db = db;
+		this.settingsService = settingsService;
+		this.emailService = emailService;
+		this.stringService = stringService;
+		this.errorService = errorService;
+	}
+
+	get serviceName() {
+		return InviteService.SERVICE_NAME;
+	}
+
+	getInviteToken = async ({ invite, teamId }) => {
+		invite.teamId = teamId;
+		const inviteToken = await this.db.requestInviteToken(invite);
+		return inviteToken;
+	};
+
+	sendInviteEmail = async ({ inviteRequest, firstName }) => {
+		const inviteToken = await this.db.requestInviteToken({ ...inviteRequest });
+		const { clientHost } = this.settingsService.getSettings();
+
+		const html = await this.emailService.buildEmail("employeeActivationTemplate", {
+			name: firstName,
+			link: `${clientHost}/register/${inviteToken.token}`,
+		});
+		const result = await this.emailService.sendEmail(inviteRequest.email, "Welcome to Uptime Monitor", html);
+		if (!result) {
+			throw this.errorService.createServerError("Failed to send invite e-mail... Please verify your settings.");
+		}
+	};
+
+	verifyInviteToken = async ({ inviteToken }) => {
+		const invite = await this.db.getInviteToken(inviteToken);
+		return invite;
+	};
+}
+
+export default InviteService;

server/src/service/business/maintenanceWindowService.js

@@ -0,0 +1,66 @@
+const SERVICE_NAME = "maintenanceWindowService";
+
+class MaintenanceWindowService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, settingsService, stringService, errorService }) {
+		this.db = db;
+		this.settingsService = settingsService;
+		this.stringService = stringService;
+		this.errorService = errorService;
+	}
+
+	get serviceName() {
+		return MaintenanceWindowService.SERVICE_NAME;
+	}
+
+	createMaintenanceWindow = async ({ teamId, body }) => {
+		const monitorIds = body.monitors;
+		const monitors = await this.db.getMonitorsByIds(monitorIds);
+
+		const unauthorizedMonitors = monitors.filter((monitor) => !monitor.teamId.equals(teamId));
+
+		if (unauthorizedMonitors.length > 0) {
+			throw this.errorService.createAuthorizationError();
+		}
+
+		const dbTransactions = monitorIds.map((monitorId) => {
+			return this.db.createMaintenanceWindow({
+				teamId,
+				monitorId,
+				name: body.name,
+				active: body.active ? body.active : true,
+				repeat: body.repeat,
+				start: body.start,
+				end: body.end,
+			});
+		});
+		await Promise.all(dbTransactions);
+	};
+
+	getMaintenanceWindowById = async ({ id, teamId }) => {
+		const maintenanceWindow = await this.db.getMaintenanceWindowById({ id, teamId });
+		return maintenanceWindow;
+	};
+
+	getMaintenanceWindowsByTeamId = async ({ teamId, query }) => {
+		const maintenanceWindows = await this.db.getMaintenanceWindowsByTeamId(teamId, query);
+		return maintenanceWindows;
+	};
+
+	getMaintenanceWindowsByMonitorId = async ({ monitorId, teamId }) => {
+		const maintenanceWindows = await this.db.getMaintenanceWindowsByMonitorId({ monitorId, teamId });
+		return maintenanceWindows;
+	};
+
+	deleteMaintenanceWindow = async ({ id, teamId }) => {
+		await this.db.deleteMaintenanceWindowById({ id, teamId });
+	};
+
+	editMaintenanceWindow = async ({ id, teamId, body }) => {
+		const editedMaintenanceWindow = await this.db.editMaintenanceWindowById({ id, body, teamId });
+		return editedMaintenanceWindow;
+	};
+}
+
+export default MaintenanceWindowService;

server/src/service/business/monitorService.js

@@ -0,0 +1,266 @@
+import { createMonitorsBodyValidation } from "../../validation/joi.js";
+
+const SERVICE_NAME = "MonitorService";
+class MonitorService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, settingsService, jobQueue, stringService, emailService, papaparse, logger, errorService }) {
+		this.db = db;
+		this.settingsService = settingsService;
+		this.jobQueue = jobQueue;
+		this.stringService = stringService;
+		this.emailService = emailService;
+		this.papaparse = papaparse;
+		this.logger = logger;
+		this.errorService = errorService;
+	}
+
+	get serviceName() {
+		return MonitorService.SERVICE_NAME;
+	}
+
+	verifyTeamAccess = async ({ teamId, monitorId }) => {
+		const monitor = await this.db.getMonitorById(monitorId);
+		if (!monitor?.teamId?.equals(teamId)) {
+			throw this.errorService.createAuthorizationError();
+		}
+	};
+
+	getAllMonitors = async () => {
+		const monitors = await this.db.getAllMonitors();
+		return monitors;
+	};
+
+	getUptimeDetailsById = async ({ teamId, monitorId, dateRange, normalize }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const data = await this.db.getUptimeDetailsById({
+			monitorId,
+			dateRange,
+			normalize,
+		});
+
+		return data;
+	};
+
+	getMonitorStatsById = async ({ teamId, monitorId, limit, sortOrder, dateRange, numToDisplay, normalize }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const monitorStats = await this.db.getMonitorStatsById({
+			monitorId,
+			limit,
+			sortOrder,
+			dateRange,
+			numToDisplay,
+			normalize,
+		});
+
+		return monitorStats;
+	};
+
+	getHardwareDetailsById = async ({ teamId, monitorId, dateRange }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const monitor = await this.db.getHardwareDetailsById({ monitorId, dateRange });
+
+		return monitor;
+	};
+
+	getMonitorById = async ({ teamId, monitorId }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const monitor = await this.db.getMonitorById(monitorId);
+
+		return monitor;
+	};
+
+	createMonitor = async ({ teamId, userId, body }) => {
+		const monitor = await this.db.createMonitor({
+			body,
+			teamId,
+			userId,
+		});
+
+		this.jobQueue.addJob(monitor._id, monitor);
+	};
+
+	createBulkMonitors = async ({ fileData, userId, teamId }) => {
+		const { parse } = this.papaparse;
+
+		return new Promise((resolve, reject) => {
+			parse(fileData, {
+				header: true,
+				skipEmptyLines: true,
+				transform: (value, header) => {
+					if (value === "") return undefined; // Empty fields become undefined
+
+					// Handle 'port' and 'interval' fields, check if they're valid numbers
+					if (["port", "interval"].includes(header)) {
+						const num = parseInt(value, 10);
+						if (isNaN(num)) {
+							throw this.errorService.createBadRequestError(`${header} should be a valid number, got: ${value}`);
+						}
+						return num;
+					}
+
+					return value;
+				},
+				complete: async ({ data, errors }) => {
+					try {
+						if (errors.length > 0) {
+							throw this.errorService.createServerError("Error parsing CSV");
+						}
+
+						if (!data || data.length === 0) {
+							throw this.errorService.createServerError("CSV file contains no data rows");
+						}
+
+						const enrichedData = data.map((monitor) => ({
+							userId,
+							teamId,
+							...monitor,
+							description: monitor.description || monitor.name || monitor.url,
+							name: monitor.name || monitor.url,
+							type: monitor.type || "http",
+						}));
+
+						await createMonitorsBodyValidation.validateAsync(enrichedData);
+
+						const monitors = await this.db.createBulkMonitors(enrichedData);
+
+						await Promise.all(
+							monitors.map(async (monitor) => {
+								this.jobQueue.addJob(monitor._id, monitor);
+							})
+						);
+
+						resolve(monitors);
+					} catch (error) {
+						reject(error);
+					}
+				},
+			});
+		});
+	};
+
+	deleteMonitor = async ({ teamId, monitorId }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const monitor = await this.db.deleteMonitor({ teamId, monitorId });
+		await this.jobQueue.deleteJob(monitor);
+		await this.db.deleteStatusPagesByMonitorId(monitor._id);
+		return monitor;
+	};
+
+	deleteAllMonitors = async ({ teamId }) => {
+		const { monitors, deletedCount } = await this.db.deleteAllMonitors(teamId);
+		await Promise.all(
+			monitors.map(async (monitor) => {
+				try {
+					await this.jobQueue.deleteJob(monitor);
+					await this.db.deleteChecks(monitor._id);
+					await this.db.deletePageSpeedChecksByMonitorId(monitor._id);
+					await this.db.deleteNotificationsByMonitorId(monitor._id);
+				} catch (error) {
+					this.logger.warn({
+						message: `Error deleting associated records for monitor ${monitor._id} with name ${monitor.name}`,
+						service: SERVICE_NAME,
+						method: "deleteAllMonitors",
+						stack: error.stack,
+					});
+				}
+			})
+		);
+		return deletedCount;
+	};
+
+	editMonitor = async ({ teamId, monitorId, body }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const editedMonitor = await this.db.editMonitor({ monitorId, body });
+		await this.jobQueue.updateJob(editedMonitor);
+	};
+
+	pauseMonitor = async ({ teamId, monitorId }) => {
+		await this.verifyTeamAccess({ teamId, monitorId });
+		const monitor = await this.db.pauseMonitor({ monitorId });
+		monitor.isActive === true ? await this.jobQueue.resumeJob(monitor._id, monitor) : await this.jobQueue.pauseJob(monitor);
+		return monitor;
+	};
+
+	addDemoMonitors = async ({ userId, teamId }) => {
+		const demoMonitors = await this.db.addDemoMonitors(userId, teamId);
+		await Promise.all(demoMonitors.map((monitor) => this.jobQueue.addJob(monitor._id, monitor)));
+		return demoMonitors;
+	};
+
+	sendTestEmail = async ({ to }) => {
+		const subject = this.stringService.testEmailSubject;
+		const context = { testName: "Monitoring System" };
+
+		const html = await this.emailService.buildEmail("testEmailTemplate", context);
+		const messageId = await this.emailService.sendEmail(to, subject, html);
+
+		if (!messageId) {
+			throw this.errorService.createServerError("Failed to send test email.");
+		}
+
+		return messageId;
+	};
+
+	getMonitorsByTeamId = async ({ teamId, limit, type, page, rowsPerPage, filter, field, order }) => {
+		const monitors = await this.db.getMonitorsByTeamId({
+			limit,
+			type,
+			page,
+			rowsPerPage,
+			filter,
+			field,
+			order,
+			teamId,
+		});
+		return monitors;
+	};
+
+	getMonitorsAndSummaryByTeamId = async ({ teamId, type, explain }) => {
+		const result = await this.db.getMonitorsAndSummaryByTeamId({
+			type,
+			explain,
+			teamId,
+		});
+		return result;
+	};
+
+	getMonitorsWithChecksByTeamId = async ({ teamId, limit, type, page, rowsPerPage, filter, field, order, explain }) => {
+		const result = await this.db.getMonitorsWithChecksByTeamId({
+			limit,
+			type,
+			page,
+			rowsPerPage,
+			filter,
+			field,
+			order,
+			teamId,
+			explain,
+		});
+		return result;
+	};
+
+	exportMonitorsToCSV = async ({ teamId }) => {
+		const monitors = await this.db.getMonitorsByTeamId({ teamId });
+
+		if (!monitors || monitors.length === 0) {
+			throw this.errorService.createNotFoundError("No monitors to export");
+		}
+
+		const csvData = monitors?.filteredMonitors?.map((monitor) => ({
+			name: monitor.name,
+			description: monitor.description,
+			type: monitor.type,
+			url: monitor.url,
+			interval: monitor.interval,
+			port: monitor.port,
+			ignoreTlsErrors: monitor.ignoreTlsErrors,
+			isActive: monitor.isActive,
+		}));
+
+		const csv = this.papaparse.unparse(csvData);
+		return csv;
+	};
+}
+
+export default MonitorService;

server/src/service/business/userService.js

@@ -0,0 +1,213 @@
+const SERVICE_NAME = "userService";
+
+class UserService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, emailService, settingsService, logger, stringService, jwt, errorService }) {
+		this.db = db;
+		this.emailService = emailService;
+		this.settingsService = settingsService;
+		this.logger = logger;
+		this.stringService = stringService;
+		this.jwt = jwt;
+		this.errorService = errorService;
+	}
+
+	get serviceName() {
+		return UserService.SERVICE_NAME;
+	}
+
+	issueToken = (payload, appSettings) => {
+		const tokenTTL = appSettings?.jwtTTL ?? "2h";
+		const tokenSecret = appSettings?.jwtSecret;
+		const payloadData = payload;
+		return this.jwt.sign(payloadData, tokenSecret, { expiresIn: tokenTTL });
+	};
+
+	registerUser = async (user, file) => {
+		// Create a new user
+		// If superAdmin exists, a token should be attached to all further register requests
+		const superAdminExists = await this.db.checkSuperadmin();
+		if (superAdminExists) {
+			const invitedUser = await this.db.getInviteTokenAndDelete(user.inviteToken);
+			user.role = invitedUser.role;
+			user.teamId = invitedUser.teamId;
+		} else {
+			// This is the first account, create JWT secret to use if one is not supplied by env
+			const jwtSecret = crypto.randomBytes(64).toString("hex");
+			await this.db.updateAppSettings({ jwtSecret });
+		}
+
+		const newUser = await this.db.insertUser({ ...user }, file);
+
+		this.logger.debug({
+			message: "New user created",
+			service: SERVICE_NAME,
+			method: "registerUser",
+			details: newUser._id,
+		});
+
+		const userForToken = { ...newUser._doc };
+		delete userForToken.profileImage;
+		delete userForToken.avatarImage;
+
+		const appSettings = await this.settingsService.getSettings();
+
+		const token = this.issueToken(userForToken, appSettings);
+
+		try {
+			const html = await this.emailService.buildEmail("welcomeEmailTemplate", {
+				name: newUser.firstName,
+			});
+			this.emailService.sendEmail(newUser.email, "Welcome to Uptime Monitor", html).catch((error) => {
+				this.logger.warn({
+					message: error.message,
+					service: SERVICE_NAME,
+					method: "registerUser",
+					stack: error.stack,
+				});
+			});
+		} catch (error) {
+			this.logger.warn({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "registerUser",
+				stack: error.stack,
+			});
+		}
+
+		return { user: newUser, token };
+	};
+
+	loginUser = async (email, password) => {
+		// Check if user exists
+		const user = await this.db.getUserByEmail(email);
+		// Compare password
+		const match = await user.comparePassword(password);
+		if (match !== true) {
+			throw this.errorService.createAuthenticationError(this.stringService.authIncorrectPassword);
+		}
+
+		// Remove password from user object.  Should this be abstracted to DB layer?
+		const userWithoutPassword = { ...user._doc };
+		delete userWithoutPassword.password;
+		delete userWithoutPassword.avatarImage;
+
+		// Happy path, return token
+		const appSettings = await this.settingsService.getSettings();
+		const token = this.issueToken(userWithoutPassword, appSettings);
+		// reset avatar image
+		userWithoutPassword.avatarImage = user.avatarImage;
+		return { user: userWithoutPassword, token };
+	};
+
+	editUser = async (updates, file, currentUser) => {
+		// Change Password check
+		if (updates?.password && updates?.newPassword) {
+			// Get user's email
+			// Add user email to body for DB operation
+			updates.email = currentUser.email;
+			// Get user
+			const user = await this.db.getUserByEmail(currentUser.email);
+			// Compare passwords
+			const match = await user.comparePassword(updates?.password);
+			// If not a match, throw a 403
+			// 403 instead of 401 to avoid triggering axios interceptor
+			if (!match) {
+				throw this.errorService.createAuthorizationError(this.stringService.authIncorrectPassword);
+			}
+			// If a match, update the password
+			updates.password = updates.newPassword;
+		}
+
+		const updatedUser = await this.db.updateUser({ userId: currentUser?._id, user: updates, file: file });
+		return updatedUser;
+	};
+
+	checkSuperadminExists = async () => {
+		const superAdminExists = await this.db.checkSuperadmin();
+		return superAdminExists;
+	};
+
+	requestRecovery = async (email) => {
+		const user = await this.db.getUserByEmail(email);
+		const recoveryToken = await this.db.requestRecoveryToken(email);
+		const name = user.firstName;
+		const { clientHost } = this.settingsService.getSettings();
+		const url = `${clientHost}/set-new-password/${recoveryToken.token}`;
+
+		const html = await this.emailService.buildEmail("passwordResetTemplate", {
+			name,
+			email,
+			url,
+		});
+		const msgId = await this.emailService.sendEmail(email, "Checkmate Password Reset", html);
+		return msgId;
+	};
+
+	validateRecovery = async (recoveryToken) => {
+		await this.db.validateRecoveryToken(recoveryToken);
+	};
+
+	resetPassword = async (password, recoveryToken) => {
+		const user = await this.db.resetPassword(password, recoveryToken);
+		const appSettings = await this.settingsService.getSettings();
+		const token = this.issueToken(user._doc, appSettings);
+		return { user, token };
+	};
+
+	deleteUser = async (user) => {
+		const email = user?.email;
+		if (!email) {
+			throw this.errorService.createBadRequestError("No email in request");
+		}
+
+		const teamId = user?.teamId;
+		const userId = user?._id;
+
+		if (!teamId) {
+			throw this.errorService.createBadRequestError("No team ID in request");
+		}
+
+		if (!userId) {
+			throw this.errorService.createBadRequestError("No user ID in request");
+		}
+
+		const roles = user?.role;
+		if (roles.includes("demo")) {
+			throw this.errorService.createBadRequestError("Demo user cannot be deleted");
+		}
+
+		// 1. Find all the monitors associated with the team ID if superadmin
+		const result = await this.db.getMonitorsByTeamId({
+			teamId: teamId,
+		});
+
+		if (roles.includes("superadmin")) {
+			// 2.  Remove all jobs, delete checks and alerts
+			result?.monitors.length > 0 &&
+				(await Promise.all(
+					result.monitors.map(async (monitor) => {
+						await this.jobQueue.deleteJob(monitor);
+					})
+				));
+		}
+		// 6. Delete the user by id
+		await this.db.deleteUser(userId);
+	};
+
+	getAllUsers = async () => {
+		const users = await this.db.getAllUsers();
+		return users;
+	};
+
+	getUserById = async (roles, userId) => {
+		const user = await this.db.getUserById(roles, userId);
+		return user;
+	};
+
+	editUserById = async (userId, user) => {
+		await this.db.editUserById(userId, user);
+	};
+}
+export default UserService;

server/src/service/data/redisService.js

@@ -0,0 +1,64 @@
+const SERVICE_NAME = "RedisService";
+
+class RedisService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ Redis, logger }) {
+		this.Redis = Redis;
+		this.connections = new Set();
+		this.logger = logger;
+	}
+
+	get serviceName() {
+		return RedisService.SERVICE_NAME;
+	}
+
+	getNewConnection(options = {}) {
+		const connection = new this.Redis(process.env.REDIS_URL, {
+			retryStrategy: (times) => {
+				return null;
+			},
+			...options,
+		});
+		this.connections.add(connection);
+		return connection;
+	}
+
+	async closeAllConnections() {
+		const closePromises = Array.from(this.connections).map((conn) =>
+			conn.quit().catch((err) => {
+				this.logger.error({
+					message: "Error closing Redis connection",
+					service: SERVICE_NAME,
+					method: "closeAllConnections",
+					details: { error: err },
+				});
+			})
+		);
+
+		await Promise.all(closePromises);
+		this.connections.clear();
+		this.logger.info({
+			message: "All Redis connections closed",
+			service: SERVICE_NAME,
+			method: "closeAllConnections",
+		});
+	}
+
+	async flushRedis() {
+		this.logger.info({
+			message: "Flushing Redis",
+			service: SERVICE_NAME,
+			method: "flushRedis",
+		});
+		const flushPromises = Array.from(this.connections).map((conn) => conn.flushall());
+		await Promise.all(flushPromises);
+		this.logger.info({
+			message: "Redis flushed",
+			service: SERVICE_NAME,
+			method: "flushRedis",
+		});
+	}
+}
+
+export default RedisService;

server/src/service/infrastructure/JobQueue/JobQueue.js

@@ -0,0 +1,321 @@
+const QUEUE_NAMES = ["uptime", "pagespeed", "hardware"];
+const SERVICE_NAME = "JobQueue";
+const HEALTH_CHECK_INTERVAL = 10 * 60 * 1000; // 10 minutes
+const QUEUE_LOOKUP = {
+	hardware: "hardware",
+	http: "uptime",
+	ping: "uptime",
+	port: "uptime",
+	docker: "uptime",
+	pagespeed: "pagespeed",
+};
+const getSchedulerId = (monitor) => `scheduler:${monitor.type}:${monitor._id}`;
+
+class JobQueue {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, jobQueueHelper, logger, stringService }) {
+		this.db = db;
+		this.jobQueueHelper = jobQueueHelper;
+		this.stringService = stringService;
+		this.logger = logger;
+		this.queues = {};
+		this.workers = [];
+	}
+
+	get serviceName() {
+		return JobQueue.SERVICE_NAME;
+	}
+
+	static async create({ db, jobQueueHelper, logger, stringService }) {
+		const instance = new JobQueue({ db, jobQueueHelper, logger, stringService });
+		await instance.init();
+		return instance;
+	}
+
+	async init() {
+		try {
+			await this.initQueues();
+			await this.initWorkers();
+			const monitors = await this.db.getAllMonitors();
+			await Promise.all(
+				monitors
+					.filter((monitor) => monitor.isActive)
+					.map(async (monitor) => {
+						try {
+							await this.addJob(monitor._id, monitor);
+						} catch (error) {
+							this.logger.error({
+								message: error.message,
+								service: SERVICE_NAME,
+								method: "initJobQueue",
+								stack: error.stack,
+							});
+						}
+					})
+			);
+			this.healthCheckInterval = setInterval(async () => {
+				try {
+					const queueHealthChecks = await this.checkQueueHealth();
+					const queueIsStuck = queueHealthChecks.some((healthCheck) => healthCheck.stuck);
+					if (queueIsStuck) {
+						this.logger.warn({
+							message: "Queue is stuck",
+							service: SERVICE_NAME,
+							method: "periodicHealthCheck",
+							details: queueHealthChecks,
+						});
+						await this.flushQueues();
+					}
+				} catch (error) {
+					this.logger.error({
+						message: error.message,
+						service: SERVICE_NAME,
+						method: "periodicHealthCheck",
+						stack: error.stack,
+					});
+				}
+			}, HEALTH_CHECK_INTERVAL);
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "initJobQueue",
+				stack: error.stack,
+			});
+		}
+	}
+
+	async initQueues() {
+		const readyPromises = [];
+
+		for (const queueName of QUEUE_NAMES) {
+			const q = this.jobQueueHelper.createQueue(queueName);
+			this.queues[queueName] = q;
+			readyPromises.push(q.waitUntilReady());
+		}
+		await Promise.all(readyPromises);
+		this.logger.info({
+			message: "Queues ready",
+			service: SERVICE_NAME,
+			method: "initQueues",
+		});
+	}
+
+	async initWorkers() {
+		const workerReadyPromises = [];
+
+		for (const queueName of QUEUE_NAMES) {
+			const worker = this.jobQueueHelper.createWorker(queueName, this.queues[queueName]);
+			this.workers.push(worker);
+			workerReadyPromises.push(worker.waitUntilReady());
+		}
+		await Promise.all(workerReadyPromises);
+		this.logger.info({
+			message: "Workers ready",
+			service: SERVICE_NAME,
+			method: "initWorkers",
+		});
+	}
+
+	pauseJob = async (monitor) => {
+		this.deleteJob(monitor);
+	};
+
+	resumeJob = async (monitor) => {
+		this.addJob(monitor._id, monitor);
+	};
+
+	async addJob(jobName, monitor) {
+		this.logger.info({
+			message: `Adding job ${monitor?.url ?? "No URL"}`,
+			service: SERVICE_NAME,
+			method: "addJob",
+		});
+
+		const queueName = QUEUE_LOOKUP[monitor.type];
+		const queue = this.queues[queueName];
+		if (typeof queue === "undefined") {
+			throw new Error(`Queue for ${monitor.type} not found`);
+		}
+		const jobTemplate = {
+			name: jobName,
+			data: monitor,
+			opts: {
+				attempts: 1,
+				backoff: {
+					type: "exponential",
+					delay: 1000,
+				},
+				removeOnComplete: true,
+				removeOnFail: false,
+				timeout: 1 * 60 * 1000,
+			},
+		};
+
+		const schedulerId = getSchedulerId(monitor);
+		await queue.upsertJobScheduler(schedulerId, { every: monitor?.interval ?? 60000 }, jobTemplate);
+	}
+
+	async deleteJob(monitor) {
+		try {
+			const queue = this.queues[QUEUE_LOOKUP[monitor.type]];
+			const schedulerId = getSchedulerId(monitor);
+			const wasDeleted = await queue.removeJobScheduler(schedulerId);
+
+			if (wasDeleted === true) {
+				this.logger.info({
+					message: this.stringService.jobQueueDeleteJob,
+					service: SERVICE_NAME,
+					method: "deleteJob",
+					details: `Deleted job ${monitor._id}`,
+				});
+				return true;
+			} else {
+				this.logger.error({
+					message: this.stringService.jobQueueDeleteJob,
+					service: SERVICE_NAME,
+					method: "deleteJob",
+					details: `Failed to delete job ${monitor._id}`,
+				});
+				return false;
+			}
+		} catch (error) {
+			error.service === undefined ? (error.service = SERVICE_NAME) : null;
+			error.method === undefined ? (error.method = "deleteJob") : null;
+			throw error;
+		}
+	}
+
+	async updateJob(monitor) {
+		await this.deleteJob(monitor);
+		await this.addJob(monitor._id, monitor);
+	}
+
+	async getJobs() {
+		try {
+			let stats = {};
+			await Promise.all(
+				QUEUE_NAMES.map(async (name) => {
+					const queue = this.queues[name];
+					const jobs = await queue.getJobs();
+					const ret = await Promise.all(
+						jobs.map(async (job) => {
+							const state = await job.getState();
+							return { url: job.data.url, state, progress: job.progress };
+						})
+					);
+					stats[name] = { jobs: ret };
+				})
+			);
+			return stats;
+		} catch (error) {
+			error.service === undefined ? (error.service = SERVICE_NAME) : null;
+			error.method === undefined ? (error.method = "getJobStats") : null;
+			throw error;
+		}
+	}
+
+	async getMetrics() {
+		try {
+			let metrics = {};
+
+			await Promise.all(
+				QUEUE_NAMES.map(async (name) => {
+					const queue = this.queues[name];
+					const [waiting, active, failed, delayed, repeatableJobs] = await Promise.all([
+						queue.getWaitingCount(),
+						queue.getActiveCount(),
+						queue.getFailedCount(),
+						queue.getDelayedCount(),
+						queue.getRepeatableJobs(),
+					]);
+
+					metrics[name] = {
+						waiting,
+						active,
+						failed,
+						delayed,
+						repeatableJobs: repeatableJobs.length,
+					};
+				})
+			);
+
+			return metrics;
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "getMetrics",
+				stack: error.stack,
+			});
+		}
+	}
+
+	async checkQueueHealth() {
+		const res = [];
+		for (const queueName of QUEUE_NAMES) {
+			const q = this.queues[queueName];
+			await q.waitUntilReady();
+
+			const lastJobProcessedTime = q.lastJobProcessedTime;
+			const currentTime = Date.now();
+			const timeDiff = currentTime - lastJobProcessedTime;
+
+			// Check for jobs
+			const jobCounts = await q.getJobCounts();
+			const hasJobs = Object.values(jobCounts).some((count) => count > 0);
+
+			res.push({
+				queueName,
+				timeSinceLastJob: timeDiff,
+				stuck: hasJobs && timeDiff > 10000,
+				jobCounts,
+			});
+		}
+		return res;
+	}
+
+	async flushQueues() {
+		try {
+			this.logger.warn({
+				message: "Flushing queues",
+				method: "flushQueues",
+				service: SERVICE_NAME,
+			});
+			for (const worker of this.workers) {
+				await worker.close();
+			}
+			this.workers = [];
+
+			for (const queue of Object.values(this.queues)) {
+				await queue.obliterate();
+			}
+			this.queue = {};
+			await this.init();
+			return true;
+		} catch (error) {
+			this.logger.warn({
+				message: `${error.message} - Flushing redis manually`,
+				service: SERVICE_NAME,
+				method: "flushQueues",
+			});
+			return await this.jobQueueHelper.flushRedis();
+		}
+	}
+
+	async shutdown() {
+		if (this.healthCheckInterval) {
+			clearInterval(this.healthCheckInterval);
+			this.healthCheckInterval = null;
+		}
+		for (const worker of this.workers) {
+			await worker.close();
+		}
+		for (const queue of Object.values(this.queues)) {
+			await queue.obliterate();
+		}
+	}
+}
+
+export default JobQueue;

server/src/service/infrastructure/JobQueue/JobQueueHelper.js

@@ -0,0 +1,308 @@
+const SERVICE_NAME = "JobQueueHelper";
+
+class JobQueueHelper {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ redisService, Queue, Worker, logger, db, networkService, statusService, notificationService }) {
+		this.db = db;
+		this.redisService = redisService;
+		this.Queue = Queue;
+		this.Worker = Worker;
+		this.logger = logger;
+		this.networkService = networkService;
+		this.statusService = statusService;
+		this.notificationService = notificationService;
+	}
+
+	get serviceName() {
+		return JobQueueHelper.SERVICE_NAME;
+	}
+
+	createQueue(queueName) {
+		const connection = this.redisService.getNewConnection();
+		const q = new this.Queue(queueName, {
+			connection,
+		});
+		q.lastJobProcessedTime = Date.now();
+		q.on("cleaned", (jobs, type) => {
+			this.logger.debug({
+				message: `Queue ${queueName} is cleaned with jobs: ${jobs} and type: ${type}`,
+				service: SERVICE_NAME,
+				method: "createQueue:cleaned",
+			});
+		});
+		q.on("error", (err) => {
+			this.logger.error({
+				message: `Queue ${queueName} is error with msg: ${err}`,
+				service: SERVICE_NAME,
+				method: "createQueue:error",
+			});
+		});
+		q.on("ioredis:close", () => {
+			this.logger.debug({
+				message: `Queue ${queueName} is ioredis:close`,
+				service: SERVICE_NAME,
+				method: "createQueue:ioredis:close",
+			});
+		});
+		q.on("paused", () => {
+			this.logger.debug({
+				message: `Queue ${queueName} is paused`,
+				service: SERVICE_NAME,
+				method: "createQueue:paused",
+			});
+		});
+		q.on("progress", (job, progress) => {
+			this.logger.debug({
+				message: `Queue ${queueName} is progress with msg: ${progress}`,
+				service: SERVICE_NAME,
+				method: "createQueue:progress",
+			});
+		});
+		q.on("removed", (job) => {
+			this.logger.debug({
+				message: `Queue ${queueName} is removed with msg: ${job}`,
+				service: SERVICE_NAME,
+				method: "createQueue:removed",
+			});
+		});
+		q.on("resumed", () => {
+			this.logger.debug({
+				message: `Queue ${queueName} is resumed`,
+				service: SERVICE_NAME,
+				method: "createQueue:resumed",
+			});
+		});
+		q.on("waiting", () => {
+			this.logger.debug({
+				message: `Queue ${queueName} is waiting`,
+				service: SERVICE_NAME,
+				method: "createQueue:waiting",
+			});
+		});
+		return q;
+	}
+
+	createWorker(queueName, queue) {
+		const connection = this.redisService.getNewConnection({
+			maxRetriesPerRequest: null,
+		});
+		const worker = new this.Worker(queueName, this.createJobHandler(queue), {
+			connection,
+			concurrency: 50,
+		});
+		worker.on("active", (job) => {
+			this.logger.debug({
+				message: `Worker ${queueName} is active`,
+				service: SERVICE_NAME,
+				method: "createWorker:active",
+			});
+		});
+
+		worker.on("closed", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is closed`,
+				service: SERVICE_NAME,
+				method: "createWorker:closed",
+			});
+		});
+
+		worker.on("closing", (msg) => {
+			this.logger.debug({
+				message: `Worker ${queueName} is closing with msg: ${msg}`,
+				service: SERVICE_NAME,
+				method: "createWorker:closing",
+			});
+		});
+
+		worker.on("completed", (job) => {
+			this.logger.debug({
+				message: `Worker ${queueName} is completed`,
+				service: SERVICE_NAME,
+				method: "createWorker:completed",
+			});
+		});
+
+		worker.on("drained", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is drained`,
+				service: SERVICE_NAME,
+				method: "createWorker:drained",
+			});
+		});
+
+		worker.on("error", (failedReason) => {
+			this.logger.error({
+				message: `Worker ${queueName} is error with msg: ${failedReason}`,
+				service: SERVICE_NAME,
+				method: "createWorker:error",
+			});
+		});
+
+		worker.on("failed", (job, error, prev) => {
+			this.logger.error({
+				message: `Worker ${queueName} is failed with msg: ${error.message}`,
+				service: error?.service ?? SERVICE_NAME,
+				method: error?.method ?? "createWorker:failed",
+				stack: error?.stack,
+			});
+		});
+
+		worker.on("ioredis:close", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is ioredis:close`,
+				service: SERVICE_NAME,
+				method: "createWorker:ioredis:close",
+			});
+		});
+
+		worker.on("paused", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is paused`,
+				service: SERVICE_NAME,
+				method: "createWorker:paused",
+			});
+		});
+
+		worker.on("progress", (job, progress) => {
+			this.logger.debug({
+				message: `Worker ${queueName} is progress with msg: ${progress}`,
+				service: SERVICE_NAME,
+				method: "createWorker:progress",
+			});
+		});
+
+		worker.on("ready", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is ready`,
+				service: SERVICE_NAME,
+				method: "createWorker:ready",
+			});
+		});
+
+		worker.on("resumed", () => {
+			this.logger.debug({
+				message: `Worker ${queueName} is resumed`,
+				service: SERVICE_NAME,
+				method: "createWorker:resumed",
+			});
+		});
+
+		worker.on("stalled", () => {
+			this.logger.warn({
+				message: `Worker ${queueName} is stalled`,
+				service: SERVICE_NAME,
+				method: "createWorker:stalled",
+			});
+		});
+		return worker;
+	}
+
+	async isInMaintenanceWindow(monitorId) {
+		const maintenanceWindows = await this.db.getMaintenanceWindowsByMonitorId(monitorId);
+		// Check for active maintenance window:
+		const maintenanceWindowIsActive = maintenanceWindows.reduce((acc, window) => {
+			if (window.active) {
+				const start = new Date(window.start);
+				const end = new Date(window.end);
+				const now = new Date();
+				const repeatInterval = window.repeat || 0;
+
+				// If start is < now and end > now, we're in maintenance
+				if (start <= now && end >= now) return true;
+
+				// If maintenance window was set in the past with a repeat,
+				// we need to advance start and end to see if we are in range
+
+				while (start < now && repeatInterval !== 0) {
+					start.setTime(start.getTime() + repeatInterval);
+					end.setTime(end.getTime() + repeatInterval);
+					if (start <= now && end >= now) {
+						return true;
+					}
+				}
+				return false;
+			}
+			return acc;
+		}, false);
+		return maintenanceWindowIsActive;
+	}
+
+	createJobHandler(q) {
+		return async (job) => {
+			try {
+				// Update the last job processed time for this queue
+				q.lastJobProcessedTime = Date.now();
+				// Get all maintenance windows for this monitor
+				await job.updateProgress(0);
+				const monitorId = job.data._id;
+				const maintenanceWindowActive = await this.isInMaintenanceWindow(monitorId);
+				// If a maintenance window is active, we're done
+
+				if (maintenanceWindowActive) {
+					await job.updateProgress(100);
+					this.logger.info({
+						message: `Monitor ${monitorId} is in maintenance window`,
+						service: SERVICE_NAME,
+						method: "createWorker",
+					});
+					return false;
+				}
+
+				// Get the current status
+				await job.updateProgress(30);
+				const monitor = job.data;
+				const networkResponse = await this.networkService.getStatus(monitor);
+
+				// If the network response is not found, we're done
+				if (!networkResponse) {
+					await job.updateProgress(100);
+					return false;
+				}
+
+				// Handle status change
+				await job.updateProgress(60);
+				const { monitor: updatedMonitor, statusChanged, prevStatus } = await this.statusService.updateStatus(networkResponse);
+				// Handle notifications
+				await job.updateProgress(80);
+				this.notificationService
+					.handleNotifications({
+						...networkResponse,
+						monitor: updatedMonitor,
+						prevStatus,
+						statusChanged,
+					})
+					.catch((error) => {
+						this.logger.error({
+							message: error.message,
+							service: SERVICE_NAME,
+							method: "createJobHandler",
+							details: `Error sending notifications for job ${job.id}: ${error.message}`,
+							stack: error.stack,
+						});
+					});
+				await job.updateProgress(100);
+				return true;
+			} catch (error) {
+				await job.updateProgress(100);
+				throw error;
+			}
+		};
+	}
+	async flushRedis() {
+		try {
+			const connection = this.redisService.getNewConnection();
+			const flushResult = await connection.flushall();
+			return flushResult;
+		} catch (error) {
+			this.logger.warn({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "flushRedis",
+			});
+			return false;
+		}
+	}
+}
+
+export default JobQueueHelper;

server/src/service/infrastructure/PulseQueue/PulseQueue.js

@@ -0,0 +1,213 @@
+import { Pulse } from "@pulsecron/pulse";
+
+const SERVICE_NAME = "JobQueue";
+class PulseQueue {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ appSettings, db, pulseQueueHelper, logger }) {
+		this.db = db;
+		this.appSettings = appSettings;
+		this.pulseQueueHelper = pulseQueueHelper;
+		this.logger = logger;
+	}
+
+	get serviceName() {
+		return PulseQueue.SERVICE_NAME;
+	}
+
+	static async create({ appSettings, db, pulseQueueHelper, logger }) {
+		const instance = new PulseQueue({ appSettings, db, pulseQueueHelper, logger });
+		await instance.init();
+		return instance;
+	}
+
+	// ****************************************
+	// Core methods
+	// ****************************************
+	init = async () => {
+		try {
+			const mongoConnectionString = this.appSettings.dbConnectionString || "mongodb://localhost:27017/uptime_db";
+			this.pulse = new Pulse({ db: { address: mongoConnectionString } });
+			await this.pulse.start();
+			this.pulse.define("monitor-job", this.pulseQueueHelper.getMonitorJob(), {});
+
+			const monitors = await this.db.getAllMonitors();
+			for (const monitor of monitors) {
+				await this.addJob(monitor._id, monitor);
+			}
+			return true;
+		} catch (error) {
+			this.logger.error({
+				message: "Failed to initialize PulseQueue",
+				service: SERVICE_NAME,
+				method: "init",
+				details: error,
+			});
+			return false;
+		}
+	};
+
+	addJob = async (monitorId, monitor) => {
+		this.logger.debug({
+			message: `Adding job ${monitor?.url ?? "No URL"}`,
+			service: SERVICE_NAME,
+			method: "addJob",
+		});
+		const intervalInSeconds = monitor.interval / 1000;
+		const job = this.pulse.create("monitor-job", {
+			monitor,
+		});
+		job.unique({ "data.monitor._id": monitor._id });
+		job.attrs.jobId = monitorId.toString();
+		job.repeatEvery(`${intervalInSeconds} seconds`);
+		if (monitor.isActive === false) {
+			job.disable();
+		}
+		await job.save();
+	};
+
+	deleteJob = async (monitor) => {
+		this.logger.debug({
+			message: `Deleting job ${monitor?.url ?? "No URL"}`,
+			service: SERVICE_NAME,
+			method: "deleteJob",
+		});
+		await this.pulse.cancel({
+			"data.monitor._id": monitor._id,
+		});
+	};
+
+	pauseJob = async (monitor) => {
+		const result = await this.pulse.disable({
+			"data.monitor._id": monitor._id,
+		});
+
+		if (result.length < 1) {
+			throw new Error("Failed to pause monitor");
+		}
+
+		this.logger.debug({
+			message: `Paused monitor ${monitor._id}`,
+			service: SERVICE_NAME,
+			method: "pauseJob",
+		});
+	};
+
+	resumeJob = async (monitor) => {
+		const result = await this.pulse.enable({
+			"data.monitor._id": monitor._id,
+		});
+
+		if (result.length < 1) {
+			throw new Error("Failed to resume monitor");
+		}
+
+		this.logger.debug({
+			message: `Resumed monitor ${monitor._id}`,
+			service: SERVICE_NAME,
+			method: "resumeJob",
+		});
+	};
+
+	updateJob = async (monitor) => {
+		const jobs = await this.pulse.jobs({
+			"data.monitor._id": monitor._id,
+		});
+
+		const job = jobs[0];
+		if (!job) {
+			throw new Error("Job not found");
+		}
+
+		const intervalInSeconds = monitor.interval / 1000;
+		job.repeatEvery(`${intervalInSeconds} seconds`);
+		job.attrs.data.monitor = monitor;
+		await job.save();
+	};
+
+	shutdown = async () => {
+		this.logger.info({
+			message: "Shutting down JobQueue",
+			service: SERVICE_NAME,
+			method: "shutdown",
+		});
+		await this.pulse.stop();
+	};
+
+	// ****************************************
+	// Diagnostic methods
+	// ****************************************
+
+	getMetrics = async () => {
+		const jobs = await this.pulse.jobs();
+		const metrics = jobs.reduce(
+			(acc, job) => {
+				acc.totalRuns += job.attrs.runCount || 0;
+				acc.totalFailures += job.attrs.failCount || 0;
+				acc.jobs++;
+				if (job.attrs.failCount > 0 && job.attrs.failedAt >= job.attrs.lastFinishedAt) {
+					acc.failingJobs++;
+				}
+				if (job.attrs.lockedAt) {
+					acc.activeJobs++;
+				}
+				if (job.attrs.failCount > 0) {
+					acc.jobsWithFailures.push({
+						monitorId: job.attrs.data.monitor._id,
+						monitorUrl: job.attrs.data.monitor.url,
+						monitorType: job.attrs.data.monitor.type,
+						failedAt: job.attrs.failedAt,
+						failCount: job.attrs.failCount,
+						failReason: job.attrs.failReason,
+					});
+				}
+				return acc;
+			},
+			{
+				jobs: 0,
+				activeJobs: 0,
+				failingJobs: 0,
+				jobsWithFailures: [],
+				totalRuns: 0,
+				totalFailures: 0,
+			}
+		);
+		return metrics;
+	};
+
+	getJobs = async () => {
+		const jobs = await this.pulse.jobs();
+		return jobs.map((job) => {
+			return {
+				monitorId: job.attrs.data.monitor._id,
+				monitorUrl: job.attrs.data.monitor.url,
+				monitorType: job.attrs.data.monitor.type,
+				active: !job.attrs.disabled,
+				lockedAt: job.attrs.lockedAt,
+				runCount: job.attrs.runCount || 0,
+				failCount: job.attrs.failCount || 0,
+				failReason: job.attrs.failReason,
+				lastRunAt: job.attrs.lastRunAt,
+				lastFinishedAt: job.attrs.lastFinishedAt,
+				lastRunTook: job.attrs.lockedAt ? null : job.attrs.lastFinishedAt - job.attrs.lastRunAt,
+				lastFailedAt: job.attrs.failedAt,
+			};
+		});
+	};
+
+	flushQueues = async () => {
+		const cancelRes = await this.pulse.cancel();
+		await this.pulse.stop();
+		const initRes = await this.init();
+		return {
+			flushedJobs: cancelRes,
+			initSuccess: initRes,
+		};
+	};
+
+	obliterate = async () => {
+		await this.flushQueues();
+	};
+}
+
+export default PulseQueue;

server/src/service/infrastructure/PulseQueue/PulseQueueHelper.js

@@ -0,0 +1,104 @@
+const SERVICE_NAME = "PulseQueueHelper";
+
+class PulseQueueHelper {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ db, logger, networkService, statusService, notificationService }) {
+		this.db = db;
+		this.logger = logger;
+		this.networkService = networkService;
+		this.statusService = statusService;
+		this.notificationService = notificationService;
+	}
+
+	get serviceName() {
+		return PulseQueueHelper.SERVICE_NAME;
+	}
+
+	getMonitorJob = () => {
+		return async (job) => {
+			try {
+				const monitor = job.attrs.data.monitor;
+				const monitorId = job.attrs.data.monitor._id;
+				if (!monitorId) {
+					throw new Error("No monitor id");
+				}
+
+				const maintenanceWindowActive = await this.isInMaintenanceWindow(monitorId);
+				if (maintenanceWindowActive) {
+					this.logger.info({
+						message: `Monitor ${monitorId} is in maintenance window`,
+						service: SERVICE_NAME,
+						method: "getMonitorJob",
+					});
+					return;
+				}
+
+				const networkResponse = await this.networkService.getStatus(monitor);
+
+				if (!networkResponse) {
+					throw new Error("No network response");
+				}
+
+				const { monitor: updatedMonitor, statusChanged, prevStatus } = await this.statusService.updateStatus(networkResponse);
+
+				this.notificationService
+					.handleNotifications({
+						...networkResponse,
+						monitor: updatedMonitor,
+						prevStatus,
+						statusChanged,
+					})
+					.catch((error) => {
+						this.logger.error({
+							message: error.message,
+							service: SERVICE_NAME,
+							method: "getMonitorJob",
+							details: `Error sending notifications for job ${job.id}: ${error.message}`,
+							stack: error.stack,
+						});
+					});
+			} catch (error) {
+				this.logger.warn({
+					message: error.message,
+					service: error.service || SERVICE_NAME,
+					method: error.method || "getMonitorJob",
+					stack: error.stack,
+				});
+				throw error;
+			}
+		};
+	};
+
+	async isInMaintenanceWindow(monitorId) {
+		const maintenanceWindows = await this.db.getMaintenanceWindowsByMonitorId(monitorId);
+		// Check for active maintenance window:
+		const maintenanceWindowIsActive = maintenanceWindows.reduce((acc, window) => {
+			if (window.active) {
+				const start = new Date(window.start);
+				const end = new Date(window.end);
+				const now = new Date();
+				const repeatInterval = window.repeat || 0;
+
+				// If start is < now and end > now, we're in maintenance
+				if (start <= now && end >= now) return true;
+
+				// If maintenance window was set in the past with a repeat,
+				// we need to advance start and end to see if we are in range
+
+				while (start < now && repeatInterval !== 0) {
+					start.setTime(start.getTime() + repeatInterval);
+					end.setTime(end.getTime() + repeatInterval);
+					if (start <= now && end >= now) {
+						return true;
+					}
+				}
+				return false;
+			}
+			return acc;
+		}, false);
+		return maintenanceWindowIsActive;
+	}
+}
+
+export default PulseQueueHelper;

server/src/service/infrastructure/SuperSimpleQueue/SuperSimpleQueue.js

@@ -0,0 +1,170 @@
+import Scheduler from "super-simple-scheduler";
+const SERVICE_NAME = "JobQueue";
+
+class SuperSimpleQueue {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ appSettings, db, logger, helper }) {
+		this.appSettings = appSettings;
+		this.db = db;
+		this.logger = logger;
+		this.helper = helper;
+	}
+
+	get serviceName() {
+		return SuperSimpleQueue.SERVICE_NAME;
+	}
+
+	static async create({ appSettings, db, logger, helper }) {
+		const instance = new SuperSimpleQueue({ appSettings, db, logger, helper });
+		await instance.init();
+		return instance;
+	}
+
+	init = async () => {
+		try {
+			this.scheduler = new Scheduler({
+				// storeType: "mongo",
+				// storeType: "redis",
+				logLevel: "debug",
+				debug: true,
+				dbUri: this.appSettings.dbConnectionString,
+			});
+			this.scheduler.start();
+
+			this.scheduler.addTemplate("monitor-job", this.helper.getMonitorJob());
+			const monitors = await this.db.getAllMonitors();
+			for (const monitor of monitors) {
+				await this.addJob(monitor._id, monitor);
+			}
+			return true;
+		} catch (error) {
+			this.logger.error({
+				message: "Failed to initialize SuperSimpleQueue",
+				service: SERVICE_NAME,
+				method: "init",
+				details: error,
+			});
+			return false;
+		}
+	};
+
+	addJob = async (monitorId, monitor) => {
+		this.scheduler.addJob({
+			id: monitorId.toString(),
+			template: "monitor-job",
+			repeat: monitor.interval,
+			data: monitor.toObject(),
+		});
+	};
+
+	deleteJob = async (monitor) => {
+		this.scheduler.removeJob(monitor._id.toString());
+	};
+
+	pauseJob = async (monitor) => {
+		const result = this.scheduler.pauseJob(monitor._id.toString());
+		if (result === false) {
+			throw new Error("Failed to resume monitor");
+		}
+		this.logger.debug({
+			message: `Paused monitor ${monitor._id}`,
+			service: SERVICE_NAME,
+			method: "pauseJob",
+		});
+	};
+
+	resumeJob = async (monitor) => {
+		const result = this.scheduler.resumeJob(monitor._id.toString());
+		if (result === false) {
+			throw new Error("Failed to resume monitor");
+		}
+		this.logger.debug({
+			message: `Resumed monitor ${monitor._id}`,
+			service: SERVICE_NAME,
+			method: "resumeJob",
+		});
+	};
+
+	updateJob = async (monitor) => {
+		this.scheduler.updateJob(monitor._id.toString(), monitor.interval);
+	};
+
+	shutdown = async () => {
+		this.scheduler.stop();
+	};
+
+	getMetrics = async () => {
+		const jobs = await this.scheduler.getJobs();
+		const metrics = jobs.reduce(
+			(acc, job) => {
+				acc.totalRuns += job.runCount || 0;
+				acc.totalFailures += job.failCount || 0;
+				acc.jobs++;
+				if (job.failCount > 0 && job.lastFailedAt >= job.lsatRunAt) {
+					acc.failingJobs++;
+				}
+
+				if (job.lockedAt) {
+					acc.activeJobs++;
+				}
+
+				if (job.failCount > 0) {
+					acc.jobsWithFailures.push({
+						monitorId: job.id,
+						monitorUrl: job?.data?.url || null,
+						monitorType: job?.data?.type || null,
+						failedAt: job.lastFailedAt,
+						failCount: job.failCount,
+						failReason: job.lastFailReason,
+					});
+				}
+				return acc;
+			},
+			{
+				jobs: 0,
+				activeJobs: 0,
+				failingJobs: 0,
+				jobsWithFailures: [],
+				totalRuns: 0,
+				totalFailures: 0,
+			}
+		);
+		return metrics;
+	};
+
+	getJobs = async () => {
+		const jobs = await this.scheduler.getJobs();
+		return jobs.map((job) => {
+			return {
+				monitorId: job.id,
+				monitorUrl: job?.data?.url || null,
+				monitorType: job?.data?.type || null,
+				active: job.active,
+				lockedAt: job.lockedAt,
+				runCount: job.runCount || 0,
+				failCount: job.failCount || 0,
+				failReason: job.lastFailReason,
+				lastRunAt: job.lastRunAt,
+				lastFinishedAt: job.lastFinishedAt,
+				lastRunTook: job.lockedAt ? null : job.lastFinishedAt - job.lastRunAt,
+				lastFailedAt: job.lastFailedAt,
+			};
+		});
+	};
+
+	flushQueues = async () => {
+		const stopRes = this.scheduler.stop();
+		const flushRes = this.scheduler.flushJobs();
+		const initRes = await this.init();
+		return {
+			success: stopRes && flushRes && initRes,
+		};
+	};
+
+	obliterate = async () => {
+		console.log("obliterate not implemented");
+	};
+}
+
+export default SuperSimpleQueue;

server/src/service/infrastructure/SuperSimpleQueue/SuperSimpleQueueHelper.js

@@ -0,0 +1,100 @@
+const SERVICE_NAME = "JobQueueHelper";
+
+class SuperSimpleQueueHelper {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor({ db, logger, networkService, statusService, notificationService }) {
+		this.db = db;
+		this.logger = logger;
+		this.networkService = networkService;
+		this.statusService = statusService;
+		this.notificationService = notificationService;
+	}
+
+	get serviceName() {
+		return SuperSimpleQueueHelper.SERVICE_NAME;
+	}
+
+	getMonitorJob = () => {
+		return async (monitor) => {
+			try {
+				const monitorId = monitor._id;
+				if (!monitorId) {
+					throw new Error("No monitor id");
+				}
+
+				const maintenanceWindowActive = await this.isInMaintenanceWindow(monitorId);
+				if (maintenanceWindowActive) {
+					this.logger.info({
+						message: `Monitor ${monitorId} is in maintenance window`,
+						service: SERVICE_NAME,
+						method: "getMonitorJob",
+					});
+					return;
+				}
+				const networkResponse = await this.networkService.getStatus(monitor);
+				if (!networkResponse) {
+					throw new Error("No network response");
+				}
+
+				const { monitor: updatedMonitor, statusChanged, prevStatus } = await this.statusService.updateStatus(networkResponse);
+
+				this.notificationService
+					.handleNotifications({
+						...networkResponse,
+						monitor: updatedMonitor,
+						prevStatus,
+						statusChanged,
+					})
+					.catch((error) => {
+						this.logger.error({
+							message: error.message,
+							service: SERVICE_NAME,
+							method: "getMonitorJob",
+							details: `Error sending notifications for job ${monitor._id}: ${error.message}`,
+							stack: error.stack,
+						});
+					});
+			} catch (error) {
+				this.logger.warn({
+					message: error.message,
+					service: error.service || SERVICE_NAME,
+					method: error.method || "getMonitorJob",
+					stack: error.stack,
+				});
+				throw error;
+			}
+		};
+	};
+
+	async isInMaintenanceWindow(monitorId) {
+		const maintenanceWindows = await this.db.getMaintenanceWindowsByMonitorId(monitorId);
+		// Check for active maintenance window:
+		const maintenanceWindowIsActive = maintenanceWindows.reduce((acc, window) => {
+			if (window.active) {
+				const start = new Date(window.start);
+				const end = new Date(window.end);
+				const now = new Date();
+				const repeatInterval = window.repeat || 0;
+
+				// If start is < now and end > now, we're in maintenance
+				if (start <= now && end >= now) return true;
+
+				// If maintenance window was set in the past with a repeat,
+				// we need to advance start and end to see if we are in range
+
+				while (start < now && repeatInterval !== 0) {
+					start.setTime(start.getTime() + repeatInterval);
+					end.setTime(end.getTime() + repeatInterval);
+					if (start <= now && end >= now) {
+						return true;
+					}
+				}
+				return false;
+			}
+			return acc;
+		}, false);
+		return maintenanceWindowIsActive;
+	}
+}
+
+export default SuperSimpleQueueHelper;

server/src/service/infrastructure/bufferService.js

@@ -0,0 +1,105 @@
+const SERVICE_NAME = "BufferService";
+const BUFFER_TIMEOUT = process.env.NODE_ENV === "development" ? 5000 : 1000 * 60 * 1; // 1 minute
+const TYPE_MAP = {
+	http: "checks",
+	ping: "checks",
+	port: "checks",
+	docker: "checks",
+	pagespeed: "pagespeedChecks",
+	hardware: "hardwareChecks",
+};
+
+class BufferService {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor({ db, logger }) {
+		this.db = db;
+		this.logger = logger;
+		this.SERVICE_NAME = SERVICE_NAME;
+		this.buffers = {
+			checks: [],
+			pagespeedChecks: [],
+			hardwareChecks: [],
+		};
+		this.OPERATION_MAP = {
+			checks: this.db.createChecks,
+			pagespeedChecks: this.db.createPageSpeedChecks,
+			hardwareChecks: this.db.createHardwareChecks,
+		};
+
+		this.scheduleNextFlush();
+		this.logger.info({
+			message: `Buffer service initialized, flushing every ${BUFFER_TIMEOUT / 1000}s`,
+			service: this.SERVICE_NAME,
+			method: "constructor",
+		});
+	}
+
+	get serviceName() {
+		return BufferService.SERVICE_NAME;
+	}
+
+	addToBuffer({ check, type }) {
+		try {
+			this.buffers[TYPE_MAP[type]].push(check);
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: this.SERVICE_NAME,
+				method: "addToBuffer",
+				stack: error.stack,
+			});
+		}
+	}
+
+	scheduleNextFlush() {
+		this.bufferTimer = setTimeout(async () => {
+			try {
+				await this.flushBuffers();
+			} catch (error) {
+				this.logger.error({
+					message: `Error in flush cycle: ${error.message}`,
+					service: this.SERVICE_NAME,
+					method: "scheduleNextFlush",
+					stack: error.stack,
+				});
+			} finally {
+				// Schedule the next flush only after the current one completes
+				this.scheduleNextFlush();
+			}
+		}, BUFFER_TIMEOUT);
+	}
+	async flushBuffers() {
+		let items = 0;
+		for (const [bufferName, buffer] of Object.entries(this.buffers)) {
+			items += buffer.length;
+			const operation = this.OPERATION_MAP[bufferName];
+			if (!operation) {
+				this.logger.error({
+					message: `No operation found for ${bufferName}`,
+					service: this.SERVICE_NAME,
+					method: "flushBuffers",
+				});
+				continue;
+			}
+			try {
+				await operation(buffer);
+			} catch (error) {
+				this.logger.error({
+					message: error.message,
+					service: this.SERVICE_NAME,
+					method: "flushBuffers",
+					stack: error.stack,
+				});
+			}
+			this.buffers[bufferName] = [];
+		}
+		this.logger.debug({
+			message: `Flushed ${items} items`,
+			service: this.SERVICE_NAME,
+			method: "flushBuffers",
+		});
+		items = 0;
+	}
+}
+
+export default BufferService;

server/src/service/infrastructure/emailService.js

@@ -0,0 +1,171 @@
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const SERVICE_NAME = "EmailService";
+
+/**
+ * Represents an email service that can load templates, build, and send emails.
+ */
+class EmailService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	/**
+	 * Constructs an instance of the EmailService, initializing template loaders and the email transporter.
+	 * @param {Object} settingsService - The settings service to get email configuration.
+	 * @param {Object} fs - The file system module.
+	 * @param {Object} path - The path module.
+	 * @param {Function} compile - The Handlebars compile function.
+	 * @param {Function} mjml2html - The MJML to HTML conversion function.
+	 * @param {Object} nodemailer - The nodemailer module.
+	 * @param {Object} logger - The logger module.
+	 */
+	constructor(settingsService, fs, path, compile, mjml2html, nodemailer, logger) {
+		this.settingsService = settingsService;
+		this.fs = fs;
+		this.path = path;
+		this.compile = compile;
+		this.mjml2html = mjml2html;
+		this.nodemailer = nodemailer;
+		this.logger = logger;
+		this.init();
+	}
+
+	get serviceName() {
+		return EmailService.SERVICE_NAME;
+	}
+
+	init = async () => {
+		/**
+		 * Loads an email template from the filesystem.
+		 *
+		 * @param {string} templateName - The name of the template to load.
+		 * @returns {Function} A compiled template function that can be used to generate HTML email content.
+		 */
+		this.loadTemplate = (templateName) => {
+			try {
+				const templatePath = this.path.join(__dirname, `../../templates/${templateName}.mjml`);
+				const templateContent = this.fs.readFileSync(templatePath, "utf8");
+				return this.compile(templateContent);
+			} catch (error) {
+				this.logger.error({
+					message: error.message,
+					service: SERVICE_NAME,
+					method: "loadTemplate",
+					stack: error.stack,
+				});
+			}
+		};
+
+		/**
+		 * A lookup object to access preloaded email templates.
+		 * @type {Object.<string, Function>}
+		 * TODO  Load less used templates in their respective functions
+		 */
+		this.templateLookup = {
+			welcomeEmailTemplate: this.loadTemplate("welcomeEmail"),
+			employeeActivationTemplate: this.loadTemplate("employeeActivation"),
+			noIncidentsThisWeekTemplate: this.loadTemplate("noIncidentsThisWeek"),
+			serverIsDownTemplate: this.loadTemplate("serverIsDown"),
+			serverIsUpTemplate: this.loadTemplate("serverIsUp"),
+			passwordResetTemplate: this.loadTemplate("passwordReset"),
+			hardwareIncidentTemplate: this.loadTemplate("hardwareIncident"),
+			testEmailTemplate: this.loadTemplate("testEmailTemplate"),
+		};
+
+		/**
+		 * The email transporter used to send emails.
+		 * @type {Object}
+		 */
+	};
+
+	buildEmail = async (template, context) => {
+		try {
+			const mjml = this.templateLookup[template](context);
+			const html = await this.mjml2html(mjml);
+			return html.html;
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "buildEmail",
+				stack: error.stack,
+			});
+		}
+	};
+
+	sendEmail = async (to, subject, html, transportConfig) => {
+		let config;
+		if (typeof transportConfig !== "undefined") {
+			config = transportConfig;
+		} else {
+			config = await this.settingsService.getDBSettings();
+		}
+		const {
+			systemEmailHost,
+			systemEmailPort,
+			systemEmailSecure,
+			systemEmailPool,
+			systemEmailUser,
+			systemEmailAddress,
+			systemEmailPassword,
+			systemEmailConnectionHost,
+			systemEmailTLSServername,
+			systemEmailIgnoreTLS,
+			systemEmailRequireTLS,
+			systemEmailRejectUnauthorized,
+		} = config;
+
+		const emailConfig = {
+			host: systemEmailHost,
+			port: Number(systemEmailPort),
+			secure: systemEmailSecure,
+			auth: {
+				user: systemEmailUser || systemEmailAddress,
+				pass: systemEmailPassword,
+			},
+			name: systemEmailConnectionHost || "localhost",
+			connectionTimeout: 5000,
+			pool: systemEmailPool,
+			tls: {
+				rejectUnauthorized: systemEmailRejectUnauthorized,
+				ignoreTLS: systemEmailIgnoreTLS,
+				requireTLS: systemEmailRequireTLS,
+				servername: systemEmailTLSServername,
+			},
+		};
+		this.transporter = this.nodemailer.createTransport(emailConfig);
+
+		try {
+			await this.transporter.verify();
+		} catch (error) {
+			this.logger.warn({
+				message: "Email transporter verification failed",
+				service: SERVICE_NAME,
+				method: "verifyTransporter",
+			});
+			return false;
+		}
+
+		try {
+			const info = await this.transporter.sendMail({
+				to: to,
+				from: systemEmailAddress,
+				subject: subject,
+				html: html,
+			});
+			return info?.messageId;
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "sendEmail",
+				stack: error.stack,
+			});
+		}
+	};
+}
+
+export default EmailService;

server/src/service/infrastructure/errorService.js

@@ -0,0 +1,101 @@
+export class AppError extends Error {
+	constructor(message, status = 500, service = null, method = null, details = null) {
+		super(message);
+		this.status = status;
+		this.service = service;
+		this.method = method;
+		this.details = details;
+
+		Error.captureStackTrace(this, this.constructor);
+	}
+}
+
+class ValidationError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 422, service, method, details);
+	}
+}
+
+class AuthenticationError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 401, service, method, details);
+	}
+}
+
+class AuthorizationError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 403, service, method, details);
+	}
+}
+
+class NotFoundError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 404, service, method, details);
+	}
+}
+
+class ConflictError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 409, service, method, details);
+	}
+}
+
+class DatabaseError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 500, service, method, details);
+	}
+}
+
+class BadRequestError extends AppError {
+	constructor(message, details = null, service = null, method = null) {
+		super(message, 400, service, method, details);
+	}
+}
+
+const SERVICE_NAME = "ErrorService";
+class ErrorService {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor() {}
+
+	get serviceName() {
+		return ErrorService.SERVICE_NAME;
+	}
+
+	createError = (message, status = 500, service = null, method = null, details = null) => {
+		return new AppError(message, status, service, method, details);
+	};
+
+	createValidationError = (message, details = null, service = null, method = null) => {
+		return new ValidationError(message, details, service, method);
+	};
+
+	createAuthenticationError = (message = "Unauthorized", details = null, service = null, method = null) => {
+		return new AuthenticationError(message, details, service, method);
+	};
+
+	createAuthorizationError = (message, details = null, service = null, method = null) => {
+		return new AuthorizationError(message, details, service, method);
+	};
+
+	createNotFoundError = (message, details = null, service = null, method = null) => {
+		return new NotFoundError(message, details, service, method);
+	};
+
+	createConflictError = (message, details = null, service = null, method = null) => {
+		return new ConflictError(message, details, service, method);
+	};
+
+	createDatabaseError = (message, details = null, service = null, method = null) => {
+		return new DatabaseError(message, details, service, method);
+	};
+
+	createServerError = (message, details = null, service = null, method = null) => {
+		return this.createError(message, 500, service, method, details);
+	};
+
+	createBadRequestError = (message = "BadRequest", details = null, service = null, method = null) => {
+		return new BadRequestError(message, details, service, method);
+	};
+}
+
+export default ErrorService;

server/src/service/infrastructure/networkService.js

@@ -0,0 +1,503 @@
+import jmespath from "jmespath";
+import https from "https";
+
+const SERVICE_NAME = "NetworkService";
+const UPROCK_ENDPOINT = "https://api.uprock.com/checkmate/push";
+
+/**
+ * Constructs a new NetworkService instance.
+ *
+ * @param {Object} axios - The axios instance for HTTP requests.
+ * @param {Object} ping - The ping utility for network checks.
+ * @param {Object} logger - The logger instance for logging.
+ * @param {Object} http - The HTTP utility for network operations.
+ * @param {Object} net - The net utility for network operations.
+ */
+class NetworkService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor(axios, ping, logger, http, Docker, net, stringService, settingsService) {
+		this.TYPE_PING = "ping";
+		this.TYPE_HTTP = "http";
+		this.TYPE_PAGESPEED = "pagespeed";
+		this.TYPE_HARDWARE = "hardware";
+		this.TYPE_DOCKER = "docker";
+		this.TYPE_PORT = "port";
+		this.SERVICE_NAME = SERVICE_NAME;
+		this.NETWORK_ERROR = 5000;
+		this.PING_ERROR = 5001;
+		this.axios = axios;
+		this.ping = ping;
+		this.logger = logger;
+		this.http = http;
+		this.Docker = Docker;
+		this.net = net;
+		this.stringService = stringService;
+		this.settingsService = settingsService;
+	}
+
+	get serviceName() {
+		return NetworkService.SERVICE_NAME;
+	}
+
+	/**
+	 * Times the execution of an asynchronous operation.
+	 *
+	 * @param {Function} operation - The asynchronous operation to be timed.
+	 * @returns {Promise<Object>} An object containing the response, response time, and optionally an error.
+	 * @property {Object|null} response - The response from the operation, or null if an error occurred.
+	 * @property {number} responseTime - The time taken for the operation to complete, in milliseconds.
+	 * @property {Error} [error] - The error object if an error occurred during the operation.
+	 */
+	async timeRequest(operation) {
+		const startTime = Date.now();
+		try {
+			const response = await operation();
+			const endTime = Date.now();
+			const responseTime = endTime - startTime;
+			return { response, responseTime };
+		} catch (error) {
+			const endTime = Date.now();
+			const responseTime = endTime - startTime;
+			return { response: null, responseTime, error };
+		}
+	}
+
+	/**
+	 * Performs a ping check to a specified host to verify its availability.
+	 * @async
+	 * @param {Object} monitor - The monitor configuration object
+	 * @param {string} monitor.url - The host URL to ping
+	 * @param {string} monitor._id - The unique identifier of the monitor
+	 * @returns {Promise<Object>} A promise that resolves to a ping response object
+	 * @returns {string} pingResponse.monitorId - The ID of the monitor
+	 * @returns {string} pingResponse.type - The type of monitor (always "ping")
+	 * @returns {number} pingResponse.responseTime - The time taken for the ping
+	 * @returns {Object} pingResponse.payload - The raw ping response data
+	 * @returns {boolean} pingResponse.status - Whether the host is alive (true) or not (false)
+	 * @returns {number} pingResponse.code - Status code (200 for success, PING_ERROR for failure)
+	 * @returns {string} pingResponse.message - Success or failure message
+	 * @throws {Error} If there's an error during the ping operation
+	 */
+	async requestPing(monitor) {
+		try {
+			const url = monitor.url;
+			const { response, responseTime, error } = await this.timeRequest(() => this.ping.promise.probe(url));
+
+			const pingResponse = {
+				monitorId: monitor._id,
+				type: "ping",
+				responseTime,
+				payload: response,
+			};
+			if (error) {
+				pingResponse.status = false;
+				pingResponse.code = this.PING_ERROR;
+				pingResponse.message = "No response";
+				return pingResponse;
+			}
+
+			pingResponse.code = 200;
+			pingResponse.status = response.alive;
+			pingResponse.message = "Success";
+			return pingResponse;
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestPing";
+			throw error;
+		}
+	}
+
+	/**
+	 * Performs an HTTP GET request to a specified URL with optional validation of response data.
+	 * @async
+	 * @param {Object} monitor - The monitor configuration object
+	 * @param {string} monitor.url - The URL to make the HTTP request to
+	 * @param {string} [monitor.secret] - Optional Bearer token for authentication
+	 * @param {string} monitor._id - The unique identifier of the monitor
+	 * @param {string} monitor.name - The name of the monitor
+	 * @param {string} monitor.teamId - The team ID associated with the monitor
+	 * @param {string} monitor.type - The type of monitor
+	 * @param {boolean} [monitor.ignoreTlsErrors] - Whether to ignore TLS certificate errors
+	 * @param {string} [monitor.jsonPath] - Optional JMESPath expression to extract data from JSON response
+	 * @param {string} [monitor.matchMethod] - Method to match response data ('include', 'regex', or exact match)
+	 * @param {string} [monitor.expectedValue] - Expected value to match against response data
+	 * @returns {Promise<Object>} A promise that resolves to an HTTP response object
+	 * @returns {string} httpResponse.monitorId - The ID of the monitor
+	 * @returns {string} httpResponse.teamId - The team ID
+	 * @returns {string} httpResponse.type - The type of monitor
+	 * @returns {number} httpResponse.responseTime - The time taken for the request
+	 * @returns {Object} httpResponse.payload - The response data
+	 * @returns {boolean} httpResponse.status - Whether the request was successful and matched expected value (if specified)
+	 * @returns {number} httpResponse.code - HTTP status code or NETWORK_ERROR
+	 * @returns {string} httpResponse.message - Success or failure message
+	 * @throws {Error} If there's an error during the HTTP request or data validation
+	 */
+	async requestHttp(monitor) {
+		try {
+			const { url, secret, _id, name, teamId, type, ignoreTlsErrors, jsonPath, matchMethod, expectedValue } = monitor;
+			const config = {};
+
+			secret !== undefined && (config.headers = { Authorization: `Bearer ${secret}` });
+
+			if (ignoreTlsErrors === true) {
+				config.httpsAgent = new https.Agent({
+					rejectUnauthorized: false,
+				});
+			}
+
+			const { response, responseTime, error } = await this.timeRequest(() => this.axios.get(url, config));
+
+			const httpResponse = {
+				monitorId: _id,
+				teamId,
+				type,
+				responseTime,
+				payload: response?.data,
+			};
+
+			if (error) {
+				const code = error.response?.status || this.NETWORK_ERROR;
+				httpResponse.code = code;
+				httpResponse.status = false;
+				httpResponse.message = this.http.STATUS_CODES[code] || this.stringService.httpNetworkError;
+				return httpResponse;
+			}
+
+			httpResponse.code = response.status;
+
+			if (!expectedValue) {
+				// not configure expected value, return
+				httpResponse.status = true;
+				httpResponse.message = this.http.STATUS_CODES[response.status];
+				return httpResponse;
+			}
+
+			// validate if response data match expected value
+			let result = response?.data;
+
+			this.logger.info({
+				service: this.SERVICE_NAME,
+				method: "requestHttp",
+				message: `Job: [${name}](${_id}) match result with expected value`,
+				details: { expectedValue, result, jsonPath, matchMethod },
+			});
+
+			if (jsonPath) {
+				const contentType = response.headers["content-type"];
+
+				const isJson = contentType?.includes("application/json");
+				if (!isJson) {
+					httpResponse.status = false;
+					httpResponse.message = this.stringService.httpNotJson;
+					return httpResponse;
+				}
+
+				try {
+					result = jmespath.search(result, jsonPath);
+				} catch (error) {
+					httpResponse.status = false;
+					httpResponse.message = this.stringService.httpJsonPathError;
+					return httpResponse;
+				}
+			}
+
+			if (result === null || result === undefined) {
+				httpResponse.status = false;
+				httpResponse.message = this.stringService.httpEmptyResult;
+				return httpResponse;
+			}
+
+			let match;
+			result = typeof result === "object" ? JSON.stringify(result) : result.toString();
+			if (matchMethod === "include") match = result.includes(expectedValue);
+			else if (matchMethod === "regex") match = new RegExp(expectedValue).test(result);
+			else match = result === expectedValue;
+
+			httpResponse.status = match;
+			httpResponse.message = match ? this.stringService.httpMatchSuccess : this.stringService.httpMatchFail;
+			return httpResponse;
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestHttp";
+			throw error;
+		}
+	}
+
+	/**
+	 * Checks the performance of a webpage using Google's PageSpeed Insights API.
+	 * @async
+	 * @param {Object} monitor - The monitor configuration object
+	 * @param {string} monitor.url - The URL of the webpage to analyze
+	 * @returns {Promise<Object|undefined>} A promise that resolves to a pagespeed response object or undefined if API key is missing
+	 * @returns {string} response.monitorId - The ID of the monitor
+	 * @returns {string} response.type - The type of monitor
+	 * @returns {number} response.responseTime - The time taken for the analysis
+	 * @returns {boolean} response.status - Whether the analysis was successful
+	 * @returns {number} response.code - HTTP status code from the PageSpeed API
+	 * @returns {string} response.message - Success or failure message
+	 * @returns {Object} response.payload - The PageSpeed analysis results
+	 * @throws {Error} If there's an error during the PageSpeed analysis
+	 */
+	async requestPagespeed(monitor) {
+		try {
+			const url = monitor.url;
+			const updatedMonitor = { ...monitor };
+			let pagespeedUrl = `https://pagespeedonline.googleapis.com/pagespeedonline/v5/runPagespeed?url=${url}&category=seo&category=accessibility&category=best-practices&category=performance`;
+
+			const dbSettings = await this.settingsService.getDBSettings();
+			if (dbSettings?.pagespeedApiKey) {
+				pagespeedUrl += `&key=${dbSettings.pagespeedApiKey}`;
+			} else {
+				this.logger.warn({
+					message: "Pagespeed API key not found, job not executed",
+					service: this.SERVICE_NAME,
+					method: "requestPagespeed",
+					details: { url },
+				});
+				return;
+			}
+			updatedMonitor.url = pagespeedUrl;
+			return await this.requestHttp(updatedMonitor);
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestPagespeed";
+			throw error;
+		}
+	}
+
+	async requestHardware(monitor) {
+		try {
+			return await this.requestHttp(monitor);
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestHardware";
+			throw error;
+		}
+	}
+
+	/**
+	 * Checks the status of a Docker container by its ID.
+	 * @async
+	 * @param {Object} monitor - The monitor configuration object
+	 * @param {string} monitor.url - The Docker container ID to check
+	 * @param {string} monitor._id - The unique identifier of the monitor
+	 * @param {string} monitor.type - The type of monitor
+	 * @returns {Promise<Object>} A promise that resolves to a docker response object
+	 * @returns {string} dockerResponse.monitorId - The ID of the monitor
+	 * @returns {string} dockerResponse.type - The type of monitor
+	 * @returns {number} dockerResponse.responseTime - The time taken for the container inspection
+	 * @returns {boolean} dockerResponse.status - Whether the container is running (true) or not (false)
+	 * @returns {number} dockerResponse.code - HTTP-like status code (200 for success, NETWORK_ERROR for failure)
+	 * @returns {string} dockerResponse.message - Success or failure message
+	 * @throws {Error} If the container is not found or if there's an error inspecting the container
+	 */
+	async requestDocker(monitor) {
+		try {
+			const docker = new this.Docker({
+				socketPath: "/var/run/docker.sock",
+				handleError: true, // Enable error handling
+			});
+
+			const containers = await docker.listContainers({ all: true });
+			const containerExists = containers.some((c) => c.Id.startsWith(monitor.url));
+			if (!containerExists) {
+				throw new Error(this.stringService.dockerNotFound);
+			}
+			const container = docker.getContainer(monitor.url);
+
+			const { response, responseTime, error } = await this.timeRequest(() => container.inspect());
+
+			const dockerResponse = {
+				monitorId: monitor._id,
+				type: monitor.type,
+				responseTime,
+			};
+
+			if (error) {
+				dockerResponse.status = false;
+				dockerResponse.code = error.statusCode || this.NETWORK_ERROR;
+				dockerResponse.message = error.reason || "Failed to fetch Docker container information";
+				return dockerResponse;
+			}
+			dockerResponse.status = response?.State?.Status === "running" ? true : false;
+			dockerResponse.code = 200;
+			dockerResponse.message = "Docker container status fetched successfully";
+			return dockerResponse;
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestDocker";
+			throw error;
+		}
+	}
+
+	/**
+	 * Attempts to establish a TCP connection to a specified host and port.
+	 * @async
+	 * @param {Object} monitor - The monitor configuration object
+	 * @param {string} monitor.url - The host URL to connect to
+	 * @param {number} monitor.port - The port number to connect to
+	 * @param {string} monitor._id - The unique identifier of the monitor
+	 * @param {string} monitor.type - The type of monitor
+	 * @returns {Promise<Object>} A promise that resolves to a port response object
+	 * @returns {string} portResponse.monitorId - The ID of the monitor
+	 * @returns {string} portResponse.type - The type of monitor
+	 * @returns {number} portResponse.responseTime - The time taken for the connection attempt
+	 * @returns {boolean} portResponse.status - Whether the connection was successful
+	 * @returns {number} portResponse.code - HTTP-like status code (200 for success, NETWORK_ERROR for failure)
+	 * @returns {string} portResponse.message - Success or failure message
+	 * @throws {Error} If the connection times out or encounters an error
+	 */
+	async requestPort(monitor) {
+		try {
+			const { url, port } = monitor;
+			const { response, responseTime, error } = await this.timeRequest(async () => {
+				return new Promise((resolve, reject) => {
+					const socket = this.net.createConnection(
+						{
+							host: url,
+							port,
+						},
+						() => {
+							socket.end();
+							socket.destroy();
+							resolve({ success: true });
+						}
+					);
+
+					socket.setTimeout(5000);
+					socket.on("timeout", () => {
+						socket.destroy();
+						reject(new Error("Connection timeout"));
+					});
+
+					socket.on("error", (err) => {
+						socket.destroy();
+						reject(err);
+					});
+				});
+			});
+
+			const portResponse = {
+				monitorId: monitor._id,
+				type: monitor.type,
+				responseTime,
+			};
+
+			if (error) {
+				portResponse.status = false;
+				portResponse.code = this.NETWORK_ERROR;
+				portResponse.message = this.stringService.portFail;
+				return portResponse;
+			}
+
+			portResponse.status = response.success;
+			portResponse.code = 200;
+			portResponse.message = this.stringService.portSuccess;
+			return portResponse;
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "requestTCP";
+			throw error;
+		}
+	}
+
+	/**
+	 * Handles unsupported job types by throwing an error with details.
+	 *
+	 * @param {string} type - The unsupported job type that was provided
+	 * @throws {Error} An error with service name, method name and unsupported type message
+	 */
+	handleUnsupportedType(type) {
+		const err = new Error(`Unsupported type: ${type}`);
+		err.service = this.SERVICE_NAME;
+		err.method = "getStatus";
+		throw err;
+	}
+
+	async requestWebhook(type, url, body) {
+		try {
+			const response = await this.axios.post(url, body, {
+				headers: {
+					"Content-Type": "application/json",
+				},
+			});
+
+			return {
+				type: "webhook",
+				status: true,
+				code: response.status,
+				message: `Successfully sent ${type} notification`,
+				payload: response.data,
+			};
+		} catch (error) {
+			this.logger.warn({
+				message: error.message,
+				service: this.SERVICE_NAME,
+				method: "requestWebhook",
+			});
+
+			return {
+				type: "webhook",
+				status: false,
+				code: error.response?.status || this.NETWORK_ERROR,
+				message: `Failed to send ${type} notification`,
+				payload: error.response?.data,
+			};
+		}
+	}
+
+	async requestPagerDuty({ message, routingKey, monitorUrl }) {
+		try {
+			const response = await this.axios.post(`https://events.pagerduty.com/v2/enqueue`, {
+				routing_key: routingKey,
+				event_action: "trigger",
+				payload: {
+					summary: message,
+					severity: "critical",
+					source: monitorUrl,
+					timestamp: new Date().toISOString(),
+				},
+			});
+
+			if (response?.data?.status !== "success") return false;
+			return true;
+		} catch (error) {
+			error.details = error.response?.data;
+			error.service = this.SERVICE_NAME;
+			error.method = "requestPagerDuty";
+			throw error;
+		}
+	}
+
+	/**
+	 * Gets the status of a job based on its type and returns the appropriate response.
+	 *
+	 * @param {Object} job - The job object containing the data for the status request.
+	 * @param {Object} job.data - The data object within the job.
+	 * @param {string} job.data.type - The type of the job (e.g., "ping", "http", "pagespeed", "hardware").
+	 * @returns {Promise<Object>} The response object from the appropriate request method.
+	 * @throws {Error} Throws an error if the job type is unsupported.
+	 */
+	async getStatus(monitor) {
+		const type = monitor.type ?? "unknown";
+		switch (type) {
+			case this.TYPE_PING:
+				return await this.requestPing(monitor);
+			case this.TYPE_HTTP:
+				return await this.requestHttp(monitor);
+			case this.TYPE_PAGESPEED:
+				return await this.requestPagespeed(monitor);
+			case this.TYPE_HARDWARE:
+				return await this.requestHardware(monitor);
+			case this.TYPE_DOCKER:
+				return await this.requestDocker(monitor);
+			case this.TYPE_PORT:
+				return await this.requestPort(monitor);
+			default:
+				return this.handleUnsupportedType(type);
+		}
+	}
+}
+
+export default NetworkService;

server/src/service/infrastructure/notificationService.js

@@ -0,0 +1,119 @@
+const SERVICE_NAME = "NotificationService";
+
+class NotificationService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ emailService, db, logger, networkService, stringService, notificationUtils }) {
+		this.emailService = emailService;
+		this.db = db;
+		this.logger = logger;
+		this.networkService = networkService;
+		this.stringService = stringService;
+		this.notificationUtils = notificationUtils;
+	}
+
+	get serviceName() {
+		return NotificationService.SERVICE_NAME;
+	}
+
+	sendNotification = async ({ notification, subject, content, html }) => {
+		const { type, address } = notification;
+
+		if (type === "email") {
+			const messageId = await this.emailService.sendEmail(address, subject, html);
+			if (!messageId) return false;
+			return true;
+		}
+
+		// Create a body for webhooks
+		let body = { text: content };
+		if (type === "discord") {
+			body = { content };
+		}
+
+		if (type === "slack" || type === "discord" || type === "webhook") {
+			const response = await this.networkService.requestWebhook(type, address, body);
+			return response.status;
+		}
+		if (type === "pager_duty") {
+			const response = await this.networkService.requestPagerDuty({
+				message: content,
+				monitorUrl: subject,
+				routingKey: address,
+			});
+
+			return response;
+		}
+	};
+
+	async handleNotifications(networkResponse) {
+		const { monitor, statusChanged, prevStatus } = networkResponse;
+		const { type } = monitor;
+		if (type !== "hardware" && statusChanged === false) return false;
+		// if prevStatus is undefined, monitor is resuming, we're done
+		if (type !== "hardware" && prevStatus === undefined) return false;
+
+		const notificationIDs = networkResponse.monitor?.notifications ?? [];
+		if (notificationIDs.length === 0) return false;
+
+		if (networkResponse.monitor.type === "hardware") {
+			const thresholds = networkResponse?.monitor?.thresholds;
+
+			if (thresholds === undefined) return false; // No thresholds set, we're done
+			const metrics = networkResponse?.payload?.data ?? null;
+			if (metrics === null) return false; // No metrics, we're done
+
+			const alerts = await this.notificationUtils.buildHardwareAlerts(networkResponse);
+			if (alerts.length === 0) return false;
+
+			const { subject, html } = await this.notificationUtils.buildHardwareEmail(networkResponse, alerts);
+			const content = await this.notificationUtils.buildHardwareNotificationMessage(alerts);
+
+			const success = await this.notifyAll({ notificationIDs, subject, html, content });
+			return success;
+		}
+
+		// Status monitors
+		const { subject, html } = await this.notificationUtils.buildStatusEmail(networkResponse);
+		const content = await this.notificationUtils.buildWebhookMessage(networkResponse);
+		const success = this.notifyAll({ notificationIDs, subject, html, content });
+		return success;
+	}
+
+	async notifyAll({ notificationIDs, subject, html, content }) {
+		const notifications = await this.db.getNotificationsByIds(notificationIDs);
+
+		// Map each notification to a test promise
+		const promises = notifications.map(async (notification) => {
+			try {
+				await this.sendNotification({ notification, subject, content, html });
+				return true;
+			} catch (err) {
+				return false;
+			}
+		});
+
+		const results = await Promise.all(promises);
+		return results.every((r) => r === true);
+	}
+
+	async getTestNotification() {
+		const html = await this.notificationUtils.buildTestEmail();
+		const content = "This is a test notification";
+		const subject = "Test Notification";
+		return { subject, html, content };
+	}
+
+	async testAllNotifications(notificationIDs) {
+		const { subject, html, content } = await this.getTestNotification();
+		return this.notifyAll({ notificationIDs, subject, html, content });
+	}
+
+	async sendTestNotification(notification) {
+		const { subject, html, content } = await this.getTestNotification();
+		const success = await this.sendNotification({ notification, subject, content, html });
+		return success;
+	}
+}
+
+export default NotificationService;

server/src/service/infrastructure/notificationUtils.js

@@ -0,0 +1,132 @@
+const SERVICE_NAME = "NotificationUtils";
+
+class NotificationUtils {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor({ stringService, emailService }) {
+		this.stringService = stringService;
+		this.emailService = emailService;
+	}
+
+	get serviceName() {
+		return NotificationUtils.SERVICE_NAME;
+	}
+
+	buildTestEmail = async () => {
+		const context = { testName: "Monitoring System" };
+		const html = await this.emailService.buildEmail("testEmailTemplate", context);
+		return html;
+	};
+
+	buildStatusEmail = async (networkResponse) => {
+		const { monitor, status, prevStatus } = networkResponse;
+		const template = prevStatus === false ? "serverIsUpTemplate" : "serverIsDownTemplate";
+		const context = { monitor: monitor.name, url: monitor.url };
+		const subject = `Monitor ${monitor.name} is ${status === true ? "up" : "down"}`;
+		const html = await this.emailService.buildEmail(template, context);
+		return { subject, html };
+	};
+
+	buildWebhookMessage = (networkResponse) => {
+		const { monitor, status, code, timestamp } = networkResponse;
+		// Format timestamp using the local system timezone
+		const formatTime = (timestamp) => {
+			const date = new Date(timestamp);
+
+			// Get timezone abbreviation and format the date
+			const timeZoneAbbr = date.toLocaleTimeString("en-US", { timeZoneName: "short" }).split(" ").pop();
+
+			// Format the date with readable format
+			return (
+				date
+					.toLocaleString("en-US", {
+						year: "numeric",
+						month: "2-digit",
+						day: "2-digit",
+						hour: "2-digit",
+						minute: "2-digit",
+						second: "2-digit",
+						hour12: false,
+					})
+					.replace(/(\d+)\/(\d+)\/(\d+),\s/, "$3-$1-$2 ") +
+				" " +
+				timeZoneAbbr
+			);
+		};
+
+		// Get formatted time
+		const formattedTime = timestamp ? formatTime(timestamp) : formatTime(new Date().getTime());
+
+		// Create different messages based on status with extra spacing
+		let messageText;
+		if (status === true) {
+			messageText = this.stringService.monitorUpAlert
+				.replace("{monitorName}", monitor.name)
+				.replace("{time}", formattedTime)
+				.replace("{code}", code || "Unknown");
+		} else {
+			messageText = this.stringService.monitorDownAlert
+				.replace("{monitorName}", monitor.name)
+				.replace("{time}", formattedTime)
+				.replace("{code}", code || "Unknown");
+		}
+		return messageText;
+	};
+
+	buildHardwareAlerts = async (networkResponse) => {
+		const monitor = networkResponse?.monitor;
+		const thresholds = networkResponse?.monitor?.thresholds;
+		const { usage_cpu: cpuThreshold = -1, usage_memory: memoryThreshold = -1, usage_disk: diskThreshold = -1 } = thresholds;
+
+		const metrics = networkResponse?.payload?.data;
+		const { cpu: { usage_percent: cpuUsage = -1 } = {}, memory: { usage_percent: memoryUsage = -1 } = {}, disk = [] } = metrics;
+
+		const alerts = {
+			cpu: cpuThreshold !== -1 && cpuUsage > cpuThreshold ? true : false,
+			memory: memoryThreshold !== -1 && memoryUsage > memoryThreshold ? true : false,
+			disk: disk?.some((d) => diskThreshold !== -1 && typeof d?.usage_percent === "number" && d?.usage_percent > diskThreshold) ?? false,
+		};
+
+		const alertsToSend = [];
+		const alertTypes = ["cpu", "memory", "disk"];
+		for (const type of alertTypes) {
+			// Iterate over each alert type to see if any need to be decremented
+			if (alerts[type] === true) {
+				monitor[`${type}AlertThreshold`]--; // Decrement threshold if an alert is triggered
+
+				if (monitor[`${type}AlertThreshold`] <= 0) {
+					// If threshold drops below 0, reset and send notification
+					monitor[`${type}AlertThreshold`] = monitor.alertThreshold;
+
+					const formatAlert = {
+						cpu: () => `Your current CPU usage (${(cpuUsage * 100).toFixed(0)}%) is above your threshold (${(cpuThreshold * 100).toFixed(0)}%)`,
+						memory: () =>
+							`Your current memory usage (${(memoryUsage * 100).toFixed(0)}%) is above your threshold (${(memoryThreshold * 100).toFixed(0)}%)`,
+						disk: () =>
+							`Your current disk usage: ${disk
+								.map((d, idx) => `(Disk${idx}: ${(d.usage_percent * 100).toFixed(0)}%)`)
+								.join(", ")} is above your threshold (${(diskThreshold * 100).toFixed(0)}%)`,
+					};
+					alertsToSend.push(formatAlert[type]());
+				}
+			}
+		}
+		await monitor.save();
+		return alertsToSend;
+	};
+
+	buildHardwareEmail = async (networkResponse, alerts) => {
+		const { monitor } = networkResponse;
+		const template = "hardwareIncidentTemplate";
+		const context = { monitor: monitor.name, url: monitor.url, alerts };
+		const subject = `Monitor ${monitor.name} infrastructure alerts`;
+		const html = await this.emailService.buildEmail(template, context);
+		return { subject, html };
+	};
+
+	buildHardwareNotificationMessage = (alerts) => {
+		return alerts.map((alert) => alert).join("\n");
+	};
+}
+
+export default NotificationUtils;

server/src/service/infrastructure/statusService.js

@@ -0,0 +1,288 @@
+import MonitorStats from "../../db/models/MonitorStats.js";
+import { safelyParseFloat } from "../../utils/dataUtils.js";
+const SERVICE_NAME = "StatusService";
+
+class StatusService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	/**
+	 * Creates an instance of StatusService.
+	 *
+	 * @param {Object} db - The database instance.
+	 * @param {Object} logger - The logger instance.
+	 */
+	constructor({ db, logger, buffer }) {
+		this.db = db;
+		this.logger = logger;
+		this.buffer = buffer;
+	}
+
+	get serviceName() {
+		return StatusService.SERVICE_NAME;
+	}
+
+	async updateRunningStats({ monitor, networkResponse }) {
+		try {
+			const monitorId = monitor._id;
+			const { responseTime, status, upt_burnt } = networkResponse;
+			// Get stats
+			let stats = await MonitorStats.findOne({ monitorId });
+			if (!stats) {
+				stats = new MonitorStats({
+					monitorId,
+					avgResponseTime: 0,
+					totalChecks: 0,
+					totalUpChecks: 0,
+					totalDownChecks: 0,
+					uptimePercentage: 0,
+					lastCheck: null,
+					timeSInceLastCheck: 0,
+					uptBurnt: 0,
+				});
+			}
+
+			// Update stats
+
+			// Last response time
+			stats.lastResponseTime = responseTime;
+
+			// Avg response time:
+			let avgResponseTime = stats.avgResponseTime;
+			if (typeof responseTime !== "undefined" && responseTime !== null) {
+				if (avgResponseTime === 0) {
+					avgResponseTime = responseTime;
+				} else {
+					avgResponseTime = (avgResponseTime * (stats.totalChecks - 1) + responseTime) / stats.totalChecks;
+				}
+			}
+			stats.avgResponseTime = avgResponseTime;
+
+			// Total checks
+			stats.totalChecks++;
+			if (status === true) {
+				stats.totalUpChecks++;
+				// Update the timeSinceLastFailure if needed
+				if (stats.timeOfLastFailure === 0) {
+					stats.timeOfLastFailure = new Date().getTime();
+				}
+			} else {
+				stats.totalDownChecks++;
+				stats.timeOfLastFailure = 0;
+			}
+
+			// Calculate uptime percentage
+			let uptimePercentage;
+			if (stats.totalChecks > 0) {
+				uptimePercentage = stats.totalUpChecks / stats.totalChecks;
+			} else {
+				uptimePercentage = status === true ? 100 : 0;
+			}
+			stats.uptimePercentage = uptimePercentage;
+
+			// latest check
+			stats.lastCheckTimestamp = new Date().getTime();
+
+			// UPT burned
+			if (typeof upt_burnt !== "undefined" && upt_burnt !== null) {
+				const currentUptBurnt = safelyParseFloat(stats.uptBurnt);
+				const newUptBurnt = safelyParseFloat(upt_burnt);
+				stats.uptBurnt = currentUptBurnt + newUptBurnt;
+			}
+			await stats.save();
+			return true;
+		} catch (error) {
+			this.logger.error({
+				service: this.SERVICE_NAME,
+				message: error.message,
+				method: "updateRunningStats",
+				stack: error.stack,
+			});
+			return false;
+		}
+	}
+
+	getStatusString = (status) => {
+		if (status === true) return "up";
+		if (status === false) return "down";
+		return "unknown";
+	};
+	/**
+	 * Updates the status of a monitor based on the network response.
+	 *
+	 * @param {Object} networkResponse - The network response containing monitorId and status.
+	 * @param {string} networkResponse.monitorId - The ID of the monitor.
+	 * @param {string} networkResponse.status - The new status of the monitor.
+	 * @returns {Promise<Object>} - A promise that resolves to an object containinfg the monitor, statusChanged flag, and previous status if the status changed, or false if an error occurred.
+	 * @returns {Promise<Object>} returnObject - The object returned by the function.
+	 * @returns {Object} returnObject.monitor - The monitor object.
+	 * @returns {boolean} returnObject.statusChanged - Flag indicating if the status has changed.
+	 * @returns {boolean} returnObject.prevStatus - The previous status of the monitor
+	 */
+	updateStatus = async (networkResponse) => {
+		this.insertCheck(networkResponse);
+		try {
+			const { monitorId, status, code } = networkResponse;
+			const monitor = await this.db.getMonitorById(monitorId);
+
+			// Update running stats
+			this.updateRunningStats({ monitor, networkResponse });
+
+			// No change in monitor status, return early
+			if (monitor.status === status)
+				return {
+					monitor,
+					statusChanged: false,
+					prevStatus: monitor.status,
+					code,
+					timestamp: new Date().getTime(),
+				};
+
+			// Monitor status changed, save prev status and update monitor
+			this.logger.info({
+				service: this.SERVICE_NAME,
+				message: `${monitor.name} went from ${this.getStatusString(monitor.status)} to ${this.getStatusString(status)}`,
+				prevStatus: monitor.status,
+				newStatus: status,
+			});
+
+			const prevStatus = monitor.status;
+			monitor.status = status;
+			await monitor.save();
+
+			return {
+				monitor,
+				statusChanged: true,
+				prevStatus,
+				code,
+				timestamp: new Date().getTime(),
+			};
+		} catch (error) {
+			error.service = this.SERVICE_NAME;
+			error.method = "updateStatus";
+			throw error;
+		}
+	};
+
+	/**
+	 * Builds a check object from the network response.
+	 *
+	 * @param {Object} networkResponse - The network response object.
+	 * @param {string} networkResponse.monitorId - The monitor ID.
+	 * @param {string} networkResponse.type - The type of the response.
+	 * @param {string} networkResponse.status - The status of the response.
+	 * @param {number} networkResponse.responseTime - The response time.
+	 * @param {number} networkResponse.code - The status code.
+	 * @param {string} networkResponse.message - The message.
+	 * @param {Object} networkResponse.payload - The payload of the response.
+	 * @returns {Object} The check object.
+	 */
+	buildCheck = (networkResponse) => {
+		const {
+			monitorId,
+			teamId,
+			type,
+			status,
+			responseTime,
+			code,
+			message,
+			payload,
+			first_byte_took,
+			body_read_took,
+			dns_took,
+			conn_took,
+			connect_took,
+			tls_took,
+		} = networkResponse;
+
+		const check = {
+			monitorId,
+			teamId,
+			status,
+			statusCode: code,
+			responseTime,
+			message,
+			first_byte_took,
+			body_read_took,
+			dns_took,
+			conn_took,
+			connect_took,
+			tls_took,
+		};
+
+		if (type === "pagespeed") {
+			if (typeof payload === "undefined") {
+				this.logger.warn({
+					message: "Failed to build check",
+					service: this.SERVICE_NAME,
+					method: "buildCheck",
+					details: "empty payload",
+				});
+				return undefined;
+			}
+			const categories = payload?.lighthouseResult?.categories ?? {};
+			const audits = payload?.lighthouseResult?.audits ?? {};
+			const {
+				"cumulative-layout-shift": cls = 0,
+				"speed-index": si = 0,
+				"first-contentful-paint": fcp = 0,
+				"largest-contentful-paint": lcp = 0,
+				"total-blocking-time": tbt = 0,
+			} = audits;
+			check.accessibility = (categories?.accessibility?.score || 0) * 100;
+			check.bestPractices = (categories?.["best-practices"]?.score || 0) * 100;
+			check.seo = (categories?.seo?.score || 0) * 100;
+			check.performance = (categories?.performance?.score || 0) * 100;
+			check.audits = { cls, si, fcp, lcp, tbt };
+		}
+
+		if (type === "hardware") {
+			const { cpu, memory, disk, host } = payload?.data ?? {};
+			const { errors } = payload?.errors ?? [];
+			check.cpu = cpu ?? {};
+			check.memory = memory ?? {};
+			check.disk = disk ?? {};
+			check.host = host ?? {};
+			check.errors = errors ?? [];
+			check.capture = payload?.capture ?? {};
+		}
+		return check;
+	};
+
+	/**
+	 * Inserts a check into the database based on the network response.
+	 *
+	 * @param {Object} networkResponse - The network response object.
+	 * @param {string} networkResponse.monitorId - The monitor ID.
+	 * @param {string} networkResponse.type - The type of the response.
+	 * @param {string} networkResponse.status - The status of the response.
+	 * @param {number} networkResponse.responseTime - The response time.
+	 * @param {number} networkResponse.code - The status code.
+	 * @param {string} networkResponse.message - The message.
+	 * @param {Object} networkResponse.payload - The payload of the response.
+	 * @returns {Promise<void>} A promise that resolves when the check is inserted.
+	 */
+	insertCheck = async (networkResponse) => {
+		try {
+			const check = this.buildCheck(networkResponse);
+			if (typeof check === "undefined") {
+				this.logger.warn({
+					message: "Failed to build check",
+					service: this.SERVICE_NAME,
+					method: "insertCheck",
+					details: networkResponse,
+				});
+				return;
+			}
+			this.buffer.addToBuffer({ check, type: networkResponse.type });
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: error.service || this.SERVICE_NAME,
+				method: error.method || "insertCheck",
+				details: error.details || `Error inserting check for monitor: ${networkResponse?.monitorId}`,
+				stack: error.stack,
+			});
+		}
+	};
+}
+export default StatusService;

server/src/service/system/serviceRegistry.js

@@ -0,0 +1,39 @@
+const SERVICE_NAME = "ServiceRegistry";
+import logger from "../../utils/logger.js";
+class ServiceRegistry {
+	static SERVICE_NAME = SERVICE_NAME;
+	constructor() {
+		this.services = {};
+	}
+
+	get serviceName() {
+		return ServiceRegistry.SERVICE_NAME;
+	}
+
+	register(name, service) {
+		logger.info({
+			message: `Registering service ${name}`,
+			service: SERVICE_NAME,
+			method: "register",
+		});
+		this.services[name] = service;
+	}
+
+	get(name) {
+		if (!this.services[name]) {
+			logger.error({
+				message: `Service ${name} is not registered`,
+				service: SERVICE_NAME,
+				method: "get",
+			});
+			throw new Error(`Service ${name} is not registered`);
+		}
+		return this.services[name];
+	}
+
+	listServices() {
+		return Object.keys(this.services);
+	}
+}
+
+export default new ServiceRegistry();

server/src/service/system/settingsService.js

@@ -0,0 +1,81 @@
+const SERVICE_NAME = "SettingsService";
+
+const envConfig = {
+	nodeEnv: process.env.NODE_ENV,
+	logLevel: process.env.LOG_LEVEL,
+	systemEmailHost: process.env.SYSTEM_EMAIL_HOST,
+	systemEmailPort: process.env.SYSTEM_EMAIL_PORT,
+	systemEmailUser: process.env.SYSTEM_EMAIL_USER,
+	systemEmailAddress: process.env.SYSTEM_EMAIL_ADDRESS,
+	systemEmailPassword: process.env.SYSTEM_EMAIL_PASSWORD,
+	jwtSecret: process.env.JWT_SECRET,
+	jwtTTL: process.env.TOKEN_TTL,
+	clientHost: process.env.CLIENT_HOST,
+	dbConnectionString: process.env.DB_CONNECTION_STRING,
+	redisUrl: process.env.REDIS_URL,
+	callbackUrl: process.env.CALLBACK_URL,
+	port: process.env.PORT,
+	pagespeedApiKey: process.env.PAGESPEED_API_KEY,
+	uprockApiKey: process.env.UPROCK_API_KEY,
+};
+/**
+ * SettingsService
+ *
+ * This service is responsible for loading and managing the application settings.
+ */
+class SettingsService {
+	static SERVICE_NAME = "SettingsService";
+
+	/**
+	 * Constructs a new SettingsService
+	 * @constructor
+	 * @throws {Error}
+	 */ constructor(AppSettings) {
+		this.AppSettings = AppSettings;
+		this.settings = { ...envConfig };
+	}
+
+	get serviceName() {
+		return SettingsService.SERVICE_NAME;
+	}
+
+	/**
+	 * Load settings from env settings
+	 * @returns {Object>} The settings.
+	 */
+	loadSettings() {
+		return this.settings;
+	}
+	/**
+	 * Reload settings by calling loadSettings.
+	 * @returns {Promise<Object>} The reloaded settings.
+	 */
+	reloadSettings() {
+		return this.loadSettings();
+	}
+	/**
+	 * Get the current settings.
+	 * @returns {Object} The current settings.
+	 * @throws Will throw an error if settings have not been loaded.
+	 */
+	getSettings() {
+		if (!this.settings) {
+			throw new Error("Settings have not been loaded");
+		}
+		return this.settings;
+	}
+
+	async getDBSettings() {
+		// Remove any old settings
+		await this.AppSettings.deleteMany({ version: { $exists: false } });
+
+		let settings = await this.AppSettings.findOne({ singleton: true }).select("-__v -_id -createdAt -updatedAt -singleton").lean();
+		if (settings === null) {
+			await this.AppSettings.create({});
+			settings = await this.AppSettings.findOne({ singleton: true }).select("-__v -_id -createdAt -updatedAt -singleton").lean();
+		}
+		return settings;
+	}
+}
+
+export default SettingsService;

server/src/service/system/stringService.js

@@ -0,0 +1,448 @@
+const SERVICE_NAME = "StringService";
+
+class StringService {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	constructor(translationService) {
+		if (StringService.instance) {
+			return StringService.instance;
+		}
+
+		this.translationService = translationService;
+		this._language = "en"; // default language
+		StringService.instance = this;
+	}
+
+	get serviceName() {
+		return StringService.SERVICE_NAME;
+	}
+
+	setLanguage(language) {
+		this._language = language;
+	}
+
+	get language() {
+		return this._language;
+	}
+
+	// Auth Messages
+	get dontHaveAccount() {
+		return this.translationService.getTranslation("dontHaveAccount");
+	}
+
+	get email() {
+		return this.translationService.getTranslation("email");
+	}
+
+	get forgotPassword() {
+		return this.translationService.getTranslation("forgotPassword");
+	}
+
+	get password() {
+		return this.translationService.getTranslation("password");
+	}
+
+	get signUp() {
+		return this.translationService.getTranslation("signUp");
+	}
+
+	get submit() {
+		return this.translationService.getTranslation("submit");
+	}
+
+	get title() {
+		return this.translationService.getTranslation("title");
+	}
+
+	get continue() {
+		return this.translationService.getTranslation("continue");
+	}
+
+	get enterEmail() {
+		return this.translationService.getTranslation("enterEmail");
+	}
+
+	get authLoginTitle() {
+		return this.translationService.getTranslation("authLoginTitle");
+	}
+
+	get authLoginEnterPassword() {
+		return this.translationService.getTranslation("authLoginEnterPassword");
+	}
+
+	get commonPassword() {
+		return this.translationService.getTranslation("commonPassword");
+	}
+
+	get commonBack() {
+		return this.translationService.getTranslation("commonBack");
+	}
+
+	get authForgotPasswordTitle() {
+		return this.translationService.getTranslation("authForgotPasswordTitle");
+	}
+
+	get authForgotPasswordResetPassword() {
+		return this.translationService.getTranslation("authForgotPasswordResetPassword");
+	}
+
+	get createPassword() {
+		return this.translationService.getTranslation("createPassword");
+	}
+
+	get createAPassword() {
+		return this.translationService.getTranslation("createAPassword");
+	}
+
+	get authRegisterAlreadyHaveAccount() {
+		return this.translationService.getTranslation("authRegisterAlreadyHaveAccount");
+	}
+
+	get commonAppName() {
+		return this.translationService.getTranslation("commonAppName");
+	}
+
+	get authLoginEnterEmail() {
+		return this.translationService.getTranslation("authLoginEnterEmail");
+	}
+
+	get authRegisterTitle() {
+		return this.translationService.getTranslation("authRegisterTitle");
+	}
+
+	get monitorGetAll() {
+		return this.translationService.getTranslation("monitorGetAll");
+	}
+
+	get monitorGetById() {
+		return this.translationService.getTranslation("monitorGetById");
+	}
+
+	get monitorGetByIdSuccess() {
+		return this.translationService.getTranslation("monitorGetByIdSuccess");
+	}
+
+	get monitorCreate() {
+		return this.translationService.getTranslation("monitorCreate");
+	}
+
+	get bulkMonitorsCreate() {
+		return this.translationService.getTranslation("bulkMonitorsCreate");
+	}
+
+	get monitorEdit() {
+		return this.translationService.getTranslation("monitorEdit");
+	}
+
+	get monitorDelete() {
+		return this.translationService.getTranslation("monitorDelete");
+	}
+
+	get monitorPause() {
+		return this.translationService.getTranslation("monitorPause");
+	}
+
+	get monitorResume() {
+		return this.translationService.getTranslation("monitorResume");
+	}
+
+	get monitorDemoAdded() {
+		return this.translationService.getTranslation("monitorDemoAdded");
+	}
+
+	get monitorStatsById() {
+		return this.translationService.getTranslation("monitorStatsById");
+	}
+
+	get monitorCertificate() {
+		return this.translationService.getTranslation("monitorCertificate");
+	}
+
+	// Maintenance Window Messages
+	get maintenanceWindowCreate() {
+		return this.translationService.getTranslation("maintenanceWindowCreate");
+	}
+
+	get maintenanceWindowGetById() {
+		return this.translationService.getTranslation("maintenanceWindowGetById");
+	}
+
+	get maintenanceWindowGetByTeam() {
+		return this.translationService.getTranslation("maintenanceWindowGetByTeam");
+	}
+
+	get maintenanceWindowDelete() {
+		return this.translationService.getTranslation("maintenanceWindowDelete");
+	}
+
+	get maintenanceWindowEdit() {
+		return this.translationService.getTranslation("maintenanceWindowEdit");
+	}
+
+	// Webhook Messages
+	get webhookUnsupportedPlatform() {
+		return this.translationService.getTranslation("webhookUnsupportedPlatform");
+	}
+
+	get webhookSendError() {
+		return this.translationService.getTranslation("webhookSendError");
+	}
+
+	get webhookSendSuccess() {
+		return this.translationService.getTranslation("webhookSendSuccess");
+	}
+
+	get telegramRequiresBotTokenAndChatId() {
+		return this.translationService.getTranslation("telegramRequiresBotTokenAndChatId");
+	}
+
+	get webhookUrlRequired() {
+		return this.translationService.getTranslation("webhookUrlRequired");
+	}
+
+	get platformRequired() {
+		return this.translationService.getTranslation("platformRequired");
+	}
+
+	get testNotificationFailed() {
+		return this.translationService.getTranslation("testNotificationFailed");
+	}
+
+	get monitorUpAlert() {
+		return this.translationService.getTranslation("monitorUpAlert");
+	}
+
+	get monitorDownAlert() {
+		return this.translationService.getTranslation("monitorDownAlert");
+	}
+
+	getWebhookUnsupportedPlatform(platform) {
+		return this.translationService.getTranslation("webhookUnsupportedPlatform").replace("{platform}", platform);
+	}
+
+	getWebhookSendError(platform) {
+		return this.translationService.getTranslation("webhookSendError").replace("{platform}", platform);
+	}
+
+	getMonitorStatus(name, status, url) {
+		const translationKey = status === true ? "monitorStatusUp" : "monitorStatusDown";
+		return this.translationService.getTranslation(translationKey).replace("{name}", name).replace("{url}", url);
+	}
+
+	// Error Messages
+	get unknownError() {
+		return this.translationService.getTranslation("unknownError");
+	}
+
+	get friendlyError() {
+		return this.translationService.getTranslation("friendlyError");
+	}
+
+	get authIncorrectPassword() {
+		return this.translationService.getTranslation("authIncorrectPassword");
+	}
+
+	get unauthorized() {
+		return this.translationService.getTranslation("unauthorized");
+	}
+
+	get authAdminExists() {
+		return this.translationService.getTranslation("authAdminExists");
+	}
+
+	get authInviteNotFound() {
+		return this.translationService.getTranslation("authInviteNotFound");
+	}
+
+	get unknownService() {
+		return this.translationService.getTranslation("unknownService");
+	}
+
+	get noAuthToken() {
+		return this.translationService.getTranslation("noAuthToken");
+	}
+
+	get invalidAuthToken() {
+		return this.translationService.getTranslation("invalidAuthToken");
+	}
+
+	get expiredAuthToken() {
+		return this.translationService.getTranslation("expiredAuthToken");
+	}
+
+	// Queue Messages
+	get queueGetMetrics() {
+		return this.translationService.getTranslation("queueGetMetrics");
+	}
+
+	get queueGetJobs() {
+		return this.translationService.getTranslation("queueGetJobs");
+	}
+
+	get queueAddJob() {
+		return this.translationService.getTranslation("queueAddJob");
+	}
+
+	get queueObliterate() {
+		return this.translationService.getTranslation("queueObliterate");
+	}
+
+	// Job Queue Messages
+	get jobQueueDeleteJobSuccess() {
+		return this.translationService.getTranslation("jobQueueDeleteJobSuccess");
+	}
+
+	get jobQueuePauseJob() {
+		return this.translationService.getTranslation("jobQueuePauseJob");
+	}
+
+	get jobQueueResumeJob() {
+		return this.translationService.getTranslation("jobQueueResumeJob");
+	}
+
+	// Status Page Messages
+	get statusPageByUrl() {
+		return this.translationService.getTranslation("statusPageByUrl");
+	}
+
+	get statusPageCreate() {
+		return this.translationService.getTranslation("statusPageCreate");
+	}
+
+	get statusPageDelete() {
+		return this.translationService.getTranslation("statusPageDelete");
+	}
+
+	get statusPageUpdate() {
+		return this.translationService.getTranslation("statusPageUpdate");
+	}
+
+	get statusPageNotFound() {
+		return this.translationService.getTranslation("statusPageNotFound");
+	}
+
+	get statusPageByTeamId() {
+		return this.translationService.getTranslation("statusPageByTeamId");
+	}
+
+	get statusPageUrlNotUnique() {
+		return this.translationService.getTranslation("statusPageUrlNotUnique");
+	}
+
+	// Docker Messages
+	get dockerFail() {
+		return this.translationService.getTranslation("dockerFail");
+	}
+
+	get dockerNotFound() {
+		return this.translationService.getTranslation("dockerNotFound");
+	}
+
+	get dockerSuccess() {
+		return this.translationService.getTranslation("dockerSuccess");
+	}
+
+	// Port Messages
+	get portFail() {
+		return this.translationService.getTranslation("portFail");
+	}
+
+	get portSuccess() {
+		return this.translationService.getTranslation("portSuccess");
+	}
+
+	// Alert Messages
+	get alertCreate() {
+		return this.translationService.getTranslation("alertCreate");
+	}
+
+	get alertGetByUser() {
+		return this.translationService.getTranslation("alertGetByUser");
+	}
+
+	get alertGetByMonitor() {
+		return this.translationService.getTranslation("alertGetByMonitor");
+	}
+
+	get alertGetById() {
+		return this.translationService.getTranslation("alertGetById");
+	}
+
+	get alertEdit() {
+		return this.translationService.getTranslation("alertEdit");
+	}
+
+	get alertDelete() {
+		return this.translationService.getTranslation("alertDelete");
+	}
+
+	getDeletedCount(count) {
+		return this.translationService.getTranslation("deletedCount").replace("{count}", count);
+	}
+
+	get pingSuccess() {
+		return this.translationService.getTranslation("pingSuccess");
+	}
+
+	get getAppSettings() {
+		return this.translationService.getTranslation("getAppSettings");
+	}
+
+	get httpNetworkError() {
+		return this.translationService.getTranslation("httpNetworkError");
+	}
+
+	get httpNotJson() {
+		return this.translationService.getTranslation("httpNotJson");
+	}
+
+	get httpJsonPathError() {
+		return this.translationService.getTranslation("httpJsonPathError");
+	}
+
+	get httpEmptyResult() {
+		return this.translationService.getTranslation("httpEmptyResult");
+	}
+
+	get httpMatchSuccess() {
+		return this.translationService.getTranslation("httpMatchSuccess");
+	}
+
+	get httpMatchFail() {
+		return this.translationService.getTranslation("httpMatchFail");
+	}
+
+	get updateAppSettings() {
+		return this.translationService.getTranslation("updateAppSettings");
+	}
+
+	get insufficientPermissions() {
+		return this.translationService.getTranslation("insufficientPermissions");
+	}
+
+	getDbFindMonitorById(monitorId) {
+		return this.translationService.getTranslation("dbFindMonitorById").replace("${monitorId}", monitorId);
+	}
+
+	get dbUserExists() {
+		return this.translationService.getTranslation("dbUserExists");
+	}
+
+	get testEmailSubject() {
+		return this.translationService.getTranslation("testEmailSubject");
+	}
+
+	get verifyOwnerNotFound() {
+		return this.translationService.getTranslation("verifyOwnerNotFound");
+	}
+
+	get verifyOwnerUnauthorized() {
+		return this.translationService.getTranslation("verifyOwnerUnauthorized");
+	}
+
+	get dbUserNotFound() {
+		return this.translationService.getTranslation("dbUserNotFound");
+	}
+}
+
+export default StringService;

server/src/service/system/translationService.js

@@ -0,0 +1,92 @@
+import fs from "fs";
+import path from "path";
+
+class TranslationService {
+	static SERVICE_NAME = "TranslationService";
+	constructor(logger) {
+		this.logger = logger;
+		this.translations = {};
+		this._language = "en";
+		this.localesDir = path.join(process.cwd(), "locales");
+	}
+
+	get serviceName() {
+		return TranslationService.SERVICE_NAME;
+	}
+
+	setLanguage(language) {
+		this._language = language;
+	}
+
+	get language() {
+		return this._language;
+	}
+
+	async initialize() {
+		try {
+			await this.loadFromFiles();
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: "TranslationService",
+				method: "initialize",
+				stack: error.stack,
+			});
+		}
+	}
+
+	async loadFromFiles() {
+		try {
+			if (!fs.existsSync(this.localesDir)) {
+				return false;
+			}
+
+			const files = fs.readdirSync(this.localesDir).filter((file) => file.endsWith(".json"));
+
+			if (files.length === 0) {
+				return false;
+			}
+
+			for (const file of files) {
+				const language = file.replace(".json", "");
+				const filePath = path.join(this.localesDir, file);
+				const content = fs.readFileSync(filePath, "utf8");
+				this.translations[language] = JSON.parse(content);
+			}
+
+			this.logger.info({
+				message: "Translations loaded from files successfully",
+				service: "TranslationService",
+				method: "loadFromFiles",
+			});
+
+			return true;
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: "TranslationService",
+				method: "loadFromFiles",
+				stack: error.stack,
+			});
+			return false;
+		}
+	}
+
+	getTranslation(key) {
+		let language = this._language;
+
+		try {
+			return this.translations[language]?.[key] || this.translations["en"]?.[key] || key;
+		} catch (error) {
+			this.logger.error({
+				message: error.message,
+				service: "TranslationService",
+				method: "getTranslation",
+				stack: error.stack,
+			});
+			return key;
+		}
+	}
+}
+
+export default TranslationService;

server/src/shutdown.js

@@ -0,0 +1,34 @@
+import logger from "./utils/logger.js";
+
+export const initShutdownListener = (server, services) => {
+	const SERVICE_NAME = "Server";
+
+	let isShuttingDown = false;
+
+	const shutdown = async () => {
+		if (isShuttingDown) {
+			return;
+		}
+		isShuttingDown = true;
+		logger.info({ message: "Attempting graceful shutdown" });
+
+		try {
+			server.close();
+			await services.jobQueue.shutdown();
+			await services.db.disconnect();
+			logger.info({ message: "Graceful shutdown complete" });
+			process.exit(0);
+		} catch (error) {
+			logger.error({
+				message: error.message,
+				service: SERVICE_NAME,
+				method: "shutdown",
+				stack: error.stack,
+			});
+			process.exit(1);
+		}
+	};
+	process.on("SIGUSR2", shutdown);
+	process.on("SIGINT", shutdown);
+	process.on("SIGTERM", shutdown);
+};

server/src/templates/addReview.mjml

@@ -0,0 +1,58 @@
+<!-- name -->
+<mjml>
+	<mj-head>
+		<mj-font
+			name="Roboto"
+			href="https://fonts.googleapis.com/css?family=Roboto:300,500"
+		></mj-font>
+		<mj-attributes>
+			<mj-all font-family="Roboto, Helvetica, sans-serif"></mj-all>
+			<mj-text
+				font-weight="300"
+				font-size="16px"
+				color="#616161"
+				line-height="24px"
+			></mj-text>
+			<mj-section padding="0px"></mj-section>
+		</mj-attributes>
+	</mj-head>
+	<mj-body>
+		<mj-section padding="20px 0">
+			<mj-column width="100%">
+				<mj-text
+					align="left"
+					font-size="10px"
+				>
+					Message from Checkmate Service
+				</mj-text>
+			</mj-column>
+		</mj-section>
+		<mj-section>
+			<mj-column width="100%">
+				<mj-text>
+					<p>Hello {{ name }}!</p>
+					<p>
+						We hope you’re finding Checkmate helpful in monitoring your infrastructure. Your support means a lot to us, and we
+						<b>truly appreciate</b> having you as part of our community.
+					</p>
+					<p>
+						If you’re happy with Checkmate, we’d love to hear about your experience! Leaving a review on G2 helps others discover Checkmate and
+						supports our ongoing improvements.
+					</p>
+					G2 Link: TBD
+					<p>Thank you for taking the time to share your thoughts - we greatly appreciate it!</p>
+					Checkmate Team
+				</mj-text>
+			</mj-column>
+			<mj-column width="100%">
+				<mj-divider
+					border-width="1px"
+					border-color="#E0E0E0"
+				></mj-divider>
+				<mj-text font-size="12px">
+					<p>This email was sent by Checkmate.</p>
+				</mj-text>
+			</mj-column>
+		</mj-section>
+	</mj-body>
+</mjml>