fix: minor refactoring infrastructureMetrics

.gitignore

@@ -3,10 +3,8 @@
 .VSCodeCounter
 *.sh
 mongo
-timescaledb
 node_modules/
 docs/architecture
 docs/reviews
 docs/todo
-docs/frontend
-docs/timescale
+docs/frontend

client/package-lock.json

@@ -83,6 +83,7 @@
 		"node_modules/@babel/core": {
 			"version": "7.29.0",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/code-frame": "^7.29.0",
 				"@babel/generator": "^7.29.0",
@@ -353,6 +354,7 @@
 		"node_modules/@emotion/react": {
 			"version": "11.14.0",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/runtime": "^7.18.3",
 				"@emotion/babel-plugin": "^11.13.5",
@@ -390,6 +392,7 @@
 		"node_modules/@emotion/styled": {
 			"version": "11.14.1",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/runtime": "^7.18.3",
 				"@emotion/babel-plugin": "^11.13.5",
@@ -1159,6 +1162,7 @@
 		"node_modules/@mui/material": {
 			"version": "7.3.7",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/runtime": "^7.28.4",
 				"@mui/core-downloads-tracker": "^7.3.7",
@@ -1263,6 +1267,7 @@
 		"node_modules/@mui/system": {
 			"version": "7.3.7",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/runtime": "^7.28.4",
 				"@mui/private-theming": "^7.3.7",
@@ -2303,6 +2308,7 @@
 			"version": "24.5.2",
 			"devOptional": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.12.0"
 			}
@@ -2318,6 +2324,7 @@
 		"node_modules/@types/react": {
 			"version": "18.3.27",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@types/prop-types": "*",
 				"csstype": "^3.2.2"
@@ -2439,6 +2446,7 @@
 			"version": "8.15.0",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"bin": {
 				"acorn": "bin/acorn"
 			},
@@ -2763,6 +2771,7 @@
 				}
 			],
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"baseline-browser-mapping": "^2.9.0",
 				"caniuse-lite": "^1.0.30001759",
@@ -3194,7 +3203,8 @@
 		},
 		"node_modules/dayjs": {
 			"version": "1.11.13",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/debug": {
 			"version": "4.4.3",
@@ -3576,6 +3586,7 @@
 			"version": "8.57.1",
 			"dev": true,
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@eslint-community/eslint-utils": "^4.2.0",
 				"@eslint-community/regexpp": "^4.6.1",
@@ -4320,6 +4331,7 @@
 				}
 			],
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@babel/runtime": "^7.27.6"
 			},
@@ -5103,6 +5115,7 @@
 			"resolved": "https://registry.npmjs.org/maplibre-gl/-/maplibre-gl-5.19.0.tgz",
 			"integrity": "sha512-REhYUN8gNP3HlcIZS6QU2uy8iovl31cXsrNDkCcqWSQbCkcpdYLczqDz5PVIwNH42UQNyvukjes/RoHPDrOUmQ==",
 			"license": "BSD-3-Clause",
