src/services/auth.service.js - master - commondan/authapi

src/services/auth.service.js
108 строк2 KB
CommondaN0
First initial commit of auth API for web-app
04 апр 2026, 20:13
04 апр 2026, 20:1327b471c
import bcrypt from "bcrypt";
import { Op } from "sequelize";

import { User } from "../models/index.js";
import { AppError } from "../utils/app-error.js";

const sanitizeUser = (user) => ({
  id: user.id,
  name: user.name,
  email: user.email,
  role: user.role,
  createdAt: user.createdAt,
  updatedAt: user.updatedAt,
});

const persistSession = (session, userId) =>
  new Promise((resolve, reject) => {
    session.userId = userId;
    session.save((error) => {
      if (error) {
        return reject(new AppError("Failed to persist session", 500));
      }

      return resolve();
    });
  });

const register = async ({ name, email, password }, session) => {
  const normalizedEmail = email.toLowerCase();

  const existingUser = await User.unscoped().findOne({
    where: {
      [Op.or]: [{ email: normalizedEmail }, { name }],
    },
  });

  if (existingUser) {
    if (existingUser.email === normalizedEmail) {
      throw new AppError("User with this email already exists", 409);
    }

    throw new AppError("User with this name already exists", 409);
  }

  const hashedPassword = await bcrypt.hash(password, 10);
  const user = await User.create({
    name,
    email: normalizedEmail,
    password: hashedPassword,
  });

  await persistSession(session, user.id);

  return {
    user: sanitizeUser(user),
  };
};

const login = async ({ login, password }, session) => {
  const normalizedLogin = login.toLowerCase();

  const user = await User.scope("withPassword").findOne({
    where: {
      [Op.or]: [{ email: normalizedLogin }, { name: login }],
    },
  });

  if (!user) {
    throw new AppError("Invalid credentials", 401);
  }

  const isPasswordValid = await bcrypt.compare(password, user.password);

  if (!isPasswordValid) {
    throw new AppError("Invalid credentials", 401);
  }

  await persistSession(session, user.id);

  return {
    user: sanitizeUser(user),
  };
};

const logout = async (session) =>
  new Promise((resolve, reject) => {
    session.destroy((error) => {
      if (error) {
        return reject(new AppError("Failed to logout", 500));
      }

      return resolve();
    });
  });

const getCurrentUser = async (userId) => {
  const user = await User.findByPk(userId);

  if (!user) {
    throw new AppError("Unauthorized", 401);
  }

  return {
    user: sanitizeUser(user),
  };
};

export { register, login, logout, getCurrentUser };