mbkauthe 4.9.0 → 5.0.0

package/lib/middleware/auth.js

@@ -1,17 +1,21 @@
 import { dblogin } from "#pool.js";
 import { mbkautheVar } from "#config.js";
 import { renderError } from "#response.js";
-import { clearSessionCookies, cachedCookieOptions, readAccountListFromCookie, encryptSessionId } from "#cookies.js";
+import { clearSessionCookies, cachedCookieOptions, encryptSessionId } from "#cookies.js";
 import { ErrorCodes, createErrorResponse } from "../utils/errors.js";
 import { hashApiToken } from "#config.js";
 import { canAccessMethod } from "#config.js";
 import { extractAuthorizationToken, timingSafeTokenMatch } from "../utils/timingSafeToken.js";
 import { AuthRepository } from "../db/AuthRepository.js";
+import { createLogger } from "../utils/logger.js";
 
 const IS_DEV = process.env.env === 'dev' || process.env.test === 'dev' || process.env.NODE_ENV === 'development';
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const isUuid = (val) => typeof val === 'string' && UUID_RE.test(val);
+const MAX_API_TOKEN_LENGTH = 4096;
+const API_TOKEN_SESSION_RESTORE = Symbol('mbkauthe.apiTokenSessionRestore');
 const authRepo = new AuthRepository({ db: dblogin });