+			"peer": true,
 			"dependencies": {
 				"@mapbox/geojson-rewind": "^0.5.2",
 				"@mapbox/jsonlint-lines-primitives": "^2.0.2",
@@ -5750,6 +5763,7 @@
 		"node_modules/react-dom": {
 			"version": "18.3.1",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"loose-envify": "^1.1.0",
 				"scheduler": "^0.23.2"
@@ -5761,6 +5775,7 @@
 		"node_modules/react-hook-form": {
 			"version": "7.71.1",
 			"license": "MIT",
+			"peer": true,
 			"engines": {
 				"node": ">=18.0.0"
 			},
@@ -5960,7 +5975,8 @@
 		},
 		"node_modules/redux": {
 			"version": "5.0.1",
-			"license": "MIT"
+			"license": "MIT",
+			"peer": true
 		},
 		"node_modules/redux-persist": {
 			"version": "6.0.0",
@@ -6106,10 +6122,11 @@
 			"license": "Unlicense"
 		},
 		"node_modules/rollup": {
-			"version": "4.57.1",
+			"version": "4.59.0",
 			"resolved": "https://registry.npmjs.org/rollup/-/rollup-4.59.0.tgz",
 			"integrity": "sha512-2oMpl67a3zCH9H79LeMcbDhXW/UmWG/y2zuqnF2jQq5uq9TbM9TVyXvA4+t+ne2IIkBdrLpAaRQAvo7YI/Yyeg==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"@types/estree": "1.0.8"
 			},
@@ -6898,6 +6915,7 @@
 			"version": "5.9.3",
 			"devOptional": true,
 			"license": "Apache-2.0",
+			"peer": true,
 			"bin": {
 				"tsc": "bin/tsc",
 				"tsserver": "bin/tsserver"
@@ -7033,6 +7051,7 @@
 			"resolved": "https://registry.npmjs.org/vite/-/vite-6.4.1.tgz",
 			"integrity": "sha512-+Oxm7q9hDoLMyJOYfUYBuHQo+dkAloi33apOPP56pzj+vsdJDzr+j1NISE5pyaAuKL4A3UD34qd0lx5+kfKp2g==",
 			"license": "MIT",
+			"peer": true,
 			"dependencies": {
 				"esbuild": "^0.25.0",
 				"fdir": "^6.4.4",

client/src/Components/common/charts/HeatmapResponseTimeTooltip.tsx

@@ -57,8 +57,7 @@ export const HeatmapResponseTimeTooltip = ({
 						{formatDateWithTz(check?.createdAt, "ddd, MMMM D, YYYY, HH:mm A", uiTimezone)}
 					</Typography>
 					<Typography>
-						{t("common.labels.responseTime")}:{" "}
-						{check?.originalResponseTime?.toFixed() ?? "N/A"} ms
+						{t("common.labels.responseTime")}: {check.originalResponseTime.toFixed()} ms
 					</Typography>
 					<Typography textTransform={"capitalize"}>
 						Status:{" "}

client/src/Hooks/useSettingsForm.ts

@@ -1,14 +1,14 @@
 import { useMemo } from "react";
 import { settingsSchema } from "@/Validation/settings";
 import type { Settings } from "@/Types/Settings";
-import type { SettingsFormInput } from "@/Validation/settings";
+import type { SettingsFormData } from "@/Validation/settings";
 
 interface UseSettingsFormOptions {
 	data?: Settings | null;
 }
 export const useSettingsForm = ({ data = null }: UseSettingsFormOptions = {}) => {
 	return useMemo(() => {
-		const defaults: SettingsFormInput = {
+		const defaults: SettingsFormData = {
 			systemEmailIgnoreTLS: data?.systemEmailIgnoreTLS ?? false,
 			systemEmailRequireTLS: data?.systemEmailRequireTLS ?? false,
 			systemEmailRejectUnauthorized: data?.systemEmailRejectUnauthorized ?? true,

client/src/Pages/Settings/index.tsx

@@ -20,7 +20,7 @@ import { useGet, usePatch, usePost, useLazyGet } from "@/Hooks/UseApi";
 import { useToast } from "@/Hooks/UseToast";
 import { useSettingsForm } from "@/Hooks/useSettingsForm";
 import { useIsAdmin } from "@/Hooks/useIsAdmin.js";
-import type { SettingsFormData, SettingsFormInput } from "@/Validation/settings";
+import type { SettingsFormData } from "@/Validation/settings";
 import { useState } from "react";
 import { Controller } from "react-hook-form";
 import { TextField, Button, FieldLabel, SliderWithLabel } from "@/Components/inputs";
@@ -89,7 +89,7 @@ export const SettingsPage = () => {
 	// Initialize form with schema and defaults
 	const { schema, defaults } = useSettingsForm({ data: fetchedSettings?.settings });
 
-	const form = useForm<SettingsFormInput, unknown, SettingsFormData>({
+	const form = useForm<SettingsFormData>({
 		resolver: zodResolver(schema),
 		defaultValues: defaults,
 		mode: "onChange",
@@ -256,7 +256,28 @@ export const SettingsPage = () => {
 			delete (dataToSend as any).systemEmailPassword;
 		}
 
-		const result = await patch("/settings", dataToSend as SettingsFormData);
+		// Convert undefined to empty string for backend unsetting
+		const processedData = Object.entries(dataToSend).reduce((acc, [key, value]) => {
+			const typedKey = key as keyof SettingsFormData;
+			if (value === undefined) {
+				(acc as any)[typedKey] = "";
+			} else if (typeof value === "object" && value !== null) {
+				// Handle nested objects like globalThresholds
+				// Convert 0 to "" for unsetting thresholds
+				(acc as any)[typedKey] = Object.entries(value).reduce(
+					(nested, [nestedKey, nestedValue]) => ({
+						...nested,
+						[nestedKey]: nestedValue === undefined ? "" : nestedValue,
+					}),
+					{}
+				);
+			} else {
+				(acc as any)[typedKey] = value;
+			}
+			return acc;
+		}, {} as Partial<SettingsFormData>);
+
+		const result = await patch("/settings", processedData as SettingsFormData);
 
 		if (result?.success) {
 			// Update API key state from response

client/src/Pages/StatusPage/Create/index.tsx

@@ -29,25 +29,32 @@ import type { StatusPageFormData } from "@/Validation/statusPage";
 import { useGet, usePost, usePut, useDelete } from "@/Hooks/UseApi";
 import type { Monitor } from "@/Types/Monitor";
 import type { MonitorDisplayType, StatusPageResponse } from "@/Types/StatusPage";
-import { getMonitorTypeLabel } from "@/Types/StatusPage";
 import timezones from "@/Utils/timezones.json";
 import { useNavigate, useParams } from "react-router-dom";
 import axios from "axios";
 import { HeaderConfigStatusControls } from "./Components/HeaderConfigStatusControls";
 
-const monitorsUrl = (() => {
-	const params = new URLSearchParams();
-	["http", "ping", "port", "docker", "game", "grpc", "websocket", "hardware"].forEach(
-		(type) => params.append("type", type)
-	);
-	return `/monitors/team?${params.toString()}`;
-})();
-
 interface TimezoneOption {
 	_id: string;
 	name: string;
 }
 
+const MONITOR_TYPE_KEYS: Record<string, string> = {
+	http: "pages.common.monitors.monitorTypes.optionHttp",
+	ping: "pages.common.monitors.monitorTypes.optionPing",
+	docker: "pages.common.monitors.monitorTypes.optionDocker",
+	port: "pages.common.monitors.monitorTypes.optionPort",
+	game: "pages.common.monitors.monitorTypes.optionGame",
+	grpc: "pages.common.monitors.monitorTypes.optionGrpc",
+	websocket: "pages.common.monitors.monitorTypes.optionWebSocket",
+	hardware: "pages.common.monitors.monitorTypes.optionHardware",
+};
+
+const getMonitorTypeLabel = (type: string, t: (key: string) => string): string => {
+	const i18nMonitorKey = MONITOR_TYPE_KEYS[type];
+	return i18nMonitorKey ? t(i18nMonitorKey) : type;
+};
+
 const CreateStatusPage = () => {
 	const theme = useTheme();
 	const { t } = useTranslation();
@@ -62,7 +69,9 @@ const CreateStatusPage = () => {
 			isCreate ? null : `/status-page/${url}?type=uptime&type=infrastructure`
 		);
 
-	const { data: monitorsResponse } = useGet<Monitor[]>(monitorsUrl);
+	const { data: monitorsResponse } = useGet<Monitor[]>(
+		"/monitors/team?type=http&type=ping&type=port&type=docker&type=hardware"
+	);
 	const monitors = monitorsResponse ?? [];
 
 	const { post, loading: isSubmittingPost } = usePost();
@@ -102,7 +111,7 @@ const CreateStatusPage = () => {
 		});
 
 		return typesSet.size ? Array.from(typesSet) : ["uptime"];
-	}, [watchedMonitorIds, monitors]);
+	}, [JSON.stringify(watchedMonitorIds), monitors]);
 
 	useEffect(() => {
 		form.setValue("type", computedTypes);

client/src/Pages/StatusPage/Status/Components/MonitorsList.tsx

@@ -12,7 +12,6 @@ import { useSelector } from "react-redux";
 import { useState } from "react";
 import type { Monitor } from "@/Types/Monitor";
 import type { StatusPage } from "@/Types/StatusPage";
-import { getMonitorTypeLabel } from "@/Types/StatusPage";
 import type { RootState } from "@/Types/state";
 import { LAYOUT, SPACING } from "@/Utils/Theme/constants";
 
@@ -26,98 +25,81 @@ interface MonitorsListProps {
 }
 
 const getMonitorBadgeStyles = (monitorType: string, theme: Theme) => {
-	const bg =
-		monitorType === "hardware" ? theme.palette.info.light : theme.palette.success.light;
+	// for future: specific badge styles can be defined here based on monitor type
+	const badgeConfig: Record<string, { color: string; bg: string }> = {
+		hardware: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.info.light,
+		},
+		http: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+		ping: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+		port: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+		docker: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+		pagespeed: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+		game: {
+			color: theme.palette.background.paper,
+			bg: theme.palette.success.light,
+		},
+	};
+
+	const config = badgeConfig[monitorType] ?? badgeConfig.http;
 	return {
-		backgroundColor: bg,
-		color: theme.palette.background.paper,
+		backgroundColor: config.bg,
+		color: config.color,
 		padding: `${theme.spacing(SPACING.SM)} ${theme.spacing(SPACING.LG)}`,
 		borderRadius: theme.shape.borderRadius,
 	};
 };
 
-const MonitorHeader = ({
-	monitor,
-	showURL,
-}: {
-	monitor: StatusPageMonitor;
-	showURL: boolean;
-}) => {
-	const theme = useTheme();
-	const { t } = useTranslation();
-
-	return (
-		<Stack
-			direction="row"
-			alignItems="center"
-			justifyContent="space-between"
-			gap={theme.spacing(LAYOUT.XS)}
-			mb={theme.spacing(LAYOUT.XS)}
-		>
-			<Box sx={{ overflow: "hidden", minWidth: 0, flex: 1 }}>
-				<Stack
-					direction="row"
-					alignItems="center"
-					gap={theme.spacing(SPACING.LG)}
-					mb={theme.spacing(SPACING.SM)}
-				>
-					<Typography
-						variant="h6"
-						sx={{ overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
-					>
-						{monitor.name}
-					</Typography>
-					<Typography
-						variant="caption"
-						sx={getMonitorBadgeStyles(monitor.type ?? "", theme)}
-					>
-						{getMonitorTypeLabel(monitor.type, t)}
-					</Typography>
-				</Stack>
-				{showURL && monitor.url && (
-					<Typography
-						variant="body2"
-						color={theme.palette.text.secondary}
-						sx={{ overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap" }}
-					>
-						{monitor.url}
-					</Typography>
-				)}
-			</Box>
-			<StatusLabel status={monitor.status} />
-		</Stack>
-	);
-};
-
+// Extracted component for monitor content below the header row
 const MonitorContent = ({
 	monitor,
 	statusPage,
 	chartType,
 }: {
-	monitor: StatusPageMonitor;
+	monitor: Monitor & { checks?: Monitor["recentChecks"] };
 	statusPage: StatusPage;
 	chartType: string;
 }) => {
 	const theme = useTheme();
+	const isInfrastructureMonitor = monitor?.type === "hardware";
 
-	if (monitor.type === "hardware") {
-		if (statusPage.showInfrastructure === false) return null;
+	if (isInfrastructureMonitor) {
+		if (statusPage.showInfrastructure === false) {
+			return null;
+		}
 		return <InfrastructureMetrics monitor={monitor} />;
 	}
 
-	if (statusPage.showCharts === false) return null;
+	if (statusPage.showCharts === false) {
+		return null;
+	}
 
-	const checks = monitor.checks?.slice().reverse() ?? [];
 	return (
 		<Box sx={{ overflow: "hidden", minWidth: 0, flex: 1, mb: theme.spacing(SPACING.LG) }}>
 			{chartType === "histogram" ? (
 				<HistogramResponseTime
 					height={{ xs: 50, md: 100 }}
 					gap={{ xs: theme.spacing(SPACING.SM), md: theme.spacing(LAYOUT.SM) }}
-					checks={checks}
+					checks={monitor?.checks?.slice().reverse() ?? []}
 				/>
 			) : (
-				<HeatmapResponseTime checks={checks} />
+				<HeatmapResponseTime checks={monitor?.checks?.slice().reverse() ?? []} />
 			)}
 		</Box>
 	);
@@ -126,15 +108,17 @@ const MonitorContent = ({
 export const MonitorsList = ({ statusPage, monitors }: MonitorsListProps) => {
 	const theme = useTheme();
 	const { t } = useTranslation();
+
 	const showURL = useSelector((state: RootState) => state.ui?.showURL);
+
 	const [chartType, setChartType] = useState<"histogram" | "heatmap">("histogram");
 
 	return (
 		<Stack gap={theme.spacing(LAYOUT.MD)}>
 			{statusPage.showCharts && (
 				<Stack
-					direction="row"
-					alignItems="center"
+					direction={"row"}
+					alignItems={"center"}
 					gap={theme.spacing(LAYOUT.SM)}
 				>
 					<Typography>{t("pages.statusPages.monitorsList.chartTypeHeatmap")}</Typography>
@@ -142,7 +126,9 @@ export const MonitorsList = ({ statusPage, monitors }: MonitorsListProps) => {
 						dualOption
 						value={chartType}
 						checked={chartType === "histogram"}
-						onChange={(e) => setChartType(e.target.checked ? "histogram" : "heatmap")}
+						onChange={(e) => {
+							setChartType(e.target.checked ? "histogram" : "heatmap");
+						}}
 					/>
 					<Typography>
 						{t("pages.statusPages.monitorsList.chartTypeHistogram")}
@@ -150,22 +136,69 @@ export const MonitorsList = ({ statusPage, monitors }: MonitorsListProps) => {
 				</Stack>
 			)}
 
-			{monitors.map((monitor) => (
-				<BaseBox
-					key={monitor.id}
-					padding={theme.spacing(LAYOUT.MD)}
-				>
-					<MonitorHeader
-						monitor={monitor}
-						showURL={showURL}
-					/>
-					<MonitorContent
-						monitor={monitor}
-						statusPage={statusPage}
-						chartType={chartType}
-					/>
-				</BaseBox>
-			))}
+			{monitors?.map((monitor) => {
+				return (
+					<BaseBox
+						key={monitor.id}
+						padding={theme.spacing(LAYOUT.MD)}
+					>
+						<Stack
+							direction="row"
+							alignItems="center"
+							justifyContent="space-between"
+							gap={theme.spacing(LAYOUT.XS)}
+							mb={theme.spacing(LAYOUT.XS)}
+						>
+							<Box sx={{ overflow: "hidden", minWidth: 0, flex: 1 }}>
+								<Stack
+									direction="row"
+									alignItems="center"
+									gap={theme.spacing(SPACING.LG)}
+									mb={theme.spacing(SPACING.SM)}
+								>
+									<Typography
+										variant="h6"
+										sx={{
+											overflow: "hidden",
+											textOverflow: "ellipsis",
+											whiteSpace: "nowrap",
+										}}
+									>
+										{monitor.name}
+									</Typography>
+									<Typography
+										variant="caption"
+										sx={getMonitorBadgeStyles(monitor?.type ?? "", theme)}
+									>
+										{t(
+											`pages.common.monitors.monitorTypes.option${monitor?.type.charAt(0).toUpperCase() + monitor?.type.slice(1)}`
+										)}
+									</Typography>
+								</Stack>
+								{showURL && monitor?.url && (
+									<Typography
+										variant="body2"
+										color={theme.palette.text.secondary}
+										sx={{
+											overflow: "hidden",
+											textOverflow: "ellipsis",
+											whiteSpace: "nowrap",
+										}}
+									>
+										{monitor.url}
+									</Typography>
+								)}
+							</Box>
+							<StatusLabel status={monitor?.status} />
+						</Stack>
+						<MonitorContent
+							monitor={monitor}
+							statusPage={statusPage}
+							chartType={chartType}
+						/>
+					</BaseBox>
+				);
+			})}
 		</Stack>
 	);
 };

client/src/Pages/StatusPage/Status/index.tsx

@@ -25,20 +25,15 @@ const StatusPageView = () => {
 
 	const apiUrl = url ? `/status-page/${url}?type=uptime&type=infrastructure` : null;
 
-	const { data, isLoading, error } = useGet<StatusPageResponse>(
-		apiUrl,
-		{},
-		{
-			refreshInterval: 10000,
-		}
-	);
+	const { data, isLoading, error } = useGet<StatusPageResponse>(apiUrl);
 
 	const statusPage = data?.statusPage;
 	const monitors = data?.monitors ?? [];
+	const infrastructureMonitors = data?.infrastructureMonitors ?? [];
 
 	if (!statusPage) return null;
 
-	if (monitors.length === 0) {
+	if (monitors?.length === 0 && infrastructureMonitors?.length === 0) {
 		return (
 			<BasePage
 				loading={isLoading}

client/src/Types/StatusPage.ts

@@ -1,26 +1,6 @@
-import type { Monitor, MonitorType } from "@/Types/Monitor";
+import type { Monitor } from "@/Types/Monitor";
 export type MonitorDisplayType = "uptime" | "infrastructure";
 
-export const MONITOR_TYPE_KEYS: Partial<Record<MonitorType, string>> = {
-	http: "pages.common.monitors.monitorTypes.optionHttp",
-	ping: "pages.common.monitors.monitorTypes.optionPing",
-	docker: "pages.common.monitors.monitorTypes.optionDocker",
-	port: "pages.common.monitors.monitorTypes.optionPort",
-	game: "pages.common.monitors.monitorTypes.optionGame",
-	grpc: "pages.common.monitors.monitorTypes.optionGrpc",
-	websocket: "pages.common.monitors.monitorTypes.optionWebSocket",
-	hardware: "pages.common.monitors.monitorTypes.optionHardware",
-	pagespeed: "pages.common.monitors.monitorTypes.optionPagespeed",
-};
-
-export const getMonitorTypeLabel = (
-	type: MonitorType,
-	t: (key: string) => string
-): string => {
-	const key = MONITOR_TYPE_KEYS[type];
-	return key ? t(key) : type;
-};
-
 export interface StatusPage {
 	id: string;
 	userId: string;
@@ -50,4 +30,5 @@ export interface StatusPage {
 export interface StatusPageResponse {
 	statusPage: StatusPage;
 	monitors: Monitor[];
+	infrastructureMonitors?: Monitor[];
 }

client/src/Validation/settings.ts

@@ -7,7 +7,7 @@ export const settingsSchema = z.object({
 	systemEmailRejectUnauthorized: z.boolean(),
 	systemEmailConnectionHost: z
 		.string()
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	systemEmailSecure: z.boolean().optional(),
 	systemEmailPool: z.boolean().optional(),
@@ -19,30 +19,31 @@ export const settingsSchema = z.object({
 		.max(CHECK_TTL_SENTINEL, `Maximum ${CHECK_TTL_SENTINEL}`),
 	pagespeedApiKey: z
 		.string()
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	systemEmailHost: z
 		.string()
 		.regex(/^[a-zA-Z0-9.-]*$/, "Invalid hostname or IP address")
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	systemEmailPort: z.number().int().min(1).max(65535).optional(),
 	systemEmailAddress: z
+		.string()
 		.email("Please enter a valid email address")
 		.or(z.literal(""))
-		.transform((val) => (val === "" ? null : val.toLowerCase().trim()))
+		.transform((val) => (val === "" ? undefined : val.toLowerCase().trim()))
 		.optional(),
 	systemEmailUser: z
 		.string()
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	systemEmailPassword: z
 		.string()
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	systemEmailTLSServername: z
 		.string()
-		.transform((val) => (val.trim() === "" ? null : val.trim()))
+		.transform((val) => (val.trim() === "" ? undefined : val.trim()))
 		.optional(),
 	globalThresholds: z.object({
 		cpu: z.number().int().min(1).max(100),
@@ -52,5 +53,4 @@ export const settingsSchema = z.object({
 	}),
 });
 
-export type SettingsFormInput = z.input<typeof settingsSchema>;
 export type SettingsFormData = z.infer<typeof settingsSchema>;

client/src/locales/en.json

@@ -401,7 +401,7 @@
 				},
 				"status": {
 					"down": "down",
-					"breached": "threshold exceeded",
+					"breached": "breached",
 					"initializing": "initializing",
 					"maintenance": "maintenance",
 					"paused": "paused",

server/eslint.config.js

@@ -32,14 +32,11 @@ export default [
 		languageOptions: {
 			parser: tseslint.parser,
 			parserOptions: {
-				projectService: {
-					allowDefaultProject: ["jest.config.ts"],
-				},
+				projectService: true,
 				tsconfigRootDir: import.meta.dirname,
 			},
 		},
 		rules: {
-			"@typescript-eslint/no-unused-vars": ["error", { argsIgnorePattern: "^_" }], // Ignore unused variables that start with '_'
 			"@typescript-eslint/no-explicit-any": "warn", // Warn on 'any' types
 			"mocha/max-top-level-suites": "warn", // Warn if there are too many top-level suites instead of failing
 		},

server/openapi.json

@@ -510,24 +510,42 @@
 				"summary": "Get monitors by team",
 				"description": "Get monitors filtered by team with optional parameters",
 				"parameters": [
+					{
+						"name": "status",
+						"in": "query",
+						"description": "Filter by monitor status (up/down)",
+						"schema": {
+							"type": "boolean"
+						}
+					},
 					{
 						"name": "type",
 						"in": "query",
 						"description": "Filter by monitor type",
 						"schema": {
-							"oneOf": [
-								{
-									"type": "string",
-									"enum": ["http", "ping", "pagespeed", "docker", "hardware", "port", "game", "grpc", "websocket"]
-								},
-								{
-									"type": "array",
-									"items": {
-										"type": "string",
-										"enum": ["http", "ping", "pagespeed", "docker", "hardware", "port", "game", "grpc", "websocket"]
-									}
-								}
-							]
+							"type": "string",
+							"enum": ["http", "ping", "pagespeed", "hardware", "docker", "port"]
+						}
+					},
+					{
+						"name": "page",
+						"in": "query",
+						"description": "Page number for pagination",
+						"schema": {
+							"type": "integer",
+							"minimum": 1,
+							"default": 1
+						}
+					},
+					{
+						"name": "rowsPerPage",
+						"in": "query",
+						"description": "Number of monitors per page",
+						"schema": {
+							"type": "integer",
+							"minimum": 1,
+							"maximum": 100,
+							"default": 10
 						}
 					},
 					{
@@ -537,6 +555,15 @@
 						"schema": {
 							"type": "string"
 						}
+					},
+					{
+						"name": "field",
+						"in": "query",
+						"description": "Field to filter on",
+						"schema": {
+							"type": "string",
+							"enum": ["name", "url", "description"]
+						}
 					}
 				],
 				"responses": {
@@ -729,7 +756,7 @@
 					}
 				]
 			},
-			"patch": {
+			"put": {
 				"tags": ["monitors"],
 				"summary": "Update monitor",
 				"description": "Update an existing monitor",
@@ -3541,19 +3568,22 @@
 			},
 			"CreateMonitorRequest": {
 				"type": "object",
-				"required": ["name", "type", "url"],
+				"required": ["name", "description", "type", "url", "interval"],
 				"properties": {
 					"name": {
 						"type": "string",
+						"minLength": 1,
+						"maxLength": 100,
 						"example": "My Website Monitor"
 					},
 					"description": {
 						"type": "string",
+						"maxLength": 500,
 						"example": "Monitors the main website homepage"
 					},
 					"type": {
 						"type": "string",
-						"enum": ["http", "ping", "pagespeed", "hardware", "docker", "port", "game", "grpc", "websocket"],
+						"enum": ["http", "ping", "pagespeed", "hardware", "docker", "port"],
 						"example": "http"
 					},
 					"url": {
@@ -3563,34 +3593,14 @@
 					},
 					"interval": {
 						"type": "integer",
+						"minimum": 30,
+						"maximum": 3600,
 						"example": 300,
 						"description": "Check interval in seconds"
 					},
-					"statusWindowSize": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 20,
-						"default": 5
-					},
-					"statusWindowThreshold": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 100,
-						"default": 60
-					},
 					"isActive": {
-						"type": "boolean"
-					},
-					"ignoreTlsErrors": {
 						"type": "boolean",
-						"default": false
-					},
-					"useAdvancedMatching": {
-						"type": "boolean",
-						"default": false
-					},
-					"port": {
-						"type": "integer"
+						"default": true
 					},
 					"notifications": {
 						"type": "array",
@@ -3599,62 +3609,51 @@
 						},
 						"description": "Array of notification IDs to associate with this monitor"
 					},
-					"secret": {
-						"type": "string"
-					},
-					"jsonPath": {
-						"type": "string"
-					},
-					"expectedValue": {
-						"type": "string"
-					},
-					"matchMethod": {
-						"type": "string",
-						"enum": ["equal", "include", "regex", ""]
-					},
-					"cpuAlertThreshold": {
-						"type": "number"
-					},
-					"memoryAlertThreshold": {
-						"type": "number"
-					},
-					"diskAlertThreshold": {
-						"type": "number"
-					},
-					"tempAlertThreshold": {
-						"type": "number"
-					},
-					"gameId": {
-						"type": "string"
-					},
-					"grpcServiceName": {
-						"type": "string",
-						"default": ""
-					},
-					"selectedDisks": {
-						"type": "array",
-						"items": {
-							"type": "string"
+					"httpOptions": {
+						"type": "object",
+						"properties": {
+							"method": {
+								"type": "string",
+								"enum": ["GET", "POST", "PUT", "DELETE", "HEAD"],
+								"default": "GET"
+							},
+							"headers": {
+								"type": "object",
+								"additionalProperties": {
+									"type": "string"
+								}
+							},
+							"body": {
+								"type": "string",
+								"description": "Request body for POST/PUT requests"
+							},
+							"timeout": {
+								"type": "integer",
+								"minimum": 1000,
+								"maximum": 30000,
+								"default": 5000,
+								"description": "Request timeout in milliseconds"
+							}
 						}
 					},
-					"group": {
-						"type": "string",
-						"nullable": true,
-						"maxLength": 50
-					},
-					"geoCheckEnabled": {
-						"type": "boolean"
-					},
-					"geoCheckLocations": {
+					"assertions": {
 						"type": "array",
 						"items": {
-							"type": "string",
-							"enum": ["northAmerica", "southAmerica", "europe", "asia", "africa", "oceania"]
+							"type": "object",
+							"properties": {
+								"type": {
+									"type": "string",
+									"enum": ["status-code", "response-time", "body-contains", "header-contains"]
+								},
+								"comparison": {
+									"type": "string",
+									"enum": ["equals", "not-equals", "greater-than", "less-than", "contains", "not-contains"]
+								},
+								"value": {
+									"type": "string"
+								}
+							}
 						}
-					},
-					"geoCheckInterval": {
-						"type": "integer",
-						"minimum": 300000
 					}
 				}
 			},
@@ -3662,32 +3661,21 @@
 				"type": "object",
 				"properties": {
 					"name": {
-						"type": "string"
-					},
-					"type": {
 						"type": "string",
-						"enum": ["http", "ping", "pagespeed", "hardware", "docker", "port", "game", "grpc", "websocket", "unknown"]
-					},
-					"url": {
-						"type": "string"
-					},
-					"statusWindowSize": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 20,
-						"default": 5
-					},
-					"statusWindowThreshold": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 100,
-						"default": 60
+						"minLength": 1,
+						"maxLength": 100
 					},
 					"description": {
-						"type": "string"
+						"type": "string",
+						"maxLength": 500
 					},
 					"interval": {
-						"type": "integer"
+						"type": "integer",
+						"minimum": 30,
+						"maximum": 3600
+					},
+					"isActive": {
+						"type": "boolean"
 					},
 					"notifications": {
 						"type": "array",
@@ -3695,72 +3683,47 @@
 							"type": "string"
 						}
 					},
-					"secret": {
-						"type": "string"
-					},
-					"ignoreTlsErrors": {
-						"type": "boolean"
-					},
-					"useAdvancedMatching": {
-						"type": "boolean"
-					},
-					"jsonPath": {
-						"type": "string"
-					},
-					"expectedValue": {
-						"type": "string"
-					},
-					"matchMethod": {
-						"type": "string",
-						"enum": ["equal", "include", "regex", ""]
-					},
-					"port": {
-						"type": "integer",
-						"minimum": 1,
-						"maximum": 65535
-					},
-					"cpuAlertThreshold": {
-						"type": "number"
-					},
-					"memoryAlertThreshold": {
-						"type": "number"
-					},
-					"diskAlertThreshold": {
-						"type": "number"
-					},
-					"tempAlertThreshold": {
-						"type": "number"
-					},
-					"gameId": {
-						"type": "string"
-					},
-					"grpcServiceName": {
-						"type": "string"
-					},
-					"selectedDisks": {
-						"type": "array",
-						"items": {
-							"type": "string"
+					"httpOptions": {
+						"type": "object",
+						"properties": {
+							"method": {
+								"type": "string",
+								"enum": ["GET", "POST", "PUT", "DELETE", "HEAD"]
+							},
+							"headers": {
+								"type": "object",
+								"additionalProperties": {
+									"type": "string"
+								}
+							},
+							"body": {
+								"type": "string"
+							},
+							"timeout": {
+								"type": "integer",
+								"minimum": 1000,
+								"maximum": 30000
+							}
 						}
 					},
-					"group": {
-						"type": "string",
-						"nullable": true,
-						"maxLength": 50
-					},
-					"geoCheckEnabled": {
-						"type": "boolean"
-					},
-					"geoCheckLocations": {
+					"assertions": {
 						"type": "array",
 						"items": {
-							"type": "string",
-							"enum": ["northAmerica", "southAmerica", "europe", "asia", "africa", "oceania"]
+							"type": "object",
+							"properties": {
+								"type": {
+									"type": "string",
+									"enum": ["status-code", "response-time", "body-contains", "header-contains"]
+								},
+								"comparison": {
+									"type": "string",
+									"enum": ["equals", "not-equals", "greater-than", "less-than", "contains", "not-contains"]
+								},
+								"value": {
+									"type": "string"
+								}
+							}
 						}
-					},
-					"geoCheckInterval": {
-						"type": "integer",
-						"minimum": 300000
 					}
 				}
 			},

server/package-lock.json

@@ -37,7 +37,6 @@
 				"mongoose": "^8.3.3",
 				"multer": "^1.4.5-lts.1",
 				"nodemailer": "8.0.1",
-				"pg": "8.20.0",
 				"ping": "0.4.4",
 				"sharp": "0.33.5",
 				"ssl-checker": "2.0.10",
@@ -63,7 +62,6 @@
 				"@types/multer": "^2.0.0",
 				"@types/nodemailer": "7.0.1",
 				"@types/papaparse": "^5.5.2",
-				"@types/pg": "8.20.0",
 				"@types/ping": "0.4.4",
 				"@types/swagger-ui-express": "4.1.8",
 				"@types/ws": "^8.18.1",
@@ -875,7 +873,6 @@
 			"integrity": "sha512-H3mcG6ZDLTlYfaSNi0iOKkigqMFvkTKlGUYlD8GW7nNOYRrevuA46iTypPyv+06V3fEmvvazfntkBU34L0azAw==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@babel/code-frame": "^7.28.6",
 				"@babel/generator": "^7.28.6",
@@ -1505,7 +1502,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=18"
 			},
@@ -1550,7 +1546,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=18"
 			}
@@ -4342,7 +4337,6 @@
 			"integrity": "sha512-wGA0NX93b19/dZC1J18tKWVIYWyyF2ZjT9vin/NRu0qzzvfVzWjs04iq2rQ3H65vCTQYlRqs3YHfY7zjdV+9Kw==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@types/body-parser": "*",
 				"@types/express-serve-static-core": "^5.0.0",
@@ -4503,7 +4497,6 @@
 			"resolved": "https://registry.npmjs.org/@types/node/-/node-24.9.1.tgz",
 			"integrity": "sha512-QoiaXANRkSXK6p0Duvt56W208du4P9Uye9hWLWgGMDTEoKPhuenzNcC4vGUmrNkiOKTlIrBoyNQYNpSwfEZXSg==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"undici-types": "~7.16.0"
 			}
@@ -4529,18 +4522,6 @@
 				"@types/node": "*"
 			}
 		},
-		"node_modules/@types/pg": {
-			"version": "8.20.0",
-			"resolved": "https://registry.npmjs.org/@types/pg/-/pg-8.20.0.tgz",
-			"integrity": "sha512-bEPFOaMAHTEP1EzpvHTbmwR8UsFyHSKsRisLIHVMXnpNefSbGA1bD6CVy+qKjGSqmZqNqBDV2azOBo8TgkcVow==",
-			"dev": true,
-			"license": "MIT",
-			"dependencies": {
-				"@types/node": "*",
-				"pg-protocol": "*",
-				"pg-types": "^2.2.0"
-			}
-		},
 		"node_modules/@types/ping": {
 			"version": "0.4.4",
 			"resolved": "https://registry.npmjs.org/@types/ping/-/ping-0.4.4.tgz",
@@ -4753,7 +4734,6 @@
 			"integrity": "sha512-klQbnPAAiGYFyI02+znpBRLyjL4/BrBd0nyWkdC0s/6xFLkXYQ8OoRrSkqacS1ddVxf/LDyODIKbQ5TgKAf/Fg==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@typescript-eslint/scope-manager": "8.56.1",
 				"@typescript-eslint/types": "8.56.1",
@@ -5367,7 +5347,6 @@
 			"integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"bin": {
 				"acorn": "bin/acorn"
 			},
@@ -5946,7 +5925,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"baseline-browser-mapping": "^2.8.19",
 				"caniuse-lite": "^1.0.30001751",
@@ -6889,7 +6867,6 @@
 			"resolved": "https://registry.npmjs.org/cssnano/-/cssnano-7.1.1.tgz",
 			"integrity": "sha512-fm4D8ti0dQmFPeF8DXSAA//btEmqCOgAc/9Oa3C1LW94h5usNrJEfrON7b4FkPZgnDEn6OUs5NdxiJZmAtGOpQ==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"cssnano-preset-default": "^7.0.9",
 				"lilconfig": "^3.1.3"
@@ -7657,7 +7634,6 @@
 			"integrity": "sha512-t5aPOpmtJcZcz5UJyY2GbvpDlsK5E8JqRqoKtfiKE3cNh437KIqfJr3A3AKf5k64NPx6d0G3dno6XDY05PqPtw==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@eslint-community/eslint-utils": "^4.8.0",
 				"@eslint-community/regexpp": "^4.12.1",
@@ -8019,7 +7995,6 @@
 			"resolved": "https://registry.npmjs.org/express/-/express-4.22.1.tgz",
 			"integrity": "sha512-F2X8g9P1X7uCPZMA3MVf9wcTqlyNp7IhH5qPCI0izhaOIYXaW9L535tGA3qmjRzpH+bZczqq7hVKxTR4NWnu+g==",
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"accepts": "~1.3.8",
 				"array-flatten": "1.1.1",
@@ -9664,7 +9639,6 @@
 			"integrity": "sha512-F26gjC0yWN8uAA5m5Ss8ZQf5nDHWGlN/xWZIh8S5SRbsEKBovwZhxGd6LJlbZYxBgCYOtreSUyb8hpXyGC5O4A==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@jest/core": "30.2.0",
 				"@jest/types": "30.2.0",
@@ -12384,96 +12358,6 @@
 				"node": ">=8"
 			}
 		},
-		"node_modules/pg": {
-			"version": "8.20.0",
-			"resolved": "https://registry.npmjs.org/pg/-/pg-8.20.0.tgz",
-			"integrity": "sha512-ldhMxz2r8fl/6QkXnBD3CR9/xg694oT6DZQ2s6c/RI28OjtSOpxnPrUCGOBJ46RCUxcWdx3p6kw/xnDHjKvaRA==",
-			"license": "MIT",
-			"peer": true,
-			"dependencies": {
-				"pg-connection-string": "^2.12.0",
-				"pg-pool": "^3.13.0",
-				"pg-protocol": "^1.13.0",
-				"pg-types": "2.2.0",
-				"pgpass": "1.0.5"
-			},
-			"engines": {
-				"node": ">= 16.0.0"
-			},
-			"optionalDependencies": {
-				"pg-cloudflare": "^1.3.0"
-			},
-			"peerDependencies": {
-				"pg-native": ">=3.0.1"
-			},
-			"peerDependenciesMeta": {
-				"pg-native": {
-					"optional": true
-				}
-			}
-		},
-		"node_modules/pg-cloudflare": {
-			"version": "1.3.0",
-			"resolved": "https://registry.npmjs.org/pg-cloudflare/-/pg-cloudflare-1.3.0.tgz",
-			"integrity": "sha512-6lswVVSztmHiRtD6I8hw4qP/nDm1EJbKMRhf3HCYaqud7frGysPv7FYJ5noZQdhQtN2xJnimfMtvQq21pdbzyQ==",
-			"license": "MIT",
-			"optional": true
-		},
-		"node_modules/pg-connection-string": {
-			"version": "2.12.0",
-			"resolved": "https://registry.npmjs.org/pg-connection-string/-/pg-connection-string-2.12.0.tgz",
-			"integrity": "sha512-U7qg+bpswf3Cs5xLzRqbXbQl85ng0mfSV/J0nnA31MCLgvEaAo7CIhmeyrmJpOr7o+zm0rXK+hNnT5l9RHkCkQ==",
-			"license": "MIT"
-		},
-		"node_modules/pg-int8": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/pg-int8/-/pg-int8-1.0.1.tgz",
-			"integrity": "sha512-WCtabS6t3c8SkpDBUlb1kjOs7l66xsGdKpIPZsg4wR+B3+u9UAum2odSsF9tnvxg80h4ZxLWMy4pRjOsFIqQpw==",
-			"license": "ISC",
-			"engines": {
-				"node": ">=4.0.0"
-			}
-		},
-		"node_modules/pg-pool": {
-			"version": "3.13.0",
-			"resolved": "https://registry.npmjs.org/pg-pool/-/pg-pool-3.13.0.tgz",
-			"integrity": "sha512-gB+R+Xud1gLFuRD/QgOIgGOBE2KCQPaPwkzBBGC9oG69pHTkhQeIuejVIk3/cnDyX39av2AxomQiyPT13WKHQA==",
-			"license": "MIT",
-			"peerDependencies": {
-				"pg": ">=8.0"
-			}
-		},
-		"node_modules/pg-protocol": {
-			"version": "1.13.0",
-			"resolved": "https://registry.npmjs.org/pg-protocol/-/pg-protocol-1.13.0.tgz",
-			"integrity": "sha512-zzdvXfS6v89r6v7OcFCHfHlyG/wvry1ALxZo4LqgUoy7W9xhBDMaqOuMiF3qEV45VqsN6rdlcehHrfDtlCPc8w==",
-			"license": "MIT"
-		},
-		"node_modules/pg-types": {
-			"version": "2.2.0",
-			"resolved": "https://registry.npmjs.org/pg-types/-/pg-types-2.2.0.tgz",
-			"integrity": "sha512-qTAAlrEsl8s4OiEQY69wDvcMIdQN6wdz5ojQiOy6YRMuynxenON0O5oCpJI6lshc6scgAY8qvJ2On/p+CXY0GA==",
-			"license": "MIT",
-			"dependencies": {
-				"pg-int8": "1.0.1",
-				"postgres-array": "~2.0.0",
-				"postgres-bytea": "~1.0.0",
-				"postgres-date": "~1.0.4",
-				"postgres-interval": "^1.1.0"
-			},
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/pgpass": {
-			"version": "1.0.5",
-			"resolved": "https://registry.npmjs.org/pgpass/-/pgpass-1.0.5.tgz",
-			"integrity": "sha512-FdW9r/jQZhSeohs1Z3sI1yxFQNFvMcnmfuj4WBMUTxOrAyLMaTcE1aAMBiTlbMNaXvBCQuVi0R7hd8udDSP7ug==",
-			"license": "MIT",
-			"dependencies": {
-				"split2": "^4.1.0"
-			}
-		},
 		"node_modules/picocolors": {
 			"version": "1.1.1",
 			"resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
@@ -12625,7 +12509,6 @@
 				}
 			],
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"nanoid": "^3.3.11",
 				"picocolors": "^1.1.1",
@@ -13099,45 +12982,6 @@
 			"integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
 			"license": "MIT"
 		},
-		"node_modules/postgres-array": {
-			"version": "2.0.0",
-			"resolved": "https://registry.npmjs.org/postgres-array/-/postgres-array-2.0.0.tgz",
-			"integrity": "sha512-VpZrUqU5A69eQyW2c5CA1jtLecCsN2U/bD6VilrFDWq5+5UIEVO7nazS3TEcHf1zuPYO/sqGvUvW62g86RXZuA==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=4"
-			}
-		},
-		"node_modules/postgres-bytea": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/postgres-bytea/-/postgres-bytea-1.0.1.tgz",
-			"integrity": "sha512-5+5HqXnsZPE65IJZSMkZtURARZelel2oXUEO8rH83VS/hxH5vv1uHquPg5wZs8yMAfdv971IU+kcPUczi7NVBQ==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/postgres-date": {
-			"version": "1.0.7",
-			"resolved": "https://registry.npmjs.org/postgres-date/-/postgres-date-1.0.7.tgz",
-			"integrity": "sha512-suDmjLVQg78nMK2UZ454hAG+OAW+HQPZ6n++TNDUX+L0+uUlLywnoxJKDou51Zm+zTCjrCl0Nq6J9C5hP9vK/Q==",
-			"license": "MIT",
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
-		"node_modules/postgres-interval": {
-			"version": "1.2.0",
-			"resolved": "https://registry.npmjs.org/postgres-interval/-/postgres-interval-1.2.0.tgz",
-			"integrity": "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ==",
-			"license": "MIT",
-			"dependencies": {
-				"xtend": "^4.0.0"
-			},
-			"engines": {
-				"node": ">=0.10.0"
-			}
-		},
 		"node_modules/posthtml": {
 			"version": "0.16.7",
 			"resolved": "https://registry.npmjs.org/posthtml/-/posthtml-0.16.7.tgz",
@@ -14183,15 +14027,6 @@
 			"integrity": "sha512-Q5thBSxp5t8WPTTJQS59LrGqOZqOsrhDGDVm8azCqIBjSBd7nd9o2PM+mDulQQkh8h//4U6hFZnc/mul8t5pWQ==",
 			"license": "ISC"
 		},
-		"node_modules/split2": {
-			"version": "4.2.0",
-			"resolved": "https://registry.npmjs.org/split2/-/split2-4.2.0.tgz",
-			"integrity": "sha512-UcjcJOWknrNkF6PLX83qcHM6KHgVKNkV62Y8a5uYDVv9ydGQVwAHMKqHdJje1VTWpljG0WYpCDhrCdAOYH4TWg==",
-			"license": "ISC",
-			"engines": {
-				"node": ">= 10.x"
-			}
-		},
 		"node_modules/sprintf-js": {
 			"version": "1.0.3",
 			"resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.0.3.tgz",
@@ -14769,7 +14604,6 @@
 			"integrity": "sha512-5gTmgEY/sqK6gFXLIsQNH19lWb4ebPDLA4SdLP7dsWkIXHWlG66oPuVvXSGFPppYZz8ZDZq0dYYrbHfBCVUb1Q==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"engines": {
 				"node": ">=12"
 			},
@@ -14938,7 +14772,6 @@
 			"integrity": "sha512-f0FFpIdcHgn8zcPSbf1dRevwt047YMnaiJM3u2w2RewrB+fob/zePZcrOyQoLMMO7aBIddLcQIEK5dYjkLnGrQ==",
 			"dev": true,
 			"license": "MIT",
-			"peer": true,
 			"dependencies": {
 				"@cspotcode/source-map-support": "^0.8.0",
 				"@tsconfig/node10": "^1.0.7",
@@ -15101,7 +14934,6 @@
 			"integrity": "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A==",
 			"devOptional": true,
 			"license": "Apache-2.0",
-			"peer": true,
 			"bin": {
 				"tsc": "bin/tsc",
 				"tsserver": "bin/tsserver"

server/package.json

@@ -8,7 +8,7 @@
 		"test": "NODE_OPTIONS=--experimental-vm-modules c8 jest --runInBand",
 		"dev": "nodemon --exec tsx src/index.js",
 		"start": "node --watch ./dist/index.js",
-		"build": "tsc && tsc-alias && cp -r src/templates dist/templates",
+		"build": "tsc && tsc-alias",
 		"lint": "eslint .",
 		"lint-fix": "eslint --fix .",
 		"format": "prettier --write .",
@@ -52,7 +52,6 @@
 		"mongoose": "^8.3.3",
 		"multer": "^1.4.5-lts.1",
 		"nodemailer": "8.0.1",
-		"pg": "8.20.0",
 		"ping": "0.4.4",
 		"sharp": "0.33.5",
 		"ssl-checker": "2.0.10",
@@ -78,7 +77,6 @@
 		"@types/multer": "^2.0.0",
 		"@types/nodemailer": "7.0.1",
 		"@types/papaparse": "^5.5.2",
-		"@types/pg": "8.20.0",
 		"@types/ping": "0.4.4",
 		"@types/swagger-ui-express": "4.1.8",
 		"@types/ws": "^8.18.1",

server/src/app.ts

@@ -4,7 +4,7 @@ import cors from "cors";
 import helmet from "helmet";
 import compression from "compression";
 import cookieParser from "cookie-parser";
-import swaggerUi, { type JsonObject } from "swagger-ui-express";
+import swaggerUi from "swagger-ui-express";
 import { handleErrors } from "@/middleware/handleErrors.js";
 import { generalApiLimiter } from "@/middleware/rateLimiter.js";
 import { sanitizeBody, sanitizeQuery } from "@/middleware/sanitization.js";
@@ -24,7 +24,7 @@ export const createApp = ({
 	controllers: InitializedControllers;
 	envSettings: EnvConfig;
 	frontendPath: string;
-	openApiSpec: JsonObject;
+	openApiSpec: any;
 }) => {
 	const allowedOrigin = envSettings.clientHost;
 	const app = express();

server/src/config/controllers.ts

@@ -31,7 +31,7 @@ export interface InitializedControllers {
 export const initializeControllers = (services: InitializedServices): InitializedControllers => {
 	return {
 		authController: new AuthController(services.userService),
-		monitorController: new MonitorController(services.monitorService, services.notificationsService),
+		monitorController: new MonitorController(services.monitorService),
 		settingsController: new SettingsController(services.settingsService, services.emailService),
 		checkController: new CheckController(services.checkService),
 		geoCheckController: new GeoCheckController(services.geoChecksService),

server/src/config/routes.ts

@@ -1,9 +1,6 @@
-import type { Application } from "express";
 import { createVerifyJWT } from "../middleware/verifyJWT.js";
 import { createVerifyStatusPageAccess } from "../middleware/verifyStatusPageAccess.js";
 import { authApiLimiter } from "../middleware/rateLimiter.js";
-import type { InitializedControllers } from "./controllers.js";
-import type { InitializedServices } from "./services.js";
 
 import AuthRoutes from "../routes/authRoute.js";
 import InviteRoutes from "../routes/inviteRoute.js";
@@ -20,7 +17,7 @@ import NotificationRoutes from "../routes/notificationRoute.js";
 
 import IncidentRoutes from "../routes/incidentRoute.js";
 
-export const setupRoutes = (app: Application, controllers: InitializedControllers, services: InitializedServices) => {
+export const setupRoutes = (app: any, controllers: Record<string, any>, services: Record<string, any>) => {
 	const verifyJWT = createVerifyJWT(services.settingsService);
 	const authRoutes = new AuthRoutes(controllers.authController, verifyJWT);
 	const monitorRoutes = new MonitorRoutes(controllers.monitorController);

server/src/config/services.ts

@@ -46,7 +46,6 @@ import {
 	IIncidentService,
 	INotificationMessageBuilder,
 	ISettingsService,
-	SettingsService,
 	EnvConfig,
 } from "@/service/index.js";
 
@@ -93,23 +92,9 @@ import {
 	MongoInvitesRepository,
 	MongoRecoveryTokensRepository,
 	MongoNotificationsRepository,
-	MongoIncidentsRepository,
+	MongoIncidentRepository,
 	MongoTeamsRepository,
 	MongoMaintenanceWindowsRepository,
-	MongoSettingsRepository,
-	TimescaleMonitorsRepository,
-	TimescaleChecksRepository,
-	TimescaleGeoChecksRepository,
-	TimescaleMonitorStatsRepository,
-	TimescaleStatusPagesRepository,
-	TimescaleUsersRepository,
-	TimescaleInvitesRepository,
-	TimescaleRecoveryTokensRepository,
-	TimescaleNotificationsRepository,
-	TimescaleIncidentsRepository,
-	TimescaleTeamsRepository,
-	TimescaleMaintenanceWindowsRepository,
-	TimescaleSettingsRepository,
 	IMonitorsRepository,
 	IChecksRepository,
 	IGeoChecksRepository,
@@ -125,8 +110,6 @@ import {
 	IMaintenanceWindowsRepository,
 } from "@/repositories/index.js";
 import { ILogger } from "@/utils/logger.js";
-import TimescaleDB from "@/db/TimescaleDB.js";
-import { AppError } from "@/utils/AppError.js";
 
 export type InitializedServices = {
 	settingsService: ISettingsService;
@@ -169,81 +152,32 @@ export const initializeServices = async ({
 	logger,
 	envSettings,
 	settingsService,
+	settingsRepository,
 }: {
 	logger: ILogger;
 	envSettings: EnvConfig;
 	settingsService: ISettingsService;
+	settingsRepository: ISettingsRepository;
 }): Promise<InitializedServices> => {
 	// Create DB
 
-	const dbType = envSettings.dbType;
-
-	let db: IDb | null = null;
-
-	if (dbType === "mongodb") {
-		db = new MongoDB(logger, envSettings);
-	} else if (dbType === "timescaledb") {
-		db = new TimescaleDB(logger, envSettings);
-	}
-
-	if (!db) {
-		throw new AppError({ message: "Unsupported database type", status: 500 });
-	}
+	const db = new MongoDB(logger, envSettings);
 
 	await db.connect();
 
-	let monitorsRepository: IMonitorsRepository;
-	let checksRepository: IChecksRepository;
-	let geoChecksRepository: IGeoChecksRepository;
-	let monitorStatsRepository: IMonitorStatsRepository;
-	let statusPagesRepository: IStatusPagesRepository;
-	let usersRepository: IUsersRepository;
-	let invitesRepository: IInvitesRepository;
-	let recoveryTokensRepository: IRecoveryTokensRepository;
-	let settingsRepository: ISettingsRepository;
-	let notificationsRepository: INotificationsRepository;
-	let incidentsRepository: IIncidentsRepository;
-	let teamsRepository: ITeamsRepository;
-	let maintenanceWindowsRepository: IMaintenanceWindowsRepository;
-
 	// Repositories
-
-	if (dbType === "mongodb") {
-		monitorsRepository = new MongoMonitorsRepository();
-		checksRepository = new MongoChecksRepository(logger);
-		geoChecksRepository = new MongoGeoChecksRepository(logger);
-		monitorStatsRepository = new MongoMonitorStatsRepository();
-		statusPagesRepository = new MongoStatusPagesRepository();
-		usersRepository = new MongoUsersRepository();
-		invitesRepository = new MongoInvitesRepository();
-		recoveryTokensRepository = new MongoRecoveryTokensRepository();
-		settingsRepository = new MongoSettingsRepository();
-		notificationsRepository = new MongoNotificationsRepository();
-		incidentsRepository = new MongoIncidentsRepository();
-		teamsRepository = new MongoTeamsRepository();
-		maintenanceWindowsRepository = new MongoMaintenanceWindowsRepository();
-	} else {
-		const pool = db.getPool();
-		if (!pool) {
-			throw new Error("Failed to get database pool");
-		}
-		monitorsRepository = new TimescaleMonitorsRepository(pool);
-		checksRepository = new TimescaleChecksRepository(pool);
-		geoChecksRepository = new TimescaleGeoChecksRepository(pool);
-		monitorStatsRepository = new TimescaleMonitorStatsRepository(pool);
-		statusPagesRepository = new TimescaleStatusPagesRepository(pool);
-		usersRepository = new TimescaleUsersRepository(pool);
-		invitesRepository = new TimescaleInvitesRepository(pool);
-		recoveryTokensRepository = new TimescaleRecoveryTokensRepository(pool);
-		settingsRepository = new TimescaleSettingsRepository(pool);
-		notificationsRepository = new TimescaleNotificationsRepository(pool);
-		incidentsRepository = new TimescaleIncidentsRepository(pool);
-		teamsRepository = new TimescaleTeamsRepository(pool);
-		maintenanceWindowsRepository = new TimescaleMaintenanceWindowsRepository(pool);
-	}
-
-	// Inject settings repository into settings service (now that DB is connected)
-	(settingsService as SettingsService).setRepository(settingsRepository);
+	const monitorsRepository = new MongoMonitorsRepository();
+	const checksRepository = new MongoChecksRepository(logger);
+	const geoChecksRepository = new MongoGeoChecksRepository(logger);
+	const monitorStatsRepository = new MongoMonitorStatsRepository();
+	const statusPagesRepository = new MongoStatusPagesRepository();
+	const usersRepository = new MongoUsersRepository();
+	const invitesRepository = new MongoInvitesRepository();
+	const recoveryTokensRepository = new MongoRecoveryTokensRepository();
+	const notificationsRepository = new MongoNotificationsRepository();
+	const incidentsRepository = new MongoIncidentRepository();
+	const teamsRepository = new MongoTeamsRepository();
+	const maintenanceWindowsRepository = new MongoMaintenanceWindowsRepository();
 
 	// Network providers
 	const pingProvider = new PingProvider(ping);

server/src/controllers/authController.ts

@@ -23,24 +23,7 @@ import { IUserService } from "@/service/index.js";
 
 const SERVICE_NAME = "authController";
 
-export interface IAuthController {
-	registerUser(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	createUser(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	loginUser(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	editUser(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	checkSuperadminExists(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	requestRecovery(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	validateRecovery(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	resetPassword(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	deleteUser(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	deleteUserById(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	getAllUsers(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	getUserById(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	editUserById(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	editUserPasswordById(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-}
-
-class AuthController implements IAuthController {
+class AuthController {
 	static SERVICE_NAME = SERVICE_NAME;
 
 	private userService: IUserService;

server/src/controllers/checkController.ts

@@ -12,16 +12,7 @@ import { requireTeamId } from "@/controllers/controllerUtils.js";
 
 const SERVICE_NAME = "checkController";
 
-export interface ICheckController {
-	serviceName: string;
-	getChecksByMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getChecksByTeam: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getChecksSummaryByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteChecks: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteChecksByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-
-class CheckController implements ICheckController {
+class CheckController {
 	static SERVICE_NAME = SERVICE_NAME;
 
 	private checkService: ICheckService;

server/src/controllers/controllerUtils.ts

@@ -3,7 +3,7 @@ import { Monitor, type MonitorType, MonitorTypes, UserRole } from "@/types/index
 import sslChecker, { SSLDetails } from "ssl-checker";
 type SSLCheckerType = typeof sslChecker;
 
-export const fetchMonitorCertificate = async (checker: SSLCheckerType, monitor: Monitor): Promise<SSLDetails> => {
+const fetchMonitorCertificate = async (checker: SSLCheckerType, monitor: Monitor): Promise<SSLDetails> => {
 	const monitorUrl = new URL(monitor.url);
 	const hostname = monitorUrl.hostname;
 	const cert = await checker(hostname);
@@ -12,14 +12,14 @@ export const fetchMonitorCertificate = async (checker: SSLCheckerType, monitor:
 	}
 	return cert;
 };
-export const requireString = (value: unknown, fieldName: string): string => {
+const requireString = (value: unknown, fieldName: string): string => {
 	if (typeof value === "string" && value.trim().length > 0) {
 		return value;
 	}
 	throw new AppError({ message: `${fieldName} is required`, status: 400 });
 };
 
-export const optionalString = (value: unknown, fieldName: string): string | undefined => {
+const optionalString = (value: unknown, fieldName: string): string | undefined => {
 	if (value === undefined) {
 		return undefined;
 	}
@@ -29,7 +29,7 @@ export const optionalString = (value: unknown, fieldName: string): string | unde
 	throw new AppError({ message: `${fieldName} must be a string`, status: 400 });
 };
 
-export const optionalNumber = (value: unknown, fieldName: string): number | undefined => {
+const optionalNumber = (value: unknown, fieldName: string): number | undefined => {
 	if (value === undefined) {
 		return undefined;
 	}
@@ -45,7 +45,7 @@ export const optionalNumber = (value: unknown, fieldName: string): number | unde
 	throw new AppError({ message: `${fieldName} must be a number`, status: 400 });
 };
 
-export const optionalBoolean = (value: unknown, fieldName: string): boolean | undefined => {
+const optionalBoolean = (value: unknown, fieldName: string): boolean | undefined => {
 	if (value === undefined) {
 		return undefined;
 	}
@@ -63,7 +63,7 @@ export const optionalBoolean = (value: unknown, fieldName: string): boolean | un
 	throw new AppError({ message: `${fieldName} must be a boolean`, status: 400 });
 };
 
-export const parseMonitorTypeFilter = (value: unknown): MonitorType | MonitorType[] | undefined => {
+const parseMonitorTypeFilter = (value: unknown): MonitorType | MonitorType[] | undefined => {
 	const parseSingle = (input: unknown): MonitorType => {
 		if (typeof input !== "string") {
 			throw new AppError({ message: "Monitor type must be a string", status: 400 });
@@ -83,7 +83,7 @@ export const parseMonitorTypeFilter = (value: unknown): MonitorType | MonitorTyp
 	return parseSingle(value);
 };
 
-export const parseSortOrder = (value: unknown): "asc" | "desc" | undefined => {
+const parseSortOrder = (value: unknown): "asc" | "desc" | undefined => {
 	if (value === undefined) {
 		return undefined;
 	}
@@ -93,36 +93,42 @@ export const parseSortOrder = (value: unknown): "asc" | "desc" | undefined => {
 	throw new AppError({ message: "order must be either 'asc' or 'desc'", status: 400 });
 };
 
-export const requireTeamId = (teamId?: string): string => {
+const requireTeamId = (teamId?: string): string => {
 	if (!teamId) {
 		throw new AppError({ message: "Team ID is required", status: 400 });
 	}
 	return teamId;
 };
 
-export const requireUserId = (userId?: string): string => {
+const requireUserId = (userId?: string): string => {
 	if (!userId) {
 		throw new AppError({ message: "User ID is required", status: 400 });
 	}
 	return userId;
 };
-export const requireUserEmail = (userEmail?: string): string => {
+const requireUserEmail = (userEmail?: string): string => {
 	if (!userEmail) {
 		throw new AppError({ message: "User email is required", status: 400 });
 	}
 	return userEmail;
 };
 
-export const requireFirstName = (firstName?: string): string => {
-	if (!firstName) {
-		throw new AppError({ message: "First name is required", status: 400 });
-	}
-	return firstName;
-};
-
 export const requireUserRoles = (userRoles?: UserRole[]): UserRole[] => {
 	if (!userRoles || userRoles.length === 0) {
 		throw new AppError({ message: "User roles are required", status: 400 });
 	}
 	return userRoles;
 };
+
+export {
+	fetchMonitorCertificate,
+	requireString,
+	optionalString,
+	optionalNumber,
+	optionalBoolean,
+	parseMonitorTypeFilter,
+	parseSortOrder,
+	requireTeamId,
+	requireUserId,
+	requireUserEmail,
+};

server/src/controllers/diagnosticController.ts

@@ -2,12 +2,7 @@ import { IDiagnosticService } from "@/service/index.js";
 import { Request, Response, NextFunction } from "express";
 
 const SERVICE_NAME = "diagnosticController";
-
-export interface IDiagnosticController {
-	getSystemStats: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-
-class DiagnosticController implements IDiagnosticController {
+class DiagnosticController {
 	static SERVICE_NAME = SERVICE_NAME;
 
 	private diagnosticService: IDiagnosticService;

server/src/controllers/geoCheckController.ts

@@ -1,15 +1,10 @@
 import { Request, Response, NextFunction } from "express";
 import { getChecksParamValidation, getChecksQueryValidation } from "@/validation/checkValidation.js";
 import type { IGeoChecksService } from "@/service/business/geoChecksService.js";
-import { requireTeamId } from "./controllerUtils.js";
-import { AppError } from "@/utils/AppError.js";
 
 const SERVICE_NAME = "geoCheckController";
 
-export interface IGeoCheckController {
-	getGeoChecksByMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-class GeoCheckController implements IGeoCheckController {
+class GeoCheckController {
 	static SERVICE_NAME = SERVICE_NAME;
 
 	private geoChecksService: IGeoChecksService;
@@ -23,19 +18,13 @@ class GeoCheckController implements IGeoCheckController {
 
 	getGeoChecksByMonitor = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getChecksParamValidation.parse(req.params);
-			const validatedQuery = getChecksQueryValidation.parse(req.query);
-
-			const teamId = requireTeamId(req.user?.teamId);
+			getChecksParamValidation.parse(req.params);
+			getChecksQueryValidation.parse(req.query);
 
 			const result = await this.geoChecksService.getGeoChecksByMonitor({
-				monitorId: validatedParams.monitorId,
-				teamId: teamId,
-				sortOrder: validatedQuery.sortOrder,
-				dateRange: validatedQuery.dateRange,
-				page: validatedQuery.page,
-				rowsPerPage: validatedQuery.rowsPerPage,
-				continent: validatedQuery.continent,
+				monitorId: req?.params?.monitorId as string,
+				query: req?.query,
+				teamId: req?.user?.teamId as string,
 			});
 
 			return res.status(200).json({

server/src/controllers/incidentController.ts

@@ -1,37 +1,35 @@
 import { AppError } from "@/utils/AppError.js";
 import { Request, Response, NextFunction } from "express";
 import { requireTeamId, requireUserId, requireUserEmail } from "./controllerUtils.js";
-import { IIncidentService } from "@/service/index.js";
-import { getIncidentsByTeamQueryValidation, getIncidentSummaryQueryValidation } from "@/validation/incidentValidation.js";
 
-const SERVICE_NAME = "IncidentController";
+const SERVICE_NAME = "incidentController";
 
-export interface IIncidentController {
-	getIncidentsByTeam: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getIncidentSummary: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getIncidentById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	resolveIncidentManually: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-class IncidentController implements IIncidentController {
-	private incidentService: IIncidentService;
-	constructor(incidentService: IIncidentService) {
+class IncidentController {
+	static SERVICE_NAME = SERVICE_NAME;
+
+	private incidentService: any;
+	constructor(incidentService: any) {
 		this.incidentService = incidentService;
 	}
 
+	get serviceName() {
+		return IncidentController.SERVICE_NAME;
+	}
+
 	getIncidentsByTeam = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedQuery = getIncidentsByTeamQueryValidation.parse(req.query);
+			const { sortOrder, dateRange, page, rowsPerPage, status, monitorId, resolutionType } = req.query || {};
 
 			const teamId = requireTeamId(req.user?.teamId);
 			const result = await this.incidentService.getIncidentsByTeam(
 				teamId,
-				validatedQuery.sortOrder,
-				validatedQuery.dateRange,
-				validatedQuery.page,
-				validatedQuery.rowsPerPage,
-				validatedQuery.status,
-				validatedQuery.monitorId,
-				validatedQuery.resolutionType
+				sortOrder,
+				dateRange,
+				page,
+				rowsPerPage,
+				status,
+				monitorId,
+				resolutionType
 			);
 
 			return res.status(200).json({
@@ -47,9 +45,10 @@ class IncidentController implements IIncidentController {
 	getIncidentSummary = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const teamId = requireTeamId(req.user?.teamId);
-			const validatedQuery = getIncidentSummaryQueryValidation.parse(req.query);
 
-			const summary = await this.incidentService.getIncidentSummary(teamId, validatedQuery.limit);
+			const limit = req.query.limit ? parseInt(req.query.limit as string, 10) : 10;
+
+			const summary = await this.incidentService.getIncidentSummary(teamId, limit);
 			return res.status(200).json({
 				success: true,
 				msg: "Incident summary retrieved successfully",

server/src/controllers/inviteController.ts

@@ -1,19 +1,12 @@
 import { Request, Response, NextFunction } from "express";
 import { inviteBodyValidation, inviteVerificationBodyValidation } from "@/validation/authValidation.js";
-import { requireFirstName, requireTeamId, requireUserRoles } from "@/controllers/controllerUtils.js";
-import { IInviteService } from "@/service/index.js";
+import { requireTeamId, requireUserRoles } from "@/controllers/controllerUtils.js";
 const SERVICE_NAME = "inviteController";
 
-export interface IInviteController {
-	getInviteToken: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	sendInviteEmail: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	verifyInviteToken: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-
-class InviteController implements IInviteController {
+class InviteController {
 	static SERVICE_NAME = SERVICE_NAME;
-	private inviteService: IInviteService;
-	constructor(inviteService: IInviteService) {
+	private inviteService: any;
+	constructor(inviteService: any) {
 		this.inviteService = inviteService;
 	}
 
@@ -41,9 +34,8 @@ class InviteController implements IInviteController {
 
 	sendInviteEmail = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
-			const userRoles = requireUserRoles(req.user?.role);
-			const firstName = requireFirstName(req.user?.firstName);
+			const teamId = requireTeamId(req?.user?.teamId);
+			const userRoles = requireUserRoles(req?.user?.role);
 
 			const inviteRequest = req.body;
 			inviteRequest.teamId = teamId;
@@ -51,7 +43,7 @@ class InviteController implements IInviteController {
 
 			const inviteToken = await this.inviteService.sendInviteEmail({
 				invite: inviteRequest,
-				firstName,
+				firstName: req?.user?.firstName,
 				userRoles,
 			});
 			return res.status(200).json({

server/src/controllers/logController.ts

@@ -1,16 +1,11 @@
-import { ILogger } from "@/utils/logger.js";
 import { Request, Response, NextFunction } from "express";
 
 const SERVICE_NAME = "LogController";
 
-export interface ILogController {
-	getLogs: (req: Request, res: Response, next: NextFunction) => Promise<void>;
-}
-
 class LogController {
 	static SERVICE_NAME = SERVICE_NAME;
-	private logger: ILogger;
-	constructor(logger: ILogger) {
+	private logger: any;
+	constructor(logger: any) {
 		this.logger = logger;
 	}
 	get serviceName() {
@@ -19,7 +14,7 @@ class LogController {
 
 	getLogs = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const logs = this.logger.getLogs();
+			const logs = await this.logger.getLogs();
 			res.status(200).json({
 				success: true,
 				msg: "Logs fetched successfully",

server/src/controllers/maintenanceWindowController.ts

@@ -9,37 +9,26 @@ import {
 	deleteMaintenanceWindowByIdParamValidation,
 } from "@/validation/maintenanceWindowValidation.js";
 import { requireTeamId } from "@/controllers/controllerUtils.js";
-import { IMaintenanceWindowService } from "@/service/index.js";
 
-export interface IMaintenanceWindowController {
-	createMaintenanceWindows: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMaintenanceWindowById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMaintenanceWindowsByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMaintenanceWindowsByMonitorId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteMaintenanceWindow: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	editMaintenanceWindow: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-class MaintenanceWindowController implements IMaintenanceWindowController {
-	private maintenanceWindowService: IMaintenanceWindowService;
-	constructor(maintenanceWindowService: IMaintenanceWindowService) {
+const SERVICE_NAME = "maintenanceWindowController";
+
+class MaintenanceWindowController {
+	static SERVICE_NAME = SERVICE_NAME;
+	private maintenanceWindowService: any;
+	constructor(maintenanceWindowService: any) {
 		this.maintenanceWindowService = maintenanceWindowService;
 	}
 
+	get serviceName() {
+		return MaintenanceWindowController.SERVICE_NAME;
+	}
+
 	createMaintenanceWindows = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = createMaintenanceWindowBodyValidation.parse(req.body);
+			createMaintenanceWindowBodyValidation.parse(req.body);
 			const teamId = requireTeamId(req?.user?.teamId);
 
-			const monitorIDs = validatedBody.monitors;
-			const name = validatedBody.name;
-			const active = validatedBody.active ?? true;
-			const duration = validatedBody.duration;
-			const durationUnit = validatedBody.durationUnit;
-			const repeat = validatedBody.repeat;
-			const start = validatedBody.start;
-			const end = validatedBody.end;
-
-			await this.maintenanceWindowService.createMaintenanceWindow({ teamId, monitorIDs, name, active, duration, durationUnit, repeat, start, end });
+			await this.maintenanceWindowService.createMaintenanceWindow({ teamId, body: req.body });
 
 			return res.status(200).json({
 				success: true,
@@ -51,11 +40,11 @@ class MaintenanceWindowController implements IMaintenanceWindowController {
 	};
 	getMaintenanceWindowById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMaintenanceWindowByIdParamValidation.parse(req.params);
+			getMaintenanceWindowByIdParamValidation.parse(req.params);
 
 			const teamId = requireTeamId(req.user?.teamId);
 
-			const maintenanceWindow = await this.maintenanceWindowService.getMaintenanceWindowById({ id: validatedParams.id, teamId });
+			const maintenanceWindow = await this.maintenanceWindowService.getMaintenanceWindowById({ id: req.params.id as string, teamId });
 
 			return res.status(200).json({
 				success: true,
@@ -69,18 +58,11 @@ class MaintenanceWindowController implements IMaintenanceWindowController {
 
 	getMaintenanceWindowsByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedQuery = getMaintenanceWindowsByTeamIdQueryValidation.parse(req.query);
+			getMaintenanceWindowsByTeamIdQueryValidation.parse(req.query);
 
 			const teamId = requireTeamId(req?.user?.teamId);
 
-			const maintenanceWindows = await this.maintenanceWindowService.getMaintenanceWindowsByTeamId({
-				teamId,
-				active: validatedQuery.active,
-				page: validatedQuery.page,
-				rowsPerPage: validatedQuery.rowsPerPage,
-				field: validatedQuery.field,
-				order: validatedQuery.order,
-			});
+			const maintenanceWindows = await this.maintenanceWindowService.getMaintenanceWindowsByTeamId({ teamId, query: req.query });
 
 			return res.status(200).json({
 				success: true,
@@ -94,12 +76,12 @@ class MaintenanceWindowController implements IMaintenanceWindowController {
 
 	getMaintenanceWindowsByMonitorId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMaintenanceWindowsByMonitorIdParamValidation.parse(req.params);
+			getMaintenanceWindowsByMonitorIdParamValidation.parse(req.params);
 
 			const teamId = requireTeamId(req?.user?.teamId);
 
 			const maintenanceWindows = await this.maintenanceWindowService.getMaintenanceWindowsByMonitorId({
-				monitorId: validatedParams.monitorId,
+				monitorId: req.params.monitorId as string,
 				teamId,
 			});
 
@@ -114,11 +96,11 @@ class MaintenanceWindowController implements IMaintenanceWindowController {
 	};
 	deleteMaintenanceWindow = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = deleteMaintenanceWindowByIdParamValidation.parse(req.params);
+			deleteMaintenanceWindowByIdParamValidation.parse(req.params);
 
 			const teamId = requireTeamId(req?.user?.teamId);
 
-			await this.maintenanceWindowService.deleteMaintenanceWindow({ id: validatedParams.id, teamId });
+			await this.maintenanceWindowService.deleteMaintenanceWindow({ id: req.params.id as string, teamId });
 
 			return res.status(200).json({
 				success: true,
@@ -131,14 +113,14 @@ class MaintenanceWindowController implements IMaintenanceWindowController {
 
 	editMaintenanceWindow = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = editMaintenanceWindowByIdParamValidation.parse(req.params);
-			const validatedBody = editMaintenanceByIdWindowBodyValidation.parse(req.body);
+			editMaintenanceWindowByIdParamValidation.parse(req.params);
+			editMaintenanceByIdWindowBodyValidation.parse(req.body);
 
 			const teamId = requireTeamId(req.user?.teamId);
 
 			const editedMaintenanceWindow = await this.maintenanceWindowService.editMaintenanceWindow({
-				id: validatedParams.id,
-				body: validatedBody,
+				id: req.params.id as string,
+				body: req.body,
 				teamId,
 			});
 			return res.status(200).json({

server/src/controllers/monitorController.ts

@@ -1,8 +1,9 @@
 import { Request, Response, NextFunction } from "express";
-import { updateNotificationsValidation } from "@/validation/notificationValidation.js";
+
 import {
 	getMonitorByIdParamValidation,
 	getMonitorByIdQueryValidation,
+	getMonitorsByTeamIdParamValidation,
 	getMonitorsByTeamIdQueryValidation,
 	getMonitorsWithChecksQueryValidation,
 	createMonitorBodyValidation,
@@ -11,48 +12,31 @@ import {
 	getCertificateParamValidation,
 	getHardwareDetailsByIdParamValidation,
 	getHardwareDetailsByIdQueryValidation,
-	getUptimeDetailsByIdParamValidation,
-	getUptimeDetailsByIdQueryValidation,
-	importMonitorsBodyValidation,
 } from "@/validation/monitorValidation.js";
 import sslChecker from "ssl-checker";
-import { fetchMonitorCertificate, requireTeamId, requireUserId } from "@/controllers/controllerUtils.js";
+import {
+	fetchMonitorCertificate,
+	requireString,
+	optionalString,
+	optionalNumber,
+	optionalBoolean,
+	parseMonitorTypeFilter,
+	parseSortOrder,
+	requireTeamId,
+	requireUserId,
+} from "./controllerUtils.js";
 import { AppError } from "@/utils/AppError.js";
-import { IMonitorService, INotificationsService } from "@/service/index.js";
+import { IMonitorService } from "@/service/index.js";
 import { GeoContinent } from "@/types/geoCheck.js";
 
 const SERVICE_NAME = "monitorController";
-
-export interface IMonitorController {
-	getMonitorCertificate: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getUptimeDetailsById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getHardwareDetailsById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getPageSpeedDetailsById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getGeoChecksByMonitorId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMonitorById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	createMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	importMonitorsFromJSON: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteAllMonitors: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	editMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	pauseMonitor: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	addDemoMonitors: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMonitorsByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getMonitorsWithChecksByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	exportMonitorsToJSON: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getAllGames: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getGroupsByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	updateNotifications: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-class MonitorController implements IMonitorController {
+class MonitorController {
 	static SERVICE_NAME = SERVICE_NAME;
 
 	private monitorService: IMonitorService;
-	private notificationsService: INotificationsService;
 
-	constructor(monitorService: IMonitorService, notificationsService: INotificationsService) {
+	constructor(monitorService: IMonitorService) {
 		this.monitorService = monitorService;
-		this.notificationsService = notificationsService;
 	}
 
 	get serviceName() {
@@ -61,9 +45,10 @@ class MonitorController implements IMonitorController {
 
 	getMonitorCertificate = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getCertificateParamValidation.parse(req.params);
-			const teamId = requireTeamId(req.user?.teamId);
-			const monitor = await this.monitorService.getMonitorById({ teamId, monitorId: validatedParams.monitorId });
+			getCertificateParamValidation.parse(req.params);
+			const teamId = requireTeamId(req?.user?.teamId);
+			const monitorId = requireString(req.params?.monitorId, "Monitor ID");
+			const monitor = await this.monitorService.getMonitorById({ teamId, monitorId });
 			const certificate = await fetchMonitorCertificate(sslChecker, monitor);
 
 			return res.status(200).json({
@@ -80,18 +65,16 @@ class MonitorController implements IMonitorController {
 
 	getUptimeDetailsById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getUptimeDetailsByIdParamValidation.parse(req.params);
-			const validatedQuery = getUptimeDetailsByIdQueryValidation.parse(req.query);
-
-			const monitorId = validatedParams.monitorId;
-			const dateRange = validatedQuery.dateRange;
-
-			const teamId = requireTeamId(req.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const dateRange = requireString(req?.query?.dateRange, "dateRange");
+			const normalize = optionalBoolean(req?.query?.normalize, "normalize");
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const data = await this.monitorService.getUptimeDetailsById({
 				teamId,
 				monitorId,
 				dateRange,
+				normalize,
 			});
 			return res.status(200).json({
 				success: true,
@@ -105,12 +88,12 @@ class MonitorController implements IMonitorController {
 
 	getHardwareDetailsById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getHardwareDetailsByIdParamValidation.parse(req.params);
-			const validatedQuery = getHardwareDetailsByIdQueryValidation.parse(req.query);
+			getHardwareDetailsByIdParamValidation.parse(req.params);
+			getHardwareDetailsByIdQueryValidation.parse(req.query);
 
-			const monitorId = validatedParams.monitorId;
-			const dateRange = validatedQuery.dateRange || "recent";
-			const teamId = requireTeamId(req.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const dateRange = optionalString(req?.query?.dateRange, "dateRange") || "recent";
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const data = await this.monitorService.getHardwareDetailsById({
 				teamId,
@@ -129,12 +112,12 @@ class MonitorController implements IMonitorController {
 	};
 	getPageSpeedDetailsById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getHardwareDetailsByIdParamValidation.parse(req.params);
-			const validatedQuery = getHardwareDetailsByIdQueryValidation.parse(req.query);
+			getHardwareDetailsByIdParamValidation.parse(req.params);
+			getHardwareDetailsByIdQueryValidation.parse(req.query);
 
-			const monitorId = validatedParams.monitorId;
-			const dateRange = validatedQuery.dateRange || "recent";
-			const teamId = requireTeamId(req.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const dateRange = requireString(req?.query?.dateRange, "dateRange");
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const data = await this.monitorService.getPageSpeedDetailsById({
 				teamId,
@@ -154,14 +137,18 @@ class MonitorController implements IMonitorController {
 
 	getGeoChecksByMonitorId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMonitorByIdParamValidation.parse(req.params);
-			const validatedQuery = getMonitorByIdQueryValidation.parse(req.query);
+			getMonitorByIdParamValidation.parse(req.params);
+			getMonitorByIdQueryValidation.parse(req.query);
 
-			const monitorId = validatedParams.monitorId;
-			const dateRange = validatedQuery.dateRange || "recent";
-			const continentParam = validatedQuery.continent;
-			const continents = continentParam ? (Array.isArray(continentParam) ? continentParam : [continentParam]) : undefined;
-			const teamId = requireTeamId(req.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const dateRange = requireString(req?.query?.dateRange, "dateRange");
+			const continentParam = req?.query?.continent;
+			const continents = continentParam
+				? Array.isArray(continentParam)
+					? (continentParam as GeoContinent[])
+					: [continentParam as GeoContinent]
+				: undefined;
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const data = await this.monitorService.getGeoChecksByMonitorId({
 				teamId,
@@ -182,10 +169,11 @@ class MonitorController implements IMonitorController {
 
 	getMonitorById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMonitorByIdParamValidation.parse(req.params);
+			getMonitorByIdParamValidation.parse(req.params);
+			getMonitorByIdQueryValidation.parse(req.query);
 
-			const teamId = requireTeamId(req.user?.teamId);
-			const monitorId = validatedParams.monitorId;
+			const teamId = requireTeamId(req?.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
 
 			const monitor = await this.monitorService.getMonitorById({ teamId, monitorId });
 
@@ -201,12 +189,12 @@ class MonitorController implements IMonitorController {
 
 	createMonitor = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = createMonitorBodyValidation.parse(req.body);
+			createMonitorBodyValidation.parse(req.body);
 
-			const userId = requireUserId(req.user?.id);
-			const teamId = requireTeamId(req.user?.teamId);
+			const userId = requireString(req?.user?.id, "User ID");
+			const teamId = requireTeamId(req?.user?.teamId);
 
-			const monitor = await this.monitorService.createMonitor(teamId, userId, validatedBody);
+			const monitor = await this.monitorService.createMonitor(teamId, userId, req.body);
 
 			return res.status(200).json({
 				success: true,
@@ -220,10 +208,14 @@ class MonitorController implements IMonitorController {
 
 	importMonitorsFromJSON = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
-			const userId = requireUserId(req.user?.id);
-			const validatedBody = importMonitorsBodyValidation.parse(req.body);
-			const monitors = validatedBody.monitors;
+			const teamId = requireTeamId(req?.user?.teamId);
+			const userId = requireUserId(req?.user?.id);
+
+			const { monitors } = req.body;
+
+			if (!monitors || !Array.isArray(monitors)) {
+				throw new AppError({ message: "Invalid request: monitors array is required", status: 400 });
+			}
 
 			const result = await this.monitorService.importMonitorsFromJSON({ teamId, userId, monitors });
 
@@ -239,9 +231,9 @@ class MonitorController implements IMonitorController {
 
 	deleteMonitor = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMonitorByIdParamValidation.parse(req.params);
-			const teamId = requireTeamId(req.user?.teamId);
-			const monitorId = validatedParams.monitorId;
+			getMonitorByIdParamValidation.parse(req.params);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const deletedMonitor = await this.monitorService.deleteMonitor({ teamId, monitorId });
 
@@ -257,7 +249,8 @@ class MonitorController implements IMonitorController {
 
 	deleteAllMonitors = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
+			const teamId = requireTeamId(req?.user?.teamId);
+
 			const deletedCount = await this.monitorService.deleteAllMonitors({ teamId });
 
 			return res.status(200).json({
@@ -271,12 +264,12 @@ class MonitorController implements IMonitorController {
 
 	editMonitor = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = getMonitorByIdParamValidation.parse(req.params);
-			const validatedBody = editMonitorBodyValidation.parse(req.body);
-			const monitorId = validatedParams.monitorId;
-			const teamId = requireTeamId(req.user?.teamId);
+			getMonitorByIdParamValidation.parse(req.params);
+			editMonitorBodyValidation.parse(req.body);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const teamId = requireTeamId(req?.user?.teamId);
 
-			const editedMonitor = await this.monitorService.editMonitor({ teamId, monitorId, body: validatedBody });
+			const editedMonitor = await this.monitorService.editMonitor({ teamId, monitorId, body: req.body });
 
 			return res.status(200).json({
 				success: true,
@@ -290,10 +283,10 @@ class MonitorController implements IMonitorController {
 
 	pauseMonitor = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedParams = pauseMonitorParamValidation.parse(req.params);
+			pauseMonitorParamValidation.parse(req.params);
 
-			const monitorId = validatedParams.monitorId;
-			const teamId = requireTeamId(req.user?.teamId);
+			const monitorId = requireString(req?.params?.monitorId, "Monitor ID");
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const monitor = await this.monitorService.pauseMonitor({ teamId, monitorId });
 
@@ -309,8 +302,8 @@ class MonitorController implements IMonitorController {
 
 	addDemoMonitors = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const id = requireUserId(req.user?.id);
-			const teamId = requireTeamId(req.user?.teamId);
+			const id = requireString(req?.user?.id, "User ID");
+			const teamId = requireTeamId(req?.user?.teamId);
 			const demoMonitors = await this.monitorService.addDemoMonitors({ userId: id, teamId });
 
 			return res.status(200).json({
@@ -323,13 +316,32 @@ class MonitorController implements IMonitorController {
 		}
 	};
 
+	sendTestEmail = async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			const { to } = req.body;
+			if (!to || typeof to !== "string") {
+				throw new AppError({ message: "Invalid 'to' email address", status: 400 });
+			}
+
+			const messageId = await this.monitorService.sendTestEmail({ to });
+			return res.status(200).json({
+				success: true,
+				msg: "Test email sent successfully",
+				data: { messageId },
+			});
+		} catch (error) {
+			next(error);
+		}
+	};
+
 	getMonitorsByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedQuery = getMonitorsByTeamIdQueryValidation.parse(req.query);
+			getMonitorsByTeamIdParamValidation.parse(req.params);
+			getMonitorsByTeamIdQueryValidation.parse(req.query);
 
-			const teamId = requireTeamId(req.user?.teamId);
-			const type = validatedQuery.type;
-			const filter = validatedQuery.filter;
+			const teamId = requireTeamId(req?.user?.teamId);
+			const type = parseMonitorTypeFilter(req.query?.type);
+			const filter = optionalString(req.query?.filter, "filter");
 
 			const monitors = await this.monitorService.getMonitorsByTeamId({ teamId, type, filter });
 
@@ -345,16 +357,17 @@ class MonitorController implements IMonitorController {
 
 	getMonitorsWithChecksByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedQuery = getMonitorsWithChecksQueryValidation.parse(req.query);
-
-			const limit = validatedQuery.limit;
-			const page = validatedQuery.page;
-			const rowsPerPage = validatedQuery.rowsPerPage;
-			const filter = validatedQuery.filter;
-			const field = validatedQuery.field;
-			const order = validatedQuery.order;
-			const type = validatedQuery.type;
-			const teamId = requireTeamId(req.user?.teamId);
+			getMonitorsByTeamIdParamValidation.parse(req.params);
+			getMonitorsWithChecksQueryValidation.parse(req.query);
+			const explain = optionalBoolean(req?.query?.explain, "explain");
+			const limit = optionalNumber(req?.query?.limit, "limit");
+			const page = optionalNumber(req?.query?.page, "page");
+			const rowsPerPage = optionalNumber(req?.query?.rowsPerPage, "rowsPerPage");
+			const filter = optionalString(req?.query?.filter, "filter");
+			const field = optionalString(req?.query?.field, "field");
+			const order = parseSortOrder(req?.query?.order);
+			const type = parseMonitorTypeFilter(req?.query?.type);
+			const teamId = requireTeamId(req?.user?.teamId);
 
 			const monitors = await this.monitorService.getMonitorsWithChecksByTeamId({
 				teamId,
@@ -365,6 +378,7 @@ class MonitorController implements IMonitorController {
 				filter,
 				field,
 				order,
+				explain,
 			});
 
 			return res.status(200).json({
@@ -378,7 +392,11 @@ class MonitorController implements IMonitorController {
 
 	exportMonitorsToJSON = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
+
 			const json = await this.monitorService.exportMonitorsToJSON({ teamId });
 
 			return res.status(200).json({
@@ -406,7 +424,11 @@ class MonitorController implements IMonitorController {
 
 	getGroupsByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
+
 			const groups = await this.monitorService.getGroupsByTeamId({ teamId });
 
 			return res.status(200).json({
@@ -417,42 +439,6 @@ class MonitorController implements IMonitorController {
 			next(error);
 		}
 	};
-
-	updateNotifications = async (req: Request, res: Response, next: NextFunction) => {
-		try {
-			updateNotificationsValidation.parse(req.body);
-
-			const teamId = requireTeamId(req.user?.teamId);
-			const { monitorIds, notificationIds, action } = req.body;
-
-			// Verify all requested notification IDs actually belong to this team
-			const teamNotifications = await this.notificationsService.findNotificationsByTeamId(teamId);
-			const validNotificationIds = teamNotifications.map((n) => n.id);
-
-			const invalidIds = notificationIds.filter((id: string) => !validNotificationIds.includes(id));
-			if (invalidIds.length > 0) {
-				throw new AppError({
-					message: `The following notification IDs are invalid or do not belong to your team: ${invalidIds.join(", ")}`,
-					status: 403,
-				});
-			}
-
-			const modifiedCount = await this.monitorService.updateNotifications({
-				teamId,
-				monitorIds,
-				notificationIds,
-				action,
-			});
-
-			return res.status(200).json({
-				success: true,
-				msg: `Notifications updated successfully on ${modifiedCount} monitor(s)`,
-				data: { modifiedCount },
-			});
-		} catch (error) {
-			next(error);
-		}
-	};
 }
 
 export default MonitorController;

server/src/controllers/notificationController.ts

@@ -1,30 +1,16 @@
 import { Request, Response, NextFunction } from "express";
 
-import {
-	createNotificationBodyValidation,
-	deleteNotificationParamValidation,
-	getNotificationByIdParamValidation,
-	testNotificationBodyValidation,
-	editNotificationParamValidation,
-	testAllNotificationsBodyValidation,
-} from "@/validation/notificationValidation.js";
+import { Notification } from "@/types/index.js";
+import { createNotificationBodyValidation } from "@/validation/notificationValidation.js";
 import { AppError } from "@/utils/AppError.js";
-import { INotificationsService } from "@/service/index.js";
-import { requireTeamId, requireUserId } from "./controllerUtils.js";
 import { IMonitorsRepository } from "@/repositories/index.js";
+import { INotificationsService } from "@/service/index.js";
+import { requireTeamId } from "./controllerUtils.js";
 
 const SERVICE_NAME = "NotificationController";
 
-export interface INotificationController {
-	testNotification: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	createNotification: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getNotificationsByTeamId: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	deleteNotification: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	getNotificationById: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	editNotification: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-	testAllNotifications: (req: Request, res: Response, next: NextFunction) => Promise<Response | void>;
-}
-class NotificationController implements INotificationController {
+class NotificationController {
+	static SERVICE_NAME = SERVICE_NAME;
 	private notificationsService: INotificationsService;
 	private monitorsRepository: IMonitorsRepository;
 	constructor(notificationsService: INotificationsService, monitorsRepository: IMonitorsRepository) {
@@ -32,9 +18,13 @@ class NotificationController implements INotificationController {
 		this.monitorsRepository = monitorsRepository;
 	}
 
+	get serviceName() {
+		return NotificationController.SERVICE_NAME;
+	}
+
 	testNotification = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const notification = testNotificationBodyValidation.parse(req.body);
+			const notification: Notification = req.body;
 			const success = await this.notificationsService.sendTestNotification(notification);
 
 			if (!success) {
@@ -44,7 +34,6 @@ class NotificationController implements INotificationController {
 			return res.status(200).json({
 				success: true,
 				msg: "Notification sent successfully",
-				details: { service: SERVICE_NAME },
 			});
 		} catch (error) {
 			next(error);
@@ -53,12 +42,23 @@ class NotificationController implements INotificationController {
 
 	createNotification = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = createNotificationBodyValidation.parse(req.body);
+			createNotificationBodyValidation.parse(req.body);
 
-			const teamId = requireTeamId(req.user?.teamId);
-			const userId = requireUserId(req.user?.id);
+			const body = req.body;
 
-			const notification = await this.notificationsService.createNotification(validatedBody, userId, teamId);
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
+
+			const userId = req?.user?.id;
+			if (!userId) {
+				throw new AppError({ message: "User ID is required", status: 400 });
+			}
+			body.userId = userId;
+			body.teamId = teamId;
+
+			const notification = await this.notificationsService.createNotification(body);
 			return res.status(200).json({
 				success: true,
 				msg: "Notification created successfully",
@@ -71,7 +71,11 @@ class NotificationController implements INotificationController {
 
 	getNotificationsByTeamId = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
+
 			const notifications = await this.notificationsService.findNotificationsByTeamId(teamId);
 
 			return res.status(200).json({
@@ -86,10 +90,17 @@ class NotificationController implements INotificationController {
 
 	deleteNotification = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const teamId = requireTeamId(req.user?.teamId);
-			const validatedParams = deleteNotificationParamValidation.parse(req.params);
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
 
-			await this.notificationsService.deleteById(validatedParams.id, teamId);
+			const notificationId = req.params.id as string;
+			if (!notificationId) {
+				throw new AppError({ message: "Notification ID is required", status: 400 });
+			}
+
+			await this.notificationsService.deleteById(notificationId, teamId);
 			return res.status(200).json({
 				success: true,
 				msg: "Notification deleted successfully",
@@ -102,9 +113,12 @@ class NotificationController implements INotificationController {
 	getNotificationById = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const teamId = requireTeamId(req.user?.teamId);
-			const validatedParams = getNotificationByIdParamValidation.parse(req.params);
+			const notificationId = req.params.id as string;
+			if (!notificationId) {
+				throw new AppError({ message: "Notification ID is required", status: 400 });
+			}
 
-			const notification = await this.notificationsService.findById(validatedParams.id, teamId);
+			const notification = await this.notificationsService.findById(notificationId, teamId);
 
 			return res.status(200).json({
 				success: true,
@@ -118,13 +132,14 @@ class NotificationController implements INotificationController {
 
 	editNotification = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = createNotificationBodyValidation.parse(req.body);
-			const validatedParams = editNotificationParamValidation.parse(req.params);
+			createNotificationBodyValidation.parse(req.body);
 
 			const teamId = requireTeamId(req.user?.teamId);
-			const notificationId = validatedParams.id;
-
-			const editedNotification = await this.notificationsService.updateById(notificationId, teamId, validatedBody);
+			const notificationId = req.params.id as string;
+			if (!notificationId) {
+				throw new AppError({ message: "Notification ID is required", status: 400 });
+			}
+			const editedNotification = await this.notificationsService.updateById(notificationId, teamId, req.body);
 			return res.status(200).json({
 				success: true,
 				msg: "Notification updated successfully",
@@ -137,13 +152,15 @@ class NotificationController implements INotificationController {
 
 	testAllNotifications = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = testAllNotificationsBodyValidation.parse(req.body);
+			const monitorId = req.body.monitorId;
+			const teamId = req?.user?.teamId;
+			if (!teamId) {
+				throw new AppError({ message: "Team ID is required", status: 400 });
+			}
 
-			const teamId = requireTeamId(req.user?.teamId);
-
-			const monitor = await this.monitorsRepository.findById(validatedBody.monitorId, teamId);
-			const notifications = monitor.notifications || [];
+			const monitor = await this.monitorsRepository.findById(monitorId, teamId);
 
+			const notifications = monitor.notifications;
 			if (notifications.length === 0) {
 				throw new AppError({ message: "No notifications", status: 400 });
 			}

server/src/controllers/queueController.ts

@@ -1,19 +1,11 @@
-import { ISuperSimpleQueue } from "@/service/index.js";
 import { Request, Response, NextFunction } from "express";
 
 const SERVICE_NAME = "JobQueueController";
 
-export interface IJobQueueController {
-	getMetrics(req: Request, res: Response, next: NextFunction): Promise<void>;
-	getJobs(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	getAllMetrics(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	flushQueue(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-}
-
-class JobQueueController implements IJobQueueController {
+class JobQueueController {
 	static SERVICE_NAME = SERVICE_NAME;
-	private jobQueue: ISuperSimpleQueue;
-	constructor(jobQueue: ISuperSimpleQueue) {
+	private jobQueue: any;
+	constructor(jobQueue: any) {
 		this.jobQueue = jobQueue;
 	}
 
@@ -61,6 +53,18 @@ class JobQueueController implements IJobQueueController {
 		}
 	};
 
+	addJob = async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			await this.jobQueue.addJob(Math.random().toString(36).substring(7));
+			return res.status(200).json({
+				success: true,
+				msg: "Job added to queue successfully",
+			});
+		} catch (error) {
+			next(error);
+		}
+	};
+
 	flushQueue = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			const result = await this.jobQueue.flushQueues();
@@ -73,5 +77,18 @@ class JobQueueController implements IJobQueueController {
 			next(error);
 		}
 	};
+
+	checkQueueHealth = async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			const stuckQueues = await this.jobQueue.checkQueueHealth();
+			return res.status(200).json({
+				success: true,
+				msg: "Queue health checked successfully",
+				data: stuckQueues,
+			});
+		} catch (error) {
+			next(error);
+		}
+	};
 }
 export default JobQueueController;

server/src/controllers/settingsController.ts

@@ -2,23 +2,14 @@ import { Request, Response, NextFunction } from "express";
 import { updateAppSettingsBodyValidation } from "@/validation/settingsValidation.js";
 import { sendTestEmailBodyValidation } from "@/validation/notificationValidation.js";
 import { AppError } from "@/utils/AppError.js";
-import { IEmailService, ISettingsService } from "@/service/index.js";
-import { Settings } from "@/types/settings.js";
 
 const SERVICE_NAME = "SettingsController";
 
-export interface ISettingsController {
-	serviceName: string;
-	getAppSettings(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	updateAppSettings(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	sendTestEmail(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-}
-
-class SettingsController implements ISettingsController {
+class SettingsController {
 	static SERVICE_NAME = SERVICE_NAME;
-	private settingsService: ISettingsService;
-	private emailService: IEmailService;
-	constructor(settingsService: ISettingsService, emailService: IEmailService) {
+	private settingsService: any;
+	private emailService: any;
+	constructor(settingsService: any, emailService: any) {
 		this.settingsService = settingsService;
 		this.emailService = emailService;
 	}
@@ -27,11 +18,11 @@ class SettingsController implements ISettingsController {
 		return SettingsController.SERVICE_NAME;
 	}
 
-	buildAppSettings = (dbSettings: Settings) => {
-		const sanitizedSettings: Record<string, unknown> = { ...dbSettings };
+	buildAppSettings = (dbSettings: any) => {
+		const sanitizedSettings = { ...dbSettings };
 		delete sanitizedSettings.version;
 		delete sanitizedSettings.jwtSecret;
-		const returnSettings: Record<string, unknown | null> = {
+		const returnSettings = {
 			pagespeedKeySet: false,
 			emailPasswordSet: false,
 			settings: null,
@@ -66,9 +57,9 @@ class SettingsController implements ISettingsController {
 
 	updateAppSettings = async (req: Request, res: Response, next: NextFunction) => {
 		try {
-			const validatedBody = updateAppSettingsBodyValidation.parse(req.body);
+			updateAppSettingsBodyValidation.parse(req.body);
 
-			const updatedSettings = await this.settingsService.updateDbSettings(validatedBody);
+			const updatedSettings = await this.settingsService.updateDbSettings(req.body);
 			const returnSettings = this.buildAppSettings(updatedSettings);
 			return res.status(200).json({
 				success: true,
@@ -104,9 +95,6 @@ class SettingsController implements ISettingsController {
 			const context = { testName: "Monitoring System" };
 
 			const html = await this.emailService.buildEmail("testEmailTemplate", context);
-			if (!html) {
-				throw new AppError({ message: "Failed to build email template.", status: 500 });
-			}
 			const messageId = await this.emailService.sendEmail(to, subject, html, {
 				systemEmailHost,
 				systemEmailPort,

server/src/controllers/statusPageController.ts

@@ -15,16 +15,7 @@ import { NormalizeData } from "@/utils/dataUtils.js";
 
 const SERVICE_NAME = "statusPageController";
 
-export interface IStatusPageController {
-	readonly serviceName: string;
-	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>;
-	getStatusPagesByTeamId(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-	deleteStatusPage(req: Request, res: Response, next: NextFunction): Promise<Response | void>;
-}
-
-class StatusPageController implements IStatusPageController {
+class StatusPageController {
 	static SERVICE_NAME = SERVICE_NAME;
 	private statusPageService: IStatusPageService;
 	private monitorsRepository: IMonitorsRepository;
@@ -75,7 +66,7 @@ class StatusPageController implements IStatusPageController {
 			if (statusPage === null) {
 				throw new AppError({ message: "Status page not found", status: 404 });
 			}
-			res.status(200).json({
+			return res.status(200).json({
 				success: true,
 				msg: "Status page updated successfully",
 				data: statusPage,

server/src/db/IDb.ts

@@ -1,7 +1,4 @@
-import { Pool } from "pg";
-
 export interface IDb {
 	connect(): Promise<void>;
 	disconnect(): Promise<void>;
-	getPool(): Pool | null;
 }

server/src/db/MongoDB.ts

@@ -5,7 +5,6 @@ import { ILogger } from "@/utils/logger.js";
 import { EnvConfig } from "@/service/system/settingsService.js";
 const SERVICE_NAME = "MongoDB";
 import { IDb } from "@/db/IDb.js";
-import { Pool } from "pg";
 
 class MongoDB implements IDb {
 	static SERVICE_NAME = SERVICE_NAME;
@@ -75,10 +74,6 @@ class MongoDB implements IDb {
 			});
 		}
 	};
-
-	getPool = () => {
-		return null;
-	};
 }
 
 export default MongoDB;

server/src/db/TimescaleDB.ts

@@ -1,105 +0,0 @@
-import { IDb } from "@/db/IDb.js";
-import { ILogger } from "@/utils/logger.js";
-import { EnvConfig } from "@/service/system/settingsService.js";
-import { Client, Pool } from "pg";
-import { runTimescaleDBMigrations } from "@/db/migration/timescaledb/index.js";
-
-const SERVICE_NAME = "TimescaleDB";
-
-class TimescaleDB implements IDb {
-	private pool: Pool | null = null;
-
-	constructor(
-		private logger: ILogger,
-		private envSettings: EnvConfig
-	) {}
-
-	private ensureDatabaseExists = async (connectionString: string) => {
-		const url = new URL(connectionString);
-		const dbName = url.pathname.slice(1); // Remove leading "/"
-
-		// Connect to the default "postgres" database
-		url.pathname = "/postgres";
-		const client = new Client({ connectionString: url.toString() });
-		await client.connect();
-
-		const result = await client.query("SELECT 1 FROM pg_database WHERE datname = $1", [dbName]);
-		if (result.rowCount === 0) {
-			await client.query(`CREATE DATABASE "${dbName}"`);
-			this.logger.info({
-				message: `Created database "${dbName}"`,
-				service: SERVICE_NAME,
-				method: "ensureDatabaseExists",
-			});
-		}
-		await client.end();
-	};
-
-	connect = async () => {
-		try {
-			const connectionString = this.envSettings.dbConnectionString || "postgresql://postgres:password@localhost:5432/checkmate";
-
-			await this.ensureDatabaseExists(connectionString);
-
-			this.pool = new Pool({ connectionString });
-
-			const client = await this.pool.connect();
-			client.release();
-
-			// Ensure TimescaleDB extension is enabled
-			await this.pool.query("CREATE EXTENSION IF NOT EXISTS timescaledb;");
-
-			this.logger.info({
-				message: "Connected to TimescaleDB",
-				service: SERVICE_NAME,
-				method: "connect",
-			});
-
-			await runTimescaleDBMigrations(this.pool, this.logger);
-		} catch (error: unknown) {
-			this.logger.error({
-				message: error instanceof Error ? error.message : "Unknown error",
-				service: SERVICE_NAME,
-				method: "connect",
-				stack: error instanceof Error ? error.stack : undefined,
-			});
-			throw error;
-		}
-	};
-
-	disconnect = async () => {
-		try {
-			if (this.pool === null) {
-				return;
-			}
-			this.logger.info({
-				message: "Disconnecting from TimescaleDB",
-				service: SERVICE_NAME,
-				method: "disconnect",
-			});
-			await this.pool.end();
-			this.pool = null;
-			this.logger.info({
-				message: "Disconnected from TimescaleDB",
-				service: SERVICE_NAME,
-				method: "disconnect",
-			});
-		} catch (error: unknown) {
-			this.logger.error({
-				message: error instanceof Error ? error.message : "Unknown error",
-				service: SERVICE_NAME,
-				method: "disconnect",
-				stack: error instanceof Error ? error.stack : undefined,
-			});
-		}
-	};
-
-	getPool = (): Pool => {
-		if (this.pool === null) {
-			throw new Error("TimescaleDB is not connected. Call connect() first.");
-		}
-		return this.pool;
-	};
-}
-
-export default TimescaleDB;

server/src/db/migration/0002_convertChecksToTimeSeries.ts

@@ -1,5 +1,4 @@
 import mongoose from "mongoose";
-import type { Document, AnyBulkWriteOperation } from "mongodb";
 
 const CHECKS_COLLECTION = "checks";
 const BACKUP_COLLECTION = "checks_backup";
@@ -86,7 +85,7 @@ const createTimeSeriesCollection = async (backedUp: boolean) => {
 	}
 };
 
-const validateDocument = (doc: Document): boolean => {
+const validateDocument = (doc: any): boolean => {
 	if (!doc.createdAt) {
 		return false;
 	}
@@ -96,7 +95,7 @@ const validateDocument = (doc: Document): boolean => {
 	return true;
 };
 
-const storeFailedDocument = async (doc: Document, reason: string) => {
+const storeFailedDocument = async (doc: any, reason: string) => {
 	const db = getDb();
 	await db.collection(FAILED_DOCS_COLLECTION).insertOne({
 		originalDoc: doc,
@@ -125,8 +124,8 @@ const migrateBackupData = async (backedUp: boolean): Promise<MigrationStats> =>
 		stats.totalSource = await source.countDocuments();
 
 		const cursor = source.find().addCursorFlag("noCursorTimeout", true);
-		const operations: AnyBulkWriteOperation<Document>[] = [];
-		const invalidDocs: Document[] = [];
+		const operations: any[] = [];
+		const invalidDocs: any[] = [];
 
 		while (await cursor.hasNext()) {
 			const doc = await cursor.next();
@@ -140,7 +139,6 @@ const migrateBackupData = async (backedUp: boolean): Promise<MigrationStats> =>
 			}
 
 			const { _id, monitorId, teamId, type, ...rest } = doc;
-			void _id;
 			const metadata = { monitorId, teamId, type };
 			operations.push({ insertOne: { document: { ...rest, metadata } } });
 

server/src/db/migration/0003_cleanupDuplicateMonitorStats.ts

@@ -42,10 +42,10 @@ export async function cleanupDuplicateMonitorStats(): Promise<void> {
 			const monitorId = duplicate._id;
 			const { ids, updatedAts } = duplicate;
 
-			type DocPair = { id: string; updatedAt: Date };
+			type DocPair = { id: any; updatedAt: Date };
 
 			// Create array of {id, updatedAt} pairs and sort by updatedAt descending
-			const docs: DocPair[] = ids.map((id: string, index: number) => ({
+			const docs: DocPair[] = ids.map((id: any, index: number) => ({
 				id,
 				updatedAt: updatedAts[index],
 			}));

server/src/db/migration/0004_fixInfrastructureThresholds.ts

@@ -37,8 +37,7 @@ export async function fixInfrastructureThresholds(): Promise<void> {
 			const update: Record<string, number> = {};
 
 			for (const field of thresholdFields) {
-				const value = monitor.get(field);
-				if (value === 0 || value === 5) {
+				if ((monitor as any)[field] === 0 || (monitor as any)[field] === 5) {
 					update[field] = 100;
 				}
 			}

server/src/db/migration/0005_migrateStatusPageTypeToArray.ts

@@ -2,6 +2,12 @@ import mongoose from "mongoose";
 import { logger } from "@/utils/logger.js";
 import StatusPageModel from "../models/StatusPage.js";
 
+/**
+ * Migration: Convert StatusPage `type` field from string to array of strings
+ *
+ * Old format: { type: "uptime" }
+ * New format: { type: ["uptime"] }
+ */
 export async function migrateStatusPageTypeToArray(): Promise<void> {
 	const SERVICE_NAME = "Migration:MigrateStatusPageTypeToArray";
 
@@ -13,6 +19,7 @@ export async function migrateStatusPageTypeToArray(): Promise<void> {
 			throw new Error("Database connection is not initialized");
 		}
 
+		// Find all status pages where `type` is a string (not yet migrated)
 		const result = await StatusPageModel.updateMany(
 			{
 				$expr: {

server/src/db/migration/index.ts

@@ -4,7 +4,6 @@ import { cleanupDuplicateMonitorStats } from "./0003_cleanupDuplicateMonitorStat
 import { fixInfrastructureThresholds } from "./0004_fixInfrastructureThresholds.js";
 import MigrationModel from "../models/Migration.js";
 import { migrateStatusPageTypeToArray } from "./0005_migrateStatusPageTypeToArray.js";
-import type { ILogger } from "@/utils/logger.js";
 
 type MigrationEntry = {
 	name: string;
@@ -19,7 +18,7 @@ const migrations: MigrationEntry[] = [
 	{ name: "0005_migrateStatusPageTypeToArray", execute: migrateStatusPageTypeToArray },
 ];
 
-const runMigrations = async (logger?: ILogger) => {
+const runMigrations = async (logger?: { info: Function; error: Function }) => {
 	try {
 		logger?.info({ message: "Running migrations", service: "Migrations" });
 		for (const migration of migrations) {
@@ -46,7 +45,7 @@ const runMigrations = async (logger?: ILogger) => {
 		logger?.info({ message: "Migrations completed", service: "Migrations" });
 	} catch (error) {
 		const err = error as Error;
-		logger?.error({ message: "Migration failed", service: "Migrations", details: { error: err?.message }, stack: err?.stack });
+		logger?.error({ message: "Migration failed", service: "Migrations", details: err?.message, stack: err?.stack });
 		throw error;
 	}
 };

server/src/db/migration/timescaledb/0001_create_enums.ts

@@ -1,50 +0,0 @@
-import type { Pool } from "pg";
-
-export const createEnums = async (pool: Pool) => {
-	await pool.query(`
-		DO $$ BEGIN
-			CREATE TYPE monitor_type AS ENUM ('http', 'ping', 'pagespeed', 'hardware', 'docker', 'port', 'game', 'grpc', 'websocket', 'unknown');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE monitor_status AS ENUM ('up', 'down', 'paused', 'initializing', 'maintenance', 'breached');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE notification_type AS ENUM ('email', 'slack', 'discord', 'webhook', 'pager_duty', 'matrix', 'teams');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE user_role AS ENUM ('user', 'admin', 'superadmin', 'demo');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE incident_resolution_type AS ENUM ('automatic', 'manual');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE duration_unit AS ENUM ('seconds', 'minutes', 'hours', 'days');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE status_page_type AS ENUM ('uptime', 'infrastructure');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-
-		DO $$ BEGIN
-			CREATE TYPE match_method AS ENUM ('equal', 'include', 'regex');
-		EXCEPTION WHEN duplicate_object THEN NULL; END $$;
-	`);
-};
-
-export const dropEnums = async (pool: Pool) => {
-	await pool.query(`
-		DROP TYPE IF EXISTS match_method;
-		DROP TYPE IF EXISTS status_page_type;
-		DROP TYPE IF EXISTS duration_unit;
-		DROP TYPE IF EXISTS incident_resolution_type;
-		DROP TYPE IF EXISTS user_role;
-		DROP TYPE IF EXISTS notification_type;
-		DROP TYPE IF EXISTS monitor_status;
-		DROP TYPE IF EXISTS monitor_type;
-	`);
-};

server/src/db/migration/timescaledb/0002_create_teams.ts

@@ -1,18 +0,0 @@
-import type { Pool } from "pg";
-
-export const createTeams = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS teams (
-			id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			email       TEXT NOT NULL UNIQUE,
-			created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_teams_email ON teams (email);
-	`);
-};
-
-export const dropTeams = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS teams;`);
-};

server/src/db/migration/timescaledb/0003_create_users.ts

@@ -1,30 +0,0 @@
-import type { Pool } from "pg";
-
-export const createUsers = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS users (
-			id                          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			team_id                     UUID REFERENCES teams(id) ON DELETE SET NULL,
-			first_name                  TEXT NOT NULL,
-			last_name                   TEXT NOT NULL,
-			email                       TEXT NOT NULL UNIQUE,
-			password                    TEXT NOT NULL,
-			avatar_image                TEXT,
-			profile_image               BYTEA,
-			profile_image_content_type  TEXT,
-			is_active                   BOOLEAN NOT NULL DEFAULT TRUE,
-			is_verified                 BOOLEAN NOT NULL DEFAULT FALSE,
-			roles                       user_role[] NOT NULL DEFAULT ARRAY['user']::user_role[],
-			check_ttl                   INTEGER,
-			created_at                  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at                  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_users_team_id ON users (team_id);
-		CREATE INDEX IF NOT EXISTS idx_users_email ON users (email);
-	`);
-};
-
-export const dropUsers = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS users;`);
-};

server/src/db/migration/timescaledb/0004_create_monitors.ts

@@ -1,69 +0,0 @@
-import type { Pool } from "pg";
-
-export const createMonitors = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS monitors (
-			id                      UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			user_id                 UUID NOT NULL REFERENCES users(id),
-			team_id                 UUID NOT NULL REFERENCES teams(id),
-			name                    TEXT NOT NULL,
-			description             TEXT,
-			type                    monitor_type NOT NULL,
-			status                  monitor_status NOT NULL DEFAULT 'initializing',
-
-			-- HTTP / Website monitoring
-			url                     TEXT,
-			port                    INTEGER,
-			ignore_tls_errors       BOOLEAN DEFAULT FALSE,
-			use_advanced_matching   BOOLEAN DEFAULT FALSE,
-			json_path               TEXT,
-			expected_value          TEXT,
-			match_method            match_method,
-			secret                  TEXT,
-
-			-- Scheduling
-			interval_ms             INTEGER NOT NULL DEFAULT 60000,
-			is_active               BOOLEAN NOT NULL DEFAULT TRUE,
-
-			-- Uptime tracking
-			status_window           BOOLEAN[],
-			status_window_size      INTEGER DEFAULT 5,
-			status_window_threshold INTEGER DEFAULT 60,
-			uptime_percentage       DOUBLE PRECISION,
-
-			-- Infrastructure alert thresholds
-			cpu_alert_threshold     INTEGER,
-			cpu_alert_counter       INTEGER,
-			memory_alert_threshold  INTEGER,
-			memory_alert_counter    INTEGER,
-			disk_alert_threshold    INTEGER,
-			disk_alert_counter      INTEGER,
-			temp_alert_threshold    INTEGER,
-			temp_alert_counter      INTEGER,
-			selected_disks          TEXT[],
-
-			-- Game monitoring
-			game_id                 TEXT,
-			grpc_service_name       TEXT,
-
-			-- Grouping
-			monitor_group           TEXT,
-
-			-- Geo checks
-			geo_check_enabled       BOOLEAN DEFAULT FALSE,
-			geo_check_locations     TEXT[],
-			geo_check_interval_ms   INTEGER DEFAULT 300000,
-
-			created_at              TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at              TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_monitors_team_type ON monitors (team_id, type);
-		CREATE INDEX IF NOT EXISTS idx_monitors_user_id ON monitors (user_id);
-		CREATE INDEX IF NOT EXISTS idx_monitors_status ON monitors (status);
-	`);
-};
-
-export const dropMonitors = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS monitors;`);
-};

server/src/db/migration/timescaledb/0005_create_notifications.ts

@@ -1,30 +0,0 @@
-import type { Pool } from "pg";
-
-export const createNotifications = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS notifications (
-			id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			user_id             UUID NOT NULL REFERENCES users(id),
-			team_id             UUID NOT NULL REFERENCES teams(id),
-			type                notification_type NOT NULL,
-			notification_name   TEXT,
-			address             TEXT,
-			phone               TEXT,
-
-			-- Matrix-specific fields
-			homeserver_url      TEXT,
-			room_id             TEXT,
-			access_token        TEXT,
-
-			created_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at          TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_notifications_team ON notifications (team_id);
-		CREATE INDEX IF NOT EXISTS idx_notifications_user ON notifications (user_id);
-	`);
-};
-
-export const dropNotifications = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS notifications;`);
-};

server/src/db/migration/timescaledb/0006_create_monitor_notifications.ts

@@ -1,18 +0,0 @@
-import type { Pool } from "pg";
-
-export const createMonitorNotifications = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS monitor_notifications (
-			monitor_id      UUID NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
-			notification_id UUID NOT NULL REFERENCES notifications(id) ON DELETE CASCADE,
-			PRIMARY KEY (monitor_id, notification_id)
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_monitor_notifications_notification
-			ON monitor_notifications (notification_id);
-	`);
-};
-
-export const dropMonitorNotifications = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS monitor_notifications;`);
-};

server/src/db/migration/timescaledb/0007_create_incidents.ts

@@ -1,34 +0,0 @@
-import type { Pool } from "pg";
-
-export const createIncidents = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS incidents (
-			id                  UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			monitor_id          UUID NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
-			team_id             UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
-			start_time          TIMESTAMPTZ NOT NULL,
-			end_time            TIMESTAMPTZ,
-			status              BOOLEAN,
-			message             TEXT,
-			status_code         INTEGER,
-			resolution_type     incident_resolution_type,
-			resolved_by         UUID REFERENCES users(id) ON DELETE SET NULL,
-			resolved_by_email   TEXT,
-			comment             TEXT,
-			created_at          TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at          TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_incidents_monitor_status ON incidents (monitor_id, status);
-		CREATE INDEX IF NOT EXISTS idx_incidents_team_status ON incidents (team_id, status);
-		CREATE INDEX IF NOT EXISTS idx_incidents_team_start ON incidents (team_id, start_time DESC);
-		CREATE INDEX IF NOT EXISTS idx_incidents_status_start ON incidents (status, start_time DESC);
-		CREATE INDEX IF NOT EXISTS idx_incidents_resolution ON incidents (resolution_type, status);
-		CREATE INDEX IF NOT EXISTS idx_incidents_resolved_by ON incidents (resolved_by, status);
-		CREATE INDEX IF NOT EXISTS idx_incidents_created ON incidents (created_at DESC);
-	`);
-};
-
-export const dropIncidents = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS incidents;`);
-};

server/src/db/migration/timescaledb/0008_create_monitor_stats.ts

@@ -1,25 +0,0 @@
-import type { Pool } from "pg";
-
-export const createMonitorStats = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS monitor_stats (
-			id                      UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			monitor_id              UUID NOT NULL UNIQUE REFERENCES monitors(id) ON DELETE CASCADE,
-			avg_response_time       DOUBLE PRECISION DEFAULT 0,
-			max_response_time       DOUBLE PRECISION DEFAULT 0,
-			total_checks            BIGINT DEFAULT 0,
-			total_up_checks         BIGINT DEFAULT 0,
-			total_down_checks       BIGINT DEFAULT 0,
-			uptime_percentage       DOUBLE PRECISION DEFAULT 0,
-			last_check_timestamp    TIMESTAMPTZ,
-			last_response_time      DOUBLE PRECISION DEFAULT 0,
-			time_of_last_failure    TIMESTAMPTZ,
-			created_at              TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at              TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-	`);
-};
-
-export const dropMonitorStats = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS monitor_stats;`);
-};

server/src/db/migration/timescaledb/0009_create_checks.ts

@@ -1,105 +0,0 @@
-import type { Pool } from "pg";
-
-export const createChecks = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS checks (
-			id                          UUID NOT NULL DEFAULT gen_random_uuid(),
-			monitor_id                  UUID NOT NULL,
-			team_id                     UUID NOT NULL,
-			monitor_type                monitor_type NOT NULL,
-			status                      BOOLEAN,
-			response_time               INTEGER,
-			status_code                 INTEGER,
-			message                     TEXT,
-
-			-- HTTP request timings
-			timing_start                DOUBLE PRECISION,
-			timing_socket               DOUBLE PRECISION,
-			timing_lookup               DOUBLE PRECISION,
-			timing_connect              DOUBLE PRECISION,
-			timing_secure_connect       DOUBLE PRECISION,
-			timing_upload               DOUBLE PRECISION,
-			timing_response             DOUBLE PRECISION,
-			timing_end                  DOUBLE PRECISION,
-			phase_wait                  DOUBLE PRECISION,
-			phase_dns                   DOUBLE PRECISION,
-			phase_tcp                   DOUBLE PRECISION,
-			phase_tls                   DOUBLE PRECISION,
-			phase_request               DOUBLE PRECISION,
-			phase_first_byte            DOUBLE PRECISION,
-			phase_download              DOUBLE PRECISION,
-			phase_total                 DOUBLE PRECISION,
-
-			-- CPU metrics
-			cpu_physical_core           INTEGER,
-			cpu_logical_core            INTEGER,
-			cpu_frequency               DOUBLE PRECISION,
-			cpu_current_frequency       DOUBLE PRECISION,
-			cpu_temperature             DOUBLE PRECISION[],
-			cpu_free_percent            DOUBLE PRECISION,
-			cpu_usage_percent           DOUBLE PRECISION,
-
-			-- Memory metrics
-			mem_total_bytes             BIGINT,
-			mem_available_bytes         BIGINT,
-			mem_used_bytes              BIGINT,
-			mem_usage_percent           DOUBLE PRECISION,
-
-			-- Host info
-			host_os                     TEXT,
-			host_platform               TEXT,
-			host_kernel_version         TEXT,
-			host_pretty_name            TEXT,
-
-			-- Capture agent info
-			capture_version             TEXT,
-			capture_mode                TEXT,
-
-			-- Lighthouse / PageSpeed scores
-			lighthouse_performance      DOUBLE PRECISION,
-			lighthouse_accessibility    DOUBLE PRECISION,
-			lighthouse_best_practices   DOUBLE PRECISION,
-			lighthouse_seo              DOUBLE PRECISION,
-
-			-- Lighthouse audit details
-			audit_cls_score             DOUBLE PRECISION,
-			audit_cls_value             DOUBLE PRECISION,
-			audit_cls_display           TEXT,
-			audit_si_score              DOUBLE PRECISION,
-			audit_si_value              DOUBLE PRECISION,
-			audit_si_display            TEXT,
-			audit_fcp_score             DOUBLE PRECISION,
-			audit_fcp_value             DOUBLE PRECISION,
-			audit_fcp_display           TEXT,
-			audit_lcp_score             DOUBLE PRECISION,
-			audit_lcp_value             DOUBLE PRECISION,
-			audit_lcp_display           TEXT,
-			audit_tbt_score             DOUBLE PRECISION,
-			audit_tbt_value             DOUBLE PRECISION,
-			audit_tbt_display           TEXT,
-
-			created_at                  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at                  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		SELECT create_hypertable('checks', 'created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_checks_monitor_time
-			ON checks (monitor_id, created_at DESC);
-		CREATE INDEX IF NOT EXISTS idx_checks_team_time
-			ON checks (team_id, created_at DESC);
-		CREATE INDEX IF NOT EXISTS idx_checks_monitor_type_time
-			ON checks (monitor_id, monitor_type, created_at DESC);
-		CREATE INDEX IF NOT EXISTS idx_checks_team_status_time
-			ON checks (team_id, status, created_at DESC);
-		CREATE INDEX IF NOT EXISTS idx_checks_status_code
-			ON checks (status_code, created_at DESC);
-	`);
-};
-
-export const dropChecks = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS checks;`);
-};

server/src/db/migration/timescaledb/0010_create_check_disks.ts

@@ -1,37 +0,0 @@
-import type { Pool } from "pg";
-
-export const createCheckDisks = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS check_disks (
-			id                  UUID NOT NULL DEFAULT gen_random_uuid(),
-			check_id            UUID NOT NULL,
-			check_created_at    TIMESTAMPTZ NOT NULL,
-			device              TEXT,
-			mountpoint          TEXT,
-			total_bytes         BIGINT,
-			free_bytes          BIGINT,
-			used_bytes          BIGINT,
-			usage_percent       DOUBLE PRECISION,
-			total_inodes        BIGINT,
-			free_inodes         BIGINT,
-			used_inodes         BIGINT,
-			inodes_usage_percent DOUBLE PRECISION,
-			read_bytes          BIGINT,
-			write_bytes         BIGINT,
-			read_time           BIGINT,
-			write_time          BIGINT
-		);
-
-		SELECT create_hypertable('check_disks', 'check_created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_check_disks_check
-			ON check_disks (check_id, check_created_at);
-	`);
-};
-
-export const dropCheckDisks = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS check_disks;`);
-};

server/src/db/migration/timescaledb/0011_create_check_network_interfaces.ts

@@ -1,34 +0,0 @@
-import type { Pool } from "pg";
-
-export const createCheckNetworkInterfaces = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS check_network_interfaces (
-			id                  UUID NOT NULL DEFAULT gen_random_uuid(),
-			check_id            UUID NOT NULL,
-			check_created_at    TIMESTAMPTZ NOT NULL,
-			name                TEXT,
-			bytes_sent          BIGINT,
-			bytes_recv          BIGINT,
-			packets_sent        BIGINT,
-			packets_recv        BIGINT,
-			err_in              BIGINT,
-			err_out             BIGINT,
-			drop_in             BIGINT,
-			drop_out            BIGINT,
-			fifo_in             BIGINT,
-			fifo_out            BIGINT
-		);
-
-		SELECT create_hypertable('check_network_interfaces', 'check_created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_check_net_check
-			ON check_network_interfaces (check_id, check_created_at);
-	`);
-};
-
-export const dropCheckNetworkInterfaces = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS check_network_interfaces;`);
-};

server/src/db/migration/timescaledb/0012_create_check_errors.ts

@@ -1,25 +0,0 @@
-import type { Pool } from "pg";
-
-export const createCheckErrors = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS check_errors (
-			id                  UUID NOT NULL DEFAULT gen_random_uuid(),
-			check_id            UUID NOT NULL,
-			check_created_at    TIMESTAMPTZ NOT NULL,
-			metrics             TEXT[],
-			error               TEXT
-		);
-
-		SELECT create_hypertable('check_errors', 'check_created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_check_errors_check
-			ON check_errors (check_id, check_created_at);
-	`);
-};
-
-export const dropCheckErrors = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS check_errors;`);
-};

server/src/db/migration/timescaledb/0013_create_geo_checks.ts

@@ -1,29 +0,0 @@
-import type { Pool } from "pg";
-
-export const createGeoChecks = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS geo_checks (
-			id              UUID NOT NULL DEFAULT gen_random_uuid(),
-			monitor_id      UUID NOT NULL,
-			team_id         UUID NOT NULL,
-			monitor_type    monitor_type NOT NULL,
-			expiry          TIMESTAMPTZ,
-			created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		SELECT create_hypertable('geo_checks', 'created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_geo_checks_monitor_time
-			ON geo_checks (monitor_id, created_at DESC);
-		CREATE INDEX IF NOT EXISTS idx_geo_checks_team_time
-			ON geo_checks (team_id, created_at DESC);
-	`);
-};
-
-export const dropGeoChecks = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS geo_checks;`);
-};

server/src/db/migration/timescaledb/0014_create_geo_check_results.ts

@@ -1,46 +0,0 @@
-import type { Pool } from "pg";
-
-export const createGeoCheckResults = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS geo_check_results (
-			id                      UUID NOT NULL DEFAULT gen_random_uuid(),
-			geo_check_id            UUID NOT NULL,
-			geo_check_created_at    TIMESTAMPTZ NOT NULL,
-
-			-- Status
-			status                  BOOLEAN,
-			status_code             INTEGER,
-
-			-- Location
-			location_continent      TEXT,
-			location_region         TEXT,
-			location_country        TEXT,
-			location_state          TEXT,
-			location_city           TEXT,
-			location_longitude      DOUBLE PRECISION,
-			location_latitude       DOUBLE PRECISION,
-
-			-- Timings
-			timing_total            DOUBLE PRECISION,
-			timing_dns              DOUBLE PRECISION,
-			timing_tcp              DOUBLE PRECISION,
-			timing_tls              DOUBLE PRECISION,
-			timing_first_byte       DOUBLE PRECISION,
-			timing_download         DOUBLE PRECISION
-		);
-
-		SELECT create_hypertable('geo_check_results', 'geo_check_created_at',
-			chunk_time_interval => INTERVAL '7 days',
-			if_not_exists => TRUE
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_geo_results_check
-			ON geo_check_results (geo_check_id, geo_check_created_at);
-		CREATE INDEX IF NOT EXISTS idx_geo_results_country
-			ON geo_check_results (location_country, geo_check_created_at DESC);
-	`);
-};
-
-export const dropGeoCheckResults = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS geo_check_results;`);
-};

server/src/db/migration/timescaledb/0015_create_invites.ts

@@ -1,22 +0,0 @@
-import type { Pool } from "pg";
-
-export const createInvites = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS invites (
-			id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			email       TEXT NOT NULL UNIQUE,
-			team_id     UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
-			roles       user_role[] NOT NULL DEFAULT ARRAY['user']::user_role[],
-			token       TEXT NOT NULL,
-			expiry      TIMESTAMPTZ,
-			created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_invites_expiry ON invites (expiry);
-	`);
-};
-
-export const dropInvites = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS invites;`);
-};

server/src/db/migration/timescaledb/0016_create_recovery_tokens.ts

@@ -1,20 +0,0 @@
-import type { Pool } from "pg";
-
-export const createRecoveryTokens = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS recovery_tokens (
-			id          UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			email       TEXT NOT NULL UNIQUE,
-			token       TEXT NOT NULL,
-			expiry      TIMESTAMPTZ,
-			created_at  TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at  TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_recovery_expiry ON recovery_tokens (expiry);
-	`);
-};
-
-export const dropRecoveryTokens = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS recovery_tokens;`);
-};

server/src/db/migration/timescaledb/0017_create_maintenance_windows.ts

@@ -1,29 +0,0 @@
-import type { Pool } from "pg";
-
-export const createMaintenanceWindows = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS maintenance_windows (
-			id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			monitor_id      UUID NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
-			team_id         UUID NOT NULL REFERENCES teams(id) ON DELETE CASCADE,
-			active          BOOLEAN NOT NULL DEFAULT TRUE,
-			name            TEXT,
-			duration        INTEGER,
-			duration_unit   duration_unit,
-			repeat          INTEGER,
-			start_time      TIMESTAMPTZ,
-			end_time        TIMESTAMPTZ,
-			expiry          TIMESTAMPTZ,
-			created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_maint_monitor ON maintenance_windows (monitor_id);
-		CREATE INDEX IF NOT EXISTS idx_maint_team ON maintenance_windows (team_id);
-		CREATE INDEX IF NOT EXISTS idx_maint_expiry ON maintenance_windows (expiry);
-	`);
-};
-
-export const dropMaintenanceWindows = async (pool: Pool) => {
-	await pool.query(`DROP TABLE IF EXISTS maintenance_windows;`);
-};

server/src/db/migration/timescaledb/0018_create_status_pages.ts

@@ -1,51 +0,0 @@
-import type { Pool } from "pg";
-
-export const createStatusPages = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS status_pages (
-			id                      UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			user_id                 UUID NOT NULL REFERENCES users(id),
-			team_id                 UUID NOT NULL REFERENCES teams(id),
-			types                   status_page_type[] NOT NULL DEFAULT ARRAY['uptime']::status_page_type[],
-			company_name            TEXT,
-			url                     TEXT NOT NULL UNIQUE,
-			timezone                TEXT,
-			color                   TEXT DEFAULT '#4169E1',
-			logo_data               BYTEA,
-			logo_content_type       TEXT,
-			is_published            BOOLEAN DEFAULT FALSE,
-			show_charts             BOOLEAN DEFAULT FALSE,
-			show_uptime_percentage  BOOLEAN DEFAULT FALSE,
-			show_admin_login_link   BOOLEAN DEFAULT FALSE,
-			show_infrastructure     BOOLEAN DEFAULT FALSE,
-			custom_css              TEXT,
-			created_at              TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at              TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		CREATE INDEX IF NOT EXISTS idx_status_pages_team ON status_pages (team_id);
-		CREATE INDEX IF NOT EXISTS idx_status_pages_url ON status_pages (url);
-
-		CREATE TABLE IF NOT EXISTS status_page_monitors (
-			status_page_id  UUID NOT NULL REFERENCES status_pages(id) ON DELETE CASCADE,
-			monitor_id      UUID NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
-			sort_order      INTEGER DEFAULT 0,
-			PRIMARY KEY (status_page_id, monitor_id)
-		);
-
-		CREATE TABLE IF NOT EXISTS status_page_sub_monitors (
-			status_page_id  UUID NOT NULL REFERENCES status_pages(id) ON DELETE CASCADE,
-			monitor_id      UUID NOT NULL REFERENCES monitors(id) ON DELETE CASCADE,
-			sort_order      INTEGER DEFAULT 0,
-			PRIMARY KEY (status_page_id, monitor_id)
-		);
-	`);
-};
-
-export const dropStatusPages = async (pool: Pool) => {
-	await pool.query(`
-		DROP TABLE IF EXISTS status_page_sub_monitors;
-		DROP TABLE IF EXISTS status_page_monitors;
-		DROP TABLE IF EXISTS status_pages;
-	`);
-};

server/src/db/migration/timescaledb/0019_create_app_settings.ts

@@ -1,62 +0,0 @@
-import type { Pool } from "pg";
-
-export const createAppSettings = async (pool: Pool) => {
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS app_settings (
-			id                              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			check_ttl                       INTEGER DEFAULT 30,
-			language                        TEXT,
-			jwt_secret                      TEXT,
-			pagespeed_api_key               TEXT,
-
-			-- SMTP / Email settings
-			system_email_host               TEXT,
-			system_email_port               INTEGER,
-			system_email_address            TEXT,
-			system_email_password           TEXT,
-			system_email_user               TEXT,
-			system_email_connection_host    TEXT,
-			system_email_tls_servername     TEXT,
-			system_email_secure             BOOLEAN,
-			system_email_pool               BOOLEAN,
-			system_email_ignore_tls         BOOLEAN,
-			system_email_require_tls        BOOLEAN,
-			system_email_reject_unauthorized BOOLEAN,
-
-			show_url                        BOOLEAN,
-			version                         TEXT,
-
-			-- Global infrastructure thresholds
-			threshold_cpu_usage             INTEGER,
-			threshold_memory_usage          INTEGER,
-			threshold_disk_usage            INTEGER,
-			threshold_temperature           INTEGER,
-
-			created_at                      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at                      TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-
-		-- Enforce singleton: only one row allowed
-		CREATE OR REPLACE FUNCTION enforce_singleton_app_settings()
-		RETURNS TRIGGER AS $$
-		BEGIN
-			IF (SELECT COUNT(*) FROM app_settings) >= 1 THEN
-				RAISE EXCEPTION 'app_settings allows only one row';
-			END IF;
-			RETURN NEW;
-		END;
-		$$ LANGUAGE plpgsql;
-
-		DROP TRIGGER IF EXISTS trg_singleton_app_settings ON app_settings;
-		CREATE TRIGGER trg_singleton_app_settings
-			BEFORE INSERT ON app_settings
-			FOR EACH ROW EXECUTE FUNCTION enforce_singleton_app_settings();
-	`);
-};
-
-export const dropAppSettings = async (pool: Pool) => {
-	await pool.query(`
-		DROP TABLE IF EXISTS app_settings;
-		DROP FUNCTION IF EXISTS enforce_singleton_app_settings();
-	`);
-};

server/src/db/migration/timescaledb/0020_create_continuous_aggregates.ts

@@ -1,127 +0,0 @@
-import type { Pool } from "pg";
-
-export const createContinuousAggregates = async (pool: Pool) => {
-	// Uptime & Response Time (Hourly)
-	await pool.query(`
-		CREATE MATERIALIZED VIEW IF NOT EXISTS checks_hourly
-		WITH (timescaledb.continuous) AS
-		SELECT
-			monitor_id,
-			time_bucket('1 hour', created_at) AS bucket,
-			COUNT(*)                                    AS total_checks,
-			COUNT(*) FILTER (WHERE status = TRUE)       AS up_checks,
-			COUNT(*) FILTER (WHERE status = FALSE)      AS down_checks,
-			AVG(response_time)                          AS avg_response_time,
-			AVG(response_time) FILTER (WHERE status = TRUE)  AS avg_up_response_time,
-			AVG(response_time) FILTER (WHERE status = FALSE) AS avg_down_response_time,
-			MAX(response_time)                          AS max_response_time,
-			MIN(response_time)                          AS min_response_time
-		FROM checks
-		GROUP BY monitor_id, bucket
-		WITH NO DATA;
-	`);
-	await pool.query(`ALTER MATERIALIZED VIEW checks_hourly SET (timescaledb.materialized_only = false);`);
-	await pool.query(`
-		SELECT add_continuous_aggregate_policy('checks_hourly',
-			start_offset    => INTERVAL '3 hours',
-			end_offset      => INTERVAL '1 hour',
-			schedule_interval => INTERVAL '1 hour',
-			if_not_exists   => TRUE
-		);
-	`);
-	await pool.query(`CALL refresh_continuous_aggregate('checks_hourly', NULL, NULL);`);
-
-	// Uptime & Response Time (Daily)
-	await pool.query(`
-		CREATE MATERIALIZED VIEW IF NOT EXISTS checks_daily
-		WITH (timescaledb.continuous) AS
-		SELECT
-			monitor_id,
-			time_bucket('1 day', created_at) AS bucket,
-			COUNT(*)                                    AS total_checks,
-			COUNT(*) FILTER (WHERE status = TRUE)       AS up_checks,
-			COUNT(*) FILTER (WHERE status = FALSE)      AS down_checks,
-			AVG(response_time)                          AS avg_response_time,
-			AVG(response_time) FILTER (WHERE status = TRUE)  AS avg_up_response_time,
-			AVG(response_time) FILTER (WHERE status = FALSE) AS avg_down_response_time,
-			MAX(response_time)                          AS max_response_time
-		FROM checks
-		GROUP BY monitor_id, bucket
-		WITH NO DATA;
-	`);
-	await pool.query(`ALTER MATERIALIZED VIEW checks_daily SET (timescaledb.materialized_only = false);`);
-	await pool.query(`
-		SELECT add_continuous_aggregate_policy('checks_daily',
-			start_offset    => INTERVAL '3 days',
-			end_offset      => INTERVAL '1 day',
-			schedule_interval => INTERVAL '1 day',
-			if_not_exists   => TRUE
-		);
-	`);
-	await pool.query(`CALL refresh_continuous_aggregate('checks_daily', NULL, NULL);`);
-
-	// Infrastructure Metrics (Hourly)
-	await pool.query(`
-		CREATE MATERIALIZED VIEW IF NOT EXISTS hardware_hourly
-		WITH (timescaledb.continuous) AS
-		SELECT
-			monitor_id,
-			time_bucket('1 hour', created_at) AS bucket,
-			AVG(cpu_usage_percent)              AS avg_cpu,
-			MAX(cpu_usage_percent)              AS max_cpu,
-			AVG(mem_usage_percent)              AS avg_memory,
-			MAX(mem_usage_percent)              AS max_memory,
-			COUNT(*)                            AS sample_count
-		FROM checks
-		WHERE monitor_type = 'hardware'
-		GROUP BY monitor_id, bucket
-		WITH NO DATA;
-	`);
-	await pool.query(`ALTER MATERIALIZED VIEW hardware_hourly SET (timescaledb.materialized_only = false);`);
-	await pool.query(`
-		SELECT add_continuous_aggregate_policy('hardware_hourly',
-			start_offset    => INTERVAL '3 hours',
-			end_offset      => INTERVAL '1 hour',
-			schedule_interval => INTERVAL '1 hour',
-			if_not_exists   => TRUE
-		);
-	`);
-	await pool.query(`CALL refresh_continuous_aggregate('hardware_hourly', NULL, NULL);`);
-
-	// PageSpeed Scores (Daily)
-	await pool.query(`
-		CREATE MATERIALIZED VIEW IF NOT EXISTS pagespeed_daily
-		WITH (timescaledb.continuous) AS
-		SELECT
-			monitor_id,
-			time_bucket('1 day', created_at) AS bucket,
-			AVG(lighthouse_performance)         AS avg_performance,
-			AVG(lighthouse_accessibility)       AS avg_accessibility,
-			AVG(lighthouse_best_practices)      AS avg_best_practices,
-			AVG(lighthouse_seo)                 AS avg_seo,
-			COUNT(*)                            AS sample_count
-		FROM checks
-		WHERE monitor_type = 'pagespeed'
-		GROUP BY monitor_id, bucket
-		WITH NO DATA;
-	`);
-	await pool.query(`ALTER MATERIALIZED VIEW pagespeed_daily SET (timescaledb.materialized_only = false);`);
-	await pool.query(`
-		SELECT add_continuous_aggregate_policy('pagespeed_daily',
-			start_offset    => INTERVAL '3 days',
-			end_offset      => INTERVAL '1 day',
-			schedule_interval => INTERVAL '1 day',
-			if_not_exists   => TRUE
-		);
-	`);
-	await pool.query(`CALL refresh_continuous_aggregate('pagespeed_daily', NULL, NULL);`);
-};
-
-export const dropContinuousAggregates = async (pool: Pool) => {
-	await pool.query(`
-		DROP MATERIALIZED VIEW IF EXISTS pagespeed_daily CASCADE;
-		DROP MATERIALIZED VIEW IF EXISTS hardware_hourly CASCADE;
-		DROP MATERIALIZED VIEW IF EXISTS checks_daily CASCADE;
-		DROP MATERIALIZED VIEW IF EXISTS checks_hourly CASCADE;
-	`);
-};

server/src/db/migration/timescaledb/0021_create_retention_compression.ts

@@ -1,135 +0,0 @@
-import type { Pool } from "pg";
-
-export const createRetentionCompression = async (pool: Pool) => {
-	// -- Compression policies --
-
-	// Checks
-	await pool.query(`
-		ALTER TABLE checks SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'monitor_id',
-			timescaledb.compress_orderby = 'created_at DESC'
-		);
-		SELECT add_compression_policy('checks', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	// Check child tables
-	await pool.query(`
-		ALTER TABLE check_disks SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'check_id',
-			timescaledb.compress_orderby = 'check_created_at DESC'
-		);
-		SELECT add_compression_policy('check_disks', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	await pool.query(`
-		ALTER TABLE check_network_interfaces SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'check_id',
-			timescaledb.compress_orderby = 'check_created_at DESC'
-		);
-		SELECT add_compression_policy('check_network_interfaces', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	await pool.query(`
-		ALTER TABLE check_errors SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'check_id',
-			timescaledb.compress_orderby = 'check_created_at DESC'
-		);
-		SELECT add_compression_policy('check_errors', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	// Geo checks
-	await pool.query(`
-		ALTER TABLE geo_checks SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'monitor_id',
-			timescaledb.compress_orderby = 'created_at DESC'
-		);
-		SELECT add_compression_policy('geo_checks', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	await pool.query(`
-		ALTER TABLE geo_check_results SET (
-			timescaledb.compress,
-			timescaledb.compress_segmentby = 'geo_check_id',
-			timescaledb.compress_orderby = 'geo_check_created_at DESC'
-		);
-		SELECT add_compression_policy('geo_check_results', INTERVAL '2 days', if_not_exists => TRUE);
-	`);
-
-	// -- Retention policies (default 30 days) --
-
-	await pool.query(`
-		SELECT add_retention_policy('checks', INTERVAL '30 days', if_not_exists => TRUE);
-		SELECT add_retention_policy('check_disks', INTERVAL '30 days', if_not_exists => TRUE);
-		SELECT add_retention_policy('check_network_interfaces', INTERVAL '30 days', if_not_exists => TRUE);
-		SELECT add_retention_policy('check_errors', INTERVAL '30 days', if_not_exists => TRUE);
-		SELECT add_retention_policy('geo_checks', INTERVAL '30 days', if_not_exists => TRUE);
-		SELECT add_retention_policy('geo_check_results', INTERVAL '30 days', if_not_exists => TRUE);
-	`);
-
-	// -- Dynamic retention helper function --
-
-	await pool.query(`
-		CREATE OR REPLACE FUNCTION update_check_retention(new_ttl_days INTEGER)
-		RETURNS VOID AS $$
-		DECLARE
-			ttl_interval INTERVAL;
-		BEGIN
-			ttl_interval := (new_ttl_days || ' days')::INTERVAL;
-
-			PERFORM remove_retention_policy('checks', if_exists => true);
-			PERFORM remove_retention_policy('check_disks', if_exists => true);
-			PERFORM remove_retention_policy('check_network_interfaces', if_exists => true);
-			PERFORM remove_retention_policy('check_errors', if_exists => true);
-			PERFORM remove_retention_policy('geo_checks', if_exists => true);
-			PERFORM remove_retention_policy('geo_check_results', if_exists => true);
-
-			PERFORM add_retention_policy('checks', ttl_interval);
-			PERFORM add_retention_policy('check_disks', ttl_interval);
-			PERFORM add_retention_policy('check_network_interfaces', ttl_interval);
-			PERFORM add_retention_policy('check_errors', ttl_interval);
-			PERFORM add_retention_policy('geo_checks', ttl_interval);
-			PERFORM add_retention_policy('geo_check_results', ttl_interval);
-		END;
-		$$ LANGUAGE plpgsql;
-	`);
-};
-
-export const dropRetentionCompression = async (pool: Pool) => {
-	// Remove retention policies
-	await pool.query(`
-		SELECT remove_retention_policy('checks', if_exists => true);
-		SELECT remove_retention_policy('check_disks', if_exists => true);
-		SELECT remove_retention_policy('check_network_interfaces', if_exists => true);
-		SELECT remove_retention_policy('check_errors', if_exists => true);
-		SELECT remove_retention_policy('geo_checks', if_exists => true);
-		SELECT remove_retention_policy('geo_check_results', if_exists => true);
-	`);
-
-	// Remove compression policies
-	await pool.query(`
-		SELECT remove_compression_policy('checks', if_exists => true);
-		SELECT remove_compression_policy('check_disks', if_exists => true);
-		SELECT remove_compression_policy('check_network_interfaces', if_exists => true);
-		SELECT remove_compression_policy('check_errors', if_exists => true);
-		SELECT remove_compression_policy('geo_checks', if_exists => true);
-		SELECT remove_compression_policy('geo_check_results', if_exists => true);
-	`);
-
-	// Disable compression on tables
-	await pool.query(`
-		ALTER TABLE checks SET (timescaledb.compress = false);
-		ALTER TABLE check_disks SET (timescaledb.compress = false);
-		ALTER TABLE check_network_interfaces SET (timescaledb.compress = false);
-		ALTER TABLE check_errors SET (timescaledb.compress = false);
-		ALTER TABLE geo_checks SET (timescaledb.compress = false);
-		ALTER TABLE geo_check_results SET (timescaledb.compress = false);
-	`);
-
-	// Drop dynamic retention function
-	await pool.query(`DROP FUNCTION IF EXISTS update_check_retention(INTEGER);`);
-};

server/src/db/migration/timescaledb/index.ts

@@ -1,148 +0,0 @@
-import type { Pool } from "pg";
-import type { ILogger } from "@/utils/logger.js";
-import { createEnums, dropEnums } from "./0001_create_enums.js";
-import { createTeams, dropTeams } from "./0002_create_teams.js";
-import { createUsers, dropUsers } from "./0003_create_users.js";
-import { createMonitors, dropMonitors } from "./0004_create_monitors.js";
-import { createNotifications, dropNotifications } from "./0005_create_notifications.js";
-import { createMonitorNotifications, dropMonitorNotifications } from "./0006_create_monitor_notifications.js";
-import { createIncidents, dropIncidents } from "./0007_create_incidents.js";
-import { createMonitorStats, dropMonitorStats } from "./0008_create_monitor_stats.js";
-import { createChecks, dropChecks } from "./0009_create_checks.js";
-import { createCheckDisks, dropCheckDisks } from "./0010_create_check_disks.js";
-import { createCheckNetworkInterfaces, dropCheckNetworkInterfaces } from "./0011_create_check_network_interfaces.js";
-import { createCheckErrors, dropCheckErrors } from "./0012_create_check_errors.js";
-import { createGeoChecks, dropGeoChecks } from "./0013_create_geo_checks.js";
-import { createGeoCheckResults, dropGeoCheckResults } from "./0014_create_geo_check_results.js";
-import { createInvites, dropInvites } from "./0015_create_invites.js";
-import { createRecoveryTokens, dropRecoveryTokens } from "./0016_create_recovery_tokens.js";
-import { createMaintenanceWindows, dropMaintenanceWindows } from "./0017_create_maintenance_windows.js";
-import { createStatusPages, dropStatusPages } from "./0018_create_status_pages.js";
-import { createAppSettings, dropAppSettings } from "./0019_create_app_settings.js";
-import { createContinuousAggregates, dropContinuousAggregates } from "./0020_create_continuous_aggregates.js";
-import { createRetentionCompression, dropRetentionCompression } from "./0021_create_retention_compression.js";
-
-const SERVICE_NAME = "TimescaleDB Migrations";
-
-type MigrationEntry = {
-	name: string;
-	up: (pool: Pool) => Promise<void>;
-	down: (pool: Pool) => Promise<void>;
-};
-
-const migrations: MigrationEntry[] = [
-	{ name: "0001_create_enums", up: createEnums, down: dropEnums },
-	{ name: "0002_create_teams", up: createTeams, down: dropTeams },
-	{ name: "0003_create_users", up: createUsers, down: dropUsers },
-	{ name: "0004_create_monitors", up: createMonitors, down: dropMonitors },
-	{ name: "0005_create_notifications", up: createNotifications, down: dropNotifications },
-	{ name: "0006_create_monitor_notifications", up: createMonitorNotifications, down: dropMonitorNotifications },
-	{ name: "0007_create_incidents", up: createIncidents, down: dropIncidents },
-	{ name: "0008_create_monitor_stats", up: createMonitorStats, down: dropMonitorStats },
-	{ name: "0009_create_checks", up: createChecks, down: dropChecks },
-	{ name: "0010_create_check_disks", up: createCheckDisks, down: dropCheckDisks },
-	{ name: "0011_create_check_network_interfaces", up: createCheckNetworkInterfaces, down: dropCheckNetworkInterfaces },
-	{ name: "0012_create_check_errors", up: createCheckErrors, down: dropCheckErrors },
-	{ name: "0013_create_geo_checks", up: createGeoChecks, down: dropGeoChecks },
-	{ name: "0014_create_geo_check_results", up: createGeoCheckResults, down: dropGeoCheckResults },
-	{ name: "0015_create_invites", up: createInvites, down: dropInvites },
-	{ name: "0016_create_recovery_tokens", up: createRecoveryTokens, down: dropRecoveryTokens },
-	{ name: "0017_create_maintenance_windows", up: createMaintenanceWindows, down: dropMaintenanceWindows },
-	{ name: "0018_create_status_pages", up: createStatusPages, down: dropStatusPages },
-	{ name: "0019_create_app_settings", up: createAppSettings, down: dropAppSettings },
-	{ name: "0020_create_continuous_aggregates", up: createContinuousAggregates, down: dropContinuousAggregates },
-	{ name: "0021_create_retention_compression", up: createRetentionCompression, down: dropRetentionCompression },
-];
-
-const ensureMigrationsTable = async (pool: Pool) => {
-	await pool.query(`
-		DO $$ BEGIN
-			CREATE TYPE migration_status AS ENUM ('completed', 'failed');
-		EXCEPTION
-			WHEN duplicate_object THEN NULL;
-		END $$;
-	`);
-	await pool.query(`
-		CREATE TABLE IF NOT EXISTS migrations (
-			id              UUID PRIMARY KEY DEFAULT gen_random_uuid(),
-			name            TEXT NOT NULL UNIQUE,
-			status          migration_status NOT NULL,
-			completed_at    TIMESTAMPTZ,
-			error           TEXT,
-			created_at      TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-			updated_at      TIMESTAMPTZ NOT NULL DEFAULT NOW()
-		);
-	`);
-};
-
-const runTimescaleDBMigrations = async (pool: Pool, logger?: ILogger) => {
-	try {
-		logger?.info({ message: "Running migrations", service: SERVICE_NAME });
-
-		await ensureMigrationsTable(pool);
-
-		for (const migration of migrations) {
-			const result = await pool.query("SELECT 1 FROM migrations WHERE name = $1 AND status = 'completed'", [migration.name]);
-			if (result.rowCount !== null && result.rowCount > 0) {
-				logger?.info({ message: `Skipping ${migration.name}`, service: SERVICE_NAME });
-				continue;
-			}
-
-			try {
-				await migration.up(pool);
-				await pool.query(
-					`INSERT INTO migrations (name, status, completed_at)
-					 VALUES ($1, 'completed', NOW())
-					 ON CONFLICT (name) DO UPDATE SET status = 'completed', completed_at = NOW(), error = NULL, updated_at = NOW()`,
-					[migration.name]
-				);
-				logger?.info({ message: `Completed ${migration.name}`, service: SERVICE_NAME });
-			} catch (error) {
-				const err = error as Error;
-				await pool.query(
-					`INSERT INTO migrations (name, status, error)
-					 VALUES ($1, 'failed', $2)
-					 ON CONFLICT (name) DO UPDATE SET status = 'failed', error = $2, updated_at = NOW()`,
-					[migration.name, err?.message]
-				);
-				throw error;
-			}
-		}
-
-		logger?.info({ message: "Migrations completed", service: SERVICE_NAME });
-	} catch (error) {
-		const err = error as Error;
-		logger?.error({ message: "Migration failed", service: SERVICE_NAME, details: { error: err?.message }, stack: err?.stack });
-		throw error;
-	}
-};
-
-const rollbackTimescaleDBMigration = async (pool: Pool, logger?: ILogger) => {
-	try {
-		await ensureMigrationsTable(pool);
-
-		// Find the last completed migration
-		const result = await pool.query("SELECT name FROM migrations WHERE status = 'completed' ORDER BY completed_at DESC LIMIT 1");
-		if (result.rowCount === 0) {
-			logger?.info({ message: "No migrations to roll back", service: SERVICE_NAME });
-			return;
-		}
-
-		const lastMigrationName = result.rows[0].name;
-		const migration = migrations.find((m) => m.name === lastMigrationName);
-		if (!migration) {
-			throw new Error(`Migration "${lastMigrationName}" not found in migration list`);
-		}
-
-		logger?.info({ message: `Rolling back ${migration.name}`, service: SERVICE_NAME });
-		await migration.down(pool);
-		await pool.query("DELETE FROM migrations WHERE name = $1", [migration.name]);
-		logger?.info({ message: `Rolled back ${migration.name}`, service: SERVICE_NAME });
-	} catch (error) {
-		const err = error as Error;
-		logger?.error({ message: "Rollback failed", service: SERVICE_NAME, details: { error: err?.message }, stack: err?.stack });
-		throw error;
-	}
-};
-
-export { runTimescaleDBMigrations, rollbackTimescaleDBMigration };

server/src/db/models/DLQItem.ts

@@ -1,70 +0,0 @@
-import { Schema, model, type Types } from "mongoose";
-import { DLQItemTypes, DLQItemStatuses, type DLQItem } from "@/types/dlqItem.js";
-
-export interface DLQItemDocument extends Omit<DLQItem, "id" | "monitorId" | "teamId" | "nextRetryAt" | "createdAt" | "updatedAt"> {
-	_id: Types.ObjectId;
-	monitorId: Types.ObjectId;
-	teamId: Types.ObjectId;
-	nextRetryAt: Date;
-	createdAt: Date;
-	updatedAt: Date;
-}
-
-const DLQItemSchema = new Schema<DLQItemDocument>(
-	{
-		type: {
-			type: String,
-			enum: DLQItemTypes,
-			required: true,
-		},
-		status: {
-			type: String,
-			enum: DLQItemStatuses,
-			default: "pending",
-		},
-		payload: {
-			type: Schema.Types.Mixed,
-			required: true,
-		},
-		monitorId: {
-			type: Schema.Types.ObjectId,
-			ref: "Monitor",
-			required: true,
-			immutable: true,
-			index: true,
-		},
-		teamId: {
-			type: Schema.Types.ObjectId,
-			ref: "Team",
-			required: true,
-			immutable: true,
-			index: true,
-		},
-		retryCount: {
-			type: Number,
-			default: 0,
-		},
-		maxRetries: {
-			type: Number,
-			default: 5,
-		},
-		lastError: {
-			type: String,
-			default: "",
-		},
-		nextRetryAt: {
-			type: Date,
-			required: true,
-		},
-	},
-	{ timestamps: true }
-);
-
-DLQItemSchema.index({ status: 1, nextRetryAt: 1 });
-DLQItemSchema.index({ teamId: 1, status: 1 });
-DLQItemSchema.index({ createdAt: 1 });
-
-const DLQItemModel = model<DLQItemDocument>("DLQItem", DLQItemSchema);
-
-export { DLQItemModel };
-export default DLQItemModel;

server/src/db/models/MaintenanceWindow.ts

@@ -1,5 +1,5 @@
 import { Schema, model, type Types } from "mongoose";
-import type { MaintenanceWindow } from "@/types/maintenanceWindow.js";
+import type { MaintenanceWindow, DurationUnit } from "@/types/maintenanceWindow.js";
 
 type MaintenanceWindowDocumentBase = Omit<MaintenanceWindow, "id" | "monitorId" | "teamId" | "start" | "end" | "createdAt" | "updatedAt"> & {
 	monitorId: Types.ObjectId;

server/src/db/models/Monitor.ts

@@ -1,18 +1,6 @@
-import { Schema, model, Types } from "mongoose";
+import { Schema, model, Types, type UpdateQuery } from "mongoose";
 import type { Monitor, MonitorMatchMethod, CheckSnapshot } from "@/types/monitor.js";
 import { MonitorTypes, MonitorStatuses } from "@/types/monitor.js";
-import type {
-	CheckAudits,
-	CheckCaptureInfo,
-	CheckCpuInfo,
-	CheckDiskInfo,
-	CheckErrorInfo,
-	CheckHostInfo,
-	CheckMemoryInfo,
-	CheckNetworkInterfaceInfo,
-	GotTimings,
-	ILighthouseAudit,
-} from "@/types/check.js";
 
 type CheckSnapshotDocument = Omit<CheckSnapshot, "createdAt"> & { createdAt: Date };
 
@@ -35,167 +23,13 @@ interface MonitorDocument extends MonitorDocumentBase {
 	updatedAt: Date;
 }
 
-const snapshotTimingPhasesSchema = new Schema<GotTimings["phases"]>(
-	{
-		wait: { type: Number },
-		dns: { type: Number },
-		tcp: { type: Number },
-		tls: { type: Number },
-		request: { type: Number },
-		firstByte: { type: Number },
-		download: { type: Number },
-		total: { type: Number },
-	},
-	{ _id: false }
-);
-
-const snapshotTimingsSchema = new Schema<GotTimings>(
-	{
-		start: { type: Number },
-		socket: { type: Number },
-		lookup: { type: Number },
-		connect: { type: Number },
-		secureConnect: { type: Number },
-		upload: { type: Number },
-		response: { type: Number },
-		end: { type: Number },
-		phases: { type: snapshotTimingPhasesSchema },
-	},
-	{ _id: false }
-);
-
-const snapshotCpuSchema = new Schema<CheckCpuInfo>(
-	{
-		physical_core: { type: Number },
-		logical_core: { type: Number },
-		frequency: { type: Number },
-		current_frequency: { type: Number },
-		temperature: { type: [Number] },
-		free_percent: { type: Number },
-		usage_percent: { type: Number },
-	},
-	{ _id: false }
-);
-
-const snapshotMemorySchema = new Schema<CheckMemoryInfo>(
-	{
-		total_bytes: { type: Number },
-		available_bytes: { type: Number },
-		used_bytes: { type: Number },
-		usage_percent: { type: Number },
-	},
-	{ _id: false }
-);
-
-const snapshotDiskSchema = new Schema<CheckDiskInfo>(
-	{
-		device: { type: String },
-		mountpoint: { type: String },
-		total_bytes: { type: Number },
-		free_bytes: { type: Number },
-		used_bytes: { type: Number },
-		usage_percent: { type: Number },
-		total_inodes: { type: Number },
-		free_inodes: { type: Number },
-		used_inodes: { type: Number },
-		inodes_usage_percent: { type: Number },
-		read_bytes: { type: Number },
-		write_bytes: { type: Number },
-		read_time: { type: Number },
-		write_time: { type: Number },
-	},
-	{ _id: false }
-);
-
-const snapshotHostSchema = new Schema<CheckHostInfo>(
-	{
-		os: { type: String },
-		platform: { type: String },
-		kernel_version: { type: String },
-		pretty_name: { type: String },
-	},
-	{ _id: false }
-);
-
-const snapshotErrorSchema = new Schema<CheckErrorInfo>(
-	{
-		metric: { type: [String] },
-		err: { type: String },
-	},
-	{ _id: false }
-);
-
-const snapshotCaptureSchema = new Schema<CheckCaptureInfo>(
-	{
-		version: { type: String },
-		mode: { type: String },
-	},
-	{ _id: false }
-);
-
-const snapshotNetworkInterfaceSchema = new Schema<CheckNetworkInterfaceInfo>(
-	{
-		name: { type: String },
-		bytes_sent: { type: Number },
-		bytes_recv: { type: Number },
-		packets_sent: { type: Number },
-		packets_recv: { type: Number },
-		err_in: { type: Number },
-		err_out: { type: Number },
-		drop_in: { type: Number },
-		drop_out: { type: Number },
-		fifo_in: { type: Number },
-		fifo_out: { type: Number },
-	},
-	{ _id: false }
-);
-
-const snapshotLighthouseAuditSchema = new Schema<ILighthouseAudit>(
-	{
-		id: { type: String },
-		title: { type: String },
-		score: { type: Number },
-		displayValue: { type: String },
-		numericValue: { type: Number },
-		numericUnit: { type: String },
-	},
-	{ _id: false }
-);
-
-const snapshotAuditsSchema = new Schema<CheckAudits>(
-	{
-		cls: { type: snapshotLighthouseAuditSchema },
-		si: { type: snapshotLighthouseAuditSchema },
-		fcp: { type: snapshotLighthouseAuditSchema },
-		lcp: { type: snapshotLighthouseAuditSchema },
-		tbt: { type: snapshotLighthouseAuditSchema },
-	},
-	{ _id: false }
-);
-
 const checkSnapshotSchema = new Schema<CheckSnapshotDocument>(
 	{
 		id: { type: String, required: true },
 		status: { type: Boolean, required: true },
-		responseTime: { type: Number },
-		timings: { type: snapshotTimingsSchema },
-		statusCode: { type: Number },
-		message: { type: String },
-		cpu: { type: snapshotCpuSchema },
-		memory: { type: snapshotMemorySchema },
-		disk: { type: [snapshotDiskSchema] },
-		host: { type: snapshotHostSchema },
-		errors: { type: [snapshotErrorSchema] },
-		capture: { type: snapshotCaptureSchema },
-		net: { type: [snapshotNetworkInterfaceSchema] },
-		accessibility: { type: Number },
-		bestPractices: { type: Number },
-		seo: { type: Number },
-		performance: { type: Number },
-		audits: { type: snapshotAuditsSchema },
 		createdAt: { type: Date, required: true },
 	},
-	{ _id: false }
+	{ _id: false, strict: false }
 );
 
 const MonitorSchema = new Schema<MonitorDocument>(

server/src/db/models/StatusPage.ts

@@ -45,7 +45,7 @@ const StatusPageSchema = new Schema<StatusPageDocument>(
 		type: {
 			type: [String],
 			required: true,
-			default: ["uptime"],
+			default: [],
 			enum: StatusPageTypes,
 		},
 		companyName: {

server/src/db/models/index.ts

@@ -36,6 +36,3 @@ export { default as MaintenanceWindowModel } from "@/db/models/MaintenanceWindow
 
 export * from "@/db/models/GeoCheck.js";
 export { default as GeoCheckModel } from "@/db/models/GeoCheck.js";
-
-export * from "@/db/models/DLQItem.js";
-export { default as DLQItemModel } from "@/db/models/DLQItem.js";

server/src/index.ts

@@ -1,14 +1,16 @@
 import { initializeServices } from "./config/services.js";
 import { initializeControllers } from "./config/controllers.js";
 import { createApp } from "./app.js";
-import { initShutdownListener } from "@/shutdown.js";
-import { validateEnv } from "@/validation/envValidation.js";
+import { initShutdownListener } from "./shutdown.js";
+import { validateEnv } from "./validation/envValidation.js";
 import { fileURLToPath } from "url";
 import path from "path";
 import fs from "fs";
+import { runMigrations } from "./db/migration/index.js";
 
 import Logger, { ILogger } from "@/utils/logger.js";
 import { SettingsService } from "@/service/index.js";
+import { MongoSettingsRepository } from "./repositories/index.js";
 
 const SERVICE_NAME = "Server";
 let logger: ILogger;
@@ -23,15 +25,19 @@ const startApp = async () => {
 	const openApiSpec = JSON.parse(fs.readFileSync(path.join(__dirname, "../openapi.json"), "utf8"));
 	const frontendPath = path.join(__dirname, "..", "public");
 
-	// Create settings service (env only — DB repository injected after connect)
-	const settingsService = new SettingsService(env);
+	// Create services
+	const settingsRepository = new MongoSettingsRepository();
+	const settingsService = new SettingsService(settingsRepository, env);
+
 	const envSettings = settingsService.loadSettings();
 
 	// Create logger
 	logger = new Logger({ envSettings });
 
-	// Initialize services (connects DB, creates repositories, injects settingsRepository)
-	const services = await initializeServices({ logger, envSettings, settingsService });
+	// Initialize services
+	const services = await initializeServices({ logger, envSettings, settingsService, settingsRepository });
+
+	await runMigrations(logger);
 
 	// Initialize controllers
 	const controllers = initializeControllers(services);

server/src/middleware/handleErrors.ts

@@ -1,18 +1,15 @@
 import type { NextFunction, Request, Response } from "express";
 import { logger } from "@/utils/logger.js";
-import { AppError } from "@/utils/AppError.js";
 
-const handleErrors = (error: unknown, req: Request, res: Response, _next: NextFunction) => {
-	const status = 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 method = error instanceof AppError ? error.method : "unknownMethod";
+const handleErrors = (error: any, req: Request, res: Response, next: NextFunction) => {
+	const status = error.status || 500;
+	const message = error.message || "Server error";
+	const service = error.service || "unknownService";
 	logger.error({
 		message: message,
 		service: service,
-		method: method,
-		stack: error instanceof Error ? error.stack : undefined,
-		details: error instanceof AppError ? error.details : undefined,
+		method: error.method,
+		stack: error.stack,
 	});
 	res.status(status).json({
 		status,

server/src/middleware/sanitization.ts

@@ -1,9 +1,7 @@
 import type { Request, Response, NextFunction } from "express";
 import DOMPurify from "isomorphic-dompurify";
 
-export function sanitizeInput(input: string, options?: object): string;
-export function sanitizeInput(input: unknown, options?: object): unknown;
-export function sanitizeInput(input: unknown, options = {}): unknown {
+export const sanitizeInput = (input: any, options = {}) => {
 	if (typeof input !== "string") {
 		return input;
 	}
@@ -17,9 +15,9 @@ export function sanitizeInput(input: unknown, options = {}): unknown {
 	};
 
 	return DOMPurify.sanitize(input, defaultConfig);
-}
+};
 
-export const sanitizeObject = (obj: unknown, options = {}): unknown => {
+export const sanitizeObject = (obj: Record<string, any>, options = {}): Record<string, any> => {
 	if (typeof obj !== "object" || obj === null) {
 		return obj;
 	}
@@ -28,7 +26,7 @@ export const sanitizeObject = (obj: unknown, options = {}): unknown => {
 		return obj.map((item) => sanitizeObject(item, options));
 	}
 
-	const sanitized: Record<string, unknown> = {};
+	const sanitized: Record<string, any> = {};
 	for (const [key, value] of Object.entries(obj)) {
 		if (typeof value === "string") {
 			sanitized[key] = sanitizeInput(value, options);
@@ -54,12 +52,7 @@ export const sanitizeBody = (options = {}): ((req: Request, res: Response, next:
 export const sanitizeQuery = (options = {}): ((req: Request, res: Response, next: NextFunction) => void) => {
 	return (req: Request, res: Response, next: NextFunction) => {
 		if (req.query && typeof req.query === "object") {
-			for (const key of Object.keys(req.query)) {
-				const value = req.query[key];
-				if (typeof value === "string") {
-					req.query[key] = sanitizeInput(value, options);
-				}
-			}
+			req.query = sanitizeObject(req.query, options);
 		}
 		next();
 	};

server/src/middleware/verifyJWT.ts

@@ -2,17 +2,12 @@ import { NextFunction, Request, Response } from "express";
 
 import jwt from "jsonwebtoken";
 import { AppError } from "@/utils/AppError.js";
-import type { ISettingsService } from "@/service/system/settingsService.js";
-import type { User } from "@/types/user.js";
+import { Settings } from "@/types/settings.js";
 
 const SERVICE_NAME = "verifyJWT";
 const TOKEN_PREFIX = "Bearer ";
 
-const isUser = (payload: unknown): payload is User => {
-	return typeof payload === "object" && payload !== null && "id" in payload && "teamId" in payload && "role" in payload;
-};
-
-export const createVerifyJWT = (settingsService: ISettingsService) => {
+export const createVerifyJWT = (settingsService: { getSettings: () => Settings }) => {
 	return (req: Request, res: Response, next: NextFunction) => {
 		const token = req.headers["authorization"];
 		// Make sure a token is provided
@@ -36,22 +31,21 @@ export const createVerifyJWT = (settingsService: ISettingsService) => {
 			next(error);
 			return;
 		}
-		jwt.verify(parsedToken, jwtSecret, (err: jwt.VerifyErrors | null, decoded: jwt.JwtPayload | string | undefined) => {
+		jwt.verify(parsedToken, jwtSecret, (err: any, decoded: any) => {
 			if (err) {
 				const error = new AppError({
-					message: err instanceof Error ? err.message : "Failed to authenticate token",
+					message: "Failed to authenticate token",
+					details: err,
 					status: 401,
 					service: SERVICE_NAME,
-					details: err instanceof Error ? { error: err } : undefined,
 					method: "verifyJWT",
 				});
 				next(error);
 				return;
-			} else if (isUser(decoded)) {
+			} else {
+				// Token is valid, carry on
 				req.user = decoded;
 				next();
-			} else {
-				next(new AppError({ message: "Invalid token payload", status: 401, service: SERVICE_NAME, method: "verifyJWT" }));
 			}
 		});
 	};

server/src/repositories/dlq/IDLQRepository.ts

@@ -1,30 +0,0 @@
-import type { DLQItem, DLQItemType, DLQItemStatus } from "@/types/index.js";
-
-export interface DLQQueryFilters {
-	type?: DLQItemType;
-	status?: DLQItemStatus;
-	page: number;
-	rowsPerPage: number;
-}
-
-export interface DLQStatusCount {
-	status: DLQItemStatus;
-	type: DLQItemType;
-	count: number;
-}
-
-export interface IDLQRepository {
-	// create
-	create(item: Partial<DLQItem>): Promise<DLQItem>;
-	// fetch
-	findById(id: string): Promise<DLQItem | null>;
-	findByTeamId(teamId: string, filters: DLQQueryFilters): Promise<DLQItem[]>;
-	findRetryable(limit: number): Promise<DLQItem[]>;
-	countByTeamId(teamId: string): Promise<number>;
-	countByTeamIdGrouped(teamId: string): Promise<DLQStatusCount[]>;
-	// update
-	updateById(id: string, patch: Partial<DLQItem>): Promise<DLQItem>;
-	// delete
-	deleteById(id: string, teamId: string): Promise<number>;
-	deleteOlderThan(date: Date): Promise<number>;
-}

server/src/repositories/dlq/MongoDLQRepository.ts

@@ -1,139 +0,0 @@
-import { DLQItemModel } from "@/db/models/index.js";
-import type { DLQItemDocument } from "@/db/models/DLQItem.js";
-import type { DLQItem } from "@/types/index.js";
-import type { IDLQRepository, DLQQueryFilters, DLQStatusCount } from "@/repositories/dlq/IDLQRepository.js";
-import mongoose from "mongoose";
-import { AppError } from "@/utils/AppError.js";
-
-class MongoDLQRepository implements IDLQRepository {
-	private toStringId = (value?: mongoose.Types.ObjectId | string | null): string => {
-		if (!value) {
-			return "";
-		}
-		return value instanceof mongoose.Types.ObjectId ? value.toString() : String(value);
-	};
-
-	private toDateString = (value?: Date | string | null): string => {
-		if (!value) {
-			return new Date(0).toISOString();
-		}
-		return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
-	};
-
-	protected toEntity = (doc: DLQItemDocument): DLQItem => {
-		return {
-			id: this.toStringId(doc._id),
-			type: doc.type,
-			status: doc.status,
-			payload: doc.payload,
-			monitorId: this.toStringId(doc.monitorId),
-			teamId: this.toStringId(doc.teamId),
-			retryCount: doc.retryCount,
-			maxRetries: doc.maxRetries,
-			lastError: doc.lastError,
-			nextRetryAt: this.toDateString(doc.nextRetryAt),
-			createdAt: this.toDateString(doc.createdAt),
-			updatedAt: this.toDateString(doc.updatedAt),
-		};
-	};
-
-	protected mapDocuments = (documents: DLQItemDocument[] | DLQItemDocument | null): DLQItem[] => {
-		if (!documents) {
-			return [];
-		}
-		if (Array.isArray(documents)) {
-			return documents.map((doc) => this.toEntity(doc));
-		}
-		return [this.toEntity(documents)];
-	};
-
-	async create(item: Partial<DLQItem>): Promise<DLQItem> {
-		const newItem = await DLQItemModel.create(item);
-		return this.toEntity(newItem);
-	}
-
-	findById = async (id: string): Promise<DLQItem | null> => {
-		const item = await DLQItemModel.findById(new mongoose.Types.ObjectId(id));
-		return item ? this.toEntity(item) : null;
-	};
-
-	findByTeamId = async (teamId: string, filters: DLQQueryFilters): Promise<DLQItem[]> => {
-		const query: Record<string, unknown> = {
-			teamId: new mongoose.Types.ObjectId(teamId),
-		};
-		if (filters.type) {
-			query.type = filters.type;
-		}
-		if (filters.status) {
-			query.status = filters.status;
-		}
-
-		const items = await DLQItemModel.find(query)
-			.sort({ createdAt: -1 })
-			.skip(filters.page * filters.rowsPerPage)
-			.limit(filters.rowsPerPage);
-		return this.mapDocuments(items);
-	};
-
-	findRetryable = async (limit: number): Promise<DLQItem[]> => {
-		const items = await DLQItemModel.find({
-			status: { $in: ["pending", "retrying"] },
-			nextRetryAt: { $lte: new Date() },
-		})
-			.sort({ nextRetryAt: 1 })
-			.limit(limit);
-		return this.mapDocuments(items);
-	};
-
-	countByTeamId = async (teamId: string): Promise<number> => {
-		return DLQItemModel.countDocuments({
-			teamId: new mongoose.Types.ObjectId(teamId),
-		});
-	};
-
-	countByTeamIdGrouped = async (teamId: string): Promise<DLQStatusCount[]> => {
-		const results = await DLQItemModel.aggregate([
-			{ $match: { teamId: new mongoose.Types.ObjectId(teamId) } },
-			{
-				$group: {
-					_id: { status: "$status", type: "$type" },
-					count: { $sum: 1 },
-				},
-			},
-		]);
-		return results.map((r) => ({
-			status: r._id.status,
-			type: r._id.type,
-			count: r.count,
-		}));
-	};
-
-	updateById = async (id: string, patch: Partial<DLQItem>): Promise<DLQItem> => {
-		const updated = await DLQItemModel.findOneAndUpdate(
-			{ _id: new mongoose.Types.ObjectId(id) },
-			{ $set: { ...patch } },
-			{ new: true, runValidators: true }
-		);
-		if (!updated) {
-			throw new AppError({ message: `DLQ item with id ${id} not found`, status: 404 });
-		}
-		return this.toEntity(updated);
-	};
-
-	deleteById = async (id: string, teamId: string): Promise<number> => {
-		const result = await DLQItemModel.deleteOne({
-			_id: new mongoose.Types.ObjectId(id),
-			teamId: new mongoose.Types.ObjectId(teamId),
-		});
-		return result.deletedCount || 0;
-	};
-
-	deleteOlderThan = async (date: Date): Promise<number> => {
-		const result = await DLQItemModel.deleteMany({
-			createdAt: { $lt: date },
-		});
-		return result.deletedCount || 0;
-	};
-}
-
-export default MongoDLQRepository;

server/src/repositories/geo-checks/MongoGeoChecksRepository.ts

@@ -1,8 +1,8 @@
 import { IGeoChecksRepository } from "./IGeoChecksRepository.js";
 import type { GeoCheck, GeoCheckMetadata, GeoCheckResult, GroupedGeoCheck, GeoContinent, FlatGeoCheck } from "@/types/geoCheck.js";
 import type { FlatGeoChecksQueryResult } from "./IGeoChecksRepository.js";
-import { GeoCheckMetadataDocument, GeoCheckModel, type GeoCheckDocument } from "@/db/models/index.js";
-import mongoose, { PipelineStage } from "mongoose";
+import { GeoCheckModel, type GeoCheckDocument } from "@/db/models/index.js";
+import mongoose from "mongoose";
 import { getDateForRange } from "@/utils/dataUtils.js";
 import { ILogger } from "@/utils/logger.js";
 
@@ -31,13 +31,13 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 			return value instanceof Date ? value.toISOString() : new Date(value).toISOString();
 		};
 
-		const mapMetadata = (metadata: GeoCheckMetadataDocument): GeoCheckMetadata => ({
+		const mapMetadata = (metadata: any): GeoCheckMetadata => ({
 			monitorId: toStringId(metadata.monitorId),
 			teamId: toStringId(metadata.teamId),
 			type: metadata.type,
 		});
 
-		const mapResults = (results: GeoCheckResult[]): GeoCheckResult[] => {
+		const mapResults = (results: any[]): GeoCheckResult[] => {
 			if (!results || !Array.isArray(results)) {
 				return [];
 			}
@@ -89,12 +89,12 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 				}))
 			);
 			return docs.map((doc) => this.toEntity(doc));
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Failed to createGeoChecks: ${error.message}` : "Failed to createGeoChecks",
+				message: `Failed to createGeoChecks: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "createGeoChecks",
-				stack: error instanceof Error ? error.stack : undefined,
+				stack: error.stack,
 			});
 			throw error;
 		}
@@ -109,7 +109,7 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 		continents?: GeoContinent[]
 	): Promise<FlatGeoChecksQueryResult> => {
 		try {
-			const matchStage: Record<string, unknown> = {
+			const matchStage: Record<string, any> = {
 				"metadata.monitorId": new mongoose.Types.ObjectId(monitorId),
 				...(getDateForRange(dateRange) && {
 					createdAt: {
@@ -125,8 +125,22 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 				skip = page * rowsPerPage;
 			}
 
+			if (continents && continents.length > 0) {
+				const pipeline: any[] = [
+					{ $match: matchStage },
+					{ $unwind: "$results" },
+					{
+						$match: {
+							"results.location.continent": { $in: continents },
+						},
+					},
+				];
+			} else {
+				const pipeline: any[] = [{ $match: matchStage }, { $unwind: "$results" }];
+			}
+
 			// Common pipeline stages for both paths
-			const pipeline: PipelineStage[] = [
+			const pipeline: any[] = [
 				{ $match: matchStage },
 				{ $unwind: "$results" },
 				// Filter by continent if specified
@@ -160,7 +174,7 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 			];
 
 			// Count pipeline
-			const countPipeline: PipelineStage[] = [
+			const countPipeline: any[] = [
 				{ $match: matchStage },
 				{ $unwind: "$results" },
 				...(continents && continents.length > 0
@@ -192,12 +206,12 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 			}));
 
 			return { geoChecksCount, geoChecks };
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Error finding geo checks by monitor ID: ${error.message}` : "Error finding geo checks by monitor ID",
+				message: `Error finding geo checks by monitor ID: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "findByMonitorId",
-				stack: error instanceof Error ? error.stack : undefined,
+				stack: error.stack,
 			});
 			throw error;
 		}
@@ -213,15 +227,11 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 				},
 			}).sort({ createdAt: -1 });
 			return docs.map(this.toEntity);
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message:
-					error instanceof Error
-						? `Error finding geo checks by monitor ID and date range: ${error.message}`
-						: "Error finding geo checks by monitor ID and date range",
+				message: `Error finding geo checks by monitor ID and date range: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "findByMonitorIdAndDateRange",
-				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw error;
 		}
@@ -235,7 +245,7 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 		continents?: GeoContinent[]
 	): Promise<GroupedGeoCheck[]> => {
 		try {
-			const pipeline: PipelineStage[] = [
+			const pipeline: any[] = [
 				// Match geo checks for this monitor in date range
 				{
 					$match: {
@@ -315,12 +325,11 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 
 			const results = await GeoCheckModel.aggregate(pipeline);
 			return results as GroupedGeoCheck[];
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Error finding grouped geo checks: ${error.message}` : "Error finding grouped geo checks",
+				message: `Error finding grouped geo checks: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "findGroupedByMonitorIdAndDateRange",
-				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw error;
 		}
@@ -332,12 +341,11 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 				"metadata.monitorId": new mongoose.Types.ObjectId(monitorId),
 			});
 			return result.deletedCount || 0;
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Error deleting geo checks by monitor ID: ${error.message}` : "Error deleting geo checks by monitor ID",
+				message: `Error deleting geo checks by monitor ID: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "deleteByMonitorId",
-				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw error;
 		}
@@ -349,12 +357,11 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 				"metadata.teamId": new mongoose.Types.ObjectId(teamId),
 			});
 			return result.deletedCount || 0;
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Error deleting geo checks by team ID: ${error.message}` : "Error deleting geo checks by team ID",
+				message: `Error deleting geo checks by team ID: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "deleteByTeamId",
-				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw error;
 		}
@@ -365,12 +372,11 @@ class MongoGeoChecksRepository implements IGeoChecksRepository {
 			const objectIds = monitorIds.map((id) => new mongoose.Types.ObjectId(id));
 			const result = await GeoCheckModel.deleteMany({ "metadata.monitorId": { $nin: objectIds } });
 			return result.deletedCount || 0;
-		} catch (error: unknown) {
+		} catch (error: any) {
 			this.logger.error({
-				message: error instanceof Error ? `Error deleting orphaned geo checks: ${error.message}` : "Error deleting orphaned geo checks",
+				message: `Error deleting orphaned geo checks: ${error.message}`,
 				service: SERVICE_NAME,
 				method: "deleteByMonitorIdsNotIn",
-				stack: error instanceof Error ? error.stack : undefined,
 			});
 			throw error;
 		}

server/src/repositories/geo-checks/TimescaleGeoChecksRepository.ts

@@ -1,274 +0,0 @@
-import type { Pool } from "pg";
-import type { IGeoChecksRepository, FlatGeoChecksQueryResult } from "./IGeoChecksRepository.js";
-import type { GeoCheck, GeoCheckResult, GroupedGeoCheck, GeoContinent, FlatGeoCheck, MonitorType } from "@/types/index.js";
-import { getDateForRange } from "@/utils/dataUtils.js";
-
-const dateStringToBucket = (dateString: string): string => {
-	if (dateString.includes("%M")) return "1 minute";
-	if (dateString.includes("%H")) return "1 hour";
-	return "1 day";
-};
-
-export class TimescaleGeoChecksRepository implements IGeoChecksRepository {
-	constructor(private pool: Pool) {}
-
-	createGeoChecks = async (geoChecks: Omit<GeoCheck, "id" | "__v" | "createdAt" | "updatedAt">[]): Promise<GeoCheck[]> => {
-		const created: GeoCheck[] = [];
-
-		for (const geoCheck of geoChecks) {
-			const geoResult = await this.pool.query(
-				`INSERT INTO geo_checks (monitor_id, team_id, monitor_type, expiry)
-				 VALUES ($1, $2, $3, $4)
-				 RETURNING id, monitor_id, team_id, monitor_type, expiry, created_at, updated_at`,
-				[geoCheck.metadata.monitorId, geoCheck.metadata.teamId, geoCheck.metadata.type, geoCheck.expiry ? new Date(geoCheck.expiry) : null]
-			);
-			const row = geoResult.rows[0];
-			if (!row) continue;
-
-			for (const result of geoCheck.results) {
-				await this.pool.query(
-					`INSERT INTO geo_check_results (
-						geo_check_id, geo_check_created_at,
-						status, status_code,
-						location_continent, location_region, location_country, location_state, location_city,
-						location_longitude, location_latitude,
-						timing_total, timing_dns, timing_tcp, timing_tls, timing_first_byte, timing_download
-					 ) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17)`,
-					[
-						row.id,
-						row.created_at,
-						result.status,
-						result.statusCode,
-						result.location.continent,
-						result.location.region,
-						result.location.country,
-						result.location.state,
-						result.location.city,
-						result.location.longitude,
-						result.location.latitude,
-						result.timings.total,
-						result.timings.dns,
-						result.timings.tcp,
-						result.timings.tls,
-						result.timings.firstByte,
-						result.timings.download,
-					]
-				);
-			}
-
-			created.push(this.toGeoCheck(row, geoCheck.results));
-		}
-
-		return created;
-	};
-
-	findByMonitorId = async (
-		monitorId: string,
-		sortOrder: string,
-		dateRange: string,
-		page: number,
-		rowsPerPage: number,
-		continents?: GeoContinent[]
-	): Promise<FlatGeoChecksQueryResult> => {
-		const conditions: string[] = ["gc.monitor_id = $1"];
-		const values: unknown[] = [monitorId];
-		let paramIndex = 2;
-
-		const rangeDate = getDateForRange(dateRange);
-		if (rangeDate) {
-			conditions.push(`gc.created_at >= $${paramIndex++}`);
-			values.push(rangeDate);
-		}
-
-		if (continents && continents.length > 0) {
-			conditions.push(`r.location_continent = ANY($${paramIndex++})`);
-			values.push(continents);
-		}
-
-		const where = conditions.join(" AND ");
-		const direction = sortOrder === "asc" ? "ASC" : "DESC";
-		const offset = page && rowsPerPage ? page * rowsPerPage : 0;
-
-		const countValues = [...values];
-		const dataValues = [...values, rowsPerPage, offset];
-
-		const [countResult, dataResult] = await Promise.all([
-			this.pool.query(
-				`SELECT COUNT(*)::int AS count
-				 FROM geo_checks gc
-				 JOIN geo_check_results r ON r.geo_check_id = gc.id
-				 WHERE ${where}`,
-				countValues
-			),
-			this.pool.query(
-				`SELECT gc.id, gc.monitor_id, gc.team_id, gc.monitor_type,
-					r.location_continent, r.location_region, r.location_country, r.location_state, r.location_city,
-					r.location_longitude, r.location_latitude,
-					r.status, r.status_code,
-					r.timing_total, r.timing_dns, r.timing_tcp, r.timing_tls, r.timing_first_byte, r.timing_download,
-					gc.created_at, gc.updated_at
-				 FROM geo_checks gc
-				 JOIN geo_check_results r ON r.geo_check_id = gc.id
-				 WHERE ${where}
-				 ORDER BY gc.created_at ${direction}
-				 LIMIT $${paramIndex++} OFFSET $${paramIndex}`,
-				dataValues
-			),
-		]);
-
-		const geoChecks: FlatGeoCheck[] = dataResult.rows.map((row) => ({
-			id: `${row.monitor_id}-${new Date(row.created_at).getTime()}-${row.location_continent}-${row.location_city}-${row.id.substring(0, 8)}`,
-			monitorId: row.monitor_id,
-			teamId: row.team_id,
-			type: row.monitor_type,
-			location: {
-				continent: row.location_continent,
-				region: row.location_region,
-				country: row.location_country,
-				state: row.location_state,
-				city: row.location_city,
-				longitude: row.location_longitude,
-				latitude: row.location_latitude,
-			},
-			status: row.status,
-			statusCode: row.status_code,
-			timings: {
-				total: row.timing_total ?? 0,
-				dns: row.timing_dns ?? 0,
-				tcp: row.timing_tcp ?? 0,
-				tls: row.timing_tls ?? 0,
-				firstByte: row.timing_first_byte ?? 0,
-				download: row.timing_download ?? 0,
-			},
-			createdAt: row.created_at.toISOString(),
-			updatedAt: row.updated_at.toISOString(),
-		}));
-
-		return { geoChecksCount: countResult.rows[0].count, geoChecks };
-	};
-
-	findByMonitorIdAndDateRange = async (monitorId: string, startDate: Date, endDate: Date): Promise<GeoCheck[]> => {
-		const geoRows = await this.pool.query(
-			`SELECT id, monitor_id, team_id, monitor_type, expiry, created_at, updated_at
-			 FROM geo_checks
-			 WHERE monitor_id = $1 AND created_at >= $2 AND created_at <= $3
-			 ORDER BY created_at DESC`,
-			[monitorId, startDate, endDate]
-		);
-
-		const geoChecks: GeoCheck[] = [];
-		for (const row of geoRows.rows) {
-			const resultsRows = await this.pool.query(
-				`SELECT status, status_code,
-					location_continent, location_region, location_country, location_state, location_city,
-					location_longitude, location_latitude,
-					timing_total, timing_dns, timing_tcp, timing_tls, timing_first_byte, timing_download
-				 FROM geo_check_results
-				 WHERE geo_check_id = $1`,
-				[row.id]
-			);
-
-			const results = resultsRows.rows.map(this.toGeoCheckResult);
-			geoChecks.push(this.toGeoCheck(row, results));
-		}
-
-		return geoChecks;
-	};
-
-	findGroupedByMonitorIdAndDateRange = async (
-		monitorId: string,
-		startDate: Date,
-		endDate: Date,
-		dateFormat: string,
-		continents?: GeoContinent[]
-	): Promise<GroupedGeoCheck[]> => {
-		const bucket = dateStringToBucket(dateFormat);
-
-		const conditions: string[] = ["gc.monitor_id = $2", "gc.created_at >= $3", "gc.created_at <= $4"];
-		const values: unknown[] = [bucket, monitorId, startDate, endDate];
-		let paramIndex = 5;
-
-		if (continents && continents.length > 0) {
-			conditions.push(`r.location_continent = ANY($${paramIndex++})`);
-			values.push(continents);
-		}
-
-		const result = await this.pool.query(
-			`SELECT
-				time_bucket($1::interval, gc.created_at) AS bucket_date,
-				r.location_continent AS continent,
-				ROUND(AVG(r.timing_total)::numeric, 2) AS "avgResponseTime",
-				COUNT(*)::int AS "totalChecks",
-				ROUND((100.0 * COUNT(*) FILTER (WHERE r.status = TRUE) / COUNT(*))::numeric, 2) AS "uptimePercentage"
-			 FROM geo_checks gc
-			 JOIN geo_check_results r ON r.geo_check_id = gc.id
-			 WHERE ${conditions.join(" AND ")}
-			 GROUP BY bucket_date, r.location_continent
-			 ORDER BY bucket_date, r.location_continent`,
-			values
-		);
-
-		return result.rows.map((row) => ({
-			bucketDate: (row.bucket_date as Date).toISOString(),
-			continent: row.continent as GeoContinent,
-			avgResponseTime: Number(row.avgResponseTime ?? 0),
-			totalChecks: Number(row.totalChecks ?? 0),
-			uptimePercentage: Number(row.uptimePercentage ?? 0),
-		}));
-	};
-
-	deleteByMonitorId = async (monitorId: string): Promise<number> => {
-		const result = await this.pool.query(`DELETE FROM geo_checks WHERE monitor_id = $1`, [monitorId]);
-		return result.rowCount ?? 0;
-	};
-
-	deleteByTeamId = async (teamId: string): Promise<number> => {
-		const result = await this.pool.query(`DELETE FROM geo_checks WHERE team_id = $1`, [teamId]);
-		return result.rowCount ?? 0;
-	};
-
-	deleteByMonitorIdsNotIn = async (monitorIds: string[]): Promise<number> => {
-		if (!monitorIds.length) {
-			const result = await this.pool.query(`DELETE FROM geo_checks`);
-			return result.rowCount ?? 0;
-		}
-		const result = await this.pool.query(`DELETE FROM geo_checks WHERE monitor_id != ALL($1)`, [monitorIds]);
-		return result.rowCount ?? 0;
-	};
-
-	private toGeoCheckResult = (row: Record<string, unknown>): GeoCheckResult => ({
-		location: {
-			continent: (row.location_continent as GeoContinent) ?? "",
-			region: (row.location_region as string) ?? "",
-			country: (row.location_country as string) ?? "",
-			state: (row.location_state as string) ?? "",
-			city: (row.location_city as string) ?? "",
-			longitude: (row.location_longitude as number) ?? 0,
-			latitude: (row.location_latitude as number) ?? 0,
-		},
-		status: (row.status as boolean) ?? false,
-		statusCode: (row.status_code as number) ?? 0,
-		timings: {
-			total: (row.timing_total as number) ?? 0,
-			dns: (row.timing_dns as number) ?? 0,
-			tcp: (row.timing_tcp as number) ?? 0,
-			tls: (row.timing_tls as number) ?? 0,
-			firstByte: (row.timing_first_byte as number) ?? 0,
-			download: (row.timing_download as number) ?? 0,
-		},
-	});
-
-	private toGeoCheck = (row: Record<string, unknown>, results: GeoCheckResult[]): GeoCheck => ({
-		id: row.id as string,
-		metadata: {
-			monitorId: row.monitor_id as string,
-			teamId: row.team_id as string,
-			type: row.monitor_type as MonitorType,
-		},
-		results,
-		expiry: row.expiry ? (row.expiry as Date).toISOString() : new Date(0).toISOString(),
-		__v: 0,
-		createdAt: (row.created_at as Date).toISOString(),
-		updatedAt: (row.updated_at as Date).toISOString(),
-	});
-}

server/src/repositories/incidents/MongoIncidentRepository.ts

@@ -5,7 +5,7 @@ import type { IIncidentsRepository } from "@/repositories/index.js";
 import mongoose from "mongoose";
 import { AppError } from "@/utils/AppError.js";
 
-class MongoIncidentsRepository implements IIncidentsRepository {
+class MongoIncidentRepository implements IIncidentsRepository {
 	private toStringId = (value?: mongoose.Types.ObjectId | string | null): string => {
 		if (!value) {
 			return "";
@@ -32,8 +32,8 @@ class MongoIncidentsRepository implements IIncidentsRepository {
 		status?: boolean;
 		monitorId?: string;
 		resolutionType?: string;
-	}): Record<string, unknown> {
-		const matchStage: Record<string, unknown> = {
+	}): Record<string, any> {
+		const matchStage: Record<string, any> = {
 			teamId: new mongoose.Types.ObjectId(teamId),
 			...(status !== undefined && { status }),
 			...(monitorId && { monitorId: new mongoose.Types.ObjectId(monitorId) }),
@@ -288,4 +288,4 @@ class MongoIncidentsRepository implements IIncidentsRepository {
 		return result.deletedCount ?? 0;
 	};
 }
-export default MongoIncidentsRepository;
+export default MongoIncidentRepository;

server/src/repositories/incidents/TimescaleIncidentsRepository.ts

@@ -1,294 +0,0 @@
-import type { Pool } from "pg";
-import type { Incident, IncidentSummary, IncidentResolutionType } from "@/types/incident.js";
-import type { IIncidentsRepository } from "@/repositories/incidents/IIncidentsRepository.js";
-import { AppError } from "@/utils/AppError.js";
-
-interface IncidentRow {
-	id: string;
-	monitor_id: string;
-	team_id: string;
-	start_time: Date;
-	end_time: Date | null;
-	status: boolean;
-	message: string | null;
-	status_code: number | null;
-	resolution_type: IncidentResolutionType;
-	resolved_by: string | null;
-	resolved_by_email: string | null;
-	comment: string | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, monitor_id, team_id, start_time, end_time, status, message, status_code,
-	resolution_type, resolved_by, resolved_by_email, comment, created_at, updated_at`;
-
-export class TimescaleIncidentsRepository implements IIncidentsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (incident: Partial<Incident>): Promise<Incident> => {
-		const result = await this.pool.query<IncidentRow>(
-			`INSERT INTO incidents (monitor_id, team_id, start_time, end_time, status, message, status_code, resolution_type, resolved_by, resolved_by_email, comment)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
-			 RETURNING ${COLUMNS}`,
-			[
-				incident.monitorId,
-				incident.teamId,
-				incident.startTime ? new Date(Number(incident.startTime) || incident.startTime) : new Date(),
-				incident.endTime ? new Date(Number(incident.endTime) || incident.endTime) : null,
-				incident.status ?? true,
-				incident.message ?? null,
-				incident.statusCode ?? null,
-				incident.resolutionType ?? null,
-				incident.resolvedBy ?? null,
-				incident.resolvedByEmail ?? null,
-				incident.comment ?? null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create incident", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findById = async (incidentId: string, teamId: string): Promise<Incident> => {
-		const result = await this.pool.query<IncidentRow>(`SELECT ${COLUMNS} FROM incidents WHERE id = $1 AND team_id = $2`, [incidentId, teamId]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: `Incident with id ${incidentId} not found`, status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findActiveByIncidentId = async (incidentId: string, teamId: string): Promise<Incident | null> => {
-		const result = await this.pool.query<IncidentRow>(`SELECT ${COLUMNS} FROM incidents WHERE id = $1 AND team_id = $2 AND status = TRUE`, [
-			incidentId,
-			teamId,
-		]);
-		const row = result.rows[0];
-		return row ? this.toEntity(row) : null;
-	};
-
-	findActiveByMonitorId = async (monitorId: string, teamId: string): Promise<Incident | null> => {
-		const result = await this.pool.query<IncidentRow>(`SELECT ${COLUMNS} FROM incidents WHERE monitor_id = $1 AND team_id = $2 AND status = TRUE`, [
-			monitorId,
-			teamId,
-		]);
-		const row = result.rows[0];
-		return row ? this.toEntity(row) : null;
-	};
-
-	findByTeamId = async (
-		teamId: string,
-		startDate: Date | undefined,
-		page: number,
-		rowsPerPage: number,
-		sortOrder?: string,
-		status?: boolean,
-		monitorId?: string,
-		resolutionType?: string
-	): Promise<Incident[]> => {
-		const { conditions, values, paramIndex } = this.buildWhere(teamId, startDate, status, monitorId, resolutionType);
-		const direction = sortOrder === "asc" ? "ASC" : "DESC";
-		const offset = page * rowsPerPage;
-
-		const result = await this.pool.query<IncidentRow>(
-			`SELECT ${COLUMNS} FROM incidents
-			 WHERE ${conditions.join(" AND ")}
-			 ORDER BY created_at ${direction}
-			 LIMIT $${paramIndex} OFFSET $${paramIndex + 1}`,
-			[...values, rowsPerPage, offset]
-		);
-		return result.rows.map(this.toEntity);
-	};
-
-	countByTeamId = async (
-		teamId: string,
-		startDate: Date | undefined,
-		status?: boolean,
-		monitorId?: string,
-		resolutionType?: string
-	): Promise<number> => {
-		const { conditions, values } = this.buildWhere(teamId, startDate, status, monitorId, resolutionType);
-		const result = await this.pool.query(`SELECT COUNT(*)::int AS count FROM incidents WHERE ${conditions.join(" AND ")}`, values);
-		return result.rows[0].count;
-	};
-
-	findSummaryByTeamId = async (teamId: string, limit?: number): Promise<IncidentSummary> => {
-		// Counts by status and resolution type
-		const countsResult = await this.pool.query(
-			`SELECT
-				COUNT(*)::int AS total,
-				COUNT(*) FILTER (WHERE status = TRUE)::int AS active,
-				COUNT(*) FILTER (WHERE resolution_type = 'manual')::int AS manual,
-				COUNT(*) FILTER (WHERE resolution_type = 'automatic')::int AS automatic
-			 FROM incidents WHERE team_id = $1`,
-			[teamId]
-		);
-		const counts = countsResult.rows[0] ?? { total: 0, active: 0, manual: 0, automatic: 0 };
-
-		// Average resolution time
-		const resTimeResult = await this.pool.query(
-			`SELECT AVG(EXTRACT(EPOCH FROM (end_time - start_time))) AS avg_seconds
-			 FROM incidents
-			 WHERE team_id = $1 AND status = FALSE AND end_time IS NOT NULL`,
-			[teamId]
-		);
-		const avgSeconds = resTimeResult.rows[0]?.avg_seconds ?? 0;
-		const avgResolutionTimeHours = Math.round((avgSeconds / 3600) * 100) / 100;
-
-		// Top monitor by incident count
-		const topMonitorResult = await this.pool.query(
-			`SELECT i.monitor_id, m.name AS monitor_name, COUNT(*)::int AS count
-			 FROM incidents i
-			 LEFT JOIN monitors m ON m.id = i.monitor_id
-			 WHERE i.team_id = $1
-			 GROUP BY i.monitor_id, m.name
-			 ORDER BY count DESC
-			 LIMIT 1`,
-			[teamId]
-		);
-
-		// Latest incidents
-		const latestLimit = Math.max(1, Number.isFinite(Number(limit)) ? Number(limit) : 10);
-		const latestResult = await this.pool.query(
-			`SELECT i.id, i.monitor_id, m.name AS monitor_name, i.status, i.start_time, i.end_time,
-				i.resolution_type, i.message, i.status_code, i.created_at
-			 FROM incidents i
-			 LEFT JOIN monitors m ON m.id = i.monitor_id
-			 WHERE i.team_id = $1
-			 ORDER BY i.created_at DESC
-			 LIMIT $2`,
-			[teamId, latestLimit]
-		);
-
-		const topRow = topMonitorResult.rows[0];
-
-		return {
-			total: counts.total,
-			totalActive: counts.active,
-			totalManualResolutions: counts.manual,
-			totalAutomaticResolutions: counts.automatic,
-			avgResolutionTimeHours,
-			topMonitor: topRow
-				? {
-						monitorId: topRow.monitor_id,
-						monitorName: topRow.monitor_name ?? null,
-						incidentCount: topRow.count,
-					}
-				: null,
-			latestIncidents: latestResult.rows.map((row) => ({
-				id: row.id,
-				monitorId: row.monitor_id,
-				monitorName: row.monitor_name ?? null,
-				status: row.status,
-				startTime: row.start_time.toISOString(),
-				endTime: row.end_time ? row.end_time.toISOString() : null,
-				resolutionType: row.resolution_type ?? null,
-				message: row.message ?? null,
-				statusCode: row.status_code ?? null,
-				createdAt: row.created_at.toISOString(),
-			})),
-		};
-	};
-
-	updateById = async (incidentId: string, teamId: string, patch: Partial<Incident>): Promise<Incident> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		const fieldMap: [keyof Incident, string][] = [
-			["status", "status"],
-			["message", "message"],
-			["statusCode", "status_code"],
-			["endTime", "end_time"],
-			["resolutionType", "resolution_type"],
-			["resolvedBy", "resolved_by"],
-			["resolvedByEmail", "resolved_by_email"],
-			["comment", "comment"],
-		];
-
-		for (const [key, column] of fieldMap) {
-			if (patch[key] !== undefined) {
-				const value = key === "endTime" && patch[key] ? new Date(Number(patch[key]) || (patch[key] as string)) : patch[key];
-				sets.push(`${column} = $${paramIndex++}`);
-				values.push(value);
-			}
-		}
-
-		if (sets.length === 0) {
-			return this.findById(incidentId, teamId);
-		}
-
-		sets.push(`updated_at = NOW()`);
-		values.push(incidentId, teamId);
-
-		const result = await this.pool.query<IncidentRow>(
-			`UPDATE incidents SET ${sets.join(", ")} WHERE id = $${paramIndex++} AND team_id = $${paramIndex}
-			 RETURNING ${COLUMNS}`,
-			values
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: `Failed to update incident with id ${incidentId}`, status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteByMonitorId = async (monitorId: string, teamId: string): Promise<number> => {
-		const result = await this.pool.query(`DELETE FROM incidents WHERE monitor_id = $1 AND team_id = $2`, [monitorId, teamId]);
-		return result.rowCount ?? 0;
-	};
-
-	deleteByMonitorIdsNotIn = async (monitorIds: string[]): Promise<number> => {
-		if (!monitorIds.length) {
-			const result = await this.pool.query(`DELETE FROM incidents`);
-			return result.rowCount ?? 0;
-		}
-		const result = await this.pool.query(`DELETE FROM incidents WHERE monitor_id != ALL($1)`, [monitorIds]);
-		return result.rowCount ?? 0;
-	};
-
-	private buildWhere = (teamId: string, startDate: Date | undefined, status?: boolean, monitorId?: string, resolutionType?: string) => {
-		const conditions: string[] = ["team_id = $1"];
-		const values: unknown[] = [teamId];
-		let paramIndex = 2;
-
-		if (startDate) {
-			conditions.push(`created_at >= $${paramIndex++}`);
-			values.push(startDate);
-		}
-		if (status !== undefined) {
-			conditions.push(`status = $${paramIndex++}`);
-			values.push(status);
-		}
-		if (monitorId) {
-			conditions.push(`monitor_id = $${paramIndex++}`);
-			values.push(monitorId);
-		}
-		if (resolutionType) {
-			conditions.push(`resolution_type = $${paramIndex++}`);
-			values.push(resolutionType);
-		}
-
-		return { conditions, values, paramIndex };
-	};
-
-	private toEntity = (row: IncidentRow): Incident => ({
-		id: row.id,
-		monitorId: row.monitor_id,
-		teamId: row.team_id,
-		startTime: row.start_time.toISOString(),
-		endTime: row.end_time ? row.end_time.toISOString() : null,
-		status: row.status,
-		message: row.message ?? null,
-		statusCode: row.status_code ?? null,
-		resolutionType: row.resolution_type ?? null,
-		resolvedBy: row.resolved_by ?? null,
-		resolvedByEmail: row.resolved_by_email ?? null,
-		comment: row.comment ?? null,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/index.ts

@@ -1,54 +1,38 @@
 export * from "@/repositories/monitors/IMonitorsRepository.js";
 export { default as MongoMonitorsRepository } from "@/repositories/monitors/MongoMonitorsRepository.js";
-export { TimescaleMonitorsRepository } from "@/repositories/monitors/TimescaleMonitorsRepository.js";
 
 export * from "@/repositories/checks/IChecksRepository.js";
 export { default as MongoChecksRepository } from "@/repositories/checks/MongoChecksRepistory.js";
-export { TimescaleChecksRepository } from "@/repositories/checks/TimescaleChecksRepository.js";
 
 export * from "@/repositories/monitor-stats/IMonitorStatsRepository.js";
 export { default as MongoMonitorStatsRepository } from "@/repositories/monitor-stats/MongoMonitorStatsRepository.js";
-export { TimescaleMonitorStatsRepository } from "@/repositories/monitor-stats/TimescaleMonitorStatsRepository.js";
 
 export * from "@/repositories/status-pages/IStatusPagesRepository.js";
 export { default as MongoStatusPagesRepository } from "@/repositories/status-pages/MongoStatusPagesRepository.js";
-export { TimescaleStatusPagesRepository } from "@/repositories/status-pages/TimescaleStatusPagesRepository.js";
 
 export * from "@/repositories/users/IUsersRepository.js";
 export { default as MongoUsersRepository } from "@/repositories/users/MongoUsersRepository.js";
-export { TimescaleUsersRepository } from "@/repositories/users/TimescaleUsersRepository.js";
 
 export * from "@/repositories/invites/IInvitesRepository.js";
 export { default as MongoInvitesRepository } from "@/repositories/invites/MongoInviteRepository.js";
-export { TimescaleInvitesRepository } from "@/repositories/invites/TimescaleInvitesRepository.js";
 
 export * from "@/repositories/recovery-tokens/IRecoveryTokensRepository.js";
 export { default as MongoRecoveryTokensRepository } from "@/repositories/recovery-tokens/MongoRecoveryTokensRepository.js";
-export { TimescaleRecoveryTokensRepository } from "@/repositories/recovery-tokens/TimescaleRecoveryTokensRepository.js";
 
 export * from "@/repositories/settings/ISettingsRepository.js";
 export { default as MongoSettingsRepository } from "@/repositories/settings/MongoSettingsRepository.js";
-export { TimescaleSettingsRepository } from "@/repositories/settings/TimescaleSettingsRepository.js";
 
 export * from "@/repositories/notifications/INotificationsRepository.js";
 export { default as MongoNotificationsRepository } from "@/repositories/notifications/MongoNotificationsRepository.js";
-export { TimescaleNotificationsRepository } from "@/repositories/notifications/TimescaleNotificationsRepository.js";
 
 export * from "@/repositories/incidents/IIncidentsRepository.js";
-export { default as MongoIncidentsRepository } from "@/repositories/incidents/MongoIncidentsRepository.js";
-export { TimescaleIncidentsRepository } from "@/repositories/incidents/TimescaleIncidentsRepository.js";
+export { default as MongoIncidentRepository } from "@/repositories/incidents/MongoIncidentRepository.js";
 
 export * from "@/repositories/teams/ITeamsRepository.js";
 export { default as MongoTeamsRepository } from "@/repositories/teams/MongoTeamsRepository.js";
-export { TimescaleTeamsRepository } from "@/repositories/teams/TimescaleTeamsRepository.js";
 
 export * from "@/repositories/maintenance-windows/IMaintenanceWindowsRepository.js";
 export { default as MongoMaintenanceWindowsRepository } from "@/repositories/maintenance-windows/MongoMaintenanceWindowsRepository.js";
-export { TimescaleMaintenanceWindowsRepository } from "@/repositories/maintenance-windows/TimescaleMaintenanceWindowsRepository.js";
 
 export * from "@/repositories/geo-checks/IGeoChecksRepository.js";
 export { default as MongoGeoChecksRepository } from "@/repositories/geo-checks/MongoGeoChecksRepository.js";
-
-export * from "@/repositories/dlq/IDLQRepository.js";
-export { default as MongoDLQRepository } from "@/repositories/dlq/MongoDLQRepository.js";
-export { TimescaleGeoChecksRepository } from "@/repositories/geo-checks/TimescaleGeoChecksRepository.js";

server/src/repositories/invites/TimescaleInvitesRepository.ts

@@ -1,77 +0,0 @@
-import type { Pool } from "pg";
-import crypto from "crypto";
-import type { IInvitesRepository } from "@/repositories/invites/IInvitesRepository.js";
-import type { Invite } from "@/types/invite.js";
-import type { UserRole } from "@/types/user.js";
-import { AppError } from "@/utils/AppError.js";
-
-const parsePostgresArray = (value: unknown): UserRole[] => {
-	if (typeof value !== "string") return [];
-	const inner = value.replace(/^\{|\}$/g, "");
-	if (inner === "") return [];
-	return inner.split(",") as UserRole[];
-};
-
-interface InviteRow {
-	id: string;
-	email: string;
-	team_id: string;
-	roles: UserRole[];
-	token: string;
-	expiry: Date | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, email, team_id, roles, token, expiry, created_at, updated_at`;
-
-export class TimescaleInvitesRepository implements IInvitesRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (invite: Partial<Invite>): Promise<Invite> => {
-		// Delete existing invites for this email
-		await this.pool.query(`DELETE FROM invites WHERE email = $1`, [invite.email]);
-
-		const token = crypto.randomBytes(32).toString("hex");
-		const result = await this.pool.query<InviteRow>(
-			`INSERT INTO invites (email, team_id, roles, token, expiry)
-			 VALUES ($1, $2, $3, $4, $5)
-			 RETURNING ${COLUMNS}`,
-			[invite.email, invite.teamId, invite.role ?? ["user"], token, invite.expiry ? new Date(invite.expiry) : null]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create invite", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findByToken = async (token: string): Promise<Invite> => {
-		const result = await this.pool.query<InviteRow>(`SELECT ${COLUMNS} FROM invites WHERE token = $1`, [token]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Invite not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findByTokenAndDelete = async (token: string): Promise<Invite> => {
-		const result = await this.pool.query<InviteRow>(`DELETE FROM invites WHERE token = $1 RETURNING ${COLUMNS}`, [token]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Invite not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	private toEntity = (row: InviteRow): Invite => ({
-		id: row.id,
-		email: row.email,
-		teamId: row.team_id,
-		role: Array.isArray(row.roles) ? row.roles : parsePostgresArray(row.roles),
-		token: row.token,
-		expiry: row.expiry ? row.expiry.toISOString() : new Date(0).toISOString(),
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/maintenance-windows/IMaintenanceWindowsRepository.ts

@@ -5,12 +5,12 @@ export interface IMaintenanceWindowsRepository {
 	// fetch
 	findById(id: string, teamId: string): Promise<MaintenanceWindow>;
 	findByMonitorId(monitorId: string, teamId: string): Promise<MaintenanceWindow[]>;
-	findByTeamId(teamId: string, page: number, rowsPerPage: number, field?: string, order?: string, active?: boolean): Promise<MaintenanceWindow[]>;
+	findByTeamId(teamId: string, active: boolean, page: number, rowsPerPage: number, field: string, order: string): Promise<MaintenanceWindow[]>;
 
 	// update
 	updateById(id: string, teamId: string, data: Partial<MaintenanceWindow>): Promise<MaintenanceWindow>;
 	// delete
 	deleteById(id: string, teamId: string): Promise<MaintenanceWindow>;
 	// other
-	countByTeamId(teamId: string, active?: boolean): Promise<number>;
+	countByTeamId(teamId: string, active: boolean): Promise<number>;
 }

server/src/repositories/maintenance-windows/MongoMaintenanceWindowsRepository.ts

@@ -1,7 +1,7 @@
 import type { MaintenanceWindow } from "@/types/index.js";
 import { type MaintenanceWindowDocument, MaintenanceWindowModel } from "@/db/models/index.js";
 import { IMaintenanceWindowsRepository } from "./IMaintenanceWindowsRepository.js";
-import mongoose, { SortOrder } from "mongoose";
+import mongoose from "mongoose";
 import { AppError } from "@/utils/AppError.js";
 
 class MongoMaintenanceWindowsRepository implements IMaintenanceWindowsRepository {
@@ -75,13 +75,13 @@ class MongoMaintenanceWindowsRepository implements IMaintenanceWindowsRepository
 
 	findByTeamId = async (
 		teamId: string,
+		active: boolean,
 		page: number,
 		rowsPerPage: number,
-		field?: string,
-		order?: string,
-		active?: boolean
+		field: string,
+		order: string
 	): Promise<MaintenanceWindow[]> => {
-		const maintenanceQuery: Record<string, unknown> = { teamId };
+		const maintenanceQuery: Record<string, any> = { teamId };
 
 		if (active !== undefined) maintenanceQuery.active = active;
 
@@ -92,7 +92,7 @@ class MongoMaintenanceWindowsRepository implements IMaintenanceWindowsRepository
 		}
 
 		// Sorting
-		const sort: Record<string, SortOrder> = {};
+		const sort: Record<string, any> = {};
 		if (field !== undefined && order !== undefined) {
 			sort[field] = order === "asc" ? 1 : -1;
 		}
@@ -126,8 +126,8 @@ class MongoMaintenanceWindowsRepository implements IMaintenanceWindowsRepository
 		}
 		return this.toEntity(deleted);
 	};
-	countByTeamId = async (teamId: string, active?: boolean) => {
-		const maintenanceQuery: Record<string, unknown> = { teamId };
+	countByTeamId = async (teamId: string, active: boolean) => {
+		const maintenanceQuery: Record<string, any> = { teamId };
 
 		if (active !== undefined) maintenanceQuery.active = active;
 

server/src/repositories/maintenance-windows/TimescaleMaintenanceWindowsRepository.ts

@@ -1,197 +0,0 @@
-import type { Pool } from "pg";
-import type { IMaintenanceWindowsRepository } from "./IMaintenanceWindowsRepository.js";
-import type { MaintenanceWindow, DurationUnit } from "@/types/maintenanceWindow.js";
-import { AppError } from "@/utils/AppError.js";
-
-interface MaintenanceWindowRow {
-	id: string;
-	monitor_id: string;
-	team_id: string;
-	active: boolean;
-	name: string;
-	duration: number;
-	duration_unit: DurationUnit;
-	repeat: number;
-	start_time: Date;
-	end_time: Date;
-	expiry: Date | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, monitor_id, team_id, active, name, duration, duration_unit, repeat,
-	start_time, end_time, expiry, created_at, updated_at`;
-
-export class TimescaleMaintenanceWindowsRepository implements IMaintenanceWindowsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (data: Partial<MaintenanceWindow>): Promise<MaintenanceWindow> => {
-		const startTime = data.start ? new Date(data.start) : null;
-		const endTime = data.end ? new Date(data.end) : null;
-		// One-time windows expire at end time
-		const expiry = data.repeat === 0 ? endTime : null;
-
-		const result = await this.pool.query<MaintenanceWindowRow>(
-			`INSERT INTO maintenance_windows (monitor_id, team_id, active, name, duration, duration_unit, repeat, start_time, end_time, expiry)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-			 RETURNING ${COLUMNS}`,
-			[
-				data.monitorId,
-				data.teamId,
-				data.active ?? true,
-				data.name ?? null,
-				data.duration ?? null,
-				data.durationUnit ?? null,
-				data.repeat ?? 0,
-				startTime,
-				endTime,
-				expiry,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create maintenance window", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findById = async (id: string, teamId: string): Promise<MaintenanceWindow> => {
-		const result = await this.pool.query<MaintenanceWindowRow>(`SELECT ${COLUMNS} FROM maintenance_windows WHERE id = $1 AND team_id = $2`, [
-			id,
-			teamId,
-		]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Maintenance Window not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findByMonitorId = async (monitorId: string, teamId: string): Promise<MaintenanceWindow[]> => {
-		const result = await this.pool.query<MaintenanceWindowRow>(`SELECT ${COLUMNS} FROM maintenance_windows WHERE monitor_id = $1 AND team_id = $2`, [
-			monitorId,
-			teamId,
-		]);
-		return result.rows.map(this.toEntity);
-	};
-
-	findByTeamId = async (
-		teamId: string,
-		page: number,
-		rowsPerPage: number,
-		field?: string,
-		order?: string,
-		active?: boolean
-	): Promise<MaintenanceWindow[]> => {
-		const conditions: string[] = ["team_id = $1"];
-		const values: unknown[] = [teamId];
-		let paramIndex = 2;
-
-		if (active !== undefined) {
-			conditions.push(`active = $${paramIndex++}`);
-			values.push(active);
-		}
-
-		const fieldMap: Record<string, string> = {
-			createdAt: "created_at",
-			name: "name",
-			start: "start_time",
-			end: "end_time",
-			active: "active",
-		};
-		const sortColumn = field ? (fieldMap[field] ?? "created_at") : "created_at";
-		const sortDirection = order === "asc" ? "ASC" : "DESC";
-
-		const offset = page && rowsPerPage ? page * rowsPerPage : 0;
-
-		const result = await this.pool.query<MaintenanceWindowRow>(
-			`SELECT ${COLUMNS} FROM maintenance_windows
-			 WHERE ${conditions.join(" AND ")}
-			 ORDER BY ${sortColumn} ${sortDirection}
-			 LIMIT $${paramIndex++} OFFSET $${paramIndex}`,
-			[...values, rowsPerPage, offset]
-		);
-		return result.rows.map(this.toEntity);
-	};
-
-	updateById = async (id: string, teamId: string, patch: Partial<MaintenanceWindow>): Promise<MaintenanceWindow> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		const fieldMap: [keyof MaintenanceWindow, string, boolean][] = [
-			["active", "active", false],
-			["name", "name", false],
-			["duration", "duration", false],
-			["durationUnit", "duration_unit", false],
-			["repeat", "repeat", false],
-			["start", "start_time", true],
-			["end", "end_time", true],
-		];
-
-		for (const [key, column, isDate] of fieldMap) {
-			if (patch[key] !== undefined) {
-				sets.push(`${column} = $${paramIndex++}`);
-				values.push(isDate ? new Date(patch[key] as string) : patch[key]);
-			}
-		}
-
-		if (sets.length === 0) {
-			return this.findById(id, teamId);
-		}
-
-		sets.push(`updated_at = NOW()`);
-		values.push(id, teamId);
-
-		const result = await this.pool.query<MaintenanceWindowRow>(
-			`UPDATE maintenance_windows SET ${sets.join(", ")} WHERE id = $${paramIndex++} AND team_id = $${paramIndex}
-			 RETURNING ${COLUMNS}`,
-			values
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Maintenance window not found or could not be updated", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteById = async (id: string, teamId: string): Promise<MaintenanceWindow> => {
-		const result = await this.pool.query<MaintenanceWindowRow>(
-			`DELETE FROM maintenance_windows WHERE id = $1 AND team_id = $2 RETURNING ${COLUMNS}`,
-			[id, teamId]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Maintenance window not found or could not be deleted", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	countByTeamId = async (teamId: string, active?: boolean): Promise<number> => {
-		const conditions: string[] = ["team_id = $1"];
-		const values: unknown[] = [teamId];
-
-		if (active !== undefined) {
-			conditions.push(`active = $2`);
-			values.push(active);
-		}
-
-		const result = await this.pool.query(`SELECT COUNT(*)::int AS count FROM maintenance_windows WHERE ${conditions.join(" AND ")}`, values);
-		return result.rows[0].count;
-	};
-
-	private toEntity = (row: MaintenanceWindowRow): MaintenanceWindow => ({
-		id: row.id,
-		monitorId: row.monitor_id,
-		teamId: row.team_id,
-		active: row.active,
-		name: row.name,
-		duration: row.duration,
-		durationUnit: row.duration_unit,
-		repeat: row.repeat,
-		start: row.start_time.toISOString(),
-		end: row.end_time.toISOString(),
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/monitor-stats/TimescaleMonitorStatsRepository.ts

@@ -1,140 +0,0 @@
-import type { Pool } from "pg";
-import type { IMonitorStatsRepository } from "./IMonitorStatsRepository.js";
-import type { MonitorStats } from "@/types/monitorStats.js";
-import { AppError } from "@/utils/AppError.js";
-
-interface MonitorStatsRow {
-	id: string;
-	monitor_id: string;
-	avg_response_time: number;
-	max_response_time: number;
-	total_checks: number;
-	total_up_checks: number;
-	total_down_checks: number;
-	uptime_percentage: number;
-	last_check_timestamp: Date | null;
-	last_response_time: number;
-	time_of_last_failure: Date | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, monitor_id, avg_response_time, max_response_time, total_checks, total_up_checks,
-	total_down_checks, uptime_percentage, last_check_timestamp, last_response_time, time_of_last_failure,
-	created_at, updated_at`;
-
-export class TimescaleMonitorStatsRepository implements IMonitorStatsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (data: Omit<MonitorStats, "id" | "createdAt" | "updatedAt">): Promise<MonitorStats> => {
-		const result = await this.pool.query<MonitorStatsRow>(
-			`INSERT INTO monitor_stats (monitor_id, avg_response_time, max_response_time, total_checks, total_up_checks,
-				total_down_checks, uptime_percentage, last_check_timestamp, last_response_time, time_of_last_failure)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
-			 RETURNING ${COLUMNS}`,
-			[
-				data.monitorId,
-				data.avgResponseTime,
-				data.maxResponseTime,
-				data.totalChecks,
-				data.totalUpChecks,
-				data.totalDownChecks,
-				data.uptimePercentage,
-				data.lastCheckTimestamp ? new Date(data.lastCheckTimestamp) : null,
-				data.lastResponseTime,
-				data.timeOfLastFailure ? new Date(data.timeOfLastFailure) : null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create monitor stats", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findByMonitorId = async (monitorId: string): Promise<MonitorStats> => {
-		const result = await this.pool.query<MonitorStatsRow>(`SELECT ${COLUMNS} FROM monitor_stats WHERE monitor_id = $1`, [monitorId]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Monitor stats not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	updateByMonitorId = async (monitorId: string, data: Omit<MonitorStats, "id" | "monitorId" | "createdAt" | "updatedAt">): Promise<MonitorStats> => {
-		const result = await this.pool.query<MonitorStatsRow>(
-			`UPDATE monitor_stats SET
-				avg_response_time = $2,
-				max_response_time = $3,
-				total_checks = $4,
-				total_up_checks = $5,
-				total_down_checks = $6,
-				uptime_percentage = $7,
-				last_check_timestamp = $8,
-				last_response_time = $9,
-				time_of_last_failure = $10,
-				updated_at = NOW()
-			 WHERE monitor_id = $1
-			 RETURNING ${COLUMNS}`,
-			[
-				monitorId,
-				data.avgResponseTime,
-				data.maxResponseTime,
-				data.totalChecks,
-				data.totalUpChecks,
-				data.totalDownChecks,
-				data.uptimePercentage,
-				data.lastCheckTimestamp ? new Date(data.lastCheckTimestamp) : null,
-				data.lastResponseTime,
-				data.timeOfLastFailure ? new Date(data.timeOfLastFailure) : null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Monitor stats not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteByMonitorId = async (monitorId: string): Promise<MonitorStats> => {
-		const result = await this.pool.query<MonitorStatsRow>(`DELETE FROM monitor_stats WHERE monitor_id = $1 RETURNING ${COLUMNS}`, [monitorId]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Monitor stats not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteByMonitorIds = async (monitorIds: string[]): Promise<number> => {
-		if (!monitorIds.length) {
-			return 0;
-		}
-		const result = await this.pool.query(`DELETE FROM monitor_stats WHERE monitor_id = ANY($1)`, [monitorIds]);
-		return result.rowCount ?? 0;
-	};
-
-	deleteByMonitorIdsNotIn = async (monitorIds: string[]): Promise<number> => {
-		if (!monitorIds.length) {
-			const result = await this.pool.query(`DELETE FROM monitor_stats`);
-			return result.rowCount ?? 0;
-		}
-		const result = await this.pool.query(`DELETE FROM monitor_stats WHERE monitor_id != ALL($1)`, [monitorIds]);
-		return result.rowCount ?? 0;
-	};
-
-	private toEntity = (row: MonitorStatsRow): MonitorStats => ({
-		id: row.id,
-		monitorId: row.monitor_id,
-		avgResponseTime: row.avg_response_time,
-		maxResponseTime: row.max_response_time,
-		totalChecks: Number(row.total_checks),
-		totalUpChecks: Number(row.total_up_checks),
-		totalDownChecks: Number(row.total_down_checks),
-		uptimePercentage: row.uptime_percentage,
-		lastCheckTimestamp: row.last_check_timestamp ? row.last_check_timestamp.getTime() : 0,
-		lastResponseTime: row.last_response_time,
-		timeOfLastFailure: row.time_of_last_failure ? row.time_of_last_failure.getTime() : undefined,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/monitors/IMonitorsRepository.ts

@@ -41,7 +41,6 @@ export interface IMonitorsRepository {
 	findMonitorsSummaryByTeamId(teamId: string, config?: SummaryConfig): Promise<MonitorsSummary>;
 	findGroupsByTeamId(teamId: string): Promise<string[]>;
 	removeNotificationFromMonitors(notificationId: string): Promise<void>;
-	updateNotifications(teamId: string, monitorIds: string[], notificationIds: string[], action: "add" | "remove" | "set"): Promise<number>;
 	deleteByTeamIdsNotIn(teamIds: string[]): Promise<number>;
 	findAllMonitorIds(): Promise<string[]>;
 }

server/src/repositories/monitors/MongoMonitorsRepository.ts

@@ -1,9 +1,8 @@
 import { MonitorModel } from "@/db/models/index.js";
 import type { MonitorDocument, CheckSnapshotDocument } from "@/db/models/index.js";
-import type { Monitor, MonitorsSummary, CheckSnapshot } from "@/types/index.js";
+import type { Monitor, MonitorsSummary, CheckSnapshot, Check } from "@/types/index.js";
 import mongoose, { type FilterQuery, type PipelineStage } from "mongoose";
 import type { IMonitorsRepository, TeamQueryConfig, SummaryConfig } from "./IMonitorsRepository.js";
-import { MongoBulkWriteError } from "mongodb";
 import { AppError } from "@/utils/AppError.js";
 
 class MongoMonitorsRepository implements IMonitorsRepository {
@@ -21,9 +20,12 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 		try {
 			const inserted = await MonitorModel.insertMany(payload, { ordered: false });
 			return this.mapDocuments(inserted);
-		} catch (error: unknown) {
-			if (error instanceof MongoBulkWriteError && "insertedDocs" in error && Array.isArray(error.insertedDocs) && error.insertedDocs.length > 0) {
-				return this.mapDocuments(error.insertedDocs);
+		} catch (error: any) {
+			if (error.name === "MongoBulkWriteError" || error.name === "BulkWriteError") {
+				const insertedDocs = error.insertedDocs || [];
+				if (insertedDocs.length > 0) {
+					return this.mapDocuments(insertedDocs);
+				}
 			}
 			throw error;
 		}
@@ -44,7 +46,7 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 	};
 
 	findByTeamId = async (teamId: string, config: TeamQueryConfig): Promise<Monitor[] | null> => {
-		const { page = 0, rowsPerPage = 0, filter, field = "createdAt", order = "desc", type } = config ?? {};
+		const { page = 0, rowsPerPage = 0, filter, field = "createdAt", order = "desc", type, limit } = config ?? {};
 
 		const query: Record<string, unknown> = {
 			teamId: new mongoose.Types.ObjectId(teamId),
@@ -296,41 +298,6 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 		await MonitorModel.updateMany({ notifications: notificationId }, { $pull: { notifications: notificationId } });
 	};
 
-	updateNotifications = async (
-		teamId: string,
-		monitorIds: string[],
-		notificationIds: string[],
-		action: "add" | "remove" | "set"
-	): Promise<number> => {
-		let objectIds;
-		let notificationObjectIds;
-		try {
-			objectIds = monitorIds.map((id) => new mongoose.Types.ObjectId(id));
-			notificationObjectIds = notificationIds.map((id) => new mongoose.Types.ObjectId(id));
-		} catch {
-			throw new AppError({ message: "One or more monitor or notification IDs are invalid", status: 400 });
-		}
-		const filter = { _id: { $in: objectIds }, teamId: new mongoose.Types.ObjectId(teamId) };
-
-		let update;
-		switch (action) {
-			case "add":
-				update = { $addToSet: { notifications: { $each: notificationObjectIds } } };
-				break;
-			case "remove":
-				update = { $pull: { notifications: { $in: notificationObjectIds } } };
-				break;
-			case "set":
-				update = { $set: { notifications: notificationObjectIds } };
-				break;
-			default:
-				throw new AppError({ message: `Invalid action: ${action}`, status: 400 });
-		}
-
-		const result = await MonitorModel.updateMany(filter, update);
-		return result.modifiedCount;
-	};
-
 	private mapDocuments = (documents: MonitorDocument[]): Monitor[] => {
 		if (!documents?.length) {
 			return [];
@@ -387,7 +354,7 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 			gameId: doc.gameId ?? undefined,
 			grpcServiceName: doc.grpcServiceName ?? undefined,
 			group: doc.group ?? null,
-			recentChecks: (doc.recentChecks ?? []).map((check: CheckSnapshotDocument) => this.toCheckSnapshot(check)),
+			recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)),
 			geoCheckEnabled: doc.geoCheckEnabled ?? false,
 			geoCheckLocations: doc.geoCheckLocations ?? [],
 			geoCheckInterval: doc.geoCheckInterval ?? 300000,
@@ -396,7 +363,7 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 		};
 	};
 
-	private toEntityWithChecks = (doc: MonitorDocument): Monitor => {
+	private toEntityWithChecks = (doc: any): Monitor => {
 		const toStringId = (value: unknown): string => {
 			if (value instanceof mongoose.Types.ObjectId) {
 				return value.toString();
@@ -446,7 +413,7 @@ class MongoMonitorsRepository implements IMonitorsRepository {
 			gameId: doc.gameId ?? undefined,
 			grpcServiceName: doc.grpcServiceName ?? undefined,
 			group: doc.group ?? null,
-			recentChecks: (doc.recentChecks ?? []).map((check: CheckSnapshotDocument) => this.toCheckSnapshot(check)),
+			recentChecks: (doc.recentChecks ?? []).map((check: any) => this.toCheckSnapshot(check)),
 			geoCheckEnabled: doc.geoCheckEnabled ?? false,
 			geoCheckLocations: doc.geoCheckLocations ?? [],
 			geoCheckInterval: doc.geoCheckInterval ?? 300000,

server/src/repositories/notifications/TimescaleNotificationsRepository.ts

@@ -1,140 +0,0 @@
-import type { Pool } from "pg";
-import { INotificationsRepository } from "@/repositories/notifications/INotificationsRepository.js";
-import type { Notification, NotificationChannel } from "@/types/notification.js";
-import { AppError } from "@/utils/AppError.js";
-
-interface NotificationRow {
-	id: string;
-	user_id: string;
-	team_id: string;
-	type: NotificationChannel;
-	notification_name: string;
-	address: string | null;
-	phone: string | null;
-	homeserver_url: string | null;
-	room_id: string | null;
-	access_token: string | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, user_id, team_id, type, notification_name, address, phone,
-	homeserver_url, room_id, access_token, created_at, updated_at`;
-
-export class TimescaleNotificationsRepository implements INotificationsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (data: Partial<Notification>): Promise<Notification> => {
-		const result = await this.pool.query<NotificationRow>(
-			`INSERT INTO notifications (user_id, team_id, type, notification_name, address, phone, homeserver_url, room_id, access_token)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)
-			 RETURNING ${COLUMNS}`,
-			[
-				data.userId,
-				data.teamId,
-				data.type,
-				data.notificationName,
-				data.address ?? null,
-				data.phone ?? null,
-				data.homeserverUrl ?? null,
-				data.roomId ?? null,
-				data.accessToken ?? null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create notification", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findById = async (id: string, teamId: string): Promise<Notification> => {
-		const result = await this.pool.query<NotificationRow>(`SELECT ${COLUMNS} FROM notifications WHERE id = $1 AND team_id = $2`, [id, teamId]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Notification not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findNotificationsByIds = async (ids: string[]): Promise<Notification[]> => {
-		if (!ids.length) {
-			return [];
-		}
-		const result = await this.pool.query<NotificationRow>(`SELECT ${COLUMNS} FROM notifications WHERE id = ANY($1)`, [ids]);
-		return result.rows.map(this.toEntity);
-	};
-
-	findByTeamId = async (teamId: string): Promise<Notification[]> => {
-		const result = await this.pool.query<NotificationRow>(`SELECT ${COLUMNS} FROM notifications WHERE team_id = $1`, [teamId]);
-		return result.rows.map(this.toEntity);
-	};
-
-	updateById = async (id: string, teamId: string, patch: Partial<Notification>): Promise<Notification> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		const fieldMap: [keyof Notification, string][] = [
-			["type", "type"],
-			["notificationName", "notification_name"],
-			["address", "address"],
-			["phone", "phone"],
-			["homeserverUrl", "homeserver_url"],
-			["roomId", "room_id"],
-			["accessToken", "access_token"],
-		];
-
-		for (const [key, column] of fieldMap) {
-			if (patch[key] !== undefined) {
-				sets.push(`${column} = $${paramIndex++}`);
-				values.push(patch[key]);
-			}
-		}
-
-		if (sets.length === 0) {
-			return this.findById(id, teamId);
-		}
-
-		sets.push(`updated_at = NOW()`);
-		values.push(id, teamId);
-
-		const result = await this.pool.query<NotificationRow>(
-			`UPDATE notifications SET ${sets.join(", ")} WHERE id = $${paramIndex++} AND team_id = $${paramIndex}
-			 RETURNING ${COLUMNS}`,
-			values
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Notification not found or could not be updated", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteById = async (id: string, teamId: string): Promise<Notification> => {
-		const result = await this.pool.query<NotificationRow>(`DELETE FROM notifications WHERE id = $1 AND team_id = $2 RETURNING ${COLUMNS}`, [
-			id,
-			teamId,
-		]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Notification not found or could not be deleted", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	private toEntity = (row: NotificationRow): Notification => ({
-		id: row.id,
-		userId: row.user_id,
-		teamId: row.team_id,
-		type: row.type,
-		notificationName: row.notification_name,
-		address: row.address ?? undefined,
-		phone: row.phone ?? undefined,
-		homeserverUrl: row.homeserver_url ?? undefined,
-		roomId: row.room_id ?? undefined,
-		accessToken: row.access_token ?? undefined,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/recovery-tokens/TimescaleRecoveryTokensRepository.ts

@@ -1,59 +0,0 @@
-import type { Pool } from "pg";
-import crypto from "crypto";
-import type { IRecoveryTokensRepository } from "./IRecoveryTokensRepository.js";
-import type { RecoveryToken } from "@/types/recoveryToken.js";
-import { AppError } from "@/utils/AppError.js";
-
-interface RecoveryTokenRow {
-	id: string;
-	email: string;
-	token: string;
-	expiry: Date | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, email, token, expiry, created_at, updated_at`;
-
-export class TimescaleRecoveryTokensRepository implements IRecoveryTokensRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (email: string): Promise<RecoveryToken> => {
-		const token = crypto.randomBytes(32).toString("hex");
-		const result = await this.pool.query<RecoveryTokenRow>(
-			`INSERT INTO recovery_tokens (email, token)
-			 VALUES ($1, $2)
-			 ON CONFLICT (email) DO UPDATE SET token = $2, updated_at = NOW()
-			 RETURNING ${COLUMNS}`,
-			[email, token]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create recovery token", status: 500 });
-		}
-		return this.toEntity(row);
-	};
-
-	findByToken = async (token: string): Promise<RecoveryToken> => {
-		const result = await this.pool.query<RecoveryTokenRow>(`SELECT ${COLUMNS} FROM recovery_tokens WHERE token = $1`, [token]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Recovery token not found", status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteManyByEmail = async (email: string): Promise<number> => {
-		const result = await this.pool.query(`DELETE FROM recovery_tokens WHERE email = $1`, [email]);
-		return result.rowCount ?? 0;
-	};
-
-	private toEntity = (row: RecoveryTokenRow): RecoveryToken => ({
-		id: row.id,
-		email: row.email,
-		token: row.token,
-		expiry: row.expiry ? row.expiry.toISOString() : new Date(0).toISOString(),
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/settings/ISettingsRepository.ts

@@ -1,11 +1,11 @@
-import type { Settings, SettingsUpdate } from "@/types/index.js";
+import type { Settings } from "@/types/index.js";
 export interface ISettingsRepository {
 	// create
 	create(settings: Partial<Settings>): Promise<Settings>;
 	// fetch
 	findSingleton(): Promise<Settings | null>;
 	// update
-	update(settings: SettingsUpdate): Promise<Settings>;
+	update(settings: Partial<Settings>): Promise<Settings>;
 	// delete
 	deleteLegacy: () => Promise<boolean>;
 }

server/src/repositories/settings/MongoSettingsRepository.ts

@@ -1,6 +1,6 @@
-import mongoose, { type UpdateQuery } from "mongoose";
+import mongoose from "mongoose";
 import { ISettingsRepository } from "@/repositories/settings/ISettingsRepository.js";
-import type { Settings, SettingsUpdate } from "@/types/index.js";
+import type { Settings } from "@/types/index.js";
 import { AppSettingsModel, type AppSettingsDocument } from "@/db/models/index.js";
 
 class MongoSettingsRepository implements ISettingsRepository {
@@ -59,23 +59,27 @@ class MongoSettingsRepository implements ISettingsRepository {
 		return this.toEntity(settings);
 	};
 
-	update = async (settings: SettingsUpdate) => {
-		const $set: Record<string, unknown> = {};
-		const $unset: Record<string, string> = {};
+	update = async (settings: Partial<Settings>) => {
+		const update: Record<string, any> = { $set: {}, $unset: {} };
 
 		// Iterate through settings and separate into $set and $unset
 		Object.entries(settings).forEach(([key, value]) => {
-			if (value === undefined || value === null) {
-				$unset[key] = "";
+			if (value === undefined || value === "") {
+				// Unset undefined or empty string values
+				update.$unset[key] = "";
 			} else {
-				$set[key] = value;
+				// Set defined values
+				update.$set[key] = value;
 			}
 		});
 
-		const update: UpdateQuery<AppSettingsDocument> = {
-			...(Object.keys($set).length > 0 && { $set }),
-			...(Object.keys($unset).length > 0 && { $unset }),
-		};
+		// Clean up empty operators
+		if (Object.keys(update.$set).length === 0) {
+			delete update.$set;
+		}
+		if (Object.keys(update.$unset).length === 0) {
+			delete update.$unset;
+		}
 
 		await AppSettingsModel.findOneAndUpdate({}, update, {
 			upsert: true,

server/src/repositories/settings/TimescaleSettingsRepository.ts

@@ -1,217 +0,0 @@
-import type { Pool } from "pg";
-import type { ISettingsRepository } from "./ISettingsRepository.js";
-import type { Settings, SettingsUpdate } from "@/types/settings.js";
-
-interface SettingsRow {
-	id: string;
-	check_ttl: number;
-	language: string | null;
-	jwt_secret: string | null;
-	pagespeed_api_key: string | null;
-	system_email_host: string | null;
-	system_email_port: number | null;
-	system_email_address: string | null;
-	system_email_password: string | null;
-	system_email_user: string | null;
-	system_email_connection_host: string | null;
-	system_email_tls_servername: string | null;
-	system_email_secure: boolean | null;
-	system_email_pool: boolean | null;
-	system_email_ignore_tls: boolean | null;
-	system_email_require_tls: boolean | null;
-	system_email_reject_unauthorized: boolean | null;
-	show_url: boolean | null;
-	version: string | null;
-	threshold_cpu_usage: number | null;
-	threshold_memory_usage: number | null;
-	threshold_disk_usage: number | null;
-	threshold_temperature: number | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, check_ttl, language, jwt_secret, pagespeed_api_key,
-	system_email_host, system_email_port, system_email_address, system_email_password, system_email_user,
-	system_email_connection_host, system_email_tls_servername, system_email_secure, system_email_pool,
-	system_email_ignore_tls, system_email_require_tls, system_email_reject_unauthorized,
-	show_url, version, threshold_cpu_usage, threshold_memory_usage, threshold_disk_usage, threshold_temperature,
-	created_at, updated_at`;
-
-export class TimescaleSettingsRepository implements ISettingsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (settings: Partial<Settings>): Promise<Settings> => {
-		const result = await this.pool.query<SettingsRow>(
-			`INSERT INTO app_settings (check_ttl, language, jwt_secret, pagespeed_api_key,
-				system_email_host, system_email_port, system_email_address, system_email_password, system_email_user,
-				system_email_connection_host, system_email_tls_servername, system_email_secure, system_email_pool,
-				system_email_ignore_tls, system_email_require_tls, system_email_reject_unauthorized,
-				show_url, version, threshold_cpu_usage, threshold_memory_usage, threshold_disk_usage, threshold_temperature)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21,$22)
-			 RETURNING ${COLUMNS}`,
-			[
-				settings.checkTTL ?? 30,
-				settings.language ?? null,
-				settings.jwtSecret ?? null,
-				settings.pagespeedApiKey ?? null,
-				settings.systemEmailHost ?? null,
-				settings.systemEmailPort ?? null,
-				settings.systemEmailAddress ?? null,
-				settings.systemEmailPassword ?? null,
-				settings.systemEmailUser ?? null,
-				settings.systemEmailConnectionHost ?? null,
-				settings.systemEmailTLSServername ?? null,
-				settings.systemEmailSecure ?? false,
-				settings.systemEmailPool ?? false,
-				settings.systemEmailIgnoreTLS ?? false,
-				settings.systemEmailRequireTLS ?? false,
-				settings.systemEmailRejectUnauthorized ?? true,
-				settings.showURL ?? false,
-				settings.version ?? 1,
-				settings.globalThresholds?.cpu ?? null,
-				settings.globalThresholds?.memory ?? null,
-				settings.globalThresholds?.disk ?? null,
-				settings.globalThresholds?.temperature ?? null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new Error("Failed to create app settings");
-		}
-		return this.toEntity(row);
-	};
-
-	findSingleton = async (): Promise<Settings | null> => {
-		const result = await this.pool.query<SettingsRow>(`SELECT ${COLUMNS} FROM app_settings LIMIT 1`);
-		const row = result.rows[0];
-		if (!row) {
-			return null;
-		}
-		return this.toEntity(row);
-	};
-
-	update = async (settings: SettingsUpdate): Promise<Settings> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		const fieldMap: [keyof SettingsUpdate, string][] = [
-			["checkTTL", "check_ttl"],
-			["language", "language"],
-			["jwtSecret", "jwt_secret"],
-			["pagespeedApiKey", "pagespeed_api_key"],
-			["systemEmailHost", "system_email_host"],
-			["systemEmailPort", "system_email_port"],
-			["systemEmailAddress", "system_email_address"],
-			["systemEmailPassword", "system_email_password"],
-			["systemEmailUser", "system_email_user"],
-			["systemEmailConnectionHost", "system_email_connection_host"],
-			["systemEmailTLSServername", "system_email_tls_servername"],
-			["systemEmailSecure", "system_email_secure"],
-			["systemEmailPool", "system_email_pool"],
-			["systemEmailIgnoreTLS", "system_email_ignore_tls"],
-			["systemEmailRequireTLS", "system_email_require_tls"],
-			["systemEmailRejectUnauthorized", "system_email_reject_unauthorized"],
-			["showURL", "show_url"],
-			["version", "version"],
-		];
-
-		for (const [key, column] of fieldMap) {
-			if (key in settings) {
-				sets.push(`${column} = $${paramIndex++}`);
-				// null means unset the field
-				values.push(settings[key] ?? null);
-			}
-		}
-
-		// Handle globalThresholds
-		if ("globalThresholds" in settings) {
-			const thresholds = settings.globalThresholds;
-			if (thresholds === null || thresholds === undefined) {
-				sets.push(`threshold_cpu_usage = NULL`);
-				sets.push(`threshold_memory_usage = NULL`);
-				sets.push(`threshold_disk_usage = NULL`);
-				sets.push(`threshold_temperature = NULL`);
-			} else {
-				if ("cpu" in thresholds) {
-					sets.push(`threshold_cpu_usage = $${paramIndex++}`);
-					values.push(thresholds.cpu ?? null);
-				}
-				if ("memory" in thresholds) {
-					sets.push(`threshold_memory_usage = $${paramIndex++}`);
-					values.push(thresholds.memory ?? null);
-				}
-				if ("disk" in thresholds) {
-					sets.push(`threshold_disk_usage = $${paramIndex++}`);
-					values.push(thresholds.disk ?? null);
-				}
-				if ("temperature" in thresholds) {
-					sets.push(`threshold_temperature = $${paramIndex++}`);
-					values.push(thresholds.temperature ?? null);
-				}
-			}
-		}
-
-		if (sets.length === 0) {
-			const existing = await this.findSingleton();
-			if (!existing) {
-				throw new Error("App settings not found");
-			}
-			return existing;
-		}
-
-		sets.push(`updated_at = NOW()`);
-
-		// Upsert: update the single row, or insert if none exists
-		const result = await this.pool.query<SettingsRow>(`UPDATE app_settings SET ${sets.join(", ")} RETURNING ${COLUMNS}`, values);
-		const row = result.rows[0];
-		if (!row) {
-			// No row existed, create one
-			return this.create(settings as Partial<Settings>);
-		}
-		return this.toEntity(row);
-	};
-
-	deleteLegacy = async (): Promise<boolean> => {
-		// No legacy rows in TimescaleDB — singleton is enforced by trigger
-		const result = await this.pool.query(`DELETE FROM app_settings WHERE version IS NULL`);
-		return (result.rowCount ?? 0) > 0;
-	};
-
-	private toEntity = (row: SettingsRow): Settings => ({
-		id: row.id,
-		checkTTL: row.check_ttl,
-		language: row.language ?? "",
-		jwtSecret: row.jwt_secret ?? undefined,
-		pagespeedApiKey: row.pagespeed_api_key ?? undefined,
-		systemEmailHost: row.system_email_host ?? undefined,
-		systemEmailPort: row.system_email_port ?? undefined,
-		systemEmailAddress: row.system_email_address ?? undefined,
-		systemEmailPassword: row.system_email_password ?? undefined,
-		systemEmailUser: row.system_email_user ?? undefined,
-		systemEmailConnectionHost: row.system_email_connection_host ?? undefined,
-		systemEmailTLSServername: row.system_email_tls_servername ?? undefined,
-		systemEmailSecure: row.system_email_secure ?? false,
-		systemEmailPool: row.system_email_pool ?? false,
-		systemEmailIgnoreTLS: row.system_email_ignore_tls ?? false,
-		systemEmailRequireTLS: row.system_email_require_tls ?? false,
-		systemEmailRejectUnauthorized: row.system_email_reject_unauthorized ?? true,
-		showURL: row.show_url ?? false,
-		singleton: true,
-		version: Number(row.version ?? 1),
-		globalThresholds:
-			row.threshold_cpu_usage !== null ||
-			row.threshold_memory_usage !== null ||
-			row.threshold_disk_usage !== null ||
-			row.threshold_temperature !== null
-				? {
-						cpu: row.threshold_cpu_usage ?? undefined,
-						memory: row.threshold_memory_usage ?? undefined,
-						disk: row.threshold_disk_usage ?? undefined,
-						temperature: row.threshold_temperature ?? undefined,
-					}
-				: undefined,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/status-pages/MongoStatusPagesRepository.ts

@@ -72,8 +72,7 @@ class MongoStatusPagesRepository implements IStatusPagesRepository {
 	};
 
 	create = async (userId: string, teamId: string, image: Express.Multer.File | undefined, data: Partial<StatusPage>): Promise<StatusPage> => {
-		const { logo, ...restData } = data;
-		void logo;
+		const { logo: _logo, ...restData } = data;
 		const statusPage = new StatusPageModel({
 			...restData,
 			userId,
@@ -111,8 +110,7 @@ class MongoStatusPagesRepository implements IStatusPagesRepository {
 		image: Express.Multer.File | undefined,
 		patch: Partial<StatusPage> & { removeLogo?: string }
 	): Promise<StatusPage> => {
-		const { logo, removeLogo, ...restPatch } = patch;
-		void logo;
+		const { logo: _logo, removeLogo, ...restPatch } = patch;
 		const updateData: StatusPageUpdateData = { ...restPatch };
 		if (image) {
 			updateData.logo = {

server/src/repositories/status-pages/TimescaleStatusPagesRepository.ts

@@ -1,260 +0,0 @@
-import type { Pool } from "pg";
-import type { IStatusPagesRepository } from "./IStatusPagesRepository.js";
-import type { StatusPage, StatusPageType } from "@/types/statusPage.js";
-import { AppError } from "@/utils/AppError.js";
-
-const parsePostgresArray = (value: unknown): StatusPageType[] => {
-	if (typeof value !== "string") return [];
-	const inner = value.replace(/^\{|\}$/g, "");
-	if (inner === "") return [];
-	return inner.split(",") as StatusPageType[];
-};
-
-interface StatusPageRow {
-	id: string;
-	user_id: string;
-	team_id: string;
-	types: StatusPageType[];
-	company_name: string;
-	url: string;
-	timezone: string | null;
-	color: string;
-	logo_data: Buffer | null;
-	logo_content_type: string | null;
-	is_published: boolean;
-	show_charts: boolean;
-	show_uptime_percentage: boolean;
-	show_admin_login_link: boolean;
-	show_infrastructure: boolean;
-	custom_css: string | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-const COLUMNS = `id, user_id, team_id, types, company_name, url, timezone, color,
-	logo_data, logo_content_type, is_published, show_charts, show_uptime_percentage,
-	show_admin_login_link, show_infrastructure, custom_css, created_at, updated_at`;
-
-export class TimescaleStatusPagesRepository implements IStatusPagesRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (userId: string, teamId: string, image: Express.Multer.File | undefined, data: Partial<StatusPage>): Promise<StatusPage> => {
-		const result = await this.pool.query<StatusPageRow>(
-			`INSERT INTO status_pages (user_id, team_id, types, company_name, url, timezone, color,
-				logo_data, logo_content_type, is_published, show_charts, show_uptime_percentage,
-				show_admin_login_link, show_infrastructure, custom_css)
-			 VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15)
-			 RETURNING ${COLUMNS}`,
-			[
-				userId,
-				teamId,
-				data.type ?? ["uptime"],
-				data.companyName ?? "",
-				data.url ?? "",
-				data.timezone ?? null,
-				data.color ?? "#4169E1",
-				image?.buffer ?? null,
-				image?.mimetype ?? null,
-				data.isPublished ?? false,
-				data.showCharts ?? false,
-				data.showUptimePercentage ?? false,
-				data.showAdminLoginLink ?? false,
-				data.showInfrastructure ?? false,
-				data.customCSS ?? null,
-			]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create status page", status: 500 });
-		}
-
-		// Insert monitor associations
-		if (data.monitors?.length) {
-			for (const [i, monitorId] of data.monitors.entries()) {
-				await this.pool.query(
-					`INSERT INTO status_page_monitors (status_page_id, monitor_id, sort_order) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
-					[row.id, monitorId, i]
-				);
-			}
-		}
-		if (data.subMonitors?.length) {
-			for (const [i, monitorId] of data.subMonitors.entries()) {
-				await this.pool.query(
-					`INSERT INTO status_page_sub_monitors (status_page_id, monitor_id, sort_order) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
-					[row.id, monitorId, i]
-				);
-			}
-		}
-
-		return this.loadEntity(row);
-	};
-
-	findByUrl = async (url: string): Promise<StatusPage> => {
-		const result = await this.pool.query<StatusPageRow>(`SELECT ${COLUMNS} FROM status_pages WHERE url = $1`, [url]);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Status page not found", status: 404 });
-		}
-		return this.loadEntity(row);
-	};
-
-	findByTeamId = async (teamId: string): Promise<StatusPage[]> => {
-		const result = await this.pool.query<StatusPageRow>(`SELECT ${COLUMNS} FROM status_pages WHERE team_id = $1`, [teamId]);
-		const pages: StatusPage[] = [];
-		for (const row of result.rows) {
-			pages.push(await this.loadEntity(row));
-		}
-		return pages;
-	};
-
-	updateById = async (
-		id: string,
-		teamId: string,
-		image: Express.Multer.File | undefined,
-		patch: Partial<StatusPage> & { removeLogo?: string }
-	): Promise<StatusPage> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		const fieldMap: [keyof StatusPage, string][] = [
-			["type", "types"],
-			["companyName", "company_name"],
-			["url", "url"],
-			["timezone", "timezone"],
-			["color", "color"],
-			["isPublished", "is_published"],
-			["showCharts", "show_charts"],
-			["showUptimePercentage", "show_uptime_percentage"],
-			["showAdminLoginLink", "show_admin_login_link"],
-			["showInfrastructure", "show_infrastructure"],
-			["customCSS", "custom_css"],
-		];
-
-		for (const [key, column] of fieldMap) {
-			if (patch[key] !== undefined) {
-				sets.push(`${column} = $${paramIndex++}`);
-				values.push(patch[key]);
-			}
-		}
-
-		if (image) {
-			sets.push(`logo_data = $${paramIndex++}`);
-			values.push(image.buffer);
-			sets.push(`logo_content_type = $${paramIndex++}`);
-			values.push(image.mimetype);
-		} else if (patch.removeLogo === "true") {
-			sets.push(`logo_data = NULL`);
-			sets.push(`logo_content_type = NULL`);
-		}
-
-		if (sets.length > 0) {
-			sets.push(`updated_at = NOW()`);
-			values.push(id, teamId);
-
-			const result = await this.pool.query<StatusPageRow>(
-				`UPDATE status_pages SET ${sets.join(", ")} WHERE id = $${paramIndex++} AND team_id = $${paramIndex}
-				 RETURNING ${COLUMNS}`,
-				values
-			);
-			const row = result.rows[0];
-			if (!row) {
-				throw new AppError({ message: "Status page not found", status: 404 });
-			}
-		}
-
-		// Update monitor associations if provided
-		if (patch.monitors !== undefined) {
-			await this.pool.query(`DELETE FROM status_page_monitors WHERE status_page_id = $1`, [id]);
-			for (const [i, monitorId] of patch.monitors.entries()) {
-				await this.pool.query(
-					`INSERT INTO status_page_monitors (status_page_id, monitor_id, sort_order) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
-					[id, monitorId, i]
-				);
-			}
-		}
-		if (patch.subMonitors !== undefined) {
-			await this.pool.query(`DELETE FROM status_page_sub_monitors WHERE status_page_id = $1`, [id]);
-			for (const [i, monitorId] of patch.subMonitors.entries()) {
-				await this.pool.query(
-					`INSERT INTO status_page_sub_monitors (status_page_id, monitor_id, sort_order) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`,
-					[id, monitorId, i]
-				);
-			}
-		}
-
-		// Re-fetch to return full entity
-		const freshResult = await this.pool.query<StatusPageRow>(`SELECT ${COLUMNS} FROM status_pages WHERE id = $1 AND team_id = $2`, [id, teamId]);
-		const freshRow = freshResult.rows[0];
-		if (!freshRow) {
-			throw new AppError({ message: "Status page not found", status: 404 });
-		}
-		return this.loadEntity(freshRow);
-	};
-
-	deleteById = async (id: string, teamId: string): Promise<StatusPage> => {
-		// Load entity before delete (join tables cascade)
-		const existing = await this.pool.query<StatusPageRow>(`SELECT ${COLUMNS} FROM status_pages WHERE id = $1 AND team_id = $2`, [id, teamId]);
-		const row = existing.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Status page not found", status: 404 });
-		}
-		const entity = await this.loadEntity(row);
-
-		await this.pool.query(`DELETE FROM status_pages WHERE id = $1 AND team_id = $2`, [id, teamId]);
-		return entity;
-	};
-
-	removeMonitorFromStatusPages = async (monitorId: string): Promise<number> => {
-		// Return count of distinct status pages affected, matching Mongo's modifiedCount
-		const result = await this.pool.query(
-			`SELECT COUNT(DISTINCT status_page_id)::int AS count FROM (
-				SELECT status_page_id FROM status_page_monitors WHERE monitor_id = $1
-				UNION
-				SELECT status_page_id FROM status_page_sub_monitors WHERE monitor_id = $1
-			 ) affected`,
-			[monitorId]
-		);
-		const affectedCount = result.rows[0]?.count ?? 0;
-
-		await this.pool.query(`DELETE FROM status_page_monitors WHERE monitor_id = $1`, [monitorId]);
-		await this.pool.query(`DELETE FROM status_page_sub_monitors WHERE monitor_id = $1`, [monitorId]);
-
-		return affectedCount;
-	};
-
-	private loadEntity = async (row: StatusPageRow): Promise<StatusPage> => {
-		const [monitorsResult, subMonitorsResult] = await Promise.all([
-			this.pool.query(`SELECT monitor_id FROM status_page_monitors WHERE status_page_id = $1 ORDER BY sort_order`, [row.id]),
-			this.pool.query(`SELECT monitor_id FROM status_page_sub_monitors WHERE status_page_id = $1 ORDER BY sort_order`, [row.id]),
-		]);
-
-		return {
-			id: row.id,
-			userId: row.user_id,
-			teamId: row.team_id,
-			type: Array.isArray(row.types) ? row.types : parsePostgresArray(row.types),
-			companyName: row.company_name,
-			url: row.url,
-			timezone: row.timezone ?? undefined,
-			color: row.color,
-			monitors: monitorsResult.rows.map((r) => r.monitor_id),
-			subMonitors: subMonitorsResult.rows.map((r) => r.monitor_id),
-			originalMonitors: [],
-			logo: row.logo_data
-				? {
-						data: row.logo_data.toString("base64"),
-						contentType: row.logo_content_type ?? "",
-					}
-				: undefined,
-			isPublished: row.is_published,
-			showCharts: row.show_charts,
-			showUptimePercentage: row.show_uptime_percentage,
-			showAdminLoginLink: row.show_admin_login_link,
-			showInfrastructure: row.show_infrastructure,
-			customCSS: row.custom_css ?? "",
-			createdAt: row.created_at.toISOString(),
-			updatedAt: row.updated_at.toISOString(),
-		};
-	};
-}

server/src/repositories/teams/TimescaleTeamsRepository.ts

@@ -1,24 +0,0 @@
-import type { Pool } from "pg";
-import { ITeamsRepository } from "@/repositories/teams/ITeamsRepository.js";
-import { Team } from "@/types/team.js";
-
-export class TimescaleTeamsRepository implements ITeamsRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (email: string): Promise<Team> => {
-		const result = await this.pool.query(`INSERT INTO teams (email) VALUES ($1) RETURNING id, email, created_at, updated_at`, [email]);
-		return this.toEntity(result.rows[0]);
-	};
-
-	findAllTeamIds = async (): Promise<string[]> => {
-		const result = await this.pool.query(`SELECT id FROM teams`);
-		return result.rows.map((row) => row.id);
-	};
-
-	private toEntity = (row: { id: string; email: string; created_at: Date; updated_at: Date }): Team => ({
-		id: row.id,
-		email: row.email,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/repositories/users/MongoUsersRepository.ts

@@ -117,7 +117,7 @@ class MongoUsersRepository implements IUsersRepository {
 
 		delete candidateUser.deleteProfileImage;
 
-		const updateQuery: Record<string, unknown> = { $set: candidateUser };
+		const updateQuery: Record<string, any> = { $set: candidateUser };
 		if (unsetFields) {
 			updateQuery.$unset = unsetFields;
 		}

server/src/repositories/users/TimescaleUsersRepository.ts

@@ -1,222 +0,0 @@
-import type { Pool } from "pg";
-import { IUsersRepository } from "./IUsersRepository.js";
-import type { User, UserRole } from "@/types/user.js";
-import { GenerateAvatarImage } from "@/utils/imageProcessing.js";
-import { ParseBoolean } from "@/utils/utils.js";
-import { AppError } from "@/utils/AppError.js";
-
-const SERVICE_NAME = "TimescaleUsersRepository";
-
-// pg returns custom enum arrays as strings like "{user,admin}" — parse to JS array
-const parsePostgresArray = (value: unknown): UserRole[] => {
-	if (typeof value !== "string") return [];
-	const inner = value.replace(/^\{|\}$/g, "");
-	if (inner === "") return [];
-	return inner.split(",") as UserRole[];
-};
-
-interface UserRow {
-	id: string;
-	team_id: string;
-	first_name: string;
-	last_name: string;
-	email: string;
-	password: string;
-	avatar_image: string | null;
-	profile_image: Buffer | null;
-	profile_image_content_type: string | null;
-	is_active: boolean;
-	is_verified: boolean;
-	roles: UserRole[];
-	check_ttl: number | null;
-	created_at: Date;
-	updated_at: Date;
-}
-
-export class TimescaleUsersRepository implements IUsersRepository {
-	constructor(private pool: Pool) {}
-
-	create = async (user: Partial<User>, imageFile?: Express.Multer.File | null): Promise<User> => {
-		let avatarImage: string | undefined;
-		let profileImage: Buffer | undefined;
-		let profileImageContentType: string | undefined;
-
-		if (imageFile) {
-			profileImage = imageFile.buffer;
-			profileImageContentType = imageFile.mimetype;
-			avatarImage = await GenerateAvatarImage(imageFile);
-		}
-
-		const result = await this.pool.query<UserRow>(
-			`INSERT INTO users (team_id, first_name, last_name, email, password, avatar_image, profile_image, profile_image_content_type, is_active, is_verified, roles, check_ttl)
-			 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
-			 RETURNING id, team_id, first_name, last_name, email, password, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at`,
-			[
-				user.teamId || null,
-				user.firstName,
-				user.lastName,
-				user.email,
-				user.password,
-				avatarImage || null,
-				profileImage || null,
-				profileImageContentType || null,
-				user.isActive ?? true,
-				user.isVerified ?? false,
-				user.role ?? ["user"],
-				user.checkTTL ?? null,
-			]
-		);
-
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "Failed to create user", service: SERVICE_NAME, status: 500 });
-		}
-		const entity = this.toEntity(row);
-		entity.password = "";
-		return entity;
-	};
-
-	findByEmail = async (email: string): Promise<User> => {
-		const result = await this.pool.query<UserRow>(
-			`SELECT id, team_id, first_name, last_name, email, password, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at
-			 FROM users WHERE email = $1`,
-			[email]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "User not found", service: SERVICE_NAME, status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findById = async (id: string): Promise<User> => {
-		const result = await this.pool.query<UserRow>(
-			`SELECT id, team_id, first_name, last_name, email, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at
-			 FROM users WHERE id = $1`,
-			[id]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "User not found", service: SERVICE_NAME, status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findAll = async (): Promise<User[]> => {
-		const result = await this.pool.query<UserRow>(
-			`SELECT id, team_id, first_name, last_name, email, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at
-			 FROM users`
-		);
-		return result.rows.map(this.toEntity);
-	};
-
-	updateById = async (id: string, patch: Partial<User & { deleteProfileImage?: boolean }>, file?: Express.Multer.File | null): Promise<User> => {
-		const sets: string[] = [];
-		const values: unknown[] = [];
-		let paramIndex = 1;
-
-		if (ParseBoolean(patch.deleteProfileImage) === true) {
-			sets.push(`profile_image = NULL`);
-			sets.push(`profile_image_content_type = NULL`);
-			sets.push(`avatar_image = NULL`);
-		} else if (file) {
-			const avatarImage = await GenerateAvatarImage(file);
-			sets.push(`profile_image = $${paramIndex++}`);
-			values.push(file.buffer);
-			sets.push(`profile_image_content_type = $${paramIndex++}`);
-			values.push(file.mimetype);
-			sets.push(`avatar_image = $${paramIndex++}`);
-			values.push(avatarImage);
-		}
-
-		if (patch.firstName !== undefined) {
-			sets.push(`first_name = $${paramIndex++}`);
-			values.push(patch.firstName);
-		}
-		if (patch.lastName !== undefined) {
-			sets.push(`last_name = $${paramIndex++}`);
-			values.push(patch.lastName);
-		}
-		if (patch.email !== undefined) {
-			sets.push(`email = $${paramIndex++}`);
-			values.push(patch.email);
-		}
-		if (patch.password !== undefined) {
-			sets.push(`password = $${paramIndex++}`);
-			values.push(patch.password);
-		}
-		if (patch.isActive !== undefined) {
-			sets.push(`is_active = $${paramIndex++}`);
-			values.push(patch.isActive);
-		}
-		if (patch.isVerified !== undefined) {
-			sets.push(`is_verified = $${paramIndex++}`);
-			values.push(patch.isVerified);
-		}
-		if (patch.role !== undefined) {
-			sets.push(`roles = $${paramIndex++}`);
-			values.push(patch.role);
-		}
-		if (patch.teamId !== undefined) {
-			sets.push(`team_id = $${paramIndex++}`);
-			values.push(patch.teamId);
-		}
-		if (patch.checkTTL !== undefined) {
-			sets.push(`check_ttl = $${paramIndex++}`);
-			values.push(patch.checkTTL);
-		}
-
-		if (sets.length === 0) {
-			return this.findById(id);
-		}
-
-		sets.push(`updated_at = NOW()`);
-		values.push(id);
-
-		const result = await this.pool.query<UserRow>(
-			`UPDATE users SET ${sets.join(", ")} WHERE id = $${paramIndex}
-			 RETURNING id, team_id, first_name, last_name, email, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at`,
-			values
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "User not found", service: SERVICE_NAME, status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	deleteById = async (id: string): Promise<User> => {
-		const result = await this.pool.query<UserRow>(
-			`DELETE FROM users WHERE id = $1
-			 RETURNING id, team_id, first_name, last_name, email, password, avatar_image, is_active, is_verified, roles, check_ttl, created_at, updated_at`,
-			[id]
-		);
-		const row = result.rows[0];
-		if (!row) {
-			throw new AppError({ message: "User not found", service: SERVICE_NAME, status: 404 });
-		}
-		return this.toEntity(row);
-	};
-
-	findSuperAdmin = async (): Promise<boolean> => {
-		const result = await this.pool.query(`SELECT 1 FROM users WHERE 'superadmin' = ANY(roles) LIMIT 1`);
-		return (result.rowCount ?? 0) > 0;
-	};
-
-	private toEntity = (row: UserRow): User => ({
-		id: row.id,
-		firstName: row.first_name,
-		lastName: row.last_name,
-		email: row.email,
-		password: row.password,
-		avatarImage: row.avatar_image ?? undefined,
-		profileImage: undefined,
-		isActive: row.is_active,
-		isVerified: row.is_verified,
-		role: Array.isArray(row.roles) ? row.roles : parsePostgresArray(row.roles),
-		teamId: row.team_id ?? "",
-		checkTTL: row.check_ttl ?? undefined,
-		createdAt: row.created_at.toISOString(),
-		updatedAt: row.updated_at.toISOString(),
-	});
-}

server/src/routes/authRoute.ts

@@ -1,15 +1,14 @@
 import { Router, RequestHandler } from "express";
 import { isAllowed } from "../middleware/isAllowed.js";
 import multer from "multer";
-import { IAuthController } from "@/controllers/authController.js";
 
 const upload = multer();
 
 class AuthRoutes {
 	private router: Router;
-	private authController: IAuthController;
+	private authController: any;
 
-	constructor(authController: IAuthController, verifyJWT: RequestHandler) {
+	constructor(authController: any, verifyJWT: RequestHandler) {
 		this.router = Router();
 		this.authController = authController;
 		this.initRoutes(verifyJWT);

server/src/routes/checkRoute.ts

@@ -1,13 +1,12 @@
 import { Router } from "express";
 
 import { isAllowed } from "../middleware/isAllowed.js";
-import { ICheckController } from "@/controllers/checkController.js";
 
 class CheckRoutes {
 	private router: Router;
-	private checkController: ICheckController;
+	private checkController: any;
 
-	constructor(checkController: ICheckController) {
+	constructor(checkController: any) {
 		this.router = Router();
 		this.checkController = checkController;
 		this.initRoutes();