propro-utils 1.5.64 → 1.5.65

package/middlewares/account_info.js

@@ -102,7 +102,10 @@ async function createDefaultFolders(folderSchema, accountId) {
 
 const debugLog = (area, message, data = null) => {
   const timestamp = new Date().toISOString();
-  console.log(`[${timestamp}] [${area}] ${message}`, data ? data : '');
+  console.log(
+    `[${timestamp}] [${area}] ${message}`,
+    data ? JSON.stringify(data, null, 2) : ''
+  );
 };
 
 const DEFAULT_THEME = {
@@ -113,142 +116,259 @@ const DEFAULT_THEME = {
   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}`);
 
-    // 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,
-      }));
+    // 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('Theme').catch(e => {
+            throw new Error(`Failed to get Theme: ${e.message}`);
+          }),
+        ]),
+        5000,
+        'Service initialization'
+      );
 
-    debugLog('theme', 'Theme ready', { themeId: defaultTheme._id });
+      debugLog('services', 'Services initialized successfully', {
+        serviceCount: services.length,
+        initTime: Date.now() - startTime,
+      });
+    } catch (error) {
+      debugLog('error', 'Service initialization failed', {
+        error: error.message,
+      });
+      throw error;
+    }
 
-    if (user) {
-      debugLog('user', 'Existing user found, updating if needed');
+    const [userSchema, userStyleSchema, folderSchema, Theme] = services;
 
-      const updates = [];
+    // 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'
+      );
 
-      // Collect necessary updates
-      if (!user.theme) {
-        user.theme = defaultTheme._id;
-        updates.push('theme');
-      }
+      debugLog('query', 'Queries completed', {
+        userFound: !!user,
+        themeFound: !!existingTheme,
+        queryTime: Date.now() - startTime,
+      });
+    } catch (error) {
+      debugLog('error', 'Query operations failed', { error: error.message });
+      throw error;
+    }
 
-      if (!user.userGlobalStyles) {
-        user.userGlobalStyles = await createUserGlobalStyles(
-          userStyleSchema,
-          accountId
+    // 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'
         );
-        updates.push('userGlobalStyles');
-      } else if (user.userGlobalStyles.styleShortcuts.length === 0) {
-        user.userGlobalStyles.styleShortcuts = defaultUserGlobalStyleShortcuts;
-        await user.userGlobalStyles.save();
+        debugLog('theme', 'New theme created', { themeId: defaultTheme._id });
+      } else {
+        defaultTheme = existingTheme;
+        debugLog('theme', 'Using existing theme', {
+          themeId: defaultTheme._id,
+        });
       }
+    } catch (error) {
+      debugLog('error', 'Theme operation failed', { error: error.message });
+      throw error;
+    }
 
-      // 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(
-        f => !userFolderNames.has(f.name)
-      );
+    if (user) {
+      debugLog('user', 'Processing existing user');
+      const updates = [];
+
+      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'
+          );
+        }
 
-      if (foldersToCreate.length > 0) {
-        debugLog(
-          'folders',
-          `Creating ${foldersToCreate.length} missing folders`
+        // Folder checks
+        debugLog('folders', 'Checking user folders');
+        const userFolders = await timeoutPromise(
+          folderSchema.find({ user_id: user.id }, { name: 1 }),
+          5000,
+          'Folder query'
         );
-        await Promise.all(
-          foldersToCreate.map(folder =>
-            folderSchema.create({
-              ...folder,
-              user_id: user.id,
-            })
-          )
+
+        const userFolderNames = new Set(userFolders.map(f => f.name));
+        const foldersToCreate = defaultFolders.filter(
+          f => !userFolderNames.has(f.name)
         );
-      }
 
-      // Save user only if there were updates
-      if (updates.length > 0) {
-        debugLog('update', `Saving user updates: ${updates.join(', ')}`);
-        await user.save();
+        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,
+        });
+        throw error;
       }
 
-      debugLog('complete', 'Existing user processed successfully');
+      debugLog('complete', 'Existing user processed', {
+        userId: user.id,
+        totalTime: Date.now() - startTime,
+      });
       return user;
     }
 
-    debugLog('create', 'Creating new user');
+    // Create new user
+    try {
+      debugLog('create', 'Creating new user');
+      const userGlobalStyles = await timeoutPromise(
+        createUserGlobalStyles(userStyleSchema, accountId),
+        5000,
+        'Global styles creation'
+      );
 
-    // Create new user with all required relations
-    const userGlobalStyles = await createUserGlobalStyles(
-      userStyleSchema,
-      accountId
-    );
+      const newUserId = uuidv4();
 
-    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,
-    });
-    return newUser;
+      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'
+      );
+
+      newUser.folders = newFolders.map(folder => folder._id);
+      await timeoutPromise(newUser.save(), 5000, 'New user save');
+
+      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,
     });
 
-    // Throw error with original cause and context
-    throw new Error('Failed to get or create user', {
+    throw new Error(`Failed to get or create user: ${error.message}`, {
       cause: error,
-      accountId,
     });
   }
 };
+
 module.exports = {
   getAccountProfile,
   checkIfUserExists,

package/package.json

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