propro-utils 1.5.67 → 1.5.69

package/middlewares/account_info.js

@@ -99,6 +99,35 @@ async function createDefaultFolders(folderSchema, accountId) {
   }
 }
 
+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
+      )
+    ),
+  ]);
+};
+
 /**
  * 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.
@@ -109,70 +138,242 @@ async function createDefaultFolders(folderSchema, accountId) {
  * @throws {Error} If there's an issue with database operations.
  */
 const checkIfUserExists = async accountId => {
+  const startTime = Date.now();
   try {
-    const userSchema = await ServiceManager.getService('UserSchema');
-    const userStyleSchema = await ServiceManager.getService('UserStyleSchema');
-    const folderSchema = await ServiceManager.getService('FolderSchema');
+    if (!accountId) {
+      throw new Error('AccountId is required');
+    }
+    debugLog('init', `Starting user check for accountId: ${accountId}`);
 
-    let user = await userSchema
-      .findOne({ accountId })
-      .populate('userGlobalStyles');
+    // 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'
+      );
 
-    if (user) {
-      if (!user.userGlobalStyles) {
-        user.userGlobalStyles = await createUserGlobalStyles(
-          userStyleSchema,
-          accountId
+      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'
+      );
+
+      debugLog('query', 'Queries completed', {
+        userFound: !!user,
+        themeFound: !!existingTheme,
+        queryTime: Date.now() - startTime,
+      });
+    } catch (error) {
+      debugLog('error', 'Query operations failed', { error: error.message });
+      throw error;
+    }
+
+    // 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'
         );
-        await user.save();
-      } 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,
+        });
       }
-      // 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);
+    } catch (error) {
+      debugLog('error', 'Theme operation failed', { error: error.message });
+      throw error;
+    }
 
-      const foldersToCreate = defaultFolders.filter(
-        folder => !userFolderNames.includes(folder.name)
-      );
+    if (user) {
+      debugLog('user', 'Processing existing user');
+      const updates = [];
 
-      if (foldersToCreate.length > 0) {
-        await Promise.all(
-          foldersToCreate.map(folder =>
-            folderSchema.create({
-              ...folder,
-              user_id: user.id,
-            })
-          )
+      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 userFolderNames = new Set(userFolders.map(f => f.name));
+        const foldersToCreate = defaultFolders.filter(
+          f => !userFolderNames.has(f.name)
         );
+
+        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', {
+        userId: user.id,
+        totalTime: Date.now() - startTime,
+      });
       return user;
     }
 
-    const userGlobalStyles = await createUserGlobalStyles(
-      userStyleSchema,
-      accountId
-    );
+    // Create new user
+    try {
+      debugLog('create', 'Creating new user');
+      const userGlobalStyles = await timeoutPromise(
+        createUserGlobalStyles(userStyleSchema, accountId),
+        5000,
+        'Global styles creation'
+      );
 
-    user = await userSchema.create({
-      accountId,
-      id: uuidv4(),
-      verified: false,
-      userGlobalStyles: userGlobalStyles._id,
-    });
+      const newUserId = uuidv4();
+
+      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'
+      );
 
-    const folders = await createDefaultFolders(folderSchema, user.id);
-    console.log('Folders created:', folders);
-    user.folders = folders.map(folder => folder._id);
-    await user.save();
+      newUser.folders = newFolders.map(folder => folder._id);
+      await timeoutPromise(newUser.save(), 5000, 'New user save');
 
-    return user;
+      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) {
-    console.error('Error in checkIfUserExists:', error);
-    throw new Error('Failed to get or create user');
+    const totalTime = Date.now() - startTime;
+    debugLog('error', 'Operation failed', {
+      error: error.message,
+      stack: error.stack,
+      totalTime,
+    });
+
+    throw new Error(`Failed to get or create user: ${error.message}`, {
+      cause: error,
+    });
   }
 };
 

package/package.json

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

package/src/server/index.js

@@ -33,7 +33,13 @@ const upload = multer().single('file');
  * @returns {Function} - Express middleware function.
  */
 class AuthMiddleware {
-  constructor(options = {}, userSchema, userStyleSchema, redisClient) {
+  constructor(
+    options = {},
+    userSchema,
+    userStyleSchema,
+    themeSchema,
+    redisClient
+  ) {
     this.options = {
       secret: options.secret || 'RESTFULAPIs',
       authUrl: options.authUrl || process.env.AUTH_URL,
@@ -47,6 +53,7 @@ class AuthMiddleware {
     this.userSchema = userSchema;
     this.redisClient = redisClient;
     this.userStyleSchema = userStyleSchema;
+    this.themeSchema = themeSchema;
     this.router = Router();
     this.initializeRoutes();
   }
@@ -84,8 +91,7 @@ class AuthMiddleware {
 
       const { account, tokens } = response.data;
       console.log('account:', account);
-      // const user = await checkIfUserExists(account.accountId);
-      const user = await UserService.checkIfUserExists(account.accountId);
+      const user = await checkIfUserExists(account.accountId);
       console.log('user:', user);
 
       if (returnTokens === 'true') {