src/server/services/authService.js - master - Gabryelf/Pixel-Orb

src/server/services/authService.js
201 строка5 KB
Valeev Serj
restruct_v0.0.1
07 авг 2026, 22:50
07 авг 2026, 22:5041f78a4
const bcrypt = require('bcryptjs');
const jwt = require('jsonwebtoken');

class AuthService {
  constructor() {
    this.users = new Map();
    this.guestCounter = 0;
  }

  generateId() {
    return 'user_' + Date.now().toString(36) + Math.random().toString(36).substr(2, 9);
  }

  async register(req, res) {
    try {
      const { username, email, password } = req.body;

      // Валидация
      if (!username || username.length < 3) {
        return res.status(400).json({ error: 'Username must be at least 3 characters' });
      }
      if (!email || !email.includes('@')) {
        return res.status(400).json({ error: 'Invalid email' });
      }
      if (!password || password.length < 6) {
        return res.status(400).json({ error: 'Password must be at least 6 characters' });
      }

      // Проверка существования
      for (let user of this.users.values()) {
        if (user.email === email) {
          return res.status(400).json({ error: 'Email already registered' });
        }
        if (user.username === username) {
          return res.status(400).json({ error: 'Username already taken' });
        }
      }

      // Хеширование пароля
      const hashedPassword = await bcrypt.hash(password, 10);

      const user = {
        id: this.generateId(),
        username,
        email,
        password: hashedPassword,
        isGuest: false,
        experience: 0,
        level: 1,
        publishedProjects: [],
        achievements: [],
        createdAt: new Date()
      };

      this.users.set(user.id, user);

      // Генерация JWT
      const token = jwt.sign(
        { id: user.id, email: user.email },
        process.env.JWT_SECRET || 'secret',
        { expiresIn: '7d' }
      );

      return res.json({
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          experience: user.experience,
          level: user.level,
          isGuest: user.isGuest
        },
        token
      });
    } catch (error) {
      console.error('Register error:', error);
      return res.status(500).json({ error: 'Registration failed' });
    }
  }

  async login(req, res) {
    try {
      const { email, password } = req.body;

      if (!email || !password) {
        return res.status(400).json({ error: 'Email and password required' });
      }

      let foundUser = null;
      for (let user of this.users.values()) {
        if (user.email === email) {
          foundUser = user;
          break;
        }
      }

      if (!foundUser) {
        return res.status(401).json({ error: 'Invalid credentials' });
      }

      const isValid = await bcrypt.compare(password, foundUser.password);
      if (!isValid) {
        return res.status(401).json({ error: 'Invalid credentials' });
      }

      const token = jwt.sign(
        { id: foundUser.id, email: foundUser.email },
        process.env.JWT_SECRET || 'secret',
        { expiresIn: '7d' }
      );

      return res.json({
        user: {
          id: foundUser.id,
          username: foundUser.username,
          email: foundUser.email,
          experience: foundUser.experience,
          level: foundUser.level,
          isGuest: foundUser.isGuest
        },
        token
      });
    } catch (error) {
      console.error('Login error:', error);
      return res.status(500).json({ error: 'Login failed' });
    }
  }

  async createGuest(req, res) {
    try {
      const guest = {
        id: this.generateId(),
        username: `Guest_${++this.guestCounter}`,
        email: null,
        password: null,
        isGuest: true,
        experience: 0,
        level: 1,
        publishedProjects: [],
        achievements: [],
        createdAt: new Date()
      };

      this.users.set(guest.id, guest);

      const token = jwt.sign(
        { id: guest.id, guest: true },
        process.env.JWT_SECRET || 'secret',
        { expiresIn: '1d' }
      );

      return res.json({
        user: {
          id: guest.id,
          username: guest.username,
          isGuest: guest.isGuest,
          experience: guest.experience,
          level: guest.level
        },
        token
      });
    } catch (error) {
      console.error('Guest creation error:', error);
      return res.status(500).json({ error: 'Failed to create guest' });
    }
  }

  async getCurrentUser(req, res) {
    try {
      const token = req.headers.authorization?.split(' ')[1];
      if (!token) {
        return res.status(401).json({ error: 'No token provided' });
      }

      const decoded = jwt.verify(token, process.env.JWT_SECRET || 'secret');
      const user = this.users.get(decoded.id);

      if (!user) {
        return res.status(404).json({ error: 'User not found' });
      }

      return res.json({
        user: {
          id: user.id,
          username: user.username,
          email: user.email,
          isGuest: user.isGuest,
          experience: user.experience,
          level: user.level,
          publishedProjects: user.publishedProjects,
          achievements: user.achievements
        }
      });
    } catch (error) {
      console.error('Get user error:', error);
      return res.status(401).json({ error: 'Invalid token' });
    }
  }
}

module.exports = new AuthService();