propro-utils 1.6.2 → 1.6.3

package/middlewares/account_info.js

@@ -61,55 +61,6 @@ const getAccountProfile = async (redisClient, userSchema, accountId) => {
   }
 };
 
-/**
- * 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 })
-    .options({ allowDiskUse: true });
-
-  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.
  *
@@ -118,13 +69,6 @@ async function consolidateGlobalStyles(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,
@@ -156,7 +100,7 @@ async function createDefaultFolders(folderSchema, accountId) {
 }
 
 const DEFAULT_THEME = {
-  canvasBackground: "#1E1D1D",
+  canvasBackground: "#000000",
   defaultItemWidth: 200,
   defaultColor: "#ffffff",
   fontSize: "16px",
@@ -173,6 +117,8 @@ const DEFAULT_THEME = {
  * @throws {Error} If there's an issue with database operations or invalid input
  */
 const checkIfUserExists = async (accountId) => {
+  console.log("Starting checkIfUserExists for accountId:", accountId);
+
   // Input validation
   if (!accountId || typeof accountId !== "string") {
     console.warn("Invalid accountId provided:", accountId);
@@ -180,6 +126,8 @@ const checkIfUserExists = async (accountId) => {
   }
 
   try {
+    console.log("Loading schemas...");
+    // Load all required schemas in parallel
     const schemaResults = await Promise.all([
       ServiceManager.getService("UserSchema"),
       ServiceManager.getService("UserStyleSchema"),
@@ -190,6 +138,14 @@ const checkIfUserExists = async (accountId) => {
     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");
     }
@@ -211,23 +167,83 @@ const checkIfUserExists = async (accountId) => {
       );
     }
 
-    // Find existing user with populated fields
-    const user = await userSchema
-      .findOne({ accountId })
-      .select("-theme -folderList -userGlobalStyles -mapList")
-      .lean();
+    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");
 
     if (user) {
+      console.log("Updating existing user data...");
       const updates = [];
 
-      // Handle userGlobalStyles
+      // Handle userGlobalStyles - check properly if styles exist in the database
       if (userStyleSchema) {
-        // Consolidate any duplicate global styles
-        await consolidateGlobalStyles(accountId);
+        // 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;
+              }
+            )
+          );
+        }
       }
 
       // Handle folders
       if (folderSchema) {
+        console.log("Checking folders...");
         updates.push(
           (async () => {
             const existingFolders = await folderSchema
@@ -235,6 +251,7 @@ const checkIfUserExists = async (accountId) => {
               .select("name")
               .lean();
 
+            console.log("Existing folders count:", existingFolders.length);
             const existingFolderNames = new Set(
               existingFolders.map((f) => f.name)
             );
@@ -256,6 +273,7 @@ const checkIfUserExists = async (accountId) => {
 
       // Handle themes
       if (themeSchema) {
+        console.log("Checking themes...");
         updates.push(
           (async () => {
             const defaultThemeExists = await themeSchema.exists({
@@ -263,6 +281,7 @@ const checkIfUserExists = async (accountId) => {
               accountId,
             });
 
+            console.log("Default theme exists:", defaultThemeExists);
             if (!defaultThemeExists) {
               const defaultTheme = await themeSchema.create({
                 ...DEFAULT_THEME,
@@ -282,13 +301,12 @@ 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, excluding specified fields
-      return userSchema
-        .findOne({ accountId })
-        .select("-theme -folderList -userGlobalStyles -mapList")
-        .lean();
+      // Return fresh user data after updates
+      return userSchema.findOne({ accountId }).lean();
     }
 
     // Create new user with all associated data
@@ -342,10 +360,8 @@ const checkIfUserExists = async (accountId) => {
       await createDefaultFolders(folderSchema, newUser.id);
     }
 
-    return userSchema
-      .findById(newUser._id)
-      .select("-theme -folderList -userGlobalStyles -mapList")
-      .lean();
+    console.log("Operation completed successfully");
+    return userSchema.findById(newUser._id).lean();
   } catch (error) {
     console.error("Detailed error in checkIfUserExists:", {
       accountId,
@@ -358,44 +374,7 @@ 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.6.2",
+  "version": "1.6.3",
   "description": "Auth middleware for propro-auth",
   "main": "src/index.js",
   "scripts": {

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();
@@ -102,34 +102,34 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
   let domain;
   try {
     domain = appUrl ? new URL(appUrl).hostname : undefined;
-    if (domain?.includes("mapmap.app")) {
-      domain = ".mapmap.app";
+    if (domain?.includes('mapmap.app')) {
+      domain = '.mapmap.app';
     }
-    if (domain?.includes("localhost")) {
+    if (domain?.includes('localhost')) {
       domain = undefined;
     }
-    if (domain?.includes("propro.so")) {
-      domain = ".propro.so";
+    if (domain?.includes('propro.so')) {
+      domain = 'propro.so';
     }
   } catch (error) {
-    console.error("Invalid appUrl:", { error, appUrl });
+    console.error('Invalid appUrl:', { error, appUrl });
     domain = undefined;
   }
 
   const commonAttributes = {
     secure: true,
-    sameSite: "None",
+    sameSite: 'None',
     domain,
-    path: "/",
+    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,
@@ -150,7 +150,7 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
       maxAge: refreshMaxAge,
     },
     has_account_token: {
-      value: JSON.stringify({ value: "true", expires: accessMaxAge }),
+      value: JSON.stringify({ value: 'true', expires: accessMaxAge }),
       maxAge: accessMaxAge,
     },
   };
@@ -170,21 +170,21 @@ const setAuthCookies = async (res, tokens, account, user, appUrl) => {
       ...regularCookies,
     }).map(([name, config]) => {
       return setChromeExtensionCookie({
-        url: `https://${domain || "propro.so"}`,
+        url: `https://${domain || 'propro.so'}`,
         name,
         value: config.value,
         secure: true,
         httpOnly: !!config.httpOnly,
-        sameSite: "no_restriction",
-        path: "/",
+        sameSite: 'no_restriction',
+        path: '/',
         expirationDate: Math.floor((Date.now() + config.maxAge) / 1000),
-        domain: domain?.startsWith(".") ? domain : `.${domain || "propro.so"}`,
+        domain: domain?.startsWith('.') ? domain : `.${domain || 'propro.so'}`,
       });
     });
 
     await Promise.allSettled(extensionCookiePromises);
 
-    console.log("Auth cookies set successfully", {
+    console.log('Auth cookies set successfully', {
       domain,
       sameSite: commonAttributes.sameSite,
       cookieNames: [
@@ -193,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');
   }
 };
 
@@ -208,44 +208,44 @@ const clearAuthCookies = async (res, appUrl) => {
   let domain;
   try {
     domain = appUrl ? new URL(appUrl).hostname : undefined;
-    if (domain?.includes("mapmap.app")) {
-      domain = ".mapmap.app";
+    if (domain?.includes('mapmap.app')) {
+      domain = '.mapmap.app';
     }
-    if (domain?.includes("localhost")) {
+    if (domain?.includes('localhost')) {
       domain = undefined;
     }
   } catch (error) {
-    console.error("Invalid appUrl:", error);
+    console.error('Invalid appUrl:', error);
     domain = undefined;
   }
 
   const commonAttributes = {
     secure: true,
-    sameSite: "None",
+    sameSite: 'None',
     domain,
-    path: "/",
+    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 web cookies
-  cookieNames.forEach((cookieName) => {
+  cookieNames.forEach(cookieName => {
     res.clearCookie(cookieName, commonAttributes);
   });
 
   try {
     const extensionClearPromises = cookieNames.map(
-      (name) =>
-        new Promise((resolve) => {
+      name =>
+        new Promise(resolve => {
           chrome.cookies.remove(
             {
-              url: `https://${domain || "mapmap.app"}`,
+              url: `https://${domain || 'mapmap.app'}`,
               name,
             },
             resolve
@@ -258,7 +258,7 @@ const clearAuthCookies = async (res, appUrl) => {
     // Not in extension context, ignore
   }
 
-  console.log("Auth cookies cleared successfully", {
+  console.log('Auth cookies cleared successfully', {
     domain,
     cookieNames,
     sameSite: commonAttributes.sameSite,