+const logAuth = createLogger("auth");
 
 /**
  * Decide if the incoming request should return JSON errors instead of HTML.
@@ -57,6 +61,8 @@ async function validateTokenAuthentication(req) {
 
   // 1. Check for API Token (mbk_)
   if (token.startsWith('mbk_')) {
+    if (token.length > MAX_API_TOKEN_LENGTH) return { error: 'INVALID_TOKEN' };
+
     const tokenHash = hashApiToken(token);
     const row = await authRepo.getApiTokenByHash(tokenHash);
 
@@ -74,7 +80,7 @@ async function validateTokenAuthentication(req) {
       allowedApps = tokenAllowedApps;
     }
 
-    // Update usage
+    // Update usage opportunistically, but not on every request.
     authRepo.updateApiTokenLastUsed(row.id).catch(e => console.error(`[mbkauthe] Failed to update token usage:`, e));
 
     return {
@@ -93,104 +99,98 @@ async function validateTokenAuthentication(req) {
   return null;
 }
 
-async function validateSession(req, res, next, strictTokenValidation = false) {
-  // --- Check for API Token Header first ---
-  if (req.headers.authorization) {
-    // If strict validation is enabled, reject token-based authentication
-    if (strictTokenValidation) {
-      return res.status(401).json(createErrorResponse(401, ErrorCodes.INVALID_AUTH_TOKEN, {
-        message: 'Token-based authentication not allowed for this endpoint',
-        hint: 'Use session-based authentication (cookies) instead'
-      }));
-    }
-
-    try {
-      const tokenUser = await validateTokenAuthentication(req);
-
-      if (tokenUser && !tokenUser.error) {
-        if (!tokenUser.active) {
-          return res.status(401).json(createErrorResponse(401, ErrorCodes.ACCOUNT_INACTIVE));
-        }
-
-        // SuperAdmin bypasses app permission checks
-        if (tokenUser.role !== "SuperAdmin") {
-          // API tokens must respect their app restrictions for non-SuperAdmin users
-          const allowedApps = tokenUser.allowedApps;
-          const userAllowedApps = tokenUser.userAllowedApps;
+function attachApiTokenUser(req, res, tokenUser) {
+  const user = {
+    id: tokenUser.id,
+    username: tokenUser.username,
+    fullname: tokenUser.fullname,
+    role: tokenUser.role,
+    sessionId: tokenUser.sessionId,
+    allowedApps: tokenUser.allowedApps,
+    tokenScope: tokenUser.tokenScope || null,
+  };
 
-          // allowedApps should always be an array (never null at this point)
-          // If token had null allowedApps, it was already replaced with user's apps in validateTokenAuthentication
-          if (!Array.isArray(allowedApps) || allowedApps.length === 0) {
-            return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
-          }
+  req.auth = {
+    type: 'api-token',
+    user,
+    tokenScope: user.tokenScope,
+    allowedApps: user.allowedApps,
+  };
 
-          // Check if token has access to current app
-          const hasWildcard = allowedApps.includes('*');
-          const hasSpecificApp = allowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase());
+  // Backwards compatibility: existing protected routes commonly read
+  // req.session.user. For API tokens this must be request-local so the
+  // Postgres session store is not dirtied/saved on every token request.
+  if (req.session) {
+    const originalDescriptor = Object.getOwnPropertyDescriptor(req.session, 'user');
+
+    Object.defineProperty(req.session, 'user', {
+      value: user,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    });
 
-          // If wildcard, check against user's allowed apps (wildcard means "all user's apps", not "all apps")
-          if (hasWildcard) {
-            const userHasApp = userAllowedApps && Array.isArray(userAllowedApps) &&
-              userAllowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase());
-            if (!userHasApp) {
-              return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
-            }
-          } else if (!hasSpecificApp) {
-            return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
+    if (res && !req.session[API_TOKEN_SESSION_RESTORE]) {
+      req.session[API_TOKEN_SESSION_RESTORE] = true;
+      const originalEnd = res.end;
+      let restored = false;
+
+      res.end = function apiTokenSessionEnd(...args) {
+        if (!restored) {
+          restored = true;
+          if (originalDescriptor) {
+            Object.defineProperty(req.session, 'user', originalDescriptor);
+          } else {
+            delete req.session.user;
           }
+          delete req.session[API_TOKEN_SESSION_RESTORE];
         }
+        return originalEnd.apply(this, args);
+      };
+    }
+  }
 
-        // Populate session for downstream
-        req.session.user = {
-          id: tokenUser.id,
-          username: tokenUser.username,
-          fullname: tokenUser.fullname,
-          role: tokenUser.role,
-          sessionId: tokenUser.sessionId,
-          allowedApps: tokenUser.allowedApps,
-          tokenScope: tokenUser.tokenScope || null, // Add scope for token-based auth
-        };
-        req.userRole = tokenUser.role;
-
-        // Validate token scope for API token requests
-        if (tokenUser.tokenScope) {
-          const requestMethod = req.method;
-          if (!canAccessMethod(tokenUser.tokenScope, requestMethod)) {
-            return res.status(403).json(createErrorResponse(403, ErrorCodes.TOKEN_SCOPE_INSUFFICIENT, {
-              message: `Token scope '${tokenUser.tokenScope}' does not allow ${requestMethod} requests`,
-              tokenScope: tokenUser.tokenScope,
-              requestedMethod: requestMethod,
-              hint: 'Use a token with write scope for write operations'
-            }));
-          }
-        }
+  req.user = user;
+  req.userRole = tokenUser.role;
+  return user;
+}
 
-        return next();
-      }
+function hasAppAccess(role, allowedApps) {
+  if (role === "SuperAdmin") return true;
+  return Array.isArray(allowedApps)
+    && allowedApps.length > 0
+    && allowedApps.some((app) => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase());
+}
 
-      // Token provided but invalid (or null if format incorrect)
-      let errorCode = ErrorCodes.INVALID_AUTH_TOKEN;
-      if (tokenUser && tokenUser.error === 'TOKEN_EXPIRED') {
-        errorCode = ErrorCodes.API_TOKEN_EXPIRED;
-      }
-      return res.status(401).json(createErrorResponse(401, errorCode));
+function destroySessionCookies(req, res) {
+  req.session?.destroy?.(() => { });
+  clearSessionCookies(res);
+}
 
-    } catch (err) {
-      console.error(`[mbkauthe] Token validation error:`, err);
-      return res.status(500).json(createErrorResponse(500, ErrorCodes.INTERNAL_SERVER_ERROR));
-    }
+function respondSessionFailure(req, res, { prefersJson, code, errorCode, error, message, page, pagename = "Login" }) {
+  destroySessionCookies(req, res);
+  if (prefersJson) {
+    return res.status(code).json(createErrorResponse(code, errorCode));
   }
+  return renderError(res, req, {
+    code,
+    error,
+    message,
+    pagename,
+    page,
+  });
+}
 
-  // --- Fallback to Cookie Session ---
+async function validateCookieSession(req, res, next, { prefersJson }) {
   if (!req.session.user) {
     if (IS_DEV) {
-      console.log(`[mbkauthe] User not authenticated`);
-      console.log(`[mbkauthe] req.session.user:`, req.session.user);
+      logAuth(`User not authenticated`);
+      logAuth(`req.session.user: %O`, req.session.user);
     }
-    if (isJsonRequest(req)) {
+    if (prefersJson) {
       return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_NOT_FOUND));
     }
-    // Use OAuth 2.0 style redirect to the login page for browser navigation
+
     const redirectParams = new URLSearchParams({
       redirect: req.originalUrl,
       reason: 'logged_out'
@@ -199,77 +199,61 @@ async function validateSession(req, res, next, strictTokenValidation = false) {
   }
 
   try {
-    const { sessionId, role, allowedApps } = req.session.user;
+    const { sessionId } = req.session.user;
 
-    // Defensive checks for sessionId and allowedApps
     if (!sessionId || !isUuid(sessionId)) {
       console.warn(`[mbkauthe] Missing sessionId for user "${req.session.user.username}"`);
-      req.session.destroy();
-      clearSessionCookies(res);
-      if (isJsonRequest(req)) {
-        return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_EXPIRED));
-      }
-      return renderError(res, req, {
+      return respondSessionFailure(req, res, {
+        prefersJson,
         code: 401,
+        errorCode: ErrorCodes.SESSION_EXPIRED,
         error: "Session Expired",
         message: "Your Session Has Expired. Please Log In Again.",
-        pagename: "Login",
         page: `/mbkauthe/login?redirect=${encodeURIComponent(req.originalUrl)}`,
       });
     }
 
-    // Validate session by DB primary key id and join to user
-    const sessionRow = await authRepo.getSessionAuthData(sessionId, 'validate-app-session');
+    const sessionRow = await authRepo.getSessionAuthData(
+      sessionId,
+      prefersJson ? 'validate-app-session-for-api' : 'validate-app-session'
+    );
 
     if (!sessionRow) {
-      console.log(`[mbkauthe] Session not found for user "${req.session.user.username}"`);
-      req.session.destroy();
-      clearSessionCookies(res);
-      if (isJsonRequest(req)) {
-        return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_EXPIRED));
-      }
-      return renderError(res, req, {
+      logAuth(`Session not found for user "${req.session.user.username}"`);
+      return respondSessionFailure(req, res, {
+        prefersJson,
         code: 401,
+        errorCode: prefersJson ? ErrorCodes.SESSION_INVALID : ErrorCodes.SESSION_EXPIRED,
         error: "Session Expired",
         message: "Your Session Has Expired. Please Log In Again.",
-        pagename: "Login",
         page: `/mbkauthe/login?redirect=${encodeURIComponent(req.originalUrl)}`,
       });
     }
 
-    // Check expired
     if (sessionRow.expires_at) {
       const expiresMs = sessionRow.expires_at instanceof Date
         ? sessionRow.expires_at.getTime()
         : Date.parse(sessionRow.expires_at);
+
       if (!Number.isNaN(expiresMs) && expiresMs <= Date.now()) {
-      console.log(`[mbkauthe] Session invalidated (expired) for user "${req.session.user.username}"`);
-      // destroy and clear cookies
-      req.session.destroy();
-      clearSessionCookies(res);
-      if (isJsonRequest(req)) {
-        return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_EXPIRED));
+        logAuth(`Session invalidated (expired) for user "${sessionRow.UserName || req.session.user.username}"`);
+        return respondSessionFailure(req, res, {
+          prefersJson,
+          code: 401,
+          errorCode: ErrorCodes.SESSION_EXPIRED,
+          error: "Session Expired",
+          message: "Your Session Has Expired. Please Log In Again.",
+          page: `/mbkauthe/login?redirect=${encodeURIComponent(req.originalUrl)}`,
+        });
       }
-      return renderError(res, req, {
-        code: 401,
-        error: "Session Expired",
-        message: "Your Session Has Expired. Please Log In Again.",
-        pagename: "Login",
-        page: `/mbkauthe/login?redirect=${encodeURIComponent(req.originalUrl)}`,
-      });
     }
-    }
-
 
     if (!sessionRow.Active) {
-      console.log(`[mbkauthe] Account is inactive for user "${req.session.user.username}"`);
-      req.session.destroy();
-      clearSessionCookies(res);
-      if (isJsonRequest(req)) {
-        return res.status(401).json(createErrorResponse(401, ErrorCodes.ACCOUNT_INACTIVE));
-      }
-      return renderError(res, req, {
+      logAuth(`Account is inactive for user "${sessionRow.UserName || req.session.user.username}"`);
+      return respondSessionFailure(req, res, {
+        prefersJson,
         code: 401,
+        errorCode: ErrorCodes.ACCOUNT_INACTIVE,
         error: "Account Inactive",
         message: "Your Account Is Inactive. Please Contact Support.",
         pagename: "Support",
@@ -277,104 +261,106 @@ async function validateSession(req, res, next, strictTokenValidation = false) {
       });
     }
 
-    if (role !== "SuperAdmin") {
-      // If allowedApps is not provided or not an array, treat as no access
-      const hasAllowedApps = Array.isArray(allowedApps) && allowedApps.length > 0;
-      if (!hasAllowedApps || !allowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase())) {
-        console.warn(`[mbkauthe] User \"${req.session.user.username}\" is not authorized to use the application \"${mbkautheVar.APP_NAME}\"`);
-        req.session.destroy();
-        clearSessionCookies(res);
-        if (isJsonRequest(req)) {
-          return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
-        }
-        return renderError(res, req, {
-          code: 401,
-          error: "Unauthorized",
-          message: `You Are Not Authorized To Use The Application \"${mbkautheVar.APP_NAME}\"`,
-          pagename: "Home",
-          page: `/${mbkautheVar.loginRedirectURL}`
-        });
-      }
+    if (!hasAppAccess(sessionRow.Role, sessionRow.AllowedApps)) {
+      console.warn(`[mbkauthe] User "${sessionRow.UserName || req.session.user.username}" is not authorized to use the application "${mbkautheVar.APP_NAME}"`);
+      return respondSessionFailure(req, res, {
+        prefersJson,
+        code: 401,
+        errorCode: ErrorCodes.APP_NOT_AUTHORIZED,
+        error: "Unauthorized",
+        message: `You Are Not Authorized To Use The Application "${mbkautheVar.APP_NAME}"`,
+        pagename: "Home",
+        page: `/${mbkautheVar.loginRedirectURL}`
+      });
     }
 
-    // Store user role in request for checkRolePermission to use
     req.userRole = sessionRow.Role;
-
-    next();
+    return next();
   } catch (err) {
     console.error(`[mbkauthe] Session validation error:`, err);
-    res.status(500).json({ success: false, message: "Internal Server Error" });
+    return res.status(500).json(createErrorResponse(500, ErrorCodes.INTERNAL_SERVER_ERROR));
   }
 }
 
-/**
- * API-friendly session validation middleware
- * Returns JSON error responses instead of rendering pages
- */
-async function validateApiSession(req, res, next) {
-  if (!req.session.user) {
-    return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_NOT_FOUND));
-  }
+async function validateSession(req, res, next, strictTokenValidation = false) {
+  if (req.headers.authorization) {
+    if (strictTokenValidation) {
+      return res.status(401).json(createErrorResponse(401, ErrorCodes.INVALID_AUTH_TOKEN, {
+        message: 'Token-based authentication not allowed for this endpoint',
+        hint: 'Use session-based authentication (cookies) instead'
+      }));
+    }
 
-  try {
-    const { sessionId, role, allowedApps } = req.session.user;
+    try {
+      const tokenUser = await validateTokenAuthentication(req);
 
-    // Defensive checks for sessionId and allowedApps
-    if (!sessionId || !isUuid(sessionId)) {
-      console.warn(`[mbkauthe] Missing sessionId for user "${req.session.user.username}"`);
-      req.session.destroy();
-      clearSessionCookies(res);
-      return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_EXPIRED));
-    }
+      if (tokenUser && !tokenUser.error) {
+        if (!tokenUser.active) {
+          return res.status(401).json(createErrorResponse(401, ErrorCodes.ACCOUNT_INACTIVE));
+        }
 
-    // Validate session by DB primary key id and join to user
-    const sessionRow = await authRepo.getSessionAuthData(sessionId, 'validate-app-session-for-api');
+        if (tokenUser.role !== "SuperAdmin") {
+          const allowedApps = tokenUser.allowedApps;
+          const userAllowedApps = tokenUser.userAllowedApps;
 
-    if (!sessionRow) {
-      req.session.destroy();
-      clearSessionCookies(res);
-      return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_INVALID));
-    }
+          if (!Array.isArray(allowedApps) || allowedApps.length === 0) {
+            return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
+          }
 
-    // Check expired
-    if (sessionRow.expires_at) {
-      const expiresMs = sessionRow.expires_at instanceof Date
-        ? sessionRow.expires_at.getTime()
-        : Date.parse(sessionRow.expires_at);
-      if (!Number.isNaN(expiresMs) && expiresMs <= Date.now()) {
-      req.session.destroy();
-      clearSessionCookies(res);
-      return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_EXPIRED));
-    }
-    }
+          const hasWildcard = allowedApps.includes('*');
+          const hasSpecificApp = allowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase());
 
