notification added in with subs :D

backend/db/schema/notifications.schema.ts

@@ -0,0 +1,29 @@
+import {
+	boolean,
+	jsonb,
+	pgTable,
+	text,
+	uniqueIndex,
+	uuid,
+} from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
+
+export const notifications = pgTable(
+	"notifications",
+	{
+		id: uuid("id").defaultRandom().primaryKey(),
+		name: text("name").notNull(),
+		description: text("description").notNull(),
+		active: boolean("active").default(false),
+		interval: text("interval").default("5"),
+		options: jsonb("options").default([]),
+	},
+	(table) => [uniqueIndex("notify_name").on(table.name)],
+);
+
+export const notificationSchema = createSelectSchema(notifications);
+export const newNotificationSchema = createInsertSchema(notifications);
+
+export type Notification = z.infer<typeof notificationSchema>;
+export type NewNotification = z.infer<typeof newNotificationSchema>;

backend/db/schema/notifications.sub.schema.ts

@@ -0,0 +1,30 @@
+import { pgTable, text, unique, uuid } from "drizzle-orm/pg-core";
+import { createInsertSchema, createSelectSchema } from "drizzle-zod";
+import type z from "zod";
+import { user } from "./auth.schema.js";
+import { notifications } from "./notifications.schema.js";
+
+export const notificationSub = pgTable(
+	"notification_sub",
+	{
+		id: uuid("id").defaultRandom().primaryKey(),
+		userId: text("user_id")
+			.notNull()
+			.references(() => user.id, { onDelete: "cascade" }),
+		notificationId: uuid("notification_id")
+			.notNull()
+			.references(() => notifications.id, { onDelete: "cascade" }),
+		emails: text("emails").array().default([]),
+	},
+	(table) => ({
+		userNotificationUnique: unique(
+			"notification_sub_user_notification_unique",
+		).on(table.userId, table.notificationId),
+	}),
+);
+
+export const notificationSubSchema = createSelectSchema(notificationSub);
+export const newNotificationSubSchema = createInsertSchema(notificationSub);
+
+export type NotificationSub = z.infer<typeof notificationSubSchema>;
+export type NewNotificationSub = z.infer<typeof newNotificationSubSchema>;

backend/middleware/auth.requiredPerms.middleware.ts

@@ -0,0 +1,52 @@
+import type { NextFunction, Request, Response } from "express";
+import { auth } from "../utils/auth.utils.js";
+
+type PermissionMap = Record<string, string[]>;
+
+declare global {
+	namespace Express {
+		interface Request {
+			authz?: {
+				success: boolean;
+				permissions: PermissionMap;
+			};
+		}
+	}
+}
+
+function normalizeRoles(roles: unknown): string {
+	if (Array.isArray(roles)) return roles.join(",");
+	if (typeof roles === "string") return roles;
+	return "";
+}
+
+export function requirePermission(permissions: PermissionMap) {
+	return async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			const role = normalizeRoles(req.user?.roles) as any;
+
+			const result = await auth.api.userHasPermission({
+				body: {
+					role,
+					permissions,
+				},
+			});
+
+			req.authz = {
+				success: !!result?.success,
+				permissions,
+			};
+
+			if (!result?.success) {
+				return res.status(403).json({
+					ok: false,
+					message: "You do not have permission to perform this action.",
+				});
+			}
+
+			next();
+		} catch (error) {
+			next(error);
+		}
+	};
+}

backend/notification/notification.controller.ts

