Fix formatting issues

## Summary
Restores refresh token functionality that was lost during a previous refactor.
This enables seamless session renewal without forcing users to re-login when
their access token expires.

## Server changes
- Add refresh token configuration to settingsService (7d TTL by default)
- Add issueRefreshToken method to userService
- Update login/register/resetPassword to return refreshToken
- Add refreshAuthToken method to userService for token refresh
- Add refreshAuthToken controller method
- Add POST /auth/refresh route
- Update verifyJWT middleware to return 403 for expired tokens (triggers refresh)
  and 401 for invalid tokens (triggers logout)

## Client changes
- Store refreshToken in Redux auth state
- Clear refreshToken on logout
- Add setAuthToken action for updating token after refresh
- Update NetworkService to handle 403 responses:
  - Call /auth/refresh endpoint to get new token
  - Retry failed request with new token
  - Queue concurrent requests during refresh
  - Redirect to login if refresh fails

client/src/Features/Auth/authSlice.js

@@ -5,6 +5,7 @@ import axios from "axios";
 const initialState = {
 	isLoading: false,
 	authToken: "",
+	refreshToken: "",
 	user: "",
 	success: null,
 	msg: null,
@@ -138,6 +139,7 @@ const handleAuthFulfilled = (state, action) => {
 	state.success = action.payload.success;
 	state.msg = action.payload.msg;
 	state.authToken = action.payload.data.token;
+	state.refreshToken = action.payload.data.refreshToken || "";
 	state.user = action.payload.data.user;
 };
 const handleAuthRejected = (state, action) => {
@@ -188,11 +190,15 @@ const authSlice = createSlice({
 	reducers: {
 		clearAuthState: (state) => {
 			state.authToken = "";
+			state.refreshToken = "";
 			state.user = "";
 			state.isLoading = false;
 			state.success = true;
 			state.msg = "Logged out successfully";
 		},
+		setAuthToken: (state, action) => {
+			state.authToken = action.payload;
+		},
 	},
 	extraReducers: (builder) => {
 		// Register thunk
@@ -246,4 +252,4 @@ const authSlice = createSlice({
 });
 
 export default authSlice.reducer;
-export const { clearAuthState } = authSlice.actions;
+export const { clearAuthState, setAuthToken } = authSlice.actions;

client/src/Pages/PageSpeed/Create/index.jsx

@@ -178,8 +178,7 @@ const PageSpeedSetup = () => {
 
 	const handleRemove = async (event) => {
 		event.preventDefault();
-		const TEMP_MONITOR = { id: monitor._id };
+		await deleteMonitor({ monitor: { id: monitorId }, redirect: "/pagespeed" });
-		await deleteMonitor({ monitor: TEMP_MONITOR, redirect: "/pagespeed" });
 	};
 
 	const isBusy = isLoading || isCreating || isDeleting || isUpdating || isPausing;

client/src/Pages/Settings/SettingsEmail.jsx

@@ -101,47 +101,6 @@ const SettingsEmail = ({
 		return null;
 	}
 
-	/**
-	 * Build email configuration object for code preview
-	 * Constructs the config incrementally instead of using nested conditional spreads
-	 */
-	const buildEmailConfigPreview = () => {
-		const config = {
-			host: systemEmailHost,
-			port: systemEmailPort,
-			secure: systemEmailSecure,
-			auth: {
-				user: systemEmailUser || systemEmailAddress,
-				pass: "<your_password>",
-			},
-			name: systemEmailConnectionHost || "localhost",
-			pool: systemEmailPool,
-		};
-
-		if (systemEmailSecure) {
-			if (systemEmailIgnoreTLS) {
-				config.ignoreTLS = systemEmailIgnoreTLS;
-			}
-			if (systemEmailRequireTLS) {
-				config.requireTLS = systemEmailRequireTLS;
-			}
-
-			const tlsSettings = {};
-			if (systemEmailRejectUnauthorized !== undefined) {
-				tlsSettings.rejectUnauthorized = systemEmailRejectUnauthorized;
-			}
-			if (systemEmailTLSServername && systemEmailTLSServername !== "") {
-				tlsSettings.servername = systemEmailTLSServername;
-			}
-
-			if (Object.keys(tlsSettings).length > 0) {
-				config.tls = tlsSettings;
-			}
-		}
-
-		return config;
-	};
-
 	return (
 		<ConfigBox>
 			<Box>
@@ -312,7 +271,29 @@ const SettingsEmail = ({
 								overflow: "auto",
 							}}
 						>
-							<code>{JSON.stringify(buildEmailConfigPreview(), null, 2)}</code>
+							<code>
+								{JSON.stringify(
+									{
+										host: systemEmailHost,
+										port: systemEmailPort,
+										secure: systemEmailSecure,
+										auth: {
+											user: systemEmailUser || systemEmailAddress,
+											pass: "<your_password>",
+										},
+										name: systemEmailConnectionHost || "localhost",
+										pool: systemEmailPool,
+										tls: {
+											rejectUnauthorized: systemEmailRejectUnauthorized,
+											ignoreTLS: systemEmailIgnoreTLS,
+											requireTLS: systemEmailRequireTLS,
+											servername: systemEmailTLSServername,
+										},
+									},
+									null,
+									2
+								)}
+							</code>
 						</Box>
 					</Box>
 

client/src/Utils/NetworkService.js

@@ -2,7 +2,7 @@ import axios from "axios";
 import i18next from "i18next";
 const BASE_URL = import.meta.env.VITE_APP_API_BASE_URL;
 const FALLBACK_BASE_URL = "http://localhost:5000/api/v1";
-import { clearAuthState } from "../Features/Auth/authSlice";
+import { clearAuthState, setAuthToken } from "../Features/Auth/authSlice";
 class NetworkService {
 	constructor(store, dispatch, navigate) {
 		this.store = store;
@@ -26,7 +26,7 @@ class NetworkService {
 			(config) => {
 				const currentLanguage = i18next.language || "en";
 
-				const { authToken } = store.getState().auth;
+				const { authToken, refreshToken } = store.getState().auth;
 
 				config.headers = {
 					Authorization: `Bearer ${authToken}`,
@@ -34,15 +34,36 @@ class NetworkService {
 					...config.headers,
 				};
 
+				// Only send refresh token to the refresh endpoint
+				if (refreshToken && config.url?.includes("/auth/refresh")) {
+					config.headers["x-refresh-token"] = refreshToken;
+				}
+
 				return config;
 			},
 			(error) => {
 				return Promise.reject(error);
 			}
 		);
+
+		// Track if we're currently refreshing to prevent multiple refresh calls
+		this.isRefreshing = false;
+		this.failedQueue = [];
+
+		const processQueue = (error, token = null) => {
+			this.failedQueue.forEach((prom) => {
+				if (error) {
+					prom.reject(error);
+				} else {
+					prom.resolve(token);
+				}
+			});
+			this.failedQueue = [];
+		};
+
 		this.axiosInstance.interceptors.response.use(
 			(response) => response,
-			(error) => {
+			async (error) => {
 				// Handle network errors (server unreachable)
 				if (error.code === "ERR_NETWORK") {
 					// Navigate to server unreachable page
@@ -51,8 +72,66 @@ class NetworkService {
 					return Promise.reject(error);
 				}
 
-				// Handle authentication errors
+				const originalRequest = error.config;
 
+				// Handle 403 - server is telling us to request a new access token
+				// Skip refresh logic for the refresh endpoint itself to prevent circular dependency
+				const isRefreshEndpoint = originalRequest.url?.includes("/auth/refresh");
+				if (
+					error.response &&
+					error.response.status === 403 &&
+					!originalRequest._retry &&
+					!isRefreshEndpoint
+				) {
+					// Check if we have a refresh token before attempting refresh
+					const { refreshToken } = store.getState().auth;
+					if (!refreshToken) {
+						dispatch(clearAuthState());
+						navigate("/login");
+						return Promise.reject(error);
+					}
+
+					if (this.isRefreshing) {
+						// If already refreshing, queue this request
+						return new Promise((resolve, reject) => {
+							this.failedQueue.push({ resolve, reject });
+						})
+							.then((token) => {
+								originalRequest.headers["Authorization"] = `Bearer ${token}`;
+								return this.axiosInstance(originalRequest);
+							})
+							.catch((err) => Promise.reject(err));
+					}
+
+					originalRequest._retry = true;
+					this.isRefreshing = true;
+
+					try {
+						// Call refresh endpoint
+						const response = await this.axiosInstance.post("/auth/refresh");
+						const newToken = response.data.data.token;
+
+						// Update the auth token in store
+						dispatch(setAuthToken(newToken));
+
+						// Process queued requests
+						processQueue(null, newToken);
+
+						// Retry original request with new token
+						originalRequest.headers["Authorization"] = `Bearer ${newToken}`;
+						return this.axiosInstance(originalRequest);
+					} catch (refreshError) {
+						// Refresh failed, clear auth and redirect to login
+						processQueue(refreshError, null);
+						dispatch(clearAuthState());
+						navigate("/login");
+						return Promise.reject(refreshError);
+					} finally {
+						this.isRefreshing = false;
+					}
+				}
+
+				// Handle 401 - authentication failed (invalid/expired refresh token or no token)
 				if (error.response && error.response.status === 401) {
 					dispatch(clearAuthState());
 					navigate("/login");

server/src/controllers/authController.ts

@@ -36,11 +36,11 @@ class AuthController {
 				req.body.email = req.body.email?.toLowerCase();
 			}
 			await registrationBodyValidation.validateAsync(req.body);
-			const { user, token } = await this.userService.registerUser(req.body, req.file);
+			const { user, token, refreshToken } = await this.userService.registerUser(req.body, req.file);
 			res.status(200).json({
 				success: true,
 				msg: "User registered successfully",
-				data: { user, token },
+				data: { user, token, refreshToken },
 			});
 		} catch (error) {
 			next(error);
@@ -53,7 +53,7 @@ class AuthController {
 				req.body.email = req.body.email?.toLowerCase();
 			}
 			await loginValidation.validateAsync(req.body);
-			const { user, token } = await this.userService.loginUser(req.body.email, req.body.password);
+			const { user, token, refreshToken } = await this.userService.loginUser(req.body.email, req.body.password);
 
 			return res.status(200).json({
 				success: true,
@@ -61,6 +61,7 @@ class AuthController {
 				data: {
 					user,
 					token,
+					refreshToken,
 				},
 			});
 		} catch (error) {
@@ -128,11 +129,35 @@ class AuthController {
 	resetPassword = async (req: Request, res: Response, next: NextFunction) => {
 		try {
 			await newPasswordValidation.validateAsync(req.body);
-			const { user, token } = await this.userService.resetPassword(req.body.password, req.body.recoveryToken);
+			const { user, token, refreshToken } = await this.userService.resetPassword(req.body.password, req.body.recoveryToken);
 			return res.status(200).json({
 				success: true,
 				msg: "Password has been reset successfully",
-				data: { user, token },
+				data: { user, token, refreshToken },
+			});
+		} catch (error) {
+			next(error);
+		}
+	};
+
+	refreshAuthToken = async (req: Request, res: Response, next: NextFunction) => {
+		try {
+			const authToken = req.headers.authorization?.split(" ")[1];
+			const refreshToken = req.headers["x-refresh-token"] as string;
+
+			if (!authToken || !refreshToken) {
+				return res.status(400).json({
+					success: false,
+					msg: "Auth token and refresh token are required",
+				});
+			}
+
+			const { user, token, refreshToken: newRefreshToken } = await this.userService.refreshAuthToken(authToken, refreshToken);
+
+			return res.status(200).json({
+				success: true,
+				msg: "Token refreshed successfully",
+				data: { user, token, refreshToken: newRefreshToken },
 			});
 		} catch (error) {
 			next(error);

server/src/middleware/v1/verifyJWT.js

@@ -41,7 +41,9 @@ const verifyJWT = (req, res, next) => {
 		if (err) {
 			const errorMessage = err.name === "TokenExpiredError" ? stringService.expiredAuthToken : stringService.invalidAuthToken;
 			err.details = { msg: errorMessage };
-			err.status = 401;
+			// Return 403 for expired tokens to trigger client refresh flow
+			// Return 401 for invalid tokens to trigger logout
+			err.status = err.name === "TokenExpiredError" ? 403 : 401;
 			err.service = SERVICE_NAME;
 			err.method = "verifyJWT";
 			next(err);

server/src/routes/v1/authRoute.js

@@ -15,6 +15,7 @@ class AuthRoutes {
 	initRoutes() {
 		this.router.post("/register", upload.single("profileImage"), this.authController.registerUser);
 		this.router.post("/login", this.authController.loginUser);
+		this.router.post("/refresh", this.authController.refreshAuthToken);
 
 		this.router.post("/recovery/request", this.authController.requestRecovery);
 		this.router.post("/recovery/validate", this.authController.validateRecovery);

server/src/service/business/userService.ts

@@ -62,6 +62,17 @@ class UserService {
 		return this.jwt.sign(payloadData, tokenSecret, { expiresIn: tokenTTL });
 	};
 
+	issueRefreshToken = (payload: any, appSettings: any) => {
+		const refreshTokenTTL = appSettings?.refreshTokenTTL ?? "7d";
+		const refreshTokenSecret = appSettings?.refreshTokenSecret ?? appSettings?.jwtSecret;
+		const payloadData = { ...payload };
+		// Remove sensitive data from refresh token payload
+		delete payloadData.password;
+		delete payloadData.profileImage;
+		delete payloadData.avatarImage;
+		return this.jwt.sign(payloadData, refreshTokenSecret, { expiresIn: refreshTokenTTL });
+	};
+
 	registerUser = async (user: any, file: any) => {
 		// Create a new user
 		// If superAdmin exists, a token should be attached to all further register requests
@@ -92,6 +103,7 @@ class UserService {
 		const appSettings = await this.settingsService.getSettings();
 
 		const token = this.issueToken(userForToken, appSettings);
+		const refreshToken = this.issueRefreshToken(userForToken, appSettings);
 
 		try {
 			const html = await this.emailService.buildEmail("welcomeEmailTemplate", {
@@ -114,7 +126,7 @@ class UserService {
 			});
 		}
 
-		return { user: newUser, token };
+		return { user: newUser, token, refreshToken };
 	};
 
 	loginUser = async (email: string, password: string) => {
@@ -134,9 +146,10 @@ class UserService {
 		// Happy path, return token
 		const appSettings = await this.settingsService.getSettings();
 		const token = this.issueToken(userWithoutPassword, appSettings);
+		const refreshToken = this.issueRefreshToken(userWithoutPassword, appSettings);
 		// reset avatar image
 		userWithoutPassword.avatarImage = user.avatarImage;
-		return { user: userWithoutPassword, token };
+		return { user: userWithoutPassword, token, refreshToken };
 	};
 
 	editUser = async (updates: any, file: any, currentUser: any) => {
@@ -191,7 +204,39 @@ class UserService {
 		const user = await this.db.recoveryModule.resetPassword(password, recoveryToken);
 		const appSettings = await this.settingsService.getSettings();
 		const token = this.issueToken(user._doc, appSettings);
-		return { user, token };
+		const refreshToken = this.issueRefreshToken(user._doc, appSettings);
+		return { user, token, refreshToken };
+	};
+
+	refreshAuthToken = async (oldAuthToken: string, refreshTokenFromHeader: string) => {
+		const appSettings = await this.settingsService.getSettings();
+		const refreshTokenSecret = appSettings?.refreshTokenSecret ?? appSettings?.jwtSecret;
+		const jwtSecret = appSettings?.jwtSecret;
+
+		// Verify refresh token
+		try {
+			this.jwt.verify(refreshTokenFromHeader, refreshTokenSecret);
+		} catch (err: any) {
+			const errorMessage = err.name === "TokenExpiredError" ? "Refresh token has expired" : "Invalid refresh token";
+			throw this.errorService.createAuthenticationError(errorMessage);
+		}
+
+		// Refresh token is valid, get payload from old auth token (ignoring expiration)
+		let payloadData: any;
+		try {
+			payloadData = this.jwt.verify(oldAuthToken, jwtSecret, { ignoreExpiration: true });
+		} catch (err: any) {
+			throw this.errorService.createAuthenticationError("Invalid auth token");
+		}
+
+		// Remove old token metadata
+		delete payloadData.iat;
+		delete payloadData.exp;
+
+		// Issue new access token
+		const newAuthToken = this.issueToken(payloadData, appSettings);
+
+		return { user: payloadData, token: newAuthToken, refreshToken: refreshTokenFromHeader };
 	};
 
 	deleteUser = async (user: any) => {

server/src/service/infrastructure/emailService.js

@@ -1,3 +1,9 @@
+import { fileURLToPath } from "url";
+import path from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
 const SERVICE_NAME = "EmailService";
 
 /**
@@ -40,37 +46,16 @@ class EmailService {
 		 */
 		this.loadTemplate = (templateName) => {
 			try {
-				// Use EMAIL_TEMPLATE_PATH environment variable or default to src/templates/ in cwd
+				const templatePath = this.path.join(__dirname, `../../../templates/${templateName}.mjml`);
-				const templateBase = process.env.EMAIL_TEMPLATE_PATH || this.path.join(process.cwd(), "src", "templates");
-				const templatePath = this.path.join(templateBase, `${templateName}.mjml`);
-
-				this.logger.debug({
-					message: `Loading template: ${templateName}`,
-					service: SERVICE_NAME,
-					method: "loadTemplate",
-					templatePath: templatePath,
-				});
-
 				const templateContent = this.fs.readFileSync(templatePath, "utf8");
-				const compiled = this.compile(templateContent);
+				return this.compile(templateContent);
-
-				this.logger.debug({
-					message: `Template loaded successfully: ${templateName}`,
-					service: SERVICE_NAME,
-					method: "loadTemplate",
-				});
-				return compiled;
 			} catch (error) {
 				this.logger.error({
-					message: `Failed to load template '${templateName}': ${error.message}`,
+					message: error.message,
 					service: SERVICE_NAME,
 					method: "loadTemplate",
-					templateName: templateName,
-					error: error.message,
 					stack: error.stack,
 				});
-				// Fail fast - throw error instead of returning empty function
-				throw error;
 			}
 		};
 
@@ -98,169 +83,20 @@ class EmailService {
 
 	buildEmail = async (template, context) => {
 		try {
-			if (!this.templateLookup[template]) {
-				this.logger.error({
-					message: `Template '${template}' not found in templateLookup`,
-					service: SERVICE_NAME,
-					method: "buildEmail",
-					availableTemplates: Object.keys(this.templateLookup),
-				});
-				throw new Error(`Template '${template}' not found`);
-			}
-			if (typeof this.templateLookup[template] !== "function") {
-				this.logger.error({
-					message: `Template '${template}' is not a function. Type: ${typeof this.templateLookup[template]}`,
-					service: SERVICE_NAME,
-					method: "buildEmail",
-					templateValue: this.templateLookup[template],
-				});
-				throw new Error(`Template '${template}' is not a function`);
-			}
 			const mjml = this.templateLookup[template](context);
-
-			// Check if MJML is empty (template failed to load)
-			if (!mjml || mjml.trim() === "") {
-				const msg = `Template '${template}' returned empty MJML content. Template may have failed to load.`;
-				this.logger.error({
-					message: msg,
-					service: SERVICE_NAME,
-					method: "buildEmail",
-					template: template,
-				});
-				throw new Error(msg);
-			}
-
 			const html = await this.mjml2html(mjml);
-
-			// Check if HTML is empty
-			if (!html || !html.html) {
-				const msg = `MJML conversion failed for template '${template}'. No HTML output.`;
-				this.logger.error({
-					message: msg,
-					service: SERVICE_NAME,
-					method: "buildEmail",
-					template: template,
-					mjmlLength: mjml.length,
-				});
-				throw new Error(msg);
-			}
-
 			return html.html;
 		} catch (error) {
 			this.logger.error({
-				message: `Failed to build email for template '${template}': ${error.message}`,
+				message: error.message,
 				service: SERVICE_NAME,
 				method: "buildEmail",
-				template: template,
-				error: error.message,
 				stack: error.stack,
 			});
-			throw error;
 		}
 	};
 
-	/**
-	 * Validates email parameters.
-	 * @param {string} to - The recipient email address.
-	 * @param {string} subject - The email subject.
-	 * @param {string} html - The email HTML content.
-	 * @returns {boolean} True if valid, false otherwise.
-	 */
-	validateEmailParams(to, subject, html) {
-		if (!to || !subject) {
-			this.logger.error({
-				message: "Invalid email parameters: missing 'to' or 'subject'",
-				service: SERVICE_NAME,
-				method: "validateEmailParams",
-			});
-			return false;
-		}
-
-		if (!html || html.trim() === "") {
-			this.logger.error({
-				message: "Cannot send email: HTML content is empty",
-				service: SERVICE_NAME,
-				method: "validateEmailParams",
-			});
-			return false;
-		}
-
-		return true;
-	}
-
-	/**
-	 * Validates the from email address.
-	 * @param {string} systemEmailAddress - The system email address.
-	 * @returns {boolean} True if valid, false otherwise.
-	 */
-	validateFromAddress(systemEmailAddress) {
-		const fromAddress = systemEmailAddress;
-		if (!fromAddress || !fromAddress.includes("@")) {
-			this.logger.error({
-				message: "Missing or invalid systemEmailAddress - a valid email address is required",
-				service: SERVICE_NAME,
-				method: "validateFromAddress",
-			});
-			return false;
-		}
-		return true;
-	}
-
-	/**
-	 * Builds the TLS configuration for the email transporter.
-	 * @param {Object} config - The email configuration object.
-	 * @returns {Object} The TLS configuration object.
-	 */
-	buildTLSConfig(config) {
-		const { systemEmailSecure, systemEmailIgnoreTLS, systemEmailRequireTLS, systemEmailRejectUnauthorized, systemEmailTLSServername } = config;
-
-		const tlsConfig = {};
-
-		// Only apply TLS settings if secure is enabled
-		if (systemEmailSecure) {
-			// Top-level Nodemailer options (control STARTTLS behavior):
-			// - ignoreTLS: If true, the connection will not attempt to use STARTTLS
-			// - requireTLS: If true, connection will fail if STARTTLS is not available
-			if (systemEmailIgnoreTLS !== undefined) {
-				tlsConfig.ignoreTLS = systemEmailIgnoreTLS;
-			}
-			if (systemEmailRequireTLS !== undefined) {
-				tlsConfig.requireTLS = systemEmailRequireTLS;
-			}
-
-			// Node.js TLS options (go inside the 'tls' object):
-			// - rejectUnauthorized: If false, accepts self-signed certificates
-			// - servername: Overrides the hostname for SNI (Server Name Indication)
-			const tlsSettings = {};
-
-			if (systemEmailRejectUnauthorized !== undefined) {
-				tlsSettings.rejectUnauthorized = systemEmailRejectUnauthorized;
-			}
-			if (systemEmailTLSServername !== undefined && systemEmailTLSServername !== null && systemEmailTLSServername !== "") {
-				tlsSettings.servername = systemEmailTLSServername;
-			}
-
-			// Only add tls property if we have TLS settings
-			if (Object.keys(tlsSettings).length > 0) {
-				tlsConfig.tls = tlsSettings;
-				this.logger.debug({
-					message: `TLS settings applied to email config`,
-					service: SERVICE_NAME,
-					method: "buildTLSConfig",
-					tlsSettings: Object.keys(tlsSettings),
-				});
-			}
-		}
-
-		return tlsConfig;
-	}
-
 	sendEmail = async (to, subject, html, transportConfig) => {
-		// Validate email parameters
-		if (!this.validateEmailParams(to, subject, html)) {
-			return false;
-		}
-
 		let config;
 		if (typeof transportConfig !== "undefined") {
 			config = transportConfig;
@@ -271,35 +107,35 @@ class EmailService {
 			systemEmailHost,
 			systemEmailPort,
 			systemEmailSecure,
+			systemEmailPool,
 			systemEmailUser,
 			systemEmailAddress,
 			systemEmailPassword,
 			systemEmailConnectionHost,
+			systemEmailTLSServername,
+			systemEmailIgnoreTLS,
+			systemEmailRequireTLS,
+			systemEmailRejectUnauthorized,
 		} = config;
 
-		// Validate from address
-		if (!this.validateFromAddress(systemEmailAddress)) {
-			return false;
-		}
-
-		// Build base email config
 		const emailConfig = {
 			host: systemEmailHost,
 			port: Number(systemEmailPort),
 			secure: systemEmailSecure,
-			pool: config.systemEmailPool ?? false,
 			auth: {
 				user: systemEmailUser || systemEmailAddress,
 				pass: systemEmailPassword,
 			},
 			name: systemEmailConnectionHost || "localhost",
 			connectionTimeout: 5000,
+			pool: systemEmailPool,
+			tls: {
+				rejectUnauthorized: systemEmailRejectUnauthorized,
+				ignoreTLS: systemEmailIgnoreTLS,
+				requireTLS: systemEmailRequireTLS,
+				servername: systemEmailTLSServername,
+			},
 		};
-
-		// Apply TLS configuration
-		const tlsConfig = this.buildTLSConfig(config);
-		Object.assign(emailConfig, tlsConfig);
-
 		this.transporter = this.nodemailer.createTransport(emailConfig);
 
 		try {
@@ -308,8 +144,7 @@ class EmailService {
 			this.logger.warn({
 				message: "Email transporter verification failed",
 				service: SERVICE_NAME,
-				method: "sendEmail",
+				method: "verifyTransporter",
-				error: error.message,
 			});
 			return false;
 		}
@@ -329,7 +164,6 @@ class EmailService {
 				method: "sendEmail",
 				stack: error.stack,
 			});
-			return false;
 		}
 	};
 }

server/src/service/system/settingsService.js

@@ -3,6 +3,8 @@ const SERVICE_NAME = "SettingsService";
 const envConfig = {
 	jwtSecret: process.env.JWT_SECRET,
 	jwtTTL: process.env.TOKEN_TTL,
+	refreshTokenSecret: process.env.REFRESH_TOKEN_SECRET || process.env.JWT_SECRET,
+	refreshTokenTTL: process.env.REFRESH_TOKEN_TTL || "7d",
 	systemEmailHost: process.env.SYSTEM_EMAIL_HOST,
 	nodeEnv: process.env.NODE_ENV,
 	logLevel: process.env.LOG_LEVEL,