backend/src/services/lab10/authService.js - master - Centermant/web-nodejs

backend/src/services/lab10/authService.js
214 строк6 KB
Centermant
update backend/src/services/lab10/authService.js
04 дек 2025, 10:15
04 дек 2025, 10:159fdfe69
import jwt from 'jsonwebtoken';
import bcrypt from 'bcryptjs';

const JWT_SECRET = process.env.JWT_SECRET || 'secret_key_for_lab10_marketplace';
const JWT_EXPIRES_IN = '24h';

class AuthService {
  async login(db, email, password) {
    try {
      // Находим пользователя по email
      const { rows: users } = await db.query(
        'SELECT id, name as username, password as password_hash, email, role FROM lab10.users WHERE email = $1',
        [email]
      );
      
      if (users.length === 0) {
        throw new Error('User not found');
      }
      
      const user = users[0];
      
      // Проверяем пароль
      const isValidPassword = await bcrypt.compare(password, user.password_hash);
      if (!isValidPassword) {
        throw new Error('Invalid password');
      }
      
      // Генерируем JWT токен
      const token = jwt.sign(
        { 
          id: user.id, 
          username: user.username, 
          role: user.role,
          email: user.email
        }, 
        JWT_SECRET, 
        { expiresIn: JWT_EXPIRES_IN }
      );
      
      return {
        token,
        user: {
          id: user.id,
          username: user.username,
          role: user.role,
          email: user.email
        }
      };
    } catch (error) {
      throw new Error(`Authentication failed: ${error.message}`);
    }
  }
  
  async guestLogin(db) {
    try {
      // Генерируем уникальное имя для гостя
      const guestUsername = `guest_${Date.now()}_${Math.random().toString(36).substr(2, 5)}`;
      
      // Хешируем пустой пароль
      const passwordHash = await bcrypt.hash('', 10);
      
      // Создаем гостевого пользователя
      const { rows: users } = await db.query(
        `INSERT INTO lab10.users (name, password, email, role) 
         VALUES ($1, $2, $3, 'guest') 
         RETURNING id, name AS username, role, email`,
        [guestUsername, passwordHash, `${guestUsername}@guest.marketplace`]
      );
      
      const user = users[0];
      
      // Генерируем JWT токен
      const token = jwt.sign(
        { 
          id: user.id, 
          username: user.username, 
          role: user.role,
          email: user.email
        }, 
        JWT_SECRET, 
        { expiresIn: JWT_EXPIRES_IN }
      );
      
      return {
        token,
        user: {
          id: user.id,
          username: user.username,
          role: user.role,
          email: user.email
        }
      };
    } catch (error) {
      throw new Error(`Guest login failed: ${error.message}`);
    }
  }
  
  async register(db, username, password, email) {
    try {
      // Проверяем, существует ли пользователь с таким именем или email
      const { rows: existingUsers } = await db.query(
        'SELECT id FROM lab10.users WHERE name = $1 OR email = $2',
        [username, email]
      );
      
      if (existingUsers.length > 0) {
        throw new Error('Username or email already exists');
      }
      
      // Хешируем пароль
      const passwordHash = await bcrypt.hash(password, 10);
      
      // Создаем пользователя
      const { rows: users } = await db.query(
        `INSERT INTO lab10.users (name, password, email, role) 
         VALUES ($1, $2, $3, 'user') 
         RETURNING id, name AS username, role, email`,
        [username, passwordHash, email]
      );
      
      const user = users[0];
      
      // Генерируем JWT токен
      const token = jwt.sign(
        { 
          id: user.id, 
          username: user.username, 
          role: user.role,
          email: user.email
        }, 
        JWT_SECRET, 
        { expiresIn: JWT_EXPIRES_IN }
      );
      
      return {
        token,
        user: {
          id: user.id,
          username: user.username,
          role: user.role,
          email: user.email
        }
      };
    } catch (error) {
      throw new Error(`Registration failed: ${error.message}`);
    }
  }
  
  verifyToken(token) {
    try {
      return jwt.verify(token, JWT_SECRET);
    } catch (error) {
      throw new Error('Invalid or expired token');
    }
  }
  
  async getUserById(db, userId) {
    try {
      const { rows: users } = await db.query(
        'SELECT id, name AS username, role, email FROM lab10.users WHERE id = $1',
        [userId]
      );
      
      if (users.length === 0) {
        throw new Error('User not found');
      }
      
      return users[0];
    } catch (error) {
      throw new Error(`Failed to get user: ${error.message}`);
    }
  }
  
  async checkAuth(db, token) {
    try {
      if (!token) {
        return { isLoggedIn: false, user: null };
      }
      
      // Проверяем и декодируем токен
      const decoded = this.verifyToken(token);
      
      // Получаем информацию о пользователе
      const { rows } = await db.query(
        'SELECT id, name AS username, role, email FROM lab10.users WHERE id = $1',
        [decoded.id]
      );
      
      if (rows.length === 0) {
        return { isLoggedIn: false, user: null };
      }
      
      return { 
        isLoggedIn: true, 
        user: {
          id: rows[0].id,
          username: rows[0].username,
          role: rows[0].role,
          email: rows[0].email
        }
      };
    } catch (error) {
      return { isLoggedIn: false, user: null };
    }
  }
  
  async logout() {
    // В этой реализации logout просто удаляет токен на клиенте
    // Серверная часть только валидирует токены
    return { success: true };
  }
}

export default new AuthService();