+          if (hasWildcard) {
+            const userHasApp = Array.isArray(userAllowedApps)
+              && userAllowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase());
+            if (!userHasApp) {
+              return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
+            }
+          } else if (!hasSpecificApp) {
+            return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
+          }
+        }
 
-    if (!sessionRow.Active) {
-      console.log(`[mbkauthe] Account is inactive for user "${req.session.user.username}"`);
-      req.session.destroy();
-      clearSessionCookies(res);
-      return res.status(401).json(createErrorResponse(401, ErrorCodes.ACCOUNT_INACTIVE));
-    }
+        attachApiTokenUser(req, res, tokenUser);
 
-    if (role !== "SuperAdmin") {
-      // If allowedApps is not provided or not an array, treat as no access
-      const hasAllowedApps = Array.isArray(allowedApps) && allowedApps.length > 0;
-      if (!hasAllowedApps || !allowedApps.some(app => app && app.toLowerCase() === mbkautheVar.APP_NAME.toLowerCase())) {
-        console.warn(`[mbkauthe] User \"${req.session.user.username}\" is not authorized to use the application \"${mbkautheVar.APP_NAME}\"`);
-        req.session.destroy();
-        clearSessionCookies(res);
-        return res.status(401).json(createErrorResponse(401, ErrorCodes.APP_NOT_AUTHORIZED));
+        if (tokenUser.tokenScope) {
+          const requestMethod = req.method;
+          if (!canAccessMethod(tokenUser.tokenScope, requestMethod)) {
+            return res.status(403).json(createErrorResponse(403, ErrorCodes.TOKEN_SCOPE_INSUFFICIENT, {
+              message: `Token scope '${tokenUser.tokenScope}' does not allow ${requestMethod} requests`,
+              tokenScope: tokenUser.tokenScope,
+              requestedMethod: requestMethod,
+              hint: 'Use a token with write scope for write operations'
+            }));
+          }
+        }
+
+        return next();
+      }
+
+      let errorCode = ErrorCodes.INVALID_AUTH_TOKEN;
+      if (tokenUser && tokenUser.error === 'TOKEN_EXPIRED') {
+        errorCode = ErrorCodes.API_TOKEN_EXPIRED;
       }
+      return res.status(401).json(createErrorResponse(401, errorCode));
+    } catch (err) {
+      console.error(`[mbkauthe] Token validation error:`, err);
+      return res.status(500).json(createErrorResponse(500, ErrorCodes.INTERNAL_SERVER_ERROR));
     }
