ваше сообщение коммита

backend/routes/auth.js

@@ -534,51 +534,133 @@ router.post('/link-identity', async (req, res) => {
 // Проверка статуса аутентификации
 router.get('/check', async (req, res) => {
   try {
-    console.log('Check auth, session data:', {
-      userId: req.session.userId,
-      authenticated: req.session.authenticated,
-      authType: req.session.authType,
-      telegramId: req.session.telegramId
-    });
+    logger.info(`[session/check] Checking session: ${req.sessionID}`);
     
-    // Если пользователь не аутентифицирован
-    if (!req.session.authenticated || !req.session.userId) {
-      return res.json({
-        authenticated: false
+    const authenticated = req.session.authenticated || false;
+    const authType = req.session.authType || null;
+    
+    // Подробное логирование для отладки восстановления сессии
+    logger.info(`[session/check] Session state: authenticated=${authenticated}, authType=${authType}, userId=${req.session.userId || 'none'}`);
+    
+    // Проверяем наличие идентификаторов в сессии
+    const sessionIdentities = [];
+    if (req.session.userId) sessionIdentities.push(`userId:${req.session.userId}`);
+    if (req.session.email) sessionIdentities.push(`email:${req.session.email}`);
+    if (req.session.address) sessionIdentities.push(`address:${req.session.address}`);
+    if (req.session.telegramId) sessionIdentities.push(`telegramId:${req.session.telegramId}`);
+    
+    logger.info(`[session/check] Identities in session: ${sessionIdentities.join(', ')}`);
+    
+    let identities = [];
+    let isAdmin = false;
+    
+    if (authenticated && req.session.userId) {
+      // Если пользователь аутентифицирован, получаем его идентификаторы из БД
+      try {
+        const identitiesResult = await db.query(
+          `SELECT provider, provider_id FROM user_identities WHERE user_id = $1`,
+          [req.session.userId]
+        );
+        
+        identities = identitiesResult.rows;
+        logger.info(`[session/check] Found ${identities.length} identities in database for user ${req.session.userId}`);
+        
+        // Проверяем роль пользователя
+        const roleResult = await db.query(
+          'SELECT role FROM users WHERE id = $1',
+          [req.session.userId]
+        );
+        
+        if (roleResult.rows.length > 0) {
+          isAdmin = roleResult.rows[0].role === 'admin';
+          req.session.isAdmin = isAdmin;
+        }
+      } catch (error) {
+        logger.error(`[session/check] Error fetching identities: ${error.message}`);
+      }
+    }
+    
+    // Проверяем, нужно ли создать новый гостевой ID
+    if (!authenticated && !req.session.guestId) {
+      req.session.guestId = crypto.randomBytes(16).toString('hex');
+      logger.info(`[session/check] Created new guest ID: ${req.session.guestId}`);
+      
+      // Сохраняем сессию с новым гостевым ID
+      await new Promise((resolve, reject) => {
+        req.session.save(err => {
+          if (err) {
+            logger.error('[session/check] Error saving session with new guest ID:', err);
+            reject(err);
+          } else {
+            logger.info('[session/check] Session with new guest ID saved successfully');
+            resolve();
+          }
+        });
       });
     }
     
-    // Возвращаем полную информацию об аутентифицированном пользователе
-    const userData = {
-      authenticated: true,
-      userId: req.session.userId,
-      authType: req.session.authType,
-      isAdmin: req.session.isAdmin || false
+    // Формируем ответ
+    const response = {
+      success: true,
+      authenticated,
+      userId: req.session.userId || null,
+      guestId: req.session.guestId || null,
+      authType,
+      identitiesCount: identities.length,
+      isAdmin: isAdmin || false
     };
     
-    // Добавляем идентификаторы, если они есть в сессии
-    if (req.session.address) userData.address = req.session.address;
-    if (req.session.telegramId) userData.telegramId = req.session.telegramId;
-    if (req.session.email) userData.email = req.session.email;
+    // Добавляем специфические поля в зависимости от типа аутентификации
+    if (authType === 'wallet') {
+      response.address = req.session.address || null;
+    } else if (authType === 'email') {
+      response.email = req.session.email || null;
+    } else if (authType === 'telegram') {
+      response.telegramId = req.session.telegramId || null;
+      if (req.session.telegramUsername) {
+        response.telegramUsername = req.session.telegramUsername;
+      }
+      if (req.session.telegramFirstName) {
+        response.telegramFirstName = req.session.telegramFirstName;
+      }
+    }
     
-    console.log('Returning auth data:', userData);
-    
-    res.json(userData);
+    logger.info(`[session/check] Session check complete: authenticated=${authenticated}, authType=${authType}`);
+    return res.json(response);
   } catch (error) {
-    console.error('Error checking auth status:', error);
-    res.status(500).json({ error: 'Internal server error' });
+    logger.error('[session/check] Error:', error);
+    return res.status(500).json({
+      success: false,
+      error: 'Internal server error'
+    });
   }
 });
 
 // Выход из системы
-router.post('/logout', (req, res) => {
-  req.session.destroy((err) => {
-    if (err) {
-      console.error('Error destroying session:', err);
-      return res.status(500).json({ error: 'Failed to logout' });
+router.post('/logout', async (req, res) => {
+  try {
+    logger.info('[logout] Logout request received');
+    
+    const sessionService = require('../services/session-service');
+    const result = await sessionService.logout(req.session);
+    
+    if (result) {
+      logger.info('[logout] User successfully logged out');
+      return res.json({ success: true });
+    } else {
+      logger.warn('[logout] Error during logout process');
+      return res.status(500).json({ 
+        success: false, 
+        error: 'Error during logout process' 
+      });
     }
-    res.json({ success: true });
-  });
+  } catch (error) {
+    logger.error('[logout] Error:', error);
+    return res.status(500).json({ 
+      success: false, 
+      error: 'Internal server error' 
+    });
+  }
 });
 
 // Маршрут для авторизации через Telegram
@@ -1455,29 +1537,10 @@ async function linkGuestMessagesAfterAuth(session, userId) {
       return { success: true, message: 'No guest IDs to process' };
     }
     
-    // Получаем список постоянных идентификаторов пользователя
-    const permanentIdentitiesResult = await db.query(
-      `SELECT provider, provider_id FROM user_identities WHERE user_id = $1 AND provider IN ('wallet', 'email', 'telegram')`,
-      [userId]
-    );
-    
-    // Логирование найденных постоянных идентификаторов
-    logger.info(`[linkGuestMessagesAfterAuth] Found ${permanentIdentitiesResult.rows.length} permanent identities for user ${userId}`);
-    permanentIdentitiesResult.rows.forEach(identity => {
-      logger.info(`[linkGuestMessagesAfterAuth] - ${identity.provider}:${identity.provider_id}`);
-    });
-    
-    // Сохраняем все постоянные идентификаторы из сессии
-    if (session.email) {
-      await saveUserIdentity(userId, 'email', session.email, true);
-    }
-    
-    if (session.address) {
-      await saveUserIdentity(userId, 'wallet', session.address, true);
-    }
-    
-    if (session.telegramId) {
-      await saveUserIdentity(userId, 'telegram', session.telegramId, true);
+    // Инициализируем массив обработанных ID, если он не существует
+    if (!session.processedGuestIds) {
+      session.processedGuestIds = [];
+      logger.info(`[linkGuestMessagesAfterAuth] Initialized processedGuestIds array for session`);
     }
     
     let results = [];
@@ -1487,12 +1550,13 @@ async function linkGuestMessagesAfterAuth(session, userId) {
       logger.info(`[linkGuestMessagesAfterAuth] Processing current guest ID ${guestId} for user ${userId}`);
       
       try {
-        // Сохраняем гостевой ID как идентификатор пользователя
-        await saveUserIdentity(userId, 'guest', guestId, true);
-        
         // Связываем сообщения с пользователем через обертку с правильным порядком аргументов
         const result = await processGuestMessagesWrapper(guestId, userId);
         results.push({ guestId, result });
+        
+        // Добавляем в список обработанных
+        session.processedGuestIds.push(guestId);
+        
         logger.info(`[linkGuestMessagesAfterAuth] Successfully processed guest ID ${guestId}`);
       } catch (error) {
         logger.error(`[linkGuestMessagesAfterAuth] Error processing guest ID ${guestId}:`, error);
@@ -1505,12 +1569,13 @@ async function linkGuestMessagesAfterAuth(session, userId) {
       logger.info(`[linkGuestMessagesAfterAuth] Processing previous guest ID ${previousGuestId} for user ${userId}`);
       
       try {
-        // Сохраняем предыдущий гостевой ID как идентификатор пользователя
-        await saveUserIdentity(userId, 'guest', previousGuestId, true);
-        
         // Связываем сообщения с пользователем через обертку с правильным порядком аргументов
         const result = await processGuestMessagesWrapper(previousGuestId, userId);
         results.push({ guestId: previousGuestId, result });
+        
+        // Добавляем в список обработанных
+        session.processedGuestIds.push(previousGuestId);
+        
         logger.info(`[linkGuestMessagesAfterAuth] Successfully processed previous guest ID ${previousGuestId}`);
       } catch (error) {
         logger.error(`[linkGuestMessagesAfterAuth] Error processing previous guest ID ${previousGuestId}:`, error);
@@ -1688,6 +1753,11 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
     
     logger.info(`[link-guest-messages] Request for user ${userId}`);
     
+    // Проверка кэша обработанных ID в сессии
+    if (!req.session.processedGuestIds) {
+      req.session.processedGuestIds = [];
+    }
+    
     // Получаем все идентификаторы пользователя
     const userIdentitiesResult = await db.query(
       `SELECT provider, provider_id FROM user_identities WHERE user_id = $1`,
@@ -1696,66 +1766,44 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
     
     const userIdentities = userIdentitiesResult.rows;
     logger.info(`[link-guest-messages] Found ${userIdentities.length} identities for user ${userId}`);
-    userIdentities.forEach(identity => {
-      logger.info(`[link-guest-messages] - ${identity.provider}:${identity.provider_id}`);
-    });
     
-    // Собираем все guestId, связанные с идентификаторами пользователя
-    let guestIds = [];
+    // Получаем только гостевые идентификаторы и фильтруем по неообработанным
+    const guestIdentities = userIdentities
+      .filter(identity => identity.provider === 'guest')
+      .filter(identity => !req.session.processedGuestIds.includes(identity.provider_id));
     
-    // Добавляем текущий guestId из сессии
-    if (req.session.guestId) {
-      guestIds.push(req.session.guestId);
+    // Добавляем текущий guestId из сессии если он еще не обработан
+    if (req.session.guestId && !req.session.processedGuestIds.includes(req.session.guestId)) {
+      guestIdentities.push({ provider: 'guest', provider_id: req.session.guestId });
       logger.info(`[link-guest-messages] Added session guestId: ${req.session.guestId}`);
     }
     
-    // Добавляем guestId из тела запроса, если есть
-    if (req.body.guestId) {
-      guestIds.push(req.body.guestId);
+    // Добавляем guestId из тела запроса, если есть и еще не обработан
+    if (req.body.guestId && !req.session.processedGuestIds.includes(req.body.guestId)) {
+      guestIdentities.push({ provider: 'guest', provider_id: req.body.guestId });
       logger.info(`[link-guest-messages] Added request body guestId: ${req.body.guestId}`);
     }
     
-    // Добавляем массив guestIds из тела запроса, если есть
-    if (req.body.guestIds && Array.isArray(req.body.guestIds)) {
-      logger.info(`[link-guest-messages] Adding ${req.body.guestIds.length} guestIds from request body`);
-      guestIds = [...guestIds, ...req.body.guestIds];
-    }
-    
-    // Добавляем guestId из идентификаторов пользователя
-    const guestIdentities = userIdentities.filter(identity => identity.provider === 'guest');
-    if (guestIdentities.length > 0) {
-      logger.info(`[link-guest-messages] Adding ${guestIdentities.length} guest identities from user_identities`);
-      guestIds = [...guestIds, ...guestIdentities.map(identity => identity.provider_id)];
-    }
-    
     // Убираем дубликаты
-    guestIds = [...new Set(guestIds)];
+    const uniqueGuestIds = [...new Set(guestIdentities.map(i => i.provider_id))];
     
-    logger.info(`[link-guest-messages] Final list of unique guestIds to process: ${guestIds.length}`);
-    guestIds.forEach(id => logger.info(`[link-guest-messages] - ${id}`));
-    
-    if (guestIds.length === 0) {
-      logger.info('[link-guest-messages] No guest IDs found for user');
-      return res.json({ success: true, message: 'No guest messages to link' });
+    // Если все ID уже обработаны, сразу возвращаем успех
+    if (uniqueGuestIds.length === 0) {
+      logger.info('[link-guest-messages] No new guest IDs to process');
+      return res.json({ 
+        success: true, 
+        message: 'All guest IDs already processed',
+        processedIds: req.session.processedGuestIds
+      });
     }
     
+    logger.info(`[link-guest-messages] Found ${uniqueGuestIds.length} new guestIds to process`);
+    uniqueGuestIds.forEach(id => logger.info(`[link-guest-messages] - ${id}`));
+    
     const results = [];
     
-    // Обрабатываем каждый guestId
-    for (const guestId of guestIds) {
-      // Пропускаем пустые или невалидные ID
-      if (!guestId || typeof guestId !== 'string') {
-        logger.warn(`[link-guest-messages] Skipping invalid guest ID: ${guestId}`);
-        continue;
-      }
-      
-      // Проверяем, не обрабатывали ли мы уже этот ID
-      if (req.session.processedGuestIds && req.session.processedGuestIds.includes(guestId)) {
-        logger.info(`[link-guest-messages] Guest ID ${guestId} already processed, skipping`);
-        results.push({ guestId, result: { success: true, message: 'Already processed' } });
-        continue;
-      }
-      
+    // Обрабатываем каждый новый guestId
+    for (const guestId of uniqueGuestIds) {
       // Проверяем наличие гостевых сообщений
       try {
         const guestMessagesCheck = await db.query(
@@ -1769,6 +1817,10 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
             // Используем обертку с правильным порядком аргументов
             const result = await processGuestMessagesWrapper(guestId, userId);
             results.push({ guestId, result });
+            
+            // Добавляем в список обработанных
+            req.session.processedGuestIds.push(guestId);
+            
             logger.info(`[link-guest-messages] Successfully processed guest ID ${guestId}`);
           } catch (error) {
             logger.error(`[link-guest-messages] Error processing guest ID ${guestId}:`, error);
@@ -1776,6 +1828,8 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
           }
         } else {
           logger.info(`[link-guest-messages] No guest messages found for guest ID ${guestId}`);
+          // Всё равно добавляем в обработанные, чтобы не проверять снова
+          req.session.processedGuestIds.push(guestId);
           results.push({ guestId, result: { success: true, message: 'No messages found' } });
         }
       } catch (error) {
@@ -1784,19 +1838,6 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
       }
     }
     
-    // Сохраняем все обработанные guestId, чтобы не обрабатывать их снова
-    if (!req.session.processedGuestIds) {
-      req.session.processedGuestIds = [];
-    }
-    
-    // Добавляем только успешно обработанные ID
-    const successfulGuestIds = results
-      .filter(r => r.result && r.result.success)
-      .map(r => r.guestId);
-    
-    req.session.processedGuestIds = [...new Set([...req.session.processedGuestIds, ...successfulGuestIds])];
-    logger.info(`[link-guest-messages] Updated processed guest IDs: ${req.session.processedGuestIds.join(', ')}`);
-    
     // Очищаем текущий guestId из сессии
     req.session.guestId = null;
     await req.session.save();
@@ -1805,7 +1846,8 @@ router.post('/link-guest-messages', requireAuth, async (req, res) => {
     return res.json({
       success: true,
       message: `Processed ${results.length} guest IDs`,
-      results
+      results,
+      processedIds: req.session.processedGuestIds
     });
   } catch (error) {
     logger.error('[link-guest-messages] Error:', error);

backend/routes/chat.js

@@ -142,19 +142,25 @@ async function processGuestMessages(userId, guestId) {
 // Обработчик для гостевых сообщений
 router.post('/guest-message', async (req, res) => {
   try {
-    const { message, language } = req.body;
-    const guestId = req.session.guestId || crypto.randomBytes(16).toString('hex');
+    const { content, language, guestId: requestGuestId } = req.body;
+    
+    if (!content) {
+      return res.status(400).json({ success: false, error: 'Content is required' });
+    }
+    
+    // Используем гостевой ID из запроса или из сессии, или генерируем новый
+    const guestId = requestGuestId || req.session.guestId || crypto.randomBytes(16).toString('hex');
 
     // Сохраняем ID гостя в сессии
     req.session.guestId = guestId;
     await req.session.save();
 
-    console.log('Saving guest message:', { guestId, message });
+    console.log('Saving guest message:', { guestId, content });
 
     // Сохраняем сообщение пользователя
     const result = await db.query(
       'INSERT INTO guest_messages (guest_id, content, language, is_ai) VALUES ($1, $2, $3, false) RETURNING id',
-      [guestId, message, language]
+      [guestId, content, language || 'auto']
     );
 
     console.log('Guest message saved:', result.rows[0]);

backend/services/identity-service.js

@@ -0,0 +1,200 @@
+const db = require('../db');
+const logger = require('../utils/logger');
+
+/**
+ * Сервис для работы с идентификаторами пользователей
+ */
+class IdentityService {
+  /**
+   * Сохраняет идентификатор пользователя в базу данных
+   * @param {number} userId - ID пользователя
+   * @param {string} provider - Тип идентификатора (wallet, email, telegram, guest)
+   * @param {string} providerId - Значение идентификатора
+   * @param {boolean} verified - Флаг верификации идентификатора
+   * @returns {Promise<object>} - Результат операции
+   */
+  async saveIdentity(userId, provider, providerId, verified = true) {
+    try {
+      if (!userId || !provider || !providerId) {
+        logger.warn(`[IdentityService] Missing required parameters: userId=${userId}, provider=${provider}, providerId=${providerId}`);
+        return {
+          success: false,
+          error: 'Missing required parameters'
+        };
+      }
+      
+      logger.info(`[IdentityService] Saving identity for user ${userId}: ${provider}:${providerId}`);
+      
+      // Проверяем, существует ли уже такой идентификатор
+      const existingResult = await db.query(
+        `SELECT user_id FROM user_identities WHERE provider = $1 AND provider_id = $2`,
+        [provider, providerId]
+      );
+      
+      if (existingResult.rows.length > 0) {
+        const existingUserId = existingResult.rows[0].user_id;
+        
+        // Если идентификатор уже принадлежит этому пользователю, ничего не делаем
+        if (existingUserId === userId) {
+          logger.info(`[IdentityService] Identity ${provider}:${providerId} already exists for user ${userId}`);
+        } else {
+          // Если идентификатор принадлежит другому пользователю, логируем это
+          logger.warn(`[IdentityService] Identity ${provider}:${providerId} already belongs to user ${existingUserId}, not user ${userId}`);
+          return {
+            success: false,
+            error: `Identity already belongs to another user (${existingUserId})`
+          };
+        }
+      } else {
+        // Создаем новую запись
+        await db.query(
+          `INSERT INTO user_identities (user_id, provider, provider_id) 
+           VALUES ($1, $2, $3)`,
+          [userId, provider, providerId]
+        );
+        logger.info(`[IdentityService] Created new identity ${provider}:${providerId} for user ${userId}`);
+      }
+      
+      return { success: true };
+    } catch (error) {
+      logger.error(`[IdentityService] Error saving identity ${provider}:${providerId} for user ${userId}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+  
+  /**
+   * Получает все идентификаторы пользователя
+   * @param {number} userId - ID пользователя
+   * @returns {Promise<Array>} - Массив идентификаторов
+   */
+  async getUserIdentities(userId) {
+    try {
+      if (!userId) {
+        logger.warn('[IdentityService] Missing userId parameter');
+        return [];
+      }
+      
+      const result = await db.query(
+        `SELECT provider, provider_id FROM user_identities WHERE user_id = $1`,
+        [userId]
+      );
+      
+      logger.info(`[IdentityService] Found ${result.rows.length} identities for user ${userId}`);
+      return result.rows;
+    } catch (error) {
+      logger.error(`[IdentityService] Error getting identities for user ${userId}:`, error);
+      return [];
+    }
+  }
+  
+  /**
+   * Получает все идентификаторы пользователя определенного типа
+   * @param {number} userId - ID пользователя
+   * @param {string} provider - Тип идентификатора
+   * @returns {Promise<Array>} - Массив идентификаторов
+   */
+  async getUserIdentitiesByProvider(userId, provider) {
+    try {
+      if (!userId || !provider) {
+        logger.warn(`[IdentityService] Missing parameters: userId=${userId}, provider=${provider}`);
+        return [];
+      }
+      
+      const result = await db.query(
+        `SELECT provider_id FROM user_identities WHERE user_id = $1 AND provider = $2`,
+        [userId, provider]
+      );
+      
+      logger.info(`[IdentityService] Found ${result.rows.length} ${provider} identities for user ${userId}`);
+      return result.rows.map(row => row.provider_id);
+    } catch (error) {
+      logger.error(`[IdentityService] Error getting ${provider} identities for user ${userId}:`, error);
+      return [];
+    }
+  }
+  
+  /**
+   * Находит пользователя по идентификатору
+   * @param {string} provider - Тип идентификатора
+   * @param {string} providerId - Значение идентификатора
+   * @returns {Promise<object|null>} - Информация о пользователе или null
+   */
+  async findUserByIdentity(provider, providerId) {
+    try {
+      if (!provider || !providerId) {
+        logger.warn(`[IdentityService] Missing parameters: provider=${provider}, providerId=${providerId}`);
+        return null;
+      }
+      
+      const result = await db.query(
+        `SELECT u.id, u.role FROM users u 
+         JOIN user_identities ui ON u.id = ui.user_id 
+         WHERE ui.provider = $1 AND ui.provider_id = $2`,
+        [provider, providerId]
+      );
+      
+      if (result.rows.length === 0) {
+        logger.info(`[IdentityService] No user found with identity ${provider}:${providerId}`);
+        return null;
+      }
+      
+      logger.info(`[IdentityService] Found user ${result.rows[0].id} with identity ${provider}:${providerId}`);
+      return result.rows[0];
+    } catch (error) {
+      logger.error(`[IdentityService] Error finding user by identity ${provider}:${providerId}:`, error);
+      return null;
+    }
+  }
+  
+  /**
+   * Сохраняет идентификаторы из сессии для пользователя
+   * @param {object} session - Объект сессии
+   * @param {number} userId - ID пользователя
+   * @returns {Promise<object>} - Результат операции
+   */
+  async saveIdentitiesFromSession(session, userId) {
+    try {
+      if (!session || !userId) {
+        logger.warn(`[IdentityService] Missing parameters: session=${!!session}, userId=${userId}`);
+        return { success: false, error: 'Missing required parameters' };
+      }
+      
+      const results = [];
+      
+      // Сохраняем все постоянные идентификаторы из сессии
+      if (session.email) {
+        const emailResult = await this.saveIdentity(userId, 'email', session.email.toLowerCase(), true);
+        results.push({ type: 'email', result: emailResult });
+      }
+      
+      if (session.address) {
+        const walletResult = await this.saveIdentity(userId, 'wallet', session.address.toLowerCase(), true);
+        results.push({ type: 'wallet', result: walletResult });
+      }
+      
+      if (session.telegramId) {
+        const telegramResult = await this.saveIdentity(userId, 'telegram', session.telegramId, true);
+        results.push({ type: 'telegram', result: telegramResult });
+      }
+      
+      // Сохраняем гостевые идентификаторы
+      if (session.guestId) {
+        const guestResult = await this.saveIdentity(userId, 'guest', session.guestId, true);
+        results.push({ type: 'guest', result: guestResult });
+      }
+      
+      if (session.previousGuestId && session.previousGuestId !== session.guestId) {
+        const prevGuestResult = await this.saveIdentity(userId, 'guest', session.previousGuestId, true);
+        results.push({ type: 'previousGuest', result: prevGuestResult });
+      }
+      
+      logger.info(`[IdentityService] Saved ${results.length} identities from session for user ${userId}`);
+      return { success: true, results };
+    } catch (error) {
+      logger.error(`[IdentityService] Error saving identities from session for user ${userId}:`, error);
+      return { success: false, error: error.message };
+    }
+  }
+}
+
+module.exports = new IdentityService(); 

backend/services/session-service.js

@@ -0,0 +1,169 @@
+const logger = require('../utils/logger');
+const db = require('../db');
+
+/**
+ * Сервис для работы с сессиями пользователей
+ */
+class SessionService {
+  /**
+   * Сохраняет сессию с обработкой ошибок
+   * @param {object} session - Объект сессии
+   * @param {string} context - Контекст для логирования
+   * @returns {Promise<boolean>} - Результат операции
+   */
+  async saveSession(session, context = '') {
+    if (!session) {
+      logger.warn(`[SessionService${context ? '/' + context : ''}] Cannot save null session`);
+      return false;
+    }
+    
+    try {
+      return await new Promise((resolve, reject) => {
+        session.save(err => {
+          if (err) {
+            logger.error(`[SessionService${context ? '/' + context : ''}] Error saving session:`, err);
+            reject(err);
+          } else {
+            logger.info(`[SessionService${context ? '/' + context : ''}] Session saved successfully`);
+            resolve(true);
+          }
+        });
+      });
+    } catch (error) {
+      logger.error(`[SessionService${context ? '/' + context : ''}] Error in saveSession:`, error);
+      return false;
+    }
+  }
+  
+  /**
+   * Восстанавливает сессию из базы данных по ID
+   * @param {string} sessionId - ID сессии
+   * @returns {Promise<object|null>} - Данные сессии или null
+   */
+  async getSessionData(sessionId) {
+    try {
+      if (!sessionId) {
+        logger.warn('[SessionService] Cannot restore session without sessionId');
+        return null;
+      }
+      
+      logger.info(`[SessionService] Attempting to retrieve session ${sessionId}`);
+      
+      const result = await db.query(
+        'SELECT sess FROM session WHERE sid = $1',
+        [sessionId]
+      );
+      
+      if (result.rows.length === 0) {
+        logger.info(`[SessionService] No session found with ID ${sessionId}`);
+        return null;
+      }
+      
+      const sessionData = result.rows[0].sess;
+      logger.info(`[SessionService] Retrieved session data for ${sessionId}`);
+      
+      return sessionData;
+    } catch (error) {
+      logger.error(`[SessionService] Error retrieving session ${sessionId}:`, error);
+      return null;
+    }
+  }
+  
+  /**
+   * Обновляет данные аутентификации в сессии
+   * @param {object} session - Объект сессии
+   * @param {object} authData - Данные аутентификации
+   * @returns {Promise<boolean>} - Результат операции
+   */
+  async updateAuthData(session, authData) {
+    try {
+      if (!session || !authData) {
+        logger.warn('[SessionService] Missing parameters for updateAuthData');
+        return false;
+      }
+      
+      const { userId, authType, isAdmin, ...otherData } = authData;
+      
+      if (!userId || !authType) {
+        logger.warn('[SessionService] Missing userId or authType in authData');
+        return false;
+      }
+      
+      // Обновляем основные поля аутентификации
+      session.userId = userId;
+      session.authType = authType;
+      session.authenticated = true;
+      
+      if (isAdmin !== undefined) {
+        session.isAdmin = isAdmin;
+      }
+      
+      // Обновляем дополнительные данные в зависимости от типа аутентификации
+      if (authType === 'wallet' && otherData.address) {
+        session.address = otherData.address.toLowerCase();
+      } else if (authType === 'email' && otherData.email) {
+        session.email = otherData.email.toLowerCase();
+      } else if (authType === 'telegram') {
+        if (otherData.telegramId) session.telegramId = otherData.telegramId;
+        if (otherData.telegramUsername) session.telegramUsername = otherData.telegramUsername;
+        if (otherData.telegramFirstName) session.telegramFirstName = otherData.telegramFirstName;
+      }
+      
+      // Сохраняем гостевые ID, если они предоставлены и не были ранее в сессии
+      if (otherData.guestId && !session.guestId) {
+        session.guestId = otherData.guestId;
+      }
+      
+      if (otherData.previousGuestId && !session.previousGuestId) {
+        session.previousGuestId = otherData.previousGuestId;
+      }
+      
+      // Сохраняем обновленную сессию
+      return await this.saveSession(session, 'updateAuthData');
+    } catch (error) {
+      logger.error('[SessionService] Error updating auth data:', error);
+      return false;
+    }
+  }
+  
+  /**
+   * Очищает данные аутентификации в сессии
+   * @param {object} session - Объект сессии
+   * @returns {Promise<boolean>} - Результат операции
+   */
+  async logout(session) {
+    try {
+      if (!session) {
+        logger.warn('[SessionService] Cannot logout null session');
+        return false;
+      }
+      
+      // Сохраняем гостевые ID перед очисткой
+      const guestId = session.guestId;
+      
+      // Удаляем данные аутентификации
+      delete session.userId;
+      delete session.authenticated;
+      delete session.authType;
+      delete session.isAdmin;
+      delete session.address;
+      delete session.email;
+      delete session.telegramId;
+      delete session.telegramUsername;
+      delete session.telegramFirstName;
+      
+      // Восстанавливаем гостевой ID для продолжения работы
+      if (guestId) {
+        session.guestId = guestId;
+      }
+      
+      // Сохраняем обновленную сессию
+      return await this.saveSession(session, 'logout');
+    } catch (error) {
+      logger.error('[SessionService] Error during logout:', error);
+      return false;
+    }
+  }
+}
+
+module.exports = new SessionService();