feature/24 (#35)

src/endpoints/token.js

 const Token = require('../models/token')
 const bcrypt = require('bcryptjs')
 
-const loginUser = async (req, res) => {
+const loginUser = async (req, res, next) => {
     try {
         const findUser = await Token.findByCredentials(req.body.email, req.body.password)
-        
-        if(!findUser) {
+
+        if (!findUser) {
             return res.status(400).send('Wrong credentials!')
         }
         const isValidPassword = await bcrypt.compare(req.body.password, findUser.password)
-        if(!isValidPassword) {
+        if (!isValidPassword) {
             return res.status(400).send('Password is incorrect!')
         }
         const token = await Token.generateAuthToken(findUser)
 
         return res.send(findUser)
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
 const logout = async (req, res) => {
     const result = await Token.destroyToken(req.body.token)
-    if(!result) {
+    if (!result) {
         return res.status(404).send('No user has the token provided!')
     }
     return res.send('Token ' + req.body.token + ' invalidated!')
         token: req.body.token
     }
     const result = await Token.refreshAuthToken(form.token)
-    if(!result) {
+    if (!result) {
         return res.status(404).send('Token not valid!')
     }
 

src/endpoints/user.js

 const bcrypt = require("bcryptjs/dist/bcrypt")
-const {Router} = require("express")
+const { Router } = require("express")
 const User = require("../models/user")
 const logger = require("../logging/logger")
 
-const getUsers = async (res) => {
+const getUsers = async (req, res, next) => {
     try {
         logger.silly('hello from logger')
         const allUsers = await User.find({})
         return res.status(200).send(allUsers)
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
-const getUser = async (res, id) => {
+const getUser = async (req, res, next) => {
     try {
+        const id = req.params.id
         if (!id) {
             return res.status(400).send('Bad request')
         }
 
         return res.status(200).json(user)
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
-const createUser = async (res, userModel) => {
+const createUser = async (req, res, next) => {
     try {
+        const userModel = req.body
         if (Object.entries(userModel).length === 0) {
             return res.status(400).send('Object cant be empty')
         }
     }
 }
 
-const updateUser = async (res, id, objBody) => {
+const updateUser = async (req, res, next) => {
     try {
+        const id = req.params.id
+        const objBody = req.body
         if (Object.entries(objBody).length == 0) {
             return res.status(400).send('Invalid input parameters')
         }
 
         return res.status(200).send('User updated successfully')
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
-const updateUserContacts = async (req, res) => {
+const updateUserContacts = async (req, res, next) => {
     try {
         userFound = true
         if (!userFound) {
         }
         return res.status(200).send('user contacts updated successfully')
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
-const deleteUser = async (res, id) => {
+const deleteUser = async (req, res, next) => {
     try {
+        const id = req.params.id
         if (!id) {
             return res.status(400).send('You need to provide valid Id')
         }
 
         const user = await User.findById(id)
-        if(!user){
+        if (!user) {
             return res.status(404).send("User with the id of: " + id + " doesnt exist")
         }
 
 
         return res.status(204).send('Deleting user with id of ' + id)
     } catch (e) {
-        return res.status(500).send(e)
+        next(e)
     }
 }
 
-module.exports = {getUsers, getUser, createUser, updateUser, updateUserContacts, deleteUser}
+module.exports = { getUsers, getUser, createUser, updateUser, updateUserContacts, deleteUser }

src/middleware/errorHandling.js

+const errorLogger = (err, req, res, next) => {
+    console.error('GRESKA KOLEGAA' + err)
+    next(err)
+}
+
+const errorResponder = (err, req, res, next) => {
+    res.status(err.statusCode).send(err)
+}
+
+module.exports = { errorLogger, errorResponder }

src/routes/token.js

  *       500:
  *         description: Internal server error.
  */
-router.post('/auth/token', async (req, res) => {
-    return await endpoints.loginUser(req, res)
-})
+router.post('/auth/token', endpoints.loginUser)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.post('/auth/logout', async (req, res) => {
-    return await endpoints.logout(req, res)
-})
+router.post('/auth/logout', endpoints.logout)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.post('/auth/refresh', async(req, res) => {
-    return await endpoints.refreshUserToken(req, res)
-})
+router.post('/auth/refresh', endpoints.refreshUserToken)
 
 module.exports = router

src/routes/user.js

 const router = new express.Router()
 const app = express()
 
-router.get('/users', async (req, res) => {
-    return await endpoints.getUsers(res)
-})
+router.get('/users', endpoints.getUsers)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.get('/users/:id', async (req, res) => {
-    return await endpoints.getUser(res, req.params.id)
-})
+router.get('/users/:id', endpoints.getUser)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.post('/users', async (req, res) => {
-    return await endpoints.createUser(res, req.body)
-})
+router.post('/users', endpoints.createUser)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.put('/users/:id', async (req, res) => {
-    return await endpoints.updateUser(res, req.params.id, req.body)})
+router.put('/users/:id', endpoints.updateUser)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.patch('/users/:id/contacts', async (req, res) => {
-    return await endpoints.updateUserContacts(req, res, req.body)
-})
+router.patch('/users/:id/contacts', endpoints.updateUserContacts)
 
 /**
  * @openapi
  *       500:
  *         description: Internal server error.
  */
-router.delete('/users/:id', async (req, res) => {
-    return await endpoints.deleteUser(req, res, req.body)
-})
+router.delete('/users/:id', endpoints.deleteUser)
 
 module.exports = router

src/server.js

 const tokenRouter = require('./routes/token')
 const swaggerJsDoc = require("swagger-jsdoc")
 const swaggerUi = require("swagger-ui-express")
+const { errorLogger, errorResponder } = require('./middleware/errorHandling.js')
 const cors = require('cors')
 const helmet = require('helmet')
 
+
 const swaggerOptions = {
     swaggerDefinition: {
         info: {
     }
 })
 
+app.use(errorLogger);
+app.use(errorResponder);
+
 app.listen(port, () => {
     console.log('Server is up on port ' + port)
 })