@@ -0,0 +1,153 @@
+import { notificationSub } from "db/schema/notifications.sub.schema.js";
+import { eq } from "drizzle-orm";
+import { createLogger } from "logger/logger.controller.js";
+import { minutesToCron } from "utils/croner.minConvert.js";
+import { createCronJob, stopCronJob } from "utils/croner.utils.js";
+import { db } from "../db/db.controller.js";
+import { notifications } from "../db/schema/notifications.schema.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+const log = createLogger({ module: "notifications", subModule: "start" });
+
+export const startNotifications = async () => {
+	// get active notification
+
+	const { data, error } = await tryCatch(
+		db.select().from(notifications).where(eq(notifications.active, true)),
+	);
+
+	if (error) {
+		log.error(
+			{ error: error },
+			"There was an error when getting notifications.",
+		);
+		return;
+	}
+
+	if (data) {
+		if (data.length === 0) {
+			log.info(
+				{},
+				"There are know currently active notifications to start up.",
+			);
+			return;
+		}
+
+		// get the subs and see if we have any subs currently so we can fire up the notification
+		const { data: sub, error: subError } = await tryCatch(
+			db.select().from(notificationSub),
+		);
+
+		if (subError) {
+			log.error(
+				{ error: error },
+				"There was an error when getting subscriptions.",
+			);
+			return;
+		}
+
+		if (sub.length === 0) {
+			log.info({}, "There are know currently active subscriptions.");
+			return;
+		}
+
+		const emailString = [
+			...new Set(
+				sub.flatMap((e) =>
+					e.emails?.map((email) => email.trim().toLowerCase()),
+				),
+			),
+		].join(";");
+
+		for (const n of data) {
+			createCronJob(
+				n.name,
+				minutesToCron(parseInt(n.interval ?? "15", 10)),
+				async () => {
+					try {
+						const { default: runFun } = await import(
+							`./notification.${n.name.trim()}.js`
+						);
+						await runFun(n, emailString);
+					} catch (error) {
+						log.error(
+							{ error: error },
+							"There was an error starting the notification",
+						);
+					}
+				},
+			);
+		}
+	}
+};
+
+export const modifiedNotification = async (id: string) => {
+	// when a notifications subscribed to, updated, deleted we want to get the info and rerun the startup on the single notification.
+	const { data, error } = await tryCatch(
+		db.select().from(notifications).where(eq(notifications.id, id)),
+	);
+
+	if (error) {
+		log.error(
+			{ error: error },
+			"There was an error when getting notifications.",
+		);
+		return;
+	}
+
+	if (data) {
+		if (!data[0]?.active) {
+			stopCronJob(data[0]?.name ?? "");
+			return;
+		}
+
+		// get the subs for the specific id as we only want to up the modified one
+		const { data: sub, error: subError } = await tryCatch(
+			db
+				.select()
+				.from(notificationSub)
+				.where(eq(notificationSub.notificationId, id)),
+		);
+
+		if (subError) {
+			log.error(
+				{ error: error },
+				"There was an error when getting subscriptions.",
+			);
+
+			return;
+		}
+
+		if (sub.length === 0) {
+			log.info({}, "There are know currently active subscriptions.");
+			stopCronJob(data[0]?.name ?? "");
+			return;
+		}
+
+		const emailString = [
+			...new Set(
+				sub.flatMap((e) =>
+					e.emails?.map((email) => email.trim().toLowerCase()),
+				),
+			),
+		].join(";");
+
+		createCronJob(
+			data[0].name,
+			minutesToCron(parseInt(data[0].interval ?? "15", 10)),
+			async () => {
+				try {
+					const { default: runFun } = await import(
+						`./notification.${data[0]?.name.trim()}.js`
+					);
+					await runFun(data[0], emailString);
+				} catch (error) {
+					log.error(
+						{ error: error },
+						"There was an error starting the notification",
+					);
+				}
+			},
+		);
+	}
+};

backend/notification/notification.reprintLabels.ts

@@ -0,0 +1,6 @@
+const reprint = (data: any, emails: string) => {
+	console.log(data);
+	console.log(emails);
+};
+
+export default reprint;

backend/notification/notification.route.ts

