propro-utils 1.5.72 → 1.5.74

package/middlewares/account_info.js

@@ -99,6 +99,14 @@ async function createDefaultFolders(folderSchema, accountId) {
   }
 }
 
+const DEFAULT_THEME = {
+  canvasBackground: '#000000',
+  defaultItemWidth: 200,
+  defaultColor: '#ffffff',
+  fontSize: '16px',
+  name: 'Default Theme',
+};
+
 /**
  * Checks if a user exists based on the given account ID.
  * If the user does not exist, creates a new user with the given account ID.
@@ -108,272 +116,97 @@ async function createDefaultFolders(folderSchema, accountId) {
  * @returns {Promise<Object>} A promise that resolves to the user object.
  * @throws {Error} If there's an issue with database operations.
  */
-const debugLog = (area, message, data = null) => {
-  const timestamp = new Date().toISOString();
-  console.log(
-    `[${timestamp}] [${area}] ${message}`,
-    data ? JSON.stringify(data, null, 2) : ''
-  );
-};
-
-const DEFAULT_THEME = {
-  canvasBackground: '#000000',
-  defaultItemWidth: 200,
-  defaultColor: '#ffffff',
-  fontSize: '16px',
-  name: 'Default Theme',
-};
-
-const timeoutPromise = (promise, timeout, name) => {
-  return Promise.race([
-    promise,
-    new Promise((_, reject) =>
-      setTimeout(
-        () =>
-          reject(new Error(`${name} operation timed out after ${timeout}ms`)),
-        timeout
-      )
-    ),
-  ]);
-};
-
 const checkIfUserExists = async accountId => {
-  const startTime = Date.now();
   try {
-    if (!accountId) {
-      throw new Error('AccountId is required');
-    }
-    debugLog('init', `Starting user check for accountId: ${accountId}`);
-
-    // Initialize services with timeout and individual error handling
-    let services;
-    try {
-      debugLog('services', 'Initializing services...');
-      services = await timeoutPromise(
-        Promise.all([
-          ServiceManager.getService('UserSchema').catch(e => {
-            throw new Error(`Failed to get UserSchema: ${e.message}`);
-          }),
-          ServiceManager.getService('UserStyleSchema').catch(e => {
-            throw new Error(`Failed to get UserStyleSchema: ${e.message}`);
-          }),
-          ServiceManager.getService('FolderSchema').catch(e => {
-            throw new Error(`Failed to get FolderSchema: ${e.message}`);
-          }),
-          ServiceManager.getService('ThemeSchema').catch(e => {
-            throw new Error(`Failed to get Theme: ${e.message}`);
-          }),
-        ]),
-        5000,
-        'Service initialization'
-      );
-
-      debugLog('services', 'Services initialized successfully', {
-        serviceCount: services.length,
-        initTime: Date.now() - startTime,
-      });
-    } catch (error) {
-      debugLog('error', 'Service initialization failed', {
-        error: error.message,
-      });
-      throw error;
-    }
-
-    const [userSchema, userStyleSchema, folderSchema, Theme] = services;
-
-    // Find user and theme with timeout
-    let user, existingTheme;
-    try {
-      debugLog('query', 'Starting user and theme queries');
-      [user, existingTheme] = await timeoutPromise(
-        Promise.all([
-          userSchema
-            .findOne({ accountId })
-            .populate('userGlobalStyles')
-            .exec()
-            .catch(e => {
-              throw new Error(`Failed to find user: ${e.message}`);
-            }),
-          Theme.findOne({
-            name: 'Default Theme',
-            accountId,
-          })
-            .exec()
-            .catch(e => {
-              throw new Error(`Failed to find theme: ${e.message}`);
-            }),
-        ]),
-        5000,
-        'Initial queries'
-      );
+    const userSchema = await ServiceManager.getService('UserSchema');
+    const userStyleSchema = await ServiceManager.getService('UserStyleSchema');
+    const folderSchema = await ServiceManager.getService('FolderSchema');
+    const themeSchema = await ServiceManager.getService('ThemeSchema');
 
-      debugLog('query', 'Queries completed', {
-        userFound: !!user,
-        themeFound: !!existingTheme,
-        queryTime: Date.now() - startTime,
-      });
-    } catch (error) {
-      debugLog('error', 'Query operations failed', { error: error.message });
-      throw error;
-    }
+    console.log('themeschema', themeSchema);
+    let user = await userSchema
+      .findOne({ accountId })
+      .populate('userGlobalStyles');
 
-    // Create or use existing theme
-    let defaultTheme;
-    try {
-      if (!existingTheme) {
-        debugLog('theme', 'Creating new theme');
-        defaultTheme = await timeoutPromise(
-          Theme.create({
-            ...DEFAULT_THEME,
-            id: uuidv4(),
-            accountId,
-          }),
-          5000,
-          'Theme creation'
+    if (user) {
+      if (!user.userGlobalStyles) {
+        user.userGlobalStyles = await createUserGlobalStyles(
+          userStyleSchema,
+          accountId
         );
-        debugLog('theme', 'New theme created', { themeId: defaultTheme._id });
-      } else {
-        defaultTheme = existingTheme;
-        debugLog('theme', 'Using existing theme', {
-          themeId: defaultTheme._id,
-        });
+        await user.save();
+      } else if (user.userGlobalStyles.styleShortcuts.length === 0) {
+        user.userGlobalStyles.styleShortcuts = defaultUserGlobalStyleShortcuts;
+        await user.userGlobalStyles.save();
       }
-    } catch (error) {
-      debugLog('error', 'Theme operation failed', { error: error.message });
-      throw error;
-    }
-
-    if (user) {
-      debugLog('user', 'Processing existing user');
-      const updates = [];
+      // Check if user has any folders
+      const userFolders = await folderSchema.find({ user_id: user.id });
+      const defaultFolderNames = defaultFolders.map(folder => folder.name);
+      const userFolderNames = userFolders.map(folder => folder.name);
 
-      try {
-        // Theme update if needed
-        if (!user.theme) {
-          debugLog('update', 'Adding theme to user');
-          user.theme = defaultTheme._id;
-          updates.push('theme');
-        }
-
-        // Global styles update if needed
-        if (!user.userGlobalStyles) {
-          debugLog('update', 'Creating user global styles');
-          user.userGlobalStyles = await timeoutPromise(
-            createUserGlobalStyles(userStyleSchema, accountId),
-            5000,
-            'Global styles creation'
-          );
-          updates.push('userGlobalStyles');
-        } else if (user.userGlobalStyles.styleShortcuts.length === 0) {
-          debugLog('update', 'Updating empty style shortcuts');
-          user.userGlobalStyles.styleShortcuts =
-            defaultUserGlobalStyleShortcuts;
-          await timeoutPromise(
-            user.userGlobalStyles.save(),
-            5000,
-            'Style shortcuts update'
-          );
-        }
-
-        // Folder checks
-        debugLog('folders', 'Checking user folders');
-        const userFolders = await timeoutPromise(
-          folderSchema.find({ user_id: user.id }, { name: 1 }),
-          5000,
-          'Folder query'
-        );
+      const foldersToCreate = defaultFolders.filter(
+        folder => !userFolderNames.includes(folder.name)
+      );
 
-        const userFolderNames = new Set(userFolders.map(f => f.name));
-        const foldersToCreate = defaultFolders.filter(
-          f => !userFolderNames.has(f.name)
+      if (foldersToCreate.length > 0) {
+        await Promise.all(
+          foldersToCreate.map(folder =>
+            folderSchema.create({
+              ...folder,
+              user_id: user.id,
+            })
+          )
         );
+      }
 
-        if (foldersToCreate.length > 0) {
-          debugLog('folders', 'Creating missing folders', {
-            count: foldersToCreate.length,
-          });
-          await timeoutPromise(
-            Promise.all(
-              foldersToCreate.map(folder =>
-                folderSchema.create({
-                  ...folder,
-                  user_id: user.id,
-                })
-              )
-            ),
-            5000,
-            'Folder creation'
-          );
-        }
-
-        // Save user if there were updates
-        if (updates.length > 0) {
-          debugLog('update', 'Saving user updates', { updates });
-          await timeoutPromise(user.save(), 5000, 'User save');
-        }
-      } catch (error) {
-        debugLog('error', 'User update operations failed', {
-          error: error.message,
+      // Check if user has any themes
+      const userThemes = await themeSchema.find({
+        name: 'Default Theme',
+        accountId,
+      });
+      if (userThemes.length === 0) {
+        const defaultTheme = await themeSchema.create({
+          ...DEFAULT_THEME,
+          accountId,
+          userId: user.id,
+          id: uuidv4(),
         });
-        throw error;
+        user.theme = [defaultTheme._id];
+        await user.save();
       }
 
-      debugLog('complete', 'Existing user processed', {
-        userId: user.id,
-        totalTime: Date.now() - startTime,
-      });
       return user;
     }
 
-    // Create new user
-    try {
-      debugLog('create', 'Creating new user');
-      const userGlobalStyles = await timeoutPromise(
-        createUserGlobalStyles(userStyleSchema, accountId),
-        5000,
-        'Global styles creation'
-      );
-
-      const newUserId = uuidv4();
+    const userGlobalStyles = await createUserGlobalStyles(
+      userStyleSchema,
+      accountId
+    );
 
-      const [newUser, newFolders] = await timeoutPromise(
-        Promise.all([
-          userSchema.create({
-            accountId,
-            id: newUserId,
-            verified: false,
-            userGlobalStyles: userGlobalStyles._id,
-            theme: defaultTheme._id,
-          }),
-          createDefaultFolders(folderSchema, newUserId),
-        ]),
-        5000,
-        'User and folders creation'
-      );
+    user = await userSchema.create({
+      accountId,
+      id: uuidv4(),
+      verified: false,
+      userGlobalStyles: userGlobalStyles._id,
+    });
 
-      newUser.folders = newFolders.map(folder => folder._id);
-      await timeoutPromise(newUser.save(), 5000, 'New user save');
+    const folders = await createDefaultFolders(folderSchema, user.id);
+    console.log('Folders created:', folders);
+    user.folders = folders.map(folder => folder._id);
 
-      debugLog('complete', 'New user created', {
-        userId: newUser.id,
-        totalTime: Date.now() - startTime,
-      });
-      return newUser;
-    } catch (error) {
-      debugLog('error', 'User creation failed', { error: error.message });
-      throw error;
-    }
-  } catch (error) {
-    const totalTime = Date.now() - startTime;
-    debugLog('error', 'Operation failed', {
-      error: error.message,
-      stack: error.stack,
-      totalTime,
+    const defaultTheme = await themeSchema.create({
+      ...DEFAULT_THEME,
+      accountId,
+      userId: user.id,
+      id: uuidv4(),
     });
+    user.theme = [defaultTheme._id];
+    await user.save();
 
-    throw new Error(`Failed to get or create user: ${error.message}`, {
-      cause: error,
-    });
+    return user;
+  } catch (error) {
+    console.error('Error in checkIfUserExists:', error);
+    throw new Error('Failed to get or create user');
   }
 };
 

package/package.json

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