:construction: Verification of JWT through headers/strategies achieved

backend/lib/auth/strategies/jwt.js

 'use strict'
+const JWT = require('jsonwebtoken')
 
 module.exports = options => {
     return {
             algorithms: ['HS256'],
         },
         validate: (decoded, request, h) => {
-            console.log('decoded :>>', decoded) // doesn't log to console...
+            const token = request.headers.authorization
             try {
-                // Check if the Access Token is Valid
-                // if (!accessTokenIsValid) {
-                // Look up if the Session is Active
-                // } else {
-                // isValid: true
-                // }
+                const validatedJwt = JWT.verify(token, process.env.APP_SECRET)
                 return {
                     isValid: true,
-                    credentials: { user: artifacts.decoded.payload.user },
+                    credentials: validatedJwt.payload.email,
                 }
             } catch (err) {
-                console.error(err)
-                return { isValid: false }
+                console.error('ERROR :=>', err)
+                return { isValid: false, error: err.message }
             }
         },
     }

backend/lib/routes/user/validatesession.js

 
 module.exports = {
     method: 'GET',
-    path: '/validatesession/{sessionToken}',
-    // method: 'GET' sessionToken in header ?
+    path: '/validatesession',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
-        auth: false, // set to jwt strategy
+        auth: 'default_jwt',
         cors: true,
         handler: async function (request, h) {
-            const sessionToken = request.params.sessionToken
+            const sessionToken = request.headers.authorization
             const { userService } = request.server.services()
             try {
                 const validatedSessionToken =

backend/lib/services/user.js

      */
     // TODO: Move this ino the auth strategies
     validateToken(token) {
-        const key = this.server.registrations['main-app-plugin'].options.jwtKey // mysecret
+        const key = this.server.registrations['main-app-plugin'].options.jwtKey
         try {
             return JWT.verify(token, key)
         } catch (err) {

frontend/src/services/auth.service.js

         return await db.post('/user/getaccess', req, true)
     }
     async validateSession(sessionToken) {
-        return await db.get(`/user/validatesession/${sessionToken}`)
+        return await db.get('/user/validatesession', sessionToken)
     }
 }
 

frontend/src/utils/db.js

             patch: 'PATCH',
         }
     }
-    _makeHeader({ method, payload }) {
+    _makeHeader({ method, payload, authorization }) {
         const header = { ...headerTemplate }
         header.method = method
         if (payload) {
             header.body = JSON.stringify(payload)
         }
+        if (authorization) {
+            header.headers.authorization = authorization
+        }
         return header
     }
     async _tryFetch({ endpoint, header }, returnHeaders = false) {
             console.error(`[API Util]: ${error}\nroute:`, endpoint)
         }
     }
-    async get(endpoint) {
-        return await this._tryFetch({
-            endpoint,
-            header: this._makeHeader({ method: this._verbs.get }),
-        })
+    async get(endpoint, authHeaders = false) {
+        if (authHeaders) {
+            return await this._tryFetch({
+                endpoint,
+                header: this._makeHeader({
+                    method: this._verbs.get,
+                    authorization: `${authHeaders}`,
+                }),
+            })
+        } else {
+            return await this._tryFetch({
+                endpoint,
+                header: this._makeHeader({ method: this._verbs.get }),
+            })
+        }
     }
     async post(endpoint, payload = {}, returnHeaders = false) {
         return await this._tryFetch({