@@ -0,0 +1,54 @@
+import { notifications } from "db/schema/notifications.schema.js";
+import { eq } from "drizzle-orm";
+import { type Response, Router } from "express";
+import { auth } from "utils/auth.utils.js";
+import { db } from "../db/db.controller.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+const r = Router();
+
+r.get("/", async (req, res: Response) => {
+	const hasPermissions = await auth.api.userHasPermission({
+		body: {
+			//userId: req?.user?.id,
+			role: req.user?.roles as any,
+			permissions: {
+				notifications: ["readAll"], // This must match the structure in your access control
+			},
+		},
+	});
+
+	const { data: nName, error: nError } = await tryCatch(
+		db
+			.select()
+			.from(notifications)
+			.where(
+				!hasPermissions.success ? eq(notifications.active, true) : undefined,
+			)
+			.orderBy(notifications.name),
+	);
+
+	if (nError) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "notification",
+			subModule: "get",
+			message: `There was an error getting the notifications `,
+			data: [nError],
+			status: 400,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "notification",
+		subModule: "get",
+		message: `All current notifications`,
+		data: nName ?? [],
+		status: 200,
+	});
+});
+export default r;

backend/notification/notification.routes.ts

@@ -0,0 +1,20 @@
+import type { Express } from "express";
+import { requireAuth } from "../middleware/auth.middleware.js";
+import getNotifications from "./notification.route.js";
+import updateNote from "./notification.update.route.js";
+import deleteSub from "./notificationSub.delete.route.js";
+import subs from "./notificationSub.get.route.js";
+import newSub from "./notificationSub.post.route.js";
+import updateSub from "./notificationSub.update.route.js";
+
+export const setupNotificationRoutes = (baseUrl: string, app: Express) => {
+	//stats will be like this as we dont need to change this
+	app.use(`${baseUrl}/api/notification`, requireAuth, getNotifications);
+	app.use(`${baseUrl}/api/notification`, requireAuth, updateNote);
+	app.use(`${baseUrl}/api/notification/sub`, requireAuth, subs);
+	app.use(`${baseUrl}/api/notification/sub`, requireAuth, newSub);
+	app.use(`${baseUrl}/api/notification/sub`, requireAuth, updateSub);
+	app.use(`${baseUrl}/api/notification/sub`, requireAuth, deleteSub);
+
+	// all other system should be under /api/system/*
+};

backend/notification/notification.update.route.ts

@@ -0,0 +1,81 @@
+import { notifications } from "db/schema/notifications.schema.js";
+import { eq } from "drizzle-orm";
+import { type Response, Router } from "express";
+import z from "zod";
+import { db } from "../db/db.controller.js";
+import { requirePermission } from "../middleware/auth.requiredPerms.middleware.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+import { modifiedNotification } from "./notification.controller.js";
+
+const r = Router();
+
+const updateNote = z.object({
+	description: z.string().optional(),
+	active: z.boolean().optional(),
+	interval: z.string().optional(),
+	options: z.array(z.record(z.string(), z.unknown())).optional(),
+});
+
+r.patch(
+	"/:id",
+	requirePermission({ notifications: ["update"] }),
+	async (req, res: Response) => {
+		const { id } = req.params;
+
+		try {
+			const validated = updateNote.parse(req.body);
+
+			const { data: nName, error: nError } = await tryCatch(
+				db
+					.update(notifications)
+					.set(validated)
+					.where(eq(notifications.id, id as string))
+					.returning(),
+			);
+
+			await modifiedNotification(id as string);
+
+			if (nError) {
+				return apiReturn(res, {
+					success: false,
+					level: "error",
+					module: "notification",
+					subModule: "update",
+					message: `There was an error getting the notifications `,
+					data: [nError],
+					status: 400,
+				});
+			}
+
+			return apiReturn(res, {
+				success: true,
+				level: "info",
+				module: "notification",
+				subModule: "update",
+				message: `Notification was updated`,
+				data: nName ?? [],
+				status: 200,
+			});
+		} catch (err) {
+			if (err instanceof z.ZodError) {
+				const flattened = z.flattenError(err);
+				// return res.status(400).json({
+				// 	error: "Validation failed",
+				// 	details: flattened,
+				// });
+
+				return apiReturn(res, {
+					success: false,
+					level: "error", //connect.success ? "info" : "error",
+					module: "routes",
+					subModule: "notification",
+					message: "Validation failed",
+					data: [flattened.fieldErrors],
+					status: 400, //connect.success ? 200 : 400,
+				});
+			}
+		}
+	},
+);
+export default r;

