propro-utils 1.5.62 → 1.5.63

package/middlewares/account_info.js

@@ -100,35 +100,68 @@ async function createDefaultFolders(folderSchema, accountId) {
   }
 }
 
+const debugLog = (area, message, data = null) => {
+  const timestamp = new Date().toISOString();
+  console.log(`[${timestamp}] [${area}] ${message}`, data ? data : '');
+};
+
+const DEFAULT_THEME = {
+  canvasBackground: '#000000',
+  defaultItemWidth: 200,
+  defaultColor: '#ffffff',
+  fontSize: '16px',
+  name: 'Default Theme',
+};
+
 const checkIfUserExists = async accountId => {
   try {
-    const userSchema = await ServiceManager.getService('UserSchema');
-    const userStyleSchema = await ServiceManager.getService('UserStyleSchema');
-    const folderSchema = await ServiceManager.getService('FolderSchema');
-    const Theme = await ServiceManager.getService('Theme');
+    debugLog('init', `Starting user check for accountId: ${accountId}`);
+
+    // Parallel service initialization
+    const [userSchema, userStyleSchema, folderSchema, Theme] =
+      await Promise.all([
+        ServiceManager.getService('UserSchema'),
+        ServiceManager.getService('UserStyleSchema'),
+        ServiceManager.getService('FolderSchema'),
+        ServiceManager.getService('Theme'),
+      ]);
+
+    debugLog('services', 'All services initialized');
+
+    // Find user and theme in parallel
+    const [user, existingTheme] = await Promise.all([
+      userSchema.findOne({ accountId }).populate('userGlobalStyles'),
+      Theme.findOne({
+        name: 'Default Theme',
+        accountId,
+      }),
+    ]);
+
+    debugLog('query', 'Initial queries complete', {
+      userFound: !!user,
+      themeFound: !!existingTheme,
+    });
+
+    // Create or use existing theme
+    const defaultTheme =
+      existingTheme ||
+      (await Theme.create({
+        ...DEFAULT_THEME,
+        id: uuidv4(),
+        accountId,
+      }));
 
-    let user = await userSchema
-      .findOne({ accountId })
-      .populate('userGlobalStyles');
+    debugLog('theme', 'Theme ready', { themeId: defaultTheme._id });
 
     if (user) {
+      debugLog('user', 'Existing user found, updating if needed');
+
+      const updates = [];
+
+      // Collect necessary updates
       if (!user.theme) {
-        let defaultTheme = await Theme.findOne({
-          name: 'Default Theme',
-          accountId,
-        });
-        if (!defaultTheme) {
-          defaultTheme = await Theme.create({
-            canvasBackground: '#000000',
-            defaultItemWidth: 200,
-            defaultColor: '#ffffff',
-            fontSize: '16px',
-            name: 'Default Theme',
-            id: uuidv4(),
-          });
-        }
         user.theme = defaultTheme._id;
-        await user.save();
+        updates.push('theme');
       }
 
       if (!user.userGlobalStyles) {
@@ -136,21 +169,27 @@ const checkIfUserExists = async accountId => {
           userStyleSchema,
           accountId
         );
-        await user.save();
+        updates.push('userGlobalStyles');
       } else if (user.userGlobalStyles.styleShortcuts.length === 0) {
         user.userGlobalStyles.styleShortcuts = defaultUserGlobalStyleShortcuts;
         await user.userGlobalStyles.save();
       }
 
-      const userFolders = await folderSchema.find({ user_id: user.id });
-      const defaultFolderNames = defaultFolders.map(folder => folder.name);
-      const userFolderNames = userFolders.map(folder => folder.name);
-
+      // Check folders only if needed
+      const userFolders = await folderSchema.find(
+        { user_id: user.id },
+        { name: 1 }
+      );
+      const userFolderNames = new Set(userFolders.map(f => f.name));
       const foldersToCreate = defaultFolders.filter(
-        folder => !userFolderNames.includes(folder.name)
+        f => !userFolderNames.has(f.name)
       );
 
       if (foldersToCreate.length > 0) {
+        debugLog(
+          'folders',
+          `Creating ${foldersToCreate.length} missing folders`
+        );
         await Promise.all(
           foldersToCreate.map(folder =>
             folderSchema.create({
@@ -161,49 +200,55 @@ const checkIfUserExists = async accountId => {
         );
       }
 
+      // Save user only if there were updates
+      if (updates.length > 0) {
+        debugLog('update', `Saving user updates: ${updates.join(', ')}`);
+        await user.save();
+      }
+
+      debugLog('complete', 'Existing user processed successfully');
       return user;
     }
 
-    let defaultTheme = await Theme.findOne({
-      name: 'Default Theme',
-      accountId,
-    });
-    if (!defaultTheme) {
-      defaultTheme = await Theme.create({
-        canvasBackground: '#000000',
-        defaultItemWidth: 200,
-        defaultColor: '#ffffff',
-        fontSize: '16px',
-        name: 'Default Theme',
-        id: uuidv4(),
-      });
-    }
+    debugLog('create', 'Creating new user');
 
+    // Create new user with all required relations
     const userGlobalStyles = await createUserGlobalStyles(
       userStyleSchema,
       accountId
     );
 
-    user = await userSchema.create({
-      accountId,
-      id: uuidv4(),
-      verified: false,
-      userGlobalStyles: userGlobalStyles._id,
-      theme: defaultTheme._id,
+    const [newUser, newFolders] = await Promise.all([
+      userSchema.create({
+        accountId,
+        id: uuidv4(),
+        verified: false,
+        userGlobalStyles: userGlobalStyles._id,
+        theme: defaultTheme._id,
+      }),
+      createDefaultFolders(folderSchema, uuidv4()), // Pass the new user ID
+    ]);
+
+    newUser.folders = newFolders.map(folder => folder._id);
+    await newUser.save();
+
+    debugLog('complete', 'New user created successfully', {
+      userId: newUser.id,
     });
-
-    const folders = await createDefaultFolders(folderSchema, user.id);
-    console.log('Folders created:', folders);
-    user.folders = folders.map(folder => folder._id);
-    await user.save();
-
-    return user;
+    return newUser;
   } catch (error) {
-    console.error('Error in checkIfUserExists:', error);
-    throw new Error('Failed to get or create user');
+    debugLog('error', 'Operation failed', {
+      error: error.message,
+      stack: error.stack,
+    });
+
+    // Throw error with original cause and context
+    throw new Error('Failed to get or create user', {
+      cause: error,
+      accountId,
+    });
   }
 };
-
 module.exports = {
   getAccountProfile,
   checkIfUserExists,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "propro-utils",
-  "version": "1.5.62",
+  "version": "1.5.63",
   "description": "Auth middleware for propro-auth",
   "main": "src/index.js",
   "scripts": {

package/src/server/index.js

@@ -8,6 +8,7 @@ const {
   clearAuthCookies,
 } = require('./middleware/cookieUtils');
 const { checkIfUserExists } = require('../../middlewares/account_info');
+const UserService = require('../../middlewares/userService');
 const authValidation = require('../../middlewares/access_token');
 const axios = require('axios');
 const { Router, query } = require('express');
@@ -84,7 +85,8 @@ class AuthMiddleware {
 
       const { account, tokens } = response.data;
       console.log('account:', account);
-      const user = await checkIfUserExists(account.accountId);
+      // const user = await checkIfUserExists(account.accountId);
+      const user = await UserService.checkIfUserExists(account.accountId);
       console.log('user:', user);
 
       if (returnTokens === 'true') {