add task solution

src/controllers/auth.controller.js

@@ -0,0 +1,172 @@
+import { ApiError } from '../exceptions/api.error.js';
+import { jwtService } from '../services/jwt.service.js';
+import { tokenService } from '../services/token.service.js';
+import { userService } from '../services/user.service.js';
+import bcrypt from 'bcrypt';
+
+export function validateEmail(email) {
+  const emailPattern = /^[\w.+-]+@([\w-]+\.){1,3}[\w-]{2,}$/;
+
+  if (!email) {
+    return 'Email is required';
+  }
+
+  if (!emailPattern.test(email)) {
+    return 'Email is not valid';
+  }
+}
+
+export function validatePassword(password) {
+  if (!password) {
+    return 'Password is required';
+  }
+
+  if (password.length < 6) {
+    return 'At least 6 characters';
+  }
+}
+
+const register = async (req, res, next) => {
+  const { name, email, password } = req.body;
+
+  const errors = {
+    email: validateEmail(email),
+    password: validatePassword(password),
+  };
+
+  if (Object.values(errors).some((error) => error)) {
+    throw ApiError.badRequest('Validation error', errors);
+  }
+
+  const hashedPass = await bcrypt.hash(password, 10);
+
+  await userService.register(name, email, hashedPass);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const activate = async (req, res, next) => {
+  const { activationToken } = req.params;
+  const user = await userService.findByActivationToken(activationToken);
+
+  if (!user) {
+    throw ApiError.notFound({ email: 'this email doesn`t exist' });
+  }
+
+  user.activationToken = null;
+  await user.save();
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const login = async (req, res, next) => {
+  const { email, password } = req.body;
+
+  const user = await userService.findByEmail(email);
+
+  if (!user) {
+    throw ApiError.unauthorized({ email: 'this email doesn`t exist' });
+  }
+
+  const isPasswordValid = await bcrypt.compare(password, user.password);
+
+  if (!isPasswordValid) {
+    throw ApiError.unauthorized({ password: 'wrong password' });
+  }
+
+  if (user.activationToken) {
+    throw ApiError.unauthorized({ email: 'please activate the email' });
+  }
+
+  await generateTokens(res, user);
+};
+
+const refresh = async (req, res, next) => {
+  const { refreshToken } = req.cookies;
+
+  const userData = jwtService.verifyRefresh(refreshToken);
+  const token = await tokenService.getByToken(refreshToken);
+
+  if (!userData || !token) {
+    throw ApiError.unauthorized();
+  }
+
+  const user = await userService.findByEmail(userData.email);
+
+  await generateTokens(res, user);
+};
+
+const generateTokens = async (res, user) => {
+  const normalizedUser = userService.normalize(user);
+  const accessToken = jwtService.sign(normalizedUser);
+  const refreshToken = jwtService.signRefresh(normalizedUser);
+
+  await tokenService.save(normalizedUser.id, refreshToken);
+
+  res.cookie('refreshToken', refreshToken, {
+    maxAge: 30 * 24 * 60 * 60 * 1000,
+    httpOnly: true,
+  });
+
+  res.send({
+    user: normalizedUser,
+    accessToken,
+  });
+};
+
+const sendResetMessage = async (req, res, next) => {
+  const { email } = req.body;
+
+  await userService.sendResetMessage(email);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const resetPassword = async (req, res, next) => {
+  const { resetPasswordToken } = req.params;
+  const { newPassword, confirmPassword } = req.body;
+
+  const errors = {
+    password: validatePassword(newPassword),
+  };
+
+  const user = await userService.findByResetPasswordToken(resetPasswordToken);
+
+  if (newPassword !== confirmPassword) {
+    throw ApiError.badRequest('password and confirmation fields must be equal');
+  }
+
+  if (!user) {
+    throw ApiError.notFound({ email: 'this email doesn`t exist' });
+  }
+
+  if (Object.values(errors).some((error) => error)) {
+    throw ApiError.badRequest('Validation error', errors);
+  }
+
+  const hashedPass = await bcrypt.hash(newPassword, 10);
+
+  await userService.changePassword(user.email, hashedPass);
+
+  user.resetPasswordToken = null;
+  await user.save();
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+export const authController = {
+  register,
+  activate,
+  login,
+  refresh,
+  sendResetMessage,
+  resetPassword,
+};

src/controllers/user.controller.js

@@ -0,0 +1,144 @@
+import { ApiError } from '../exceptions/api.error.js';
+import { tokenService } from '../services/token.service.js';
+import { userService } from '../services/user.service.js';
+import { validateEmail, validatePassword } from './auth.controller.js';
+import bcrypt from 'bcrypt';
+
+const getOneActivated = async (req, res, next) => {
+  const id = req.user.id;
+
+  const user = await userService.findActivatedById(id);
+
+  res.send(user);
+};
+
+const changePasswordAuthenticated = async (req, res, next) => {
+  const { oldPassword, newPassword, confirmPassword } = req.body;
+  const userData = req.user;
+
+  if (!userData) {
+    throw ApiError.unauthorized();
+  }
+
+  const user = await userService.findByEmail(userData.email);
+
+  if (newPassword !== confirmPassword) {
+    throw ApiError.badRequest('password and confirmation fields must be equal');
+  }
+
+  const isPasswordValid = await bcrypt.compare(oldPassword, user.password);
+
+  if (!isPasswordValid) {
+    throw ApiError.unauthorized({ password: 'wrong password' });
+  }
+
+  const errors = {
+    newPassword: validatePassword(newPassword),
+  };
+
+  if (Object.values(errors).some((error) => error)) {
+    throw ApiError.badRequest('Validation error', errors);
+  }
+
+  const hashedPass = await bcrypt.hash(newPassword, 10);
+
+  await userService.changePassword(userData.email, hashedPass);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const changeName = async (req, res, next) => {
+  const { name } = req.body;
+  const userData = req.user;
+
+  if (!userData) {
+    throw ApiError.unauthorized();
+  }
+
+  await userService.changeName(userData.email, name);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const changeEmail = async (req, res, next) => {
+  const { oldEmail, newEmail, password } = req.body;
+  const userData = req.user;
+
+  if (!userData) {
+    throw ApiError.unauthorized();
+  }
+
+  const user = await userService.findByEmail(userData.email);
+
+  const isPasswordValid = await bcrypt.compare(password, user.password);
+
+  if (!isPasswordValid) {
+    throw ApiError.unauthorized({ password: 'wrong password' });
+  }
+
+  const errors = {
+    email: validateEmail(newEmail),
+  };
+
+  if (Object.values(errors).some((error) => error)) {
+    throw ApiError.badRequest('Validation error', errors);
+  }
+
+  if (oldEmail === newEmail) {
+    throw ApiError.badRequest('new email must be different');
+  }
+
+  await userService.changeEmail(userData.email, newEmail);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const activateChangedEmail = async (req, res, next) => {
+  const { emailChangeToken } = req.params;
+  const user = await userService.findByEmailChangeToken(emailChangeToken);
+
+  if (!user) {
+    throw ApiError.notFound({ email: 'this email doesn`t exist' });
+  }
+
+  const existingUser = await userService.findByEmail(user.pendingEmail);
+
+  if (existingUser) {
+    throw ApiError.badRequest('email already exists');
+  }
+
+  user.email = user.pendingEmail;
+  user.pendingEmail = null;
+  user.emailChangeToken = null;
+
+  await user.save();
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+const logout = async (req, res, next) => {
+  res.clearCookie('refreshToken');
+
+  await tokenService.remove(req.user.id);
+
+  res.send({
+    message: 'OK',
+  });
+};
+
+export const userController = {
+  getOneActivated,
+  changeName,
+  changeEmail,
+  changePasswordAuthenticated,
+  activateChangedEmail,
+  logout,
+};

src/exceptions/api.error.js

@@ -0,0 +1,32 @@
+export class ApiError extends Error {
+  constructor({ message, status, errors = {} }) {
+    super(message);
+
+    this.status = status;
+    this.errors = errors;
+  }
+
+  static badRequest(message, errors = {}) {
+    return new ApiError({
+      message,
+      errors,
+      status: 400,
+    });
+  }
+
+  static unauthorized(errors = {}) {
+    return new ApiError({
+      message: 'unauthorized user',
+      errors,
+      status: 401,
+    });
+  }
+
+  static notFound(errors) {
+    return new ApiError({
+      message: 'not found',
+      errors,
+      status: 404,
+    });
+  }
+}

src/index.js

@@ -1 +1,31 @@
+/* eslint-disable no-console */
 'use strict';
+
+import express from 'express';
+import 'dotenv/config';
+import { authRouter } from './routers/auth.route.js';
+import { userRouter } from './routers/user.route.js';
+import { errorMiddleware } from './middlewares/errorMiddleware.js';
+import cookieParser from 'cookie-parser';
+
+const PORT = process.env.PORT || 3005;
+
+const app = express();
+
+app.use(express.json());
+app.use(cookieParser());
+
+app.use(authRouter);
+app.use('/user', userRouter);
+
+app.use((req, res) => {
+  res.status(404).send(`
+    <h1>Page not found</h1>
+    `);
+});
+
+app.use(errorMiddleware);
+
+app.listen(PORT, () => {
+  console.log('server is running');
+});