backend/notification/notificationSub.delete.route.ts

@@ -0,0 +1,83 @@
+import { notificationSub } from "db/schema/notifications.sub.schema.js";
+import { and, eq } from "drizzle-orm";
+import { type Response, Router } from "express";
+import z from "zod";
+import { db } from "../db/db.controller.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+import { modifiedNotification } from "./notification.controller.js";
+
+const newSubscribe = z.object({
+	emails: z
+		.email()
+		.array()
+
+		.describe("An array of emails"),
+	userId: z.string().describe("User id."),
+	notificationId: z
+		.string()
+
+		.describe("Notification id"),
+});
+
+const r = Router();
+
+r.delete("/", async (req, res: Response) => {
+	try {
+		const validated = newSubscribe.parse(req.body);
+		const { data, error } = await tryCatch(
+			db
+				.delete(notificationSub)
+				.where(
+					and(
+						eq(notificationSub.userId, validated.userId),
+						eq(notificationSub.notificationId, validated.notificationId),
+					),
+				)
+				.returning(),
+		);
+
+		await modifiedNotification(validated.notificationId);
+
+		if (error) {
+			return apiReturn(res, {
+				success: false,
+				level: "error",
+				module: "notification",
+				subModule: "post",
+				message: `There was an error deleting the subscription `,
+				data: [error],
+				status: 400,
+			});
+		}
+
+		return apiReturn(res, {
+			success: true,
+			level: "info",
+			module: "notification",
+			subModule: "post",
+			message: `Subscription deleted`,
+			data: data ?? [],
+			status: 200,
+		});
+	} catch (err) {
+		if (err instanceof z.ZodError) {
+			const flattened = z.flattenError(err);
+			// return res.status(400).json({
+			// 	error: "Validation failed",
+			// 	details: flattened,
+			// });
+
+			return apiReturn(res, {
+				success: false,
+				level: "error", //connect.success ? "info" : "error",
+				module: "routes",
+				subModule: "notification",
+				message: "Validation failed",
+				data: [flattened.fieldErrors],
+				status: 400, //connect.success ? 200 : 400,
+			});
+		}
+	}
+});
+export default r;

backend/notification/notificationSub.get.route.ts

@@ -0,0 +1,55 @@
+import { notificationSub } from "db/schema/notifications.sub.schema.js";
+import { eq } from "drizzle-orm";
+import { type Response, Router } from "express";
+import { auth } from "utils/auth.utils.js";
+import { db } from "../db/db.controller.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+
+const r = Router();
+
+r.get("/", async (req, res: Response) => {
+	const hasPermissions = await auth.api.userHasPermission({
+		body: {
+			//userId: req?.user?.id,
+			role: req.user?.roles as any,
+			permissions: {
+				notifications: ["readAll"], // This must match the structure in your access control
+			},
+		},
+	});
+
+	const { data, error } = await tryCatch(
+		db
+			.select()
+			.from(notificationSub)
+			.where(
+				!hasPermissions.success
+					? eq(notificationSub.userId, `${req?.user?.id ?? ""}`)
+					: undefined,
+			),
+	);
+
+	if (error) {
+		return apiReturn(res, {
+			success: false,
+			level: "error",
+			module: "notification",
+			subModule: "post",
+			message: `There was an error getting subscriptions `,
+			data: [error],
+			status: 400,
+		});
+	}
+
+	return apiReturn(res, {
+		success: true,
+		level: "info",
+		module: "notification",
+		subModule: "post",
+		message: `Subscription deleted`,
+		data: data ?? [],
+		status: 200,
+	});
+});
+export default r;

