Refactor Code

Author: ultimateakash

controllers/auth.controller.js

@@ -1,60 +1,53 @@
-const UserModel = require('../models/user.model');
+const AuthService = require('../services/auth.service');
 const jwtConfig = require('../config/jwt.config');
-const cache = require('../utils/cache.util');
-const jwt = require('../utils/jwt.util');
-const bcrypt = require('bcrypt');
+const bcryptUtil = require('../utils/bcrypt.util');
+const jwtUtil = require('../utils/jwt.util');
 
-exports.register = async (req, res) => {
-    const isExist = await UserModel.findOne({
-        where:{
-            email: req.body.email
-        }
-    })
+exports.register = async (req, res) => { 
+    const isExist = await AuthService.findUserByEmail(req.body.email);
     if(isExist) {
-        return res.status(400).json({ message: 'Email already exists.' });
+        return res.status(400).json({ 
+            message: 'Email already exists.' 
+        });
     }
-    const hashedPassword = await bcrypt.hash(req.body.password, 10);
-
-    const user = await UserModel.create({
+    const hashedPassword = await bcryptUtil.createHash(req.body.password);
+    const userData = {
         name: req.body.name,
         email: req.body.email,
         password: hashedPassword
+    }
+    const user = await AuthService.createUser(userData);
+    return res.json({
+        data: user,
+        message: 'User registered successfully.'
     });
-    return res.json(user);
 }
 
-exports.login = async (req, res) => {
-    const user = await UserModel.findOne({
-        where: {
-            email: req.body.email
-        }
-    });
+exports.login = async (req, res) => { 
+    const user = await AuthService.findUserByEmail(req.body.email); 
     if (user) {
-        const isMatched = await bcrypt.compare(req.body.password, user.password);
+        const isMatched = await bcryptUtil.compareHash(req.body.password, user.password);
         if (isMatched) {
-            const token = await jwt.createToken({ id: user.id });
+            const token = await jwtUtil.createToken({ id: user.id });
             return res.json({
                 access_token: token,
                 token_type: 'Bearer',
                 expires_in: jwtConfig.ttl
             });
         }
     }
-    return res.status(400).json({ message: 'Unauthorized' });
+    return res.status(400).json({ message: 'Unauthorized.' });
 }
 
 exports.getUser = async (req, res) => {
-    const user = await UserModel.findByPk(req.user.id);
-    return res.json(user);
+    const user = await AuthService.findUserById(req.user.id);  
+    return res.json({
+        data: user,
+        message: 'Success.'
+    });
 }
 
-exports.logout = async (req, res) => { 
-    const token = req.token;
-    const now = new Date();
-    const expire = new Date(req.user.exp);
-    const milliseconds = now.getTime() - expire.getTime();
-    /* ----------------------------- BlackList Token ---------------------------- */
-    await cache.set(token, token, milliseconds);
-
-    return res.json({ message: 'Logged out successfully' });
+exports.logout = async (req, res) => {    
+    await AuthService.logoutUser(req.token, req.user.exp);  
+    return res.json({ message: 'Logged out successfully.' });
 }

middleware/auth.middleware.js

@@ -1,8 +1,8 @@
-const cache = require('../utils/cache.util');
-const jwt = require('../utils/jwt.util');
+const cacheUtil = require('../utils/cache.util');
+const jwtUtil = require('../utils/jwt.util');
 
 module.exports = async (req, res, next) => {
-
+    
     let token = req.headers.authorization;
     if (token && token.startsWith('Bearer ')) {
         token = token.slice(7, token.length);
@@ -12,17 +12,16 @@ module.exports = async (req, res, next) => {
         try {
             token = token.trim();
             /* ---------------------- Check For Blacklisted Tokens ---------------------- */
-            const isBlackListed = await cache.get(token);
+            const isBlackListed = await cacheUtil.get(token);
             if (isBlackListed) {
                 return res.status(401).json({ message: 'Unauthorized' });
             }
 
-            const decoded = await jwt.verifyToken(token);
+            const decoded = await jwtUtil.verifyToken(token);
             req.user = decoded;
             req.token = token;
             next();
-
-        } catch (error) { 
+        } catch (error) {
             return res.status(401).json({ message: 'Unauthorized' });
         }
     } else {

package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-mysql-jwt",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "private": true,
   "scripts": {
     "start": "node ./bin/www"

services/auth.service.js

@@ -0,0 +1,26 @@
+const UserModel = require('../models/user.model');
+const cacheUtil = require('../utils/cache.util');
+
+exports.createUser = (user) => {
+    return UserModel.create(user);
+}
+
+exports.findUserByEmail = (email) => {
+    return UserModel.findOne({
+        where: {
+            email: email
+        }
+    })
+}
+
+exports.findUserById = (id) => {
+    return UserModel.findByPk(id);
+}
+
+exports.logoutUser = (token, exp) => {
+    const now = new Date();
+    const expire = new Date(exp * 1000);
+    const milliseconds = expire.getTime() - now.getTime();
+    /* ----------------------------- BlackList Token ---------------------------- */
+    return cacheUtil.set(token, token, milliseconds);
+}

utils/bcrypt.util.js

@@ -0,0 +1,5 @@
+const bcrypt = require('bcrypt');
+
+exports.compareHash = (plainPassword, hashedPassword) => bcrypt.compare(plainPassword, hashedPassword);
+
+exports.createHash = (plainPassword) => bcrypt.hash(plainPassword, 10);

utils/validator.util.js

@@ -1,16 +1,16 @@
-module.exports = (schema) => (req, res, next) => {
+module.exports = (schema) => async (req, res, next) => {
     if (schema) {
-        const options = {
-            errors: {
-                wrap: { label: '' }
-            },
-            abortEarly: false
-        }
-        const result = schema.validate((req.method == 'GET' ? req.query : req.body), options);
-        if (result.error) {
-            const { details } = result.error;
-            const message = details.length ? details[0].message : 'Invalid payload.'
-            return res.status(400).json({ message });
+        try {
+            const options = {
+                errors: {
+                    wrap: { label: '' }
+                },
+                abortEarly: true
+            }
+            const body = (req.method == 'GET') ? req.query : req.body;
+            await schema.validateAsync(body, options);
+        } catch (error) {
+            return res.status(400).json({ message: error.message });
         }
     }
     next();

validatons/auth.validation.js

@@ -1,10 +1,17 @@
 const Joi = require('joi');
+const passwordRegex = new RegExp(/(?=.*\d)(?=.*[a-z])(?=.*[A-Z])/);
+
+const validatePassword = (value, helper) => {  
+    if(!passwordRegex.test(String(value))) { 
+        throw new Error('Password should contains a lowercase, a uppercase character and a digit.')
+    }
+}
 
 module.exports = {
     register: Joi.object().keys({
         name: Joi.string().required(),
         email: Joi.string().email().required(),
-        password: Joi.string().required()
+        password: Joi.string().min(8).max(16).required().external(validatePassword)
     }),
     login: Joi.object().keys({
         email: Joi.string().email().required(),