all commands and buttons are working

src/services/PlayerService.js

@@ -8,15 +8,34 @@ class PlayerService {
 
   async findUserByUsername(username) {
     try {
-      const response = await axios.get(
-        `${this.baseUrl}/api/get_player_data_by_username/${encodeURIComponent(username)}`,
-        {
-          timeout: 5000
+      console.log(`Fetching data for username: ${username}`);
+      const url = `${this.baseUrl}/api/get_player_data_by_username/${encodeURIComponent(username)}`;
+      console.log(`API URL: ${url}`);
+      
+      const response = await axios.get(url, {
+        timeout: 5000
+      });
+      
+      console.log('API Response:', JSON.stringify(response.data, null, 2));
+      
+      if (response.data && response.data.success) {
+        // Parse player_data if it's a string
+        if (typeof response.data.player_data === 'string') {
+          try {
+            response.data.player_data = JSON.parse(response.data.player_data);
+          } catch (parseError) {
+            console.error('Error parsing player_data:', parseError);
+          }
         }
-      );
+      }
+      
       return response.data;
     } catch (error) {
-      console.error('Error fetching user data:', error);
+      console.error('Error fetching user data:', {
+        message: error.message,
+        response: error.response?.data,
+        status: error.response?.status
+      });
       return null;
     }
   }

src/services/ServerRegistrationService.js

@@ -2,12 +2,18 @@ class ServerRegistrationService {
     constructor(supabase, logger) {
         this.supabase = supabase;
         this.logger = logger;
-        // Log when service is instantiated
         this.logger.info('ServerRegistrationService initialized');
     }
 
     async registerServer(guildId, serverName) {
-        // Add entry point log
+        // Input validation
+        if (!guildId || typeof guildId !== 'string') {
+            throw new Error('Invalid guildId provided');
+        }
+        if (!serverName || typeof serverName !== 'string') {
+            throw new Error('Invalid serverName provided');
+        }
+
         this.logger.info('registerServer method called', { 
             guildId, 
             serverName,
@@ -15,58 +21,72 @@ class ServerRegistrationService {
         });
 
         try {
-            this.logger.debug('Starting server registration process', { 
-                guildId, 
-                serverName,
-                timestamp: new Date().toISOString() 
-            });
-
+            // Check if server exists
             const { data: existingServer, error: checkError } = await this.supabase
                 .from('servers')
                 .select('*')
                 .eq('discord_server_id', guildId)
                 .single();
 
-            // Log the database query result
             this.logger.debug('Database query result', {
                 hasExistingServer: !!existingServer,
                 hasError: !!checkError,
                 errorCode: checkError?.code
             });
 
+            // If server exists, update the name if it changed
             if (existingServer) {
-                this.logger.info('Server already exists', { 
-                    serverId: existingServer.id,
-                    guildId 
-                });
+                if (existingServer.server_name !== serverName) {
+                    const { data: updatedServer, error: updateError } = await this.supabase
+                        .from('servers')
+                        .update({ server_name: serverName })
+                        .eq('id', existingServer.id)
+                        .select()
+                        .single();
+
+                    if (updateError) {
+                        this.logger.error('Failed to update server name', { error: updateError });
+                        throw updateError;
+                    }
+
+                    this.logger.info('Server name updated', {
+                        serverId: updatedServer.id,
+                        oldName: existingServer.server_name,
+                        newName: serverName
+                    });
+                    return { status: 'updated', server: updatedServer };
+                }
+                
                 return { status: 'exists', server: existingServer };
             }
 
-            if (!existingServer || checkError?.code === 'PGRST116') {
-                this.logger.debug('Attempting to create new server');
-                const { data: newServer, error: insertError } = await this.supabase
-                    .from('servers')
-                    .insert([{
-                        discord_server_id: guildId,
-                        server_name: serverName,
-                        active: true
-                    }])
-                    .select()
-                    .single();
+            // Create new server if it doesn't exist
+            const { data: newServer, error: insertError } = await this.supabase
+                .from('servers')
+                .insert([{
+                    discord_server_id: guildId,
+                    server_name: serverName,
+                    active: true,
+                    created_at: new Date().toISOString()
+                }])
+                .select()
+                .single();
 
-                if (insertError) {
-                    this.logger.error('Failed to insert new server', { error: insertError });
-                    throw insertError;
-                }
-
-                this.logger.info('New server created successfully', {
-                    serverId: newServer.id,
-                    guildId
+            if (insertError) {
+                this.logger.error('Failed to insert new server', { 
+                    error: insertError,
+                    details: insertError.details 
                 });
-                return { status: 'created', server: newServer };
+                throw insertError;
             }
 
-            throw checkError;
+            this.logger.info('New server created successfully', {
+                serverId: newServer.id,
+                guildId,
+                serverName
+            });
+            return { status: 'created', server: newServer };
+
         } catch (error) {
             this.logger.error('Error in registerServer:', {
                 error: error.message,
@@ -77,6 +97,20 @@ class ServerRegistrationService {
             throw error;
         }
     }
+
+    // Helper method to validate server data
+    validateServerData(guildId, serverName) {
+        if (!guildId || typeof guildId !== 'string') {
+            return { valid: false, error: 'Invalid guildId' };
+        }
+        if (!serverName || typeof serverName !== 'string') {
+            return { valid: false, error: 'Invalid serverName' };
+        }
+        if (serverName.length > 100) {
+            return { valid: false, error: 'Server name too long' };
+        }
+        return { valid: true };
+    }
 }
 
 module.exports = ServerRegistrationService;