backend/notification/notificationSub.post.route.ts

@@ -0,0 +1,75 @@
+import { notificationSub } from "db/schema/notifications.sub.schema.js";
+import { type Response, Router } from "express";
+import z from "zod";
+import { db } from "../db/db.controller.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+import { modifiedNotification } from "./notification.controller.js";
+
+const newSubscribe = z.object({
+	emails: z
+		.email()
+		.array()
+
+		.describe("An array of emails"),
+	userId: z.string().describe("User id."),
+	notificationId: z
+		.string()
+
+		.describe("Notification id"),
+});
+
+const r = Router();
+
+r.post("/", async (req, res: Response) => {
+	try {
+		const validated = newSubscribe.parse(req.body);
+
+		const { data, error } = await tryCatch(
+			db.insert(notificationSub).values(validated).returning(),
+		);
+
+		await modifiedNotification(validated.notificationId);
+
+		if (error) {
+			return apiReturn(res, {
+				success: false,
+				level: "error",
+				module: "notification",
+				subModule: "post",
+				message: `There was an error getting the notifications `,
+				data: [error],
+				status: 400,
+			});
+		}
+
+		return apiReturn(res, {
+			success: true,
+			level: "info",
+			module: "notification",
+			subModule: "post",
+			message: `Subscribed to notification`,
+			data: data ?? [],
+			status: 200,
+		});
+	} catch (err) {
+		if (err instanceof z.ZodError) {
+			const flattened = z.flattenError(err);
+			// return res.status(400).json({
+			// 	error: "Validation failed",
+			// 	details: flattened,
+			// });
+
+			return apiReturn(res, {
+				success: false,
+				level: "error", //connect.success ? "info" : "error",
+				module: "routes",
+				subModule: "notification",
+				message: "Validation failed",
+				data: [flattened.fieldErrors],
+				status: 400, //connect.success ? 200 : 400,
+			});
+		}
+	}
+});
+export default r;

backend/notification/notificationSub.update.route.ts

@@ -0,0 +1,84 @@
+import { notificationSub } from "db/schema/notifications.sub.schema.js";
+import { and, eq } from "drizzle-orm";
+import { type Response, Router } from "express";
+import z from "zod";
+import { db } from "../db/db.controller.js";
+import { apiReturn } from "../utils/returnHelper.utils.js";
+import { tryCatch } from "../utils/trycatch.utils.js";
+import { modifiedNotification } from "./notification.controller.js";
+
+const newSubscribe = z.object({
+	emails: z.email().array().describe("An array of emails"),
+	userId: z.string().describe("User id."),
+	notificationId: z.string().describe("Notification id"),
+});
+
+const r = Router();
+
+r.patch("/", async (req, res: Response) => {
+	try {
+		const validated = newSubscribe.parse(req.body);
+
+		const emails = validated.emails
+			.map((e) => e.trim().toLowerCase())
+			.filter(Boolean);
+
+		const uniqueEmails = [...new Set(emails)];
+
+		const { data, error } = await tryCatch(
+			db
+				.update(notificationSub)
+				.set({ emails: uniqueEmails })
+				.where(
+					and(
+						eq(notificationSub.userId, validated.userId),
+						eq(notificationSub.notificationId, validated.notificationId),
+					),
+				)
+				.returning(),
+		);
+
+		await modifiedNotification(validated.notificationId);
+
+		if (error) {
+			return apiReturn(res, {
+				success: false,
+				level: "error",
+				module: "notification",
+				subModule: "update",
+				message: `There was an error updating the notifications `,
+				data: [error],
+				status: 400,
+			});
+		}
+
+		return apiReturn(res, {
+			success: true,
+			level: "info",
+			module: "notification",
+			subModule: "update",
+			message: `Subscription updated`,
+			data: data ?? [],
+			status: 200,
+		});
+	} catch (err) {
+		if (err instanceof z.ZodError) {
+			const flattened = z.flattenError(err);
+			// return res.status(400).json({
+			// 	error: "Validation failed",
+			// 	details: flattened,
+			// });
+
+			return apiReturn(res, {
+				success: false,
+				level: "error", //connect.success ? "info" : "error",
+				module: "routes",
+				subModule: "notification",
+				message: "Validation failed",
+				data: [flattened.fieldErrors],
+				status: 400, //connect.success ? 200 : 400,
+			});
+		}
+	}
+});
+export default r;

