propro-utils 1.7.1 → 1.7.2

package/middlewares/account_info.js

@@ -1,11 +1,11 @@
-require("dotenv").config();
-const axios = require("axios");
-const { getOrSetCache } = require("../utils/redis");
-const { v4: uuidv4 } = require("uuid");
-const ServiceManager = require("../utils/serviceManager");
+require('dotenv').config();
+const axios = require('axios');
+const { getOrSetCache } = require('../utils/redis');
+const { v4: uuidv4 } = require('uuid');
+const ServiceManager = require('../utils/serviceManager');
 const defaultUserGlobalStyleShortcuts =
-  require("./defaultUserGlobalStyleShortcuts.json").defaultGlobalStyleShortcuts;
-const defaultFolders = require("./defaultFolders.json").defaultFolders;
+  require('./defaultUserGlobalStyleShortcuts.json').defaultGlobalStyleShortcuts;
+const defaultFolders = require('./defaultFolders.json').defaultFolders;
 
 /**
  * Retrieves the account profile data from the authentication server and caches it using Redis.
@@ -20,10 +20,10 @@ const defaultFolders = require("./defaultFolders.json").defaultFolders;
 const getAccountProfile = async (redisClient, userSchema, accountId) => {
   try {
     const accessToken =
-      req.cookies["x-access-token"] || req.headers.authorization?.split(" ")[1];
+      req.cookies['x-access-token'] || req.headers.authorization?.split(' ')[1];
 
     if (!accessToken) {
-      throw new Error("Access token is required");
+      throw new Error('Access token is required');
     }
 
     const fetchPermission = async () => {
@@ -49,7 +49,7 @@ const getAccountProfile = async (redisClient, userSchema, accountId) => {
     );
 
     if (!profileData) {
-      throw new Error("Invalid permissions");
+      throw new Error('Invalid permissions');
     }
 
     return profileData;
@@ -57,10 +57,58 @@ const getAccountProfile = async (redisClient, userSchema, accountId) => {
     if (error.response && error.response.status) {
       throw new Error(error.response.data.message);
     }
-    throw new Error("Error validating token");
+    throw new Error('Error validating token');
   }
 };
 
+/**
+ * Consolidates multiple UserGlobalStyles documents for an account into one
+ * @param {string} accountId - The account ID to consolidate styles for
+ * @returns {Promise<Object>} The consolidated UserGlobalStyles document
+ */
+async function consolidateGlobalStyles(accountId) {
+  const userStyleSchema = await ServiceManager.getService('UserStyleSchema');
+
+  // Find all global styles for this account
+  const allStyles = await userStyleSchema
+    .find({ accountId })
+    .sort({ createdAt: 1 });
+
+  if (allStyles.length <= 1) {
+    return allStyles[0];
+  }
+
+  // Use the first document as the main one and merge shortcuts from others
+  const mainStyle = allStyles[0];
+  const uniqueShortcuts = new Map();
+
+  // Merge all shortcuts, keeping the latest version of each shortcut by ID
+  allStyles.forEach(style => {
+    style.styleShortcuts.forEach(shortcut => {
+      uniqueShortcuts.set(shortcut.id.toString(), shortcut);
+    });
+  });
+
+  // Update the main style document with consolidated shortcuts
+  mainStyle.styleShortcuts = Array.from(uniqueShortcuts.values());
+  await mainStyle.save();
+
+  // Delete other style documents
+  await userStyleSchema.deleteMany({
+    accountId,
+    _id: { $ne: mainStyle._id },
+  });
+
+  // Update user reference if needed
+  const userSchema = await ServiceManager.getService('UserSchema');
+  await userSchema.updateMany(
+    { accountId },
+    { userGlobalStyles: mainStyle._id }
+  );
+
+  return mainStyle;
+}
+
 /**
  * Creates a new user global styles document with default style shortcuts.
  *
@@ -69,6 +117,13 @@ const getAccountProfile = async (redisClient, userSchema, accountId) => {
  * @returns {Promise<Object>} A promise that resolves to the created user global styles object.
  */
 async function createUserGlobalStyles(userStyleSchema, accountId) {
+  // First check if any existing styles need to be consolidated
+  const existingStyles = await userStyleSchema.find({ accountId });
+
+  if (existingStyles.length > 0) {
+    return await consolidateGlobalStyles(accountId);
+  }
+
   return await userStyleSchema.create({
     id: uuidv4(),
     styleShortcuts: defaultUserGlobalStyleShortcuts,
@@ -85,8 +140,8 @@ async function createUserGlobalStyles(userStyleSchema, accountId) {
  */
 async function createDefaultFolders(folderSchema, accountId) {
   try {
-    console.log("Creating default folders for user:", accountId);
-    const folderPromises = defaultFolders.map((folder) =>
+    console.log('Creating default folders for user:', accountId);
+    const folderPromises = defaultFolders.map(folder =>
       folderSchema.create({
         ...folder,
         user_id: accountId,
@@ -94,17 +149,17 @@ async function createDefaultFolders(folderSchema, accountId) {
     );
     return Promise.all(folderPromises);
   } catch (error) {
-    console.error("Error in createDefaultFolders:", error);
-    throw new Error("Failed to create default folders");
+    console.error('Error in createDefaultFolders:', error);
+    throw new Error('Failed to create default folders');
   }
 }
 
 const DEFAULT_THEME = {
-  canvasBackground: "#000000",
+  canvasBackground: '#1E1D1D',
   defaultItemWidth: 200,
-  defaultColor: "#ffffff",
-  fontSize: "16px",
-  name: "Default Theme",
+  defaultColor: '#ffffff',
+  fontSize: '16px',
+  name: 'Default Theme',
   isDefault: true,
 };
 
@@ -116,152 +171,79 @@ const DEFAULT_THEME = {
  * @returns {Promise<Object>} A promise that resolves to the complete user object
  * @throws {Error} If there's an issue with database operations or invalid input
  */
-const checkIfUserExists = async (accountId) => {
-  console.log("Starting checkIfUserExists for accountId:", accountId);
-
+const checkIfUserExists = async accountId => {
   // Input validation
-  if (!accountId || typeof accountId !== "string") {
-    console.warn("Invalid accountId provided:", accountId);
-    throw new Error("Invalid accountId provided");
+  if (!accountId || typeof accountId !== 'string') {
+    console.warn('Invalid accountId provided:', accountId);
+    throw new Error('Invalid accountId provided');
   }
 
   try {
-    console.log("Loading schemas...");
-    // Load all required schemas in parallel
     const schemaResults = await Promise.all([
-      ServiceManager.getService("UserSchema"),
-      ServiceManager.getService("UserStyleSchema"),
-      ServiceManager.getService("FolderSchema"),
-      ServiceManager.getService("ThemeSchema"),
+      ServiceManager.getService('UserSchema'),
+      ServiceManager.getService('UserStyleSchema'),
+      ServiceManager.getService('FolderSchema'),
+      ServiceManager.getService('ThemeSchema'),
     ]);
 
     const [userSchema, userStyleSchema, folderSchema, themeSchema] =
       schemaResults;
 
-    // Log the status of each schema
-    console.log("Schema loading results:", {
-      userSchema: userSchema ? "Loaded" : "Not available",
-      userStyleSchema: userStyleSchema ? "Loaded" : "Not available",
-      folderSchema: folderSchema ? "Loaded" : "Not available",
-      themeSchema: themeSchema ? "Loaded" : "Not available",
-    });
-
     if (!userSchema) {
-      throw new Error("UserSchema service not available");
+      throw new Error('UserSchema service not available');
     }
 
     // Optional schemas warning
     if (!userStyleSchema) {
       console.warn(
-        "UserStyleSchema service not available - style features will be skipped"
+        'UserStyleSchema service not available - style features will be skipped'
       );
     }
     if (!folderSchema) {
       console.warn(
-        "FolderSchema service not available - folder features will be skipped"
+        'FolderSchema service not available - folder features will be skipped'
       );
     }
     if (!themeSchema) {
       console.warn(
-        "ThemeSchema service not available - theme features will be skipped"
+        'ThemeSchema service not available - theme features will be skipped'
       );
     }
 
-    console.log("Schema loading and validation complete");
-
-    // Find existing user without excluding fields we need to check
-    const user = await userSchema.findOne({ accountId }).lean();
-
-    console.log("User lookup result:", user ? "User found" : "User not found");
+    // Find existing user with populated fields
+    const user = await userSchema
+      .findOne({ accountId })
+      .select('-theme -folderList -userGlobalStyles -mapList')
+      .lean();
 
     if (user) {
-      console.log("Updating existing user data...");
       const updates = [];
 
-      // Handle userGlobalStyles - check properly if styles exist in the database
+      // Handle userGlobalStyles
       if (userStyleSchema) {
-        // Check if the user has a userGlobalStyles reference
-        const hasStyleReference = user.userGlobalStyles != null;
-
-        if (hasStyleReference) {
-          // Verify the referenced style document actually exists
-          const styleExists = await userStyleSchema.exists({
-            _id: user.userGlobalStyles,
-          });
-
-          if (!styleExists) {
-            console.log(
-              "User has style reference but document not found, creating new styles..."
-            );
-            updates.push(
-              createUserGlobalStyles(userStyleSchema, accountId).then(
-                async (styles) => {
-                  console.log("UserGlobalStyles created successfully");
-                  await userSchema.updateOne(
-                    { _id: user._id },
-                    { userGlobalStyles: styles._id }
-                  );
-                  return styles;
-                }
-              )
-            );
-          } else {
-            // Style exists, check if it has shortcuts
-            const styleDoc = await userStyleSchema.findById(
-              user.userGlobalStyles
-            );
-            if (
-              !styleDoc.styleShortcuts ||
-              styleDoc.styleShortcuts.length === 0
-            ) {
-              console.log("Updating empty styleShortcuts with defaults...");
-              updates.push(
-                userStyleSchema.updateOne(
-                  { _id: user.userGlobalStyles },
-                  { styleShortcuts: defaultUserGlobalStyleShortcuts }
-                )
-              );
-            }
-          }
-        } else {
-          // No style reference, create new styles
-          console.log("Creating missing userGlobalStyles...");
-          updates.push(
-            createUserGlobalStyles(userStyleSchema, accountId).then(
-              async (styles) => {
-                console.log("UserGlobalStyles created successfully");
-                await userSchema.updateOne(
-                  { _id: user._id },
-                  { userGlobalStyles: styles._id }
-                );
-                return styles;
-              }
-            )
-          );
-        }
+        // Consolidate any duplicate global styles
+        await consolidateGlobalStyles(accountId);
       }
 
       // Handle folders
       if (folderSchema) {
-        console.log("Checking folders...");
         updates.push(
           (async () => {
             const existingFolders = await folderSchema
               .find({ user_id: user.id })
-              .select("name")
+              .select('name')
               .lean();
 
-            console.log("Existing folders count:", existingFolders.length);
             const existingFolderNames = new Set(
-              existingFolders.map((f) => f.name)
+              existingFolders.map(f => f.name)
             );
             const foldersToCreate = defaultFolders.filter(
-              (folder) => !existingFolderNames.has(folder.name)
+              folder => !existingFolderNames.has(folder.name)
             );
 
             if (foldersToCreate.length > 0) {
               return folderSchema.insertMany(
-                foldersToCreate.map((folder) => ({
+                foldersToCreate.map(folder => ({
                   ...folder,
                   user_id: user.id,
                 }))
@@ -273,15 +255,13 @@ const checkIfUserExists = async (accountId) => {
 
       // Handle themes
       if (themeSchema) {
-        console.log("Checking themes...");
         updates.push(
           (async () => {
             const defaultThemeExists = await themeSchema.exists({
-              name: "Default Theme",
+              name: 'Default Theme',
               accountId,
             });
 
-            console.log("Default theme exists:", defaultThemeExists);
             if (!defaultThemeExists) {
               const defaultTheme = await themeSchema.create({
                 ...DEFAULT_THEME,
@@ -301,12 +281,13 @@ const checkIfUserExists = async (accountId) => {
       }
 
       // Wait for all updates to complete
-      console.log("Waiting for all updates to complete...");
       await Promise.all(updates);
-      console.log("All updates completed successfully");
 
-      // Return fresh user data after updates
-      return userSchema.findOne({ accountId }).lean();
+      // Return fresh user data after updates, excluding specified fields
+      return userSchema
+        .findOne({ accountId })
+        .select('-theme -folderList -userGlobalStyles -mapList')
+        .lean();
     }
 
     // Create new user with all associated data
@@ -317,7 +298,7 @@ const checkIfUserExists = async (accountId) => {
     let userGlobalStyles;
     if (userStyleSchema) {
       creationTasks.push(
-        createUserGlobalStyles(userStyleSchema, accountId).then((styles) => {
+        createUserGlobalStyles(userStyleSchema, accountId).then(styles => {
           userGlobalStyles = styles;
           return styles;
         })
@@ -335,8 +316,8 @@ const checkIfUserExists = async (accountId) => {
             userId,
             id: uuidv4(),
           })
-          .then((theme) => {
-            console.log("Created theme:", theme);
+          .then(theme => {
+            console.log('Created theme:', theme);
             defaultTheme = theme;
             return theme;
           })
@@ -360,10 +341,12 @@ const checkIfUserExists = async (accountId) => {
       await createDefaultFolders(folderSchema, newUser.id);
     }
 
-    console.log("Operation completed successfully");
-    return userSchema.findById(newUser._id).lean();
+    return userSchema
+      .findById(newUser._id)
+      .select('-theme -folderList -userGlobalStyles -mapList')
+      .lean();
   } catch (error) {
-    console.error("Detailed error in checkIfUserExists:", {
+    console.error('Detailed error in checkIfUserExists:', {
       accountId,
       errorName: error.name,
       errorMessage: error.message,
@@ -374,7 +357,44 @@ const checkIfUserExists = async (accountId) => {
   }
 };
 
+const updateUserGlobalStyleShortcuts = async (userId, shortcutId, shortcut) => {
+  try {
+    const user = await userSchema
+      .findOne({ id: userId })
+      .populate('userGlobalStyles');
+    if (!user) {
+      throw new Error('User not found');
+    }
+
+    // Ensure we have consolidated styles
+    const consolidatedStyles = await consolidateGlobalStyles(user.accountId);
+
+    // Find the index of the shortcut to update
+    const shortcutIndex = consolidatedStyles.styleShortcuts.findIndex(
+      s => s.id.toString() === shortcutId
+    );
+
+    if (shortcutIndex === -1) {
+      // If the shortcut doesn't exist, add it
+      consolidatedStyles.styleShortcuts.push(shortcut);
+    } else {
+      // If the shortcut exists, update it
+      consolidatedStyles.styleShortcuts[shortcutIndex] = {
+        ...consolidatedStyles.styleShortcuts[shortcutIndex],
+        ...shortcut,
+      };
+    }
+
+    await consolidatedStyles.save();
+    return consolidatedStyles;
+  } catch (error) {
+    console.error('Error updating user global style shortcuts:', error);
+    throw error;
+  }
+};
+
 module.exports = {
   getAccountProfile,
   checkIfUserExists,
+  updateUserGlobalStyleShortcuts,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propro-utils",
-  "version": "1.7.1",
+  "version": "1.7.2",
   "description": "Auth middleware for propro-auth",
   "main": "src/index.js",
   "scripts": {
@@ -46,7 +46,6 @@
     "jest-mock-axios": "^4.7.3",
     "jsonwebtoken": "^9.0.2",
     "multer": "^1.4.5-lts.1",
-    "neverthrow": "^8.2.0",
     "nodemailer": "^6.9.7",
     "nodemailer-mailgun-transport": "^2.1.5",
     "querystring": "^0.2.1",

package/src/server/index.js

@@ -168,7 +168,7 @@ class AuthMiddleware {
 
       setAuthCookies(res, tokens, account, user, this.options.appUrl);
 
-      res.redirect(formatRedirectUrl(this.options.appUrl));
+      res.redirect(formatRedirectUrl(this.options.redirectUri));
     } catch (error) {
       console.error('Error in callback:', error);
       res.status(500).send('Internal Server Error');

package/src/server/middleware/cookieUtils.js

@@ -3,19 +3,19 @@
  * This module provides functions for setting and clearing authentication cookies.
  */
 
-const { URL } = require("url");
+const { URL } = require('url');
 
 /**
  * Safely stringify an object, handling circular references
  * @param {Object} obj - The object to stringify
  * @return {string} A JSON string representation of the object
  */
-const safeStringify = (obj) => {
+const safeStringify = obj => {
   const seen = new WeakSet();
   return JSON.stringify(obj, (key, value) => {
-    if (typeof value === "object" && value !== null) {
+    if (typeof value === 'object' && value !== null) {
       if (seen.has(value)) {
-        return "[Circular]";
+        return '[Circular]';
       }
       seen.add(value);
     }
@@ -28,7 +28,7 @@ const safeStringify = (obj) => {
  * @param {Object} user - The user object to sanitize
  * @return {Object} A sanitized version of the user object
  */
-const sanitizeUser = (user) => {
+const sanitizeUser = user => {
   const sanitized = { ...user };
 
   delete sanitized.password;
@@ -61,10 +61,10 @@ const sanitizeUser = (user) => {
  * @param {Object} details - Cookie details
  * @returns {Promise} Promise that resolves when cookie is set
  */
-const setChromeExtensionCookie = (details) => {
+const setChromeExtensionCookie = details => {
   return new Promise((resolve, reject) => {
     try {
-      chrome.cookies.set(details, (cookie) => {
+      chrome.cookies.set(details, cookie => {
         if (chrome.runtime.lastError) {
           reject(chrome.runtime.lastError);
         } else {
@@ -83,13 +83,13 @@ const setChromeExtensionCookie = (details) => {
  */
 const setAuthCookies = async (res, tokens, account, user, appUrl) => {
   if (!tokens?.refresh?.token || !tokens?.access?.token) {
-    throw new Error("Invalid tokens object");
+    throw new Error('Invalid tokens object');
   }
   if (!account) {
-    throw new Error("Invalid account object");
+    throw new Error('Invalid account object');
   }
   if (!user) {
-    throw new Error("Invalid user object");
+    throw new Error('Invalid user object');
   }
 
   const currentDateTime = new Date();
@@ -99,47 +99,37 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
     new Date(tokens.access.expires).getTime() - currentDateTime.getTime();
 
   // Domain configuration
-  let isSecureConnection = false;
+  let domain;
   try {
-    // Handle URLs that don't include the protocol
-    let processedAppUrl = appUrl;
-    if (
-      appUrl &&
-      !appUrl.startsWith("http://") &&
-      !appUrl.startsWith("https://")
-    ) {
-      processedAppUrl = `https://${appUrl}`;
+    domain = appUrl ? new URL(appUrl).hostname : undefined;
+    if (domain?.includes('mapmap.app')) {
+      domain = '.mapmap.app';
+    }
+    if (domain?.includes('localhost')) {
+      domain = undefined;
+    }
+    if (domain?.includes('propro.so')) {
+      domain = 'propro.so';
     }
-
-    const urlObj = new URL(processedAppUrl);
-    isSecureConnection = urlObj.protocol === "https:";
-
-    console.log("Cookie configuration:", {
-      isSecure: isSecureConnection,
-      protocol: urlObj.protocol,
-      originalUrl: appUrl,
-      processedUrl: processedAppUrl,
-      hostname: urlObj.hostname,
-    });
   } catch (error) {
-    console.error("Invalid appUrl:", { error, appUrl });
-    isSecureConnection = false;
+    console.error('Invalid appUrl:', { error, appUrl });
+    domain = undefined;
   }
 
-  // Base cookie attributes without domain specification
   const commonAttributes = {
     secure: true,
-    sameSite: "None",
-    path: "/",
+    sameSite: 'None',
+    domain,
+    path: '/',
   };
 
   const httpOnlyCookies = {
-    "x-refresh-token": {
+    'x-refresh-token': {
       value: tokens.refresh.token,
       maxAge: refreshMaxAge,
       httpOnly: true,
     },
-    "x-access-token": {
+    'x-access-token': {
       value: tokens.access.token,
       maxAge: accessMaxAge,
       httpOnly: true,
@@ -154,59 +144,48 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
     user: {
       value: safeStringify(sanitizedUser),
       maxAge: refreshMaxAge,
-      httpOnly: false,
     },
     account: {
       value: safeStringify(sanitizedAccount),
       maxAge: refreshMaxAge,
-      httpOnly: false,
     },
     has_account_token: {
-      value: JSON.stringify({ value: "true", expires: accessMaxAge }),
+      value: JSON.stringify({ value: 'true', expires: accessMaxAge }),
       maxAge: accessMaxAge,
-      httpOnly: false,
     },
   };
 
   try {
-    // Set each cookie individually
     Object.entries({ ...httpOnlyCookies, ...regularCookies }).forEach(
       ([name, config]) => {
-        const cookieConfig = {
+        res.cookie(name, config.value, {
           ...commonAttributes,
           ...config,
-        };
-
-        res.cookie(name, config.value, cookieConfig);
+        });
       }
     );
 
-    // Handle extension cookies if in extension context
-    try {
-      const extensionCookiePromises = Object.entries({
-        ...httpOnlyCookies,
-        ...regularCookies,
-      }).map(([name, config]) => {
-        return setChromeExtensionCookie({
-          url: processedAppUrl,
-          name,
-          value: config.value,
-          secure: true,
-          httpOnly: !!config.httpOnly,
-          sameSite: "no_restriction",
-          path: "/",
-          expirationDate: Math.floor((Date.now() + config.maxAge) / 1000),
-        });
+    const extensionCookiePromises = Object.entries({
+      ...httpOnlyCookies,
+      ...regularCookies,
+    }).map(([name, config]) => {
+      return setChromeExtensionCookie({
+        url: `https://${domain || 'propro.so'}`,
+        name,
+        value: config.value,
+        secure: true,
+        httpOnly: !!config.httpOnly,
+        sameSite: 'no_restriction',
+        path: '/',
+        expirationDate: Math.floor((Date.now() + config.maxAge) / 1000),
+        domain: domain?.startsWith('.') ? domain : `.${domain || 'propro.so'}`,
       });
+    });
 
-      Promise.allSettled(extensionCookiePromises).catch(() => {
-        // Ignore extension errors
-      });
-    } catch (error) {
-      // Ignore extension errors
-    }
+    await Promise.allSettled(extensionCookiePromises);
 
-    console.log("Auth cookies set successfully", {
+    console.log('Auth cookies set successfully', {
+      domain,
       sameSite: commonAttributes.sameSite,
       cookieNames: [
         ...Object.keys(httpOnlyCookies),
@@ -214,11 +193,11 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
       ],
     });
   } catch (error) {
-    console.error("Error setting cookies:", {
+    console.error('Error setting cookies:', {
       error: error.message,
       stack: error.stack,
     });
-    throw new Error("Failed to set authentication cookies");
+    throw new Error('Failed to set authentication cookies');
   }
 };
 
@@ -226,77 +205,61 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
  * Clears cookies from both web and extension contexts
  */
 const clearAuthCookies = async (res, appUrl) => {
-  let isSecureConnection = false;
+  let domain;
   try {
-    // Handle URLs that don't include the protocol
-    let processedAppUrl = appUrl;
-    if (
-      appUrl &&
-      !appUrl.startsWith("http://") &&
-      !appUrl.startsWith("https://")
-    ) {
-      processedAppUrl = `https://${appUrl}`;
+    domain = appUrl ? new URL(appUrl).hostname : undefined;
+    if (domain?.includes('mapmap.app')) {
+      domain = '.mapmap.app';
+    }
+    if (domain?.includes('localhost')) {
+      domain = undefined;
     }
-
-    const urlObj = new URL(processedAppUrl);
-    isSecureConnection = urlObj.protocol === "https:";
-
-    console.log("Clear cookies configuration:", {
-      isSecure: isSecureConnection,
-      protocol: urlObj.protocol,
-      originalUrl: appUrl,
-      processedUrl: processedAppUrl,
-      hostname: urlObj.hostname,
-    });
   } catch (error) {
-    console.error("Invalid appUrl:", error);
-    isSecureConnection = false;
+    console.error('Invalid appUrl:', error);
+    domain = undefined;
   }
 
   const commonAttributes = {
     secure: true,
-    sameSite: "None",
-    path: "/",
-    expires: new Date(0),
+    sameSite: 'None',
+    domain,
+    path: '/',
   };
 
   const cookieNames = [
-    "x-refresh-token",
-    "x-access-token",
-    "user",
-    "account",
-    "has_account_token",
+    'x-refresh-token',
+    'x-access-token',
+    'user',
+    'account',
+    'has_account_token',
   ];
 
-  // Clear cookies with domain
-  cookieNames.forEach((cookieName) => {
+  // Clear web cookies
+  cookieNames.forEach(cookieName => {
     res.clearCookie(cookieName, commonAttributes);
   });
 
   try {
-    // Handle extension cookies if in extension context
     const extensionClearPromises = cookieNames.map(
-      (name) =>
-        new Promise((resolve) => {
+      name =>
+        new Promise(resolve => {
           chrome.cookies.remove(
             {
-              url: processedAppUrl,
+              url: `https://${domain || 'mapmap.app'}`,
               name,
-              secure: true,
             },
             resolve
           );
         })
     );
 
-    Promise.allSettled(extensionClearPromises).catch(() => {
-      // Ignore extension errors
-    });
+    await Promise.allSettled(extensionClearPromises);
   } catch (error) {
     // Not in extension context, ignore
   }
 
-  console.log("Auth cookies cleared successfully", {
+  console.log('Auth cookies cleared successfully', {
+    domain,
     cookieNames,
     sameSite: commonAttributes.sameSite,
   });