Merge branch 'develop' of https://github.com/bluewave-labs/checkmate into feat/customcss-status-page

# Conflicts:
#	server/src/api/routes/statusPageRoute.ts

server/src/api/controllers/queueController.ts

@@ -1,4 +1,4 @@
-import { IJobQueue } from "@/service/job-queues/job-queue.interface.js";
+import { IWorker } from "@/worker/worker.interface.js";
 import { getQueueJobsQueryValidation } from "@/api/validation/queueValidation.js";
 import { Request, Response, NextFunction } from "express";
 
@@ -13,9 +13,9 @@ export interface IJobQueueController {
 
 class JobQueueController implements IJobQueueController {
 	static SERVICE_NAME = SERVICE_NAME;
-	private jobQueue: IJobQueue;
-	constructor(jobQueue: IJobQueue) {
-		this.jobQueue = jobQueue;
+	private worker: IWorker;
+	constructor(worker: IWorker) {
+		this.worker = worker;
 	}
 
 	get serviceName() {
@@ -24,7 +24,7 @@ class JobQueueController implements IJobQueueController {
 
 	getMetrics = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const metrics = await this.jobQueue.getMetrics();
+			const metrics = await this.worker.getMetrics();
 			res.status(200).json({
 				success: true,
 				msg: "Queue metrics fetched successfully",
@@ -38,7 +38,7 @@ class JobQueueController implements IJobQueueController {
 	getJobs = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const pagination = getQueueJobsQueryValidation.parse(req.query);
-			const { jobs, count } = await this.jobQueue.getJobs(pagination);
+			const { jobs, count } = await this.worker.getJobs(pagination);
 			return res.status(200).json({
 				success: true,
 				msg: "Queue jobs fetched successfully",
@@ -52,8 +52,8 @@ class JobQueueController implements IJobQueueController {
 	getAllMetrics = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const pagination = getQueueJobsQueryValidation.parse(req.query);
-			const { jobs, count } = await this.jobQueue.getJobs(pagination);
-			const metrics = await this.jobQueue.getMetrics();
+			const { jobs, count } = await this.worker.getJobs(pagination);
+			const metrics = await this.worker.getMetrics();
 			return res.status(200).json({
 				success: true,
 				msg: "Queue metrics fetched successfully",
@@ -66,7 +66,7 @@ class JobQueueController implements IJobQueueController {
 
 	flushQueue = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const result = await this.jobQueue.flushQueues();
+			const result = await this.worker.flushQueues();
 			return res.status(200).json({
 				success: true,
 				msg: "Queue flushed successfully",

server/src/api/controllers/statusPageController.ts

@@ -5,6 +5,7 @@ import {
 	getStatusPageParamValidation,
 	getStatusPageQueryValidation,
 	imageValidation,
+	resolveStatusPageQueryValidation,
 } from "@/api/validation/statusPageValidation.js";
 import { AppError } from "@/utils/AppError.js";
 import { requireTeamId, requireUserId } from "@/api/controllers/controllerUtils.js";
@@ -12,6 +13,8 @@ import { IStatusPageService } from "@/domain/status-pages/status-page.service.js
 import { IMonitorsRepository } from "@/domain/monitors/monitor.repository.interface.js";
 import { ISettingsService } from "@/domain/app-settings/app-settings.service.js";
 import { NormalizeData } from "@/utils/dataUtils.js";
+import { resolveStatusPageDomainFromRequest } from "@/utils/statusPageDomain.js";
+import type { StatusPage } from "@/domain/status-pages/status-page.type.js";
 
 const SERVICE_NAME = "statusPageController";
 
@@ -20,6 +23,7 @@ export interface IStatusPageController {
 	createStatusPage(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
 	updateStatusPage(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
 	getStatusPageByUrl(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
+	resolveStatusPageByDomain(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
 	getStatusPagesByTeamId(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
 	deleteStatusPage(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
 }
@@ -39,6 +43,41 @@ class StatusPageController implements IStatusPageController {
 		return StatusPageController.SERVICE_NAME;
 	}
 
+	private buildStatusPagePayload = async (statusPage: StatusPage, req: Request) => {
+		if (!statusPage.isPublished) {
+			const teamId = requireTeamId(req?.user?.teamId);
+			if (statusPage.teamId !== teamId) {
+				throw new AppError({ message: "Forbidden", status: 403 });
+			}
+		}
+
+		const settings = await this.settingsService.getDBSettings();
+		const showURL = settings.showURL;
+
+		const monitors = await this.monitorsRepository.findByIds(statusPage.monitors);
+		const monitorOrder = new Map(statusPage.monitors.map((id, index) => [id, index]));
+		const sortedMonitors = [...monitors].sort((a, b) => {
+			const orderA = monitorOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER;
+			const orderB = monitorOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER;
+			return orderA - orderB;
+		});
+
+		const normalizedMonitors = sortedMonitors.map((monitor) => {
+			const normalizedChecks = NormalizeData(monitor.recentChecks, 10, 100);
+			if (!showURL) {
+				// eslint-disable-next-line @typescript-eslint/no-unused-vars
+				const { url, port, secret, notifications, ...rest } = monitor;
+				return { ...rest, checks: normalizedChecks };
+			}
+			return { ...monitor, checks: normalizedChecks };
+		});
+
+		return {
+			statusPage,
+			monitors: normalizedMonitors,
+		};
+	};
+
 	createStatusPage = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			createStatusPageBodyValidation.parse(req.body);
@@ -96,47 +135,44 @@ class StatusPageController implements IStatusPageController {
 			}
 
 			const statusPage = await this.statusPageService.getStatusPageByUrl(req.params.url as string);
+			const data = await this.buildStatusPagePayload(statusPage, req);
 
-			if (!statusPage.isPublished) {
-				const teamId = requireTeamId(req?.user?.teamId);
-				if (statusPage.teamId !== teamId) {
-					throw new AppError({ message: "Forbidden", status: 403 });
-				}
-			}
-
-			const settings = await this.settingsService.getDBSettings();
-			const showURL = settings.showURL;
-
-			const monitors = await this.monitorsRepository.findByIds(statusPage.monitors);
-			// Sort monitors according to the order in statusPage.monitors
-			const monitorOrder = new Map(statusPage.monitors.map((id, index) => [id, index]));
-			const sortedMonitors = [...monitors].sort((a, b) => {
-				const orderA = monitorOrder.get(a.id) ?? Number.MAX_SAFE_INTEGER;
-				const orderB = monitorOrder.get(b.id) ?? Number.MAX_SAFE_INTEGER;
-				return orderA - orderB;
-			});
-
-			const normalizedMonitors = sortedMonitors.map((monitor) => {
-				const normalizedChecks = NormalizeData(monitor.recentChecks, 10, 100);
-				if (!showURL) {
-					// eslint-disable-next-line @typescript-eslint/no-unused-vars
-					const { url, port, secret, notifications, ...rest } = monitor;
-					return { ...rest, checks: normalizedChecks };
-				}
-				return { ...monitor, checks: normalizedChecks };
-			});
 			return res.status(200).json({
 				success: true,
 				msg: "Status page retrieved successfully",
-				data: {
-					statusPage,
-					monitors: normalizedMonitors,
-				},
+				data,
 			});
 		} catch (error) {
 			next(error);
 		}
 	};
+
+	resolveStatusPageByDomain = async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			resolveStatusPageQueryValidation.parse(req.query);
+
+			const domain = resolveStatusPageDomainFromRequest(req.hostname, req.query.domain as string | undefined);
+			if (!domain) {
+				throw new AppError({ message: "Domain is required", status: 400 });
+			}
+
+			const statusPage = await this.statusPageService.getStatusPageByCustomDomain(domain);
+			if (!statusPage.isPublished) {
+				throw new AppError({ message: "Status page not found", status: 404 });
+			}
+
+			const data = await this.buildStatusPagePayload(statusPage, req);
+
+			return res.status(200).json({
+				success: true,
+				msg: "Status page retrieved successfully",
+				data,
+			});
+		} catch (error) {
+			next(error);
+		}
+	};
+
 	getStatusPagesByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const teamId = requireTeamId(req.user?.teamId);

server/src/api/middleware/handleErrors.ts

@@ -1,11 +1,15 @@
 import type { NextFunction, Request, Response } from "express";
+import { MulterError } from "multer";
 import { logger } from "@/utils/logger.js";
 import { AppError } from "@/utils/AppError.js";
 
+// Multer throws MulterError, send 413 Payload Too Large / 400
+const multerErrorStatus = (error: MulterError): number => (error.code === "LIMIT_FILE_SIZE" ? 413 : 400);
+
 const handleErrors = (error: unknown, req: Request, res: Response, _next: NextFunction) => {
-	const status = error instanceof AppError ? error.status || 500 : 500;
+	const status = error instanceof MulterError ? multerErrorStatus(error) : error instanceof AppError ? error.status || 500 : 500;
 	const message = error instanceof AppError ? error.message : error instanceof Error ? error.message : "Server error";
-	const service = error instanceof AppError ? error.service : "unknownService";
+	const service = error instanceof AppError ? error.service : error instanceof MulterError ? "uploadMiddleware" : "unknownService";
 	const method = error instanceof AppError ? error.method : "unknownMethod";
 	logger.error({
 		message: message,

server/src/api/middleware/statusPageCorsOrigin.ts

@@ -0,0 +1,68 @@
+import type { CorsOptions } from "cors";
+import type { IStatusPagesRepository } from "@/domain/status-pages/status-page-repository.interface.js";
+import { normalizeStatusPageDomain } from "@/utils/statusPageDomain.js";
+
+const CUSTOM_DOMAIN_CORS_POSITIVE_CACHE_TTL_MS = 5 * 60 * 1000;
+const CUSTOM_DOMAIN_CORS_NEGATIVE_CACHE_TTL_MS = 60 * 1000;
+
+type CustomDomainCorsCacheEntry = {
+	allowed: boolean;
+	expiresAt: number;
+};
+
+const getCustomDomainCorsCacheTtlMs = (allowed: boolean): number =>
+	allowed ? CUSTOM_DOMAIN_CORS_POSITIVE_CACHE_TTL_MS : CUSTOM_DOMAIN_CORS_NEGATIVE_CACHE_TTL_MS;
+
+export const createStatusPageCorsOrigin = (clientHost: string, statusPagesRepository: IStatusPagesRepository): CorsOptions["origin"] => {
+	const cache = new Map<string, CustomDomainCorsCacheEntry>();
+
+	const cacheOriginResult = (customDomain: string, allowed: boolean) => {
+		cache.set(customDomain, {
+			allowed,
+			expiresAt: Date.now() + getCustomDomainCorsCacheTtlMs(allowed),
+		});
+	};
+
+	return (origin, callback) => {
+		if (!origin) {
+			callback(null, true);
+			return;
+		}
+
+		if (origin === clientHost) {
+			callback(null, true);
+			return;
+		}
+
+		let customDomain: string | null = null;
+		try {
+			customDomain = normalizeStatusPageDomain(new URL(origin).hostname);
+		} catch {
+			callback(null, false);
+			return;
+		}
+
+		if (!customDomain) {
+			callback(null, false);
+			return;
+		}
+
+		const cached = cache.get(customDomain);
+		if (cached && cached.expiresAt > Date.now()) {
+			callback(null, cached.allowed ? origin : false);
+			return;
+		}
+
+		statusPagesRepository
+			.findByCustomDomain(customDomain)
+			.then((statusPage) => {
+				const allowed = statusPage.isPublished;
+				cacheOriginResult(customDomain, allowed);
+				callback(null, allowed ? origin : false);
+			})
+			.catch(() => {
+				cacheOriginResult(customDomain, false);
+				callback(null, false);
+			});
+	};
+};

server/src/api/middleware/statusPagePublicApiPath.ts

@@ -0,0 +1,24 @@
+const PUBLIC_STATUS_PAGE_API_PREFIX = "/api/v1/status-page";
+
+export const isPublicStatusPageApiPath = (method: string, path: string): boolean => {
+	if (!path.startsWith(PUBLIC_STATUS_PAGE_API_PREFIX)) {
+		return false;
+	}
+
+	if (method !== "GET" && method !== "OPTIONS") {
+		return false;
+	}
+
+	const subPath = path.slice(PUBLIC_STATUS_PAGE_API_PREFIX.length).split("?")[0] ?? "";
+	const slug = subPath.replace(/^\//, "");
+
+	if (slug === "resolve") {
+		return true;
+	}
+
+	if (!slug || slug === "team" || slug.includes("/")) {
+		return false;
+	}
+
+	return true;
+};

server/src/api/middleware/upload.ts

@@ -0,0 +1,27 @@
+import multer from "multer";
+import { AppError } from "@/utils/AppError.js";
+import { ImageMimeTypes, MAX_IMAGE_SIZE_BYTES } from "@/types/upload.js";
+
+// Reusable multer instance for handling image uploads
+const imageUpload = multer({
+	limits: {
+		fileSize: MAX_IMAGE_SIZE_BYTES,
+		files: 1,
+	},
+	fileFilter: (_req, file, cb) => {
+		if (!(ImageMimeTypes as readonly string[]).includes(file.mimetype)) {
+			cb(
+				new AppError({
+					status: 415,
+					message: "File must be a valid image (jpeg, jpg, or png)",
+					service: "uploadMiddleware",
+					method: "fileFilter",
+				})
+			);
+			return;
+		}
+		cb(null, true);
+	},
+});
+
+export { imageUpload };

server/src/api/routes/authRoute.ts

@@ -1,10 +1,8 @@
 import { Router, RequestHandler } from "express";
-import { isAllowed } from "../middleware/isAllowed.js";
-import multer from "multer";
+import { isAllowed } from "@/api/middleware/isAllowed.js";
+import { imageUpload } from "@/api/middleware/upload.js";
 import { IAuthController } from "@/api/controllers/authController.js";
 
-const upload = multer();
-
 class AuthRoutes {
 	private router: Router;
 	private authController: IAuthController;
@@ -16,7 +14,7 @@ class AuthRoutes {
 	}
 
 	initRoutes(verifyJWT: RequestHandler) {
-		this.router.post("/register", upload.single("profileImage"), this.authController.registerUser);
+		this.router.post("/register", imageUpload.single("profileImage"), this.authController.registerUser);
 		this.router.post("/login", this.authController.loginUser);
 
 		this.router.post("/recovery/request", this.authController.requestRecovery);
@@ -26,13 +24,19 @@ class AuthRoutes {
 		this.router.get("/users/superadmin", this.authController.checkSuperadminExists);
 
 		this.router.get("/users", verifyJWT, isAllowed(["admin", "superadmin"]), this.authController.getAllUsers);
-		this.router.post("/users", verifyJWT, isAllowed(["superadmin"]), upload.single("profileImage"), this.authController.createUser);
+		this.router.post("/users", verifyJWT, isAllowed(["superadmin"]), imageUpload.single("profileImage"), this.authController.createUser);
 		this.router.get("/users/:userId", verifyJWT, isAllowed(["admin", "superadmin"]), this.authController.getUserById);
 		this.router.patch("/users/:userId", verifyJWT, isAllowed(["superadmin"]), this.authController.editUserById);
 		this.router.patch("/users/:userId/password", verifyJWT, isAllowed(["superadmin"]), this.authController.editUserPasswordById);
 		this.router.delete("/users/:userId", verifyJWT, isAllowed(["admin", "superadmin"]), this.authController.deleteUserById);
 
-		this.router.patch("/user", verifyJWT, upload.single("profileImage"), isAllowed(["admin", "superadmin", "user"]), this.authController.editUser);
+		this.router.patch(
+			"/user",
+			verifyJWT,
+			imageUpload.single("profileImage"),
+			isAllowed(["admin", "superadmin", "user"]),
+			this.authController.editUser
+		);
 		this.router.delete("/user", verifyJWT, isAllowed(["admin", "superadmin", "user"]), this.authController.deleteUser);
 	}
 

server/src/api/routes/statusPageRoute.ts

@@ -1,8 +1,7 @@
 import { IStatusPageController } from "@/api/controllers/statusPageController.js";
 import { RequestHandler, Router } from "express";
 import { isAllowed } from "@/api/middleware/isAllowed.js";
-import multer from "multer";
-const upload = multer();
+import { imageUpload } from "@/api/middleware/upload.js";
 
 class StatusPageRoutes {
 	private router: Router;
@@ -17,9 +16,10 @@ class StatusPageRoutes {
 	initRoutes(verifyJWT: RequestHandler, verifyStatusPageAccess: RequestHandler) {
 		this.router.get("/team", verifyJWT, this.statusPageController.getStatusPagesByTeamId);
 
-		this.router.post("/", upload.single("logo"), verifyJWT, isAllowed(["admin", "superadmin"]), this.statusPageController.createStatusPage);
-		this.router.put("/:id", upload.single("logo"), verifyJWT, isAllowed(["admin", "superadmin"]), this.statusPageController.updateStatusPage);
+		this.router.post("/", imageUpload.single("logo"), verifyJWT, isAllowed(["admin", "superadmin"]), this.statusPageController.createStatusPage);
+		this.router.put("/:id", imageUpload.single("logo"), verifyJWT, isAllowed(["admin", "superadmin"]), this.statusPageController.updateStatusPage);
 
+		this.router.get("/resolve", this.statusPageController.resolveStatusPageByDomain);
 		this.router.get("/:url", verifyStatusPageAccess, this.statusPageController.getStatusPageByUrl);
 		this.router.delete("/:id", verifyJWT, isAllowed(["admin", "superadmin"]), this.statusPageController.deleteStatusPage);
 	}

server/src/api/validation/statusPageValidation.ts

@@ -1,6 +1,7 @@
 import { z } from "zod";
-import { booleanCoercion } from "./shared.js";
+import { booleanCoercion, dnsHostnameRegex } from "./shared.js";
 import { StatusPageTypes, StatusPageThemes, StatusPageThemeModes } from "@/domain/status-pages/status-page.type.js";
+import { normalizeStatusPageDomain } from "@/utils/statusPageDomain.js";
 
 //****************************************
 // Status Page Validations
@@ -15,6 +16,20 @@ export const getStatusPageQueryValidation = z.object({
 	timeFrame: z.coerce.number().optional(),
 });
 
+export const resolveStatusPageQueryValidation = getStatusPageQueryValidation.extend({
+	domain: z.string().optional(),
+});
+
+const customDomainValidation = z.preprocess(
+	(val) => {
+		if (val === undefined || val === null) {
+			return undefined;
+		}
+		return normalizeStatusPageDomain(String(val));
+	},
+	z.union([z.string().regex(dnsHostnameRegex, "Enter a valid domain name (e.g. status.example.com)"), z.null()]).optional()
+);
+
 export const createStatusPageBodyValidation = z
 	.object({
 		type: z.union([z.enum(StatusPageTypes), z.array(z.enum(StatusPageTypes))]).transform((val) => (Array.isArray(val) ? val : [val])),
@@ -22,6 +37,7 @@ export const createStatusPageBodyValidation = z
 		url: z.string().regex(/^[a-zA-Z0-9_-]+$/, {
 			message: "URL can only contain letters, numbers, underscores, and hyphens",
 		}),
+		customDomain: customDomainValidation,
 		timezone: z.string().optional(),
 		color: z.string().optional(),
 		monitors: z.array(z.string().regex(/^[0-9a-fA-F]{24}$/, "Must be a valid monitor ID")).min(1, "At least one monitor is required"),