backend/notification/notifications.master.ts

@@ -0,0 +1,50 @@
+import { db } from "db/db.controller.js";
+import {
+	type NewNotification,
+	notifications,
+} from "db/schema/notifications.schema.js";
+import { sql } from "drizzle-orm";
+import { tryCatch } from "utils/trycatch.utils.js";
+import { createLogger } from "../logger/logger.controller.js";
+
+const note: NewNotification[] = [
+	{
+		name: "reprintLabels",
+		description:
+			"Monitors the labels that are printed and returns a there data, if one falls withing the time frame.",
+		active: false,
+		interval: "10",
+		options: [{ prodID: 1 }],
+	},
+];
+
+export const createNotifications = async () => {
+	const log = createLogger({ module: "notifications", subModule: "create" });
+	const { data, error } = await tryCatch(
+		db
+			.insert(notifications)
+			.values(note)
+			.onConflictDoUpdate({
+				target: notifications.name,
+				set: {
+					description: sql`excluded.description`,
+				},
+				// where: sql`
+				//         settings.seed_version IS NULL
+				//         OR settings.seed_version < excluded.seed_version
+				//     `,
+			})
+			.returning(),
+	);
+
+	if (error) {
+		log.error(
+			{ error: error },
+			"There was an error when adding or updating the notifications.",
+		);
+	}
+
+	if (data) {
+		log.info({}, "All notifications were added/updated");
+	}
+};

backend/routeHandler.routes.ts

@@ -1,4 +1,5 @@
 import type { Express } from "express";
+import { setupNotificationRoutes } from "notification/notification.routes.js";
 import { setupAuthRoutes } from "./auth/auth.routes.js";
 // import the routes and route setups
 import { setupApiDocsRoutes } from "./configs/scaler.config.js";
@@ -17,4 +18,5 @@ export const setupRoutes = (baseUrl: string, app: Express) => {
 	setupAuthRoutes(baseUrl, app);
 	setupUtilsRoutes(baseUrl, app);
 	setupOpendockRoutes(baseUrl, app);
+	setupNotificationRoutes(baseUrl, app);
 };

backend/server.ts

@@ -1,5 +1,7 @@
 import { createServer } from "node:http";
 import os from "node:os";
+import { startNotifications } from "notification/notification.controller.js";
+import { createNotifications } from "notification/notifications.master.js";
 import createApp from "./app.js";
 import { db } from "./db/db.controller.js";
 import { dbCleanup } from "./db/dbCleanup.controller.js";
@@ -47,6 +49,10 @@ const start = async () => {
 			dbCleanup("jobs", 30),
 		);
 		createCronJob("logsCleanup", "0 15 5 * * *", () => dbCleanup("logs", 120));