+  }
 
-    // Store user role in request for checkRolePermission to use
-    req.userRole = sessionRow.Role;
+  return validateCookieSession(req, res, next, { prefersJson: isJsonRequest(req) });
+}
 
-    next();
-  } catch (err) {
-    console.error(`[mbkauthe] API session validation error:`, err);
-    return res.status(500).json(createErrorResponse(500, ErrorCodes.INTERNAL_SERVER_ERROR));
+/**
+ * API-friendly session validation middleware
+ * Returns JSON error responses instead of rendering pages
+ */
+async function validateApiSession(req, res, next) {
+  if (req.headers.authorization) {
+    return validateSession(req, res, next);
   }
+  return validateCookieSession(req, res, next, { prefersJson: true });
 }
 
 /**
@@ -388,7 +374,7 @@ async function validateApiSession(req, res, next) {
 async function reloadSessionUser(req, res) {
   if (!req.session || !req.session.user || !req.session.user.id) return false;
   try {
-    const { id, sessionId: currentSessionId } = req.session.user;
+    const { sessionId: currentSessionId } = req.session.user;
 
     if (!currentSessionId) {
       req.session.destroy(() => { });
@@ -437,15 +423,10 @@ async function reloadSessionUser(req, res) {
     req.session.user.allowedApps = row.AllowedApps;
 
     // Obtain fullname from client cookie cache when present else DB
-    if (req.cookies && req.cookies.fullName && typeof req.cookies.fullName === 'string') {
+    if (typeof row.FullName === 'string' && row.FullName.trim() !== '') {
+      req.session.user.fullname = row.FullName;
+    } else if (req.cookies && req.cookies.fullName && typeof req.cookies.fullName === 'string') {
       req.session.user.fullname = req.cookies.fullName;
-    } else {
-      try {
-        const prof = await authRepo.getUserFullNameByUsername(row.UserName, 'reload-get-fullname');
-        if (prof && prof.FullName) req.session.user.fullname = prof.FullName;
-      } catch (profileErr) {
-        console.error(`[mbkauthe] Error fetching fullname during reload:`, profileErr);
-      }
     }
 
     // Persist session changes
@@ -472,8 +453,10 @@ async function reloadSessionUser(req, res) {
 const checkRolePermission = (requiredRoles, notAllowed) => {
   return async (req, res, next) => {
     try {
-      if (!req.session || !req.session.user || !req.session.user.id) {
-        console.log(`[mbkauthe] User not authenticated`);
+      const authUser = req.auth?.user || req.session?.user;
+
+      if (!authUser || !authUser.id) {
+        logAuth(`User not authenticated`);
         if (isJsonRequest(req)) {
           return res.status(401).json(createErrorResponse(401, ErrorCodes.SESSION_NOT_FOUND));
         }
@@ -487,10 +470,10 @@ const checkRolePermission = (requiredRoles, notAllowed) => {
       }
 
       // Use role from validateSession to avoid additional DB query
-      const userRole = req.userRole;
+      const userRole = req.userRole || authUser.role;
 
       // SuperAdmin bypasses all role checks
-      if(req.session.user?.role === "SuperAdmin" || userRole === "SuperAdmin") {
+      if(authUser.role === "SuperAdmin" || userRole === "SuperAdmin") {
         return next();
       }
 
@@ -550,10 +533,10 @@ const authenticate = (authentication) => {
   return (req, res, next) => {
     const token = extractAuthorizationToken(req.headers?.authorization ?? req.headers?.["authorization"]);
     if (timingSafeTokenMatch(token, authentication)) {
-      console.log(`[mbkauthe] Authentication successful`);
+      logAuth(`Authentication successful`);
       next();
     } else {
-      console.log(`[mbkauthe] Authentication failed`);
+      logAuth(`Authentication failed`);
       res.status(401).send("Unauthorized");
     }
   };

package/lib/middleware/index.js

@@ -35,6 +35,7 @@ export const sessionConfig = {
 };
 
 const authRepo = new AuthRepository({ db: dblogin });
+const hasAuthorizationHeader = (req) => typeof req.headers?.authorization === 'string' && req.headers.authorization.trim().length > 0;
 
 // CORS middleware
 export function corsMiddleware(req, res, next) {
@@ -60,6 +61,10 @@ export function corsMiddleware(req, res, next) {
 
 // Session restoration middleware
 export async function sessionRestorationMiddleware(req, res, next) {
+  if (hasAuthorizationHeader(req)) {
+    return next();
+  }
+
   // Only restore session if not already present and sessionId cookie exists
   if (!req.session.user && req.cookies.sessionId) {
     // Decrypt the sessionId from cookie
@@ -83,33 +88,23 @@ export async function sessionRestorationMiddleware(req, res, next) {
       const row = await authRepo.getSessionWithUserById(sessionId, 'restore-user-session');
 
       if (row) {
-
         // Reject expired sessions or inactive users
         if ((row.expires_at && new Date(row.expires_at) <= new Date()) || !row.Active) {
           // leave cookies cleared and don't restore session
         } else {
           const normalizedSessionId = String(sessionId);
           req.session.user = {
-            id: row.id,
+            id: row.uid,
             username: row.UserName,
             role: row.Role,
             sessionId: normalizedSessionId,
             allowedApps: row.AllowedApps,
           };
 
-          // Use cached FullName from client cookie when available to avoid extra DB queries
-          if (req.cookies && req.cookies.fullName && typeof req.cookies.fullName === 'string') {
+          if (typeof row.FullName === 'string' && row.FullName.trim() !== '') {
+            req.session.user.fullname = row.FullName;
+          } else if (req.cookies && typeof req.cookies.fullName === 'string') {
             req.session.user.fullname = req.cookies.fullName;
-          } else {
-            // Fallback: attempt to fetch FullName from Users to populate session
-            try {
-              const profileRes = await authRepo.getUserFullNameByUsername(row.UserName, 'restore-get-fullname');
-              if (profileRes && profileRes.FullName) {
-                req.session.user.fullname = profileRes.FullName;
-              }
-            } catch (profileErr) {
-              console.error(`[mbkauthe] Error fetching FullName during session restore:`, profileErr);
-            }
           }
         }
       }
@@ -122,6 +117,10 @@ export async function sessionRestorationMiddleware(req, res, next) {
 
 // Session cookie sync middleware
 export function sessionCookieSyncMiddleware(req, res, next) {
+  if (hasAuthorizationHeader(req) || req.auth?.type === 'api-token') {
+    return next();
+  }
+
   if (req.session && req.session.user) {
     // Decrypt existing cookie to compare with session
     const currentDecryptedId = decryptSessionId(req.cookies.sessionId);