1) Корректно ли я разнес фремворк и бизнес логику
2) Корректно ли я вызываю методы логики по отдельности?
3) Корреткно ли я выбрасываю исключения?

// Express router
const express = require("express");
const router = express.Router();
const requester = require("../../../../helper/requester");
const AuthLogic = require("./auth-logic");

router.route("/").post(auth);

async function auth(req, res) {
  let authData = req.body;
  let body;
  try {
    console.log("Авторизация", authData.email);
    const authLogic = new AuthLogic(authData);
    const token = await authLogic.getToken();
    body = requester.createBody({ token });
  } catch (error) {
    body = requester.createError(error);
  }

  res.json(body);
}

module.exports = router;


// Logic Class
class AuthLogic {
  /**
   *
   * @param authData
   */
  constructor(authData) {
    this.authData = authData;
  }

  validate() {
    const isEmail = validator.isEmail(this.authData.email);
    const isEmailLength = validator.isLength(this.authData.email, {
      min: myConstants.MIN_EMAIL_LENGTH,
      max: myConstants.MAX_EMAIL_LENGTH
    });

    const isPasswordLength = validator.isLength(this.authData.password, {
      min: myConstants.MIN_PASSWORD_LENGTH,
      max: myConstants.MAX_PASSWORD_LENGTH
    });

    if (!isEmail && !isEmailLength && !isPasswordLength) {
      throw new MyError(errorCodes.INVALID_DATA);
    }
  }

  async checkIsUserExist() {
    try {
      const dbUser = await db_helper.getUserByEmail(this.authData.email);
      if (!dbUser) {
        console.log("Не существует юзера", this.authData.email);
        throw new MyError(errorCodes.INVALID_USER_OR_PASSWORD);
      }
      this.user = myParser.parseUser(dbUser);
    } catch (e) {
      console.error(e);
      throw e;
    }
  }

  checkRole() {
    if (this.user.role !== myRoles.SERVICE_SUPPORT) {
      throw new MyError(errorCodes.INVALID_USER_ROLE);
    } else {
    }
  }

  async comparePassword() {
    try {
      await bcrypt.compare(this.authData.password, this.user.password);
    } catch (e) {
      console.log(e);
      throw e;
    }
  }

  async updateLastEnter() {
    try {
      const dbUser = await db_helper.updateUserIdentity(this.user.id);
      this.user = myParser.parseUser(dbUser);
    } catch (e) {
      console.error(e);
      throw e;
    }
  }

  async getToken() {
    try {
      this.validate();
      await this.checkIsUserExist();
      this.checkRole();
      await this.comparePassword();
      await this.updateLastEnter();
      return tokenGenerator.getToken(this.user);
    } catch (e) {
      throw e;
    }
  }
}

module.exports = AuthLogic;

// Мой класс ошибок
class MyError extends Error {
  constructor(errorcode) {
    super();
    this.code = errorcode.code;
    this.text = errorcode.text;
  }
}

module.exports = MyError;

// Типы ошибок
module.exports = {
  UNKNOWN_SERVER_ERROR: {
    code: 2,
    text: "UNKNOWN_SERVER_ERROR"
  },
  USER_EXIST: {
    code: 10,
    text: "USER_EXIST"
  },.....
}


// Ебертка всех ошибок которые летят пользователю

class Requester {
  /**
   * @param {Object} error {code, text}
   *  @param {any} data
   * @param {Object} errorObect errorCodes
   * @returns {Object}
   * @memberof Requester
   */
  createError(error, data) {
    return {
      success: false,
      data: data ? data : null,
      error: {
        code: error ? error.code : 0,
        text: error ? error.text : "Server error"
      }
    };
  }
}