+
+		// one shots only needed to run on server startups
+		createNotifications();
+		startNotifications();
 	}, 5 * 1000);
 
 	server.listen(port, async () => {

backend/utils/auth.permissions.ts

@@ -0,0 +1,26 @@
+import { createAccessControl } from "better-auth/plugins/access";
+
+export const statement = {
+	app: ["read", "create", "share", "update", "delete", "readAll"],
+	user: ["ban"],
+	quality: ["read", "create", "share", "update", "delete", "readAll"],
+	notifications: ["read", "create", "share", "update", "delete", "readAll"],
+} as const;
+
+export const ac = createAccessControl(statement);
+
+export const user = ac.newRole({
+	app: ["read", "create"],
+	notifications: ["read", "create"],
+});
+
+export const admin = ac.newRole({
+	app: ["read", "create", "update"],
+});
+
+export const systemAdmin = ac.newRole({
+	app: ["read", "create", "share", "update", "delete", "readAll"],
+	user: ["ban"],
+	quality: ["read", "create", "share", "update", "delete", "readAll"],
+	notifications: ["read", "create", "share", "update", "delete", "readAll"],
+});

backend/utils/auth.utils.ts

@@ -1,7 +1,7 @@
 import { betterAuth } from "better-auth";
 import { drizzleAdapter } from "better-auth/adapters/drizzle";
 import {
-	admin,
+	admin as adminPlugin,
 	// apiKey,
 	// createAuthMiddleware,
 	//customSession,
@@ -12,6 +12,7 @@ import {
 //import { eq } from "drizzle-orm";
 import { db } from "../db/db.controller.js";
 import * as rawSchema from "../db/schema/auth.schema.js";
+import { ac, admin, systemAdmin, user } from "./auth.permissions.js";
 import { allowedOrigins } from "./cors.utils.js";
 import { sendEmail } from "./sendEmail.utils.js";
 
@@ -44,7 +45,14 @@ export const auth = betterAuth({
 	plugins: [
 		jwt({ jwt: { expirationTime: "1h" } }),
 		//apiKey(),
-		admin(),
+		adminPlugin({
+			ac,
+			roles: {
+				admin,
+				user,
+				systemAdmin,
+			},
+		}),
 		lastLoginMethod(),
 		username({
 			minUsernameLength: 5,

backend/utils/croner.minConvert.ts

@@ -0,0 +1,38 @@
+import { createLogger } from "../logger/logger.controller.js";
+
+const minTime = 5;
+export const minutesToCron = (minutes: number): string => {
+	const log = createLogger({ module: "system", subModule: "croner" });
+	if (minutes < minTime) {
+		log.error(
+			{},
+			`Conversion of less then ${minTime} min and is not allowed on this server`,
+		);
+	}
+
+	// Every X minutes (under 60)
+	if (minutes < 60) {
+		return `*/${minutes} * * * *`;
+	}
+
+	// Every X hours (clean division)
+	if (minutes % 60 === 0 && minutes < 1440) {
+		const hours = minutes / 60;
+		return `0 0 */${hours} * * *`;
+	}
+
+	// Every day
+	if (minutes === 1440) {
+		return `0 0 8 * * *`; // 8am
+	}
+
+	// Every X days (clean division)
+	if (minutes % 1440 === 0) {
+		const days = minutes / 1440;
+		return `0 0 0 */${days} * *`;
+	}
+
+	// Fallback (not cleanly divisible)
+	// Cron can't represent this perfectly → run every X minutes as approximation
+	return `0 */${minutes} * * * *`;
+};

backend/utils/returnHelper.utils.ts

@@ -3,7 +3,14 @@ import { createLogger } from "../logger/logger.controller.js";
 
 interface Data<T = unknown[]> {
 	success: boolean;
-	module: "system" | "ocp" | "routes" | "datamart" | "utils" | "opendock";
+	module:
+		| "system"
+		| "ocp"
+		| "routes"
+		| "datamart"
+		| "utils"
+		| "opendock"
+		| "notification";
 	subModule:
 		| "db"
 		| "labeling"
@@ -15,7 +22,13 @@ interface Data<T = unknown[]> {
 		| "datamart"
 		| "jobs"
 		| "apt"
-		| "settings";
+		| "settings"
+		| "get"
+		| "update"
+		| "delete"
+		| "post"
+		| "notification"
+		| "delete";
 	level: "info" | "error" | "debug" | "fatal";
 	message: string;
 	room?: string;