move to src

server/src/db/models/AppSettings.js

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

server/src/db/models/Check.js

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

server/src/db/models/HardwareCheck.js

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

server/src/db/models/InviteToken.js

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

server/src/db/models/MaintenanceWindow.js

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

server/src/db/models/Monitor.js

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

server/src/db/models/MonitorStats.js

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

server/src/db/models/NetworkCheck.js

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

server/src/db/models/Notification.js

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

server/src/db/models/PageSpeedCheck.js

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

server/src/db/models/RecoveryToken.js

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

server/src/db/models/StatusPage.js

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

server/src/db/models/Team.js

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

server/src/db/models/User.js

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