:pencil2: Fixed merge issues

backend/lib/auth/strategies/jwt.js

         },
         // TODO: Naming conventions need to be reversed again??
         validate: async (decoded, request, h) => {
-            const accessTokenFromHeaders = request.headers.authorization
-            const hashedAccessTokenFromHeaders = await hashToken(
-                accessTokenFromHeaders,
+            const sessionTokenFromHeaders = request.headers.authorization
+            const hashedSessionTokenFromHeaders = await hashToken(
+                sessionTokenFromHeaders,
             )
             const activeSession =
-                request.server.app.activeSessions[hashedAccessTokenFromHeaders]
+                request.server.app.activeSessions[hashedSessionTokenFromHeaders]
             if (!activeSession)
                 throw new Error(
-                    `No session found for ${hashedAccessTokenFromHeaders}`,
+                    `No session found for ${hashedSessionTokenFromHeaders}`,
                 )
 
-            const accessToken = activeSession.accessToken
             const sessionToken = activeSession.sessionToken
-            const validatedAccessToken = validateToken(accessToken)
+            const accessToken = activeSession.accessToken
             const validatedSessionToken = validateToken(sessionToken)
-            if (!validatedSessionToken.payload) {
-                console.log('sessionToken no longer valid, reissuing... ')
-                activeSession.sessionToken = createToken(
-                    { payload: validatedAccessToken.payload },
+            const validatedAccessToken = validateToken(accessToken)
+            if (!validatedAccessToken.payload) {
+                console.log('accessToken no longer valid, reissuing... ')
+                activeSession.accessToken = createToken(
+                    { payload: validatedSessionToken.payload },
                     // NOTE: Expiration of new sessionToken set for 200 seconds (testing)
                     100,
                 )
             }
             try {
                 const validatedJwt = JWT.verify(
-                    accessToken,
+                    sessionToken,
                     process.env.APP_SECRET,
                 )
                 return { isValid: true, credentials: validatedJwt.email }

backend/lib/plugins/user.js

 const UserSignupRoute = require('../routes/user/signup')
 const UserEmailRoute = require('../routes/user/email.js')
 const UserVerifyActiveRoute = require('../routes/user/verifyactivesession.js')
-const UserGetAccessRoute = require('../routes/user/getaccess.js')
+const UserGetSessionRoute = require('../routes/user/get-session.js')
 const UserValidateSessionRoute = require('../routes/user/validatesession.js')
 const UserRemoveSessionRoute = require('../routes/user/removesession.js')
 const UserPassword = require('../routes/user/authentication')
         await server.route(UserProfilesListRoute)
         await server.route(UserEmailRoute)
         await server.route(UserVerifyActiveRoute)
-        await server.route(UserGetAccessRoute)
+        await server.route(UserGetSessionRoute)
         await server.route(UserValidateSessionRoute)
         await server.route(UserRemoveSessionRoute)
         await server.route(UserPassword)

backend/lib/routes/user/authentication.js

 /** Validator functions by request method */
 const validators = {
     /** Validate the route params (/active/{thing}) */
-    params: params.userEmail
+    params: params.userEmail,
 }
 
 module.exports = {

backend/lib/routes/user/email.js

             const userCredentials = request.payload
             try {
                 const emailSent = await userService.emailSent(userCredentials)
-                const hashedAccessToken = Object.keys(
+                const hashedSessionToken = Object.keys(
                     userService.activeSessions,
                 ).find(hashedToken => {
                     return (
                 })
                 // Registers the activeSessions object for use by jwt auth strategy
                 request.server.app.activeSessions = userService.activeSessions
-                if (!hashedAccessToken.length) {
-                    throw Error('hashedAccessToken not Found!!')
+                if (!hashedSessionToken?.length) {
+                    throw Error('hashedSessionToken not Found!!')
                 }
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
                     data: {
                         emailSentSuccessfully: emailSent.wasSuccessfull,
-                        hashedAccessToken: hashedAccessToken,
+                        hashedSessionToken,
                     },
                 }
             } catch (err) {

backend/lib/routes/user/getaccess.js → backend/lib/routes/user/get-session.js

 
 module.exports = {
     method: 'POST',
-    path: '/getaccess',
+    path: '/get-session',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         handler: async function (request, h) {
             const { userService } = request.server.services()
             const res = request.payload
-            // NOTE: Access Token set for 5 minutes expiration (default)
-            const accessToken = await userService.createToken(res, 600)
+            // NOTE: Session Token set for 5 minutes expiration (default)
+            const sessionToken = await userService.createToken(res, 600)
             try {
                 const response = h.response({
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: accessToken,
+                    data: sessionToken,
                 })
-                response.header('Authorization', accessToken)
+                response.header('Authorization', sessionToken)
                 return response
             } catch (err) {
                 return {

backend/lib/routes/user/login.js

         handler: async function (request, h) {
             try {
                 const { userService } = request.server.services()
-                console.log('testing from here login.js :=>')
                 const res = request.payload
 
                 // Callback to use as transaction

backend/lib/routes/user/removesession.js

             exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
         },
         handler: async function (request, h) {
-            const hashedAccessToken = request.payload
+            const hashedSessionToken = request.payload
             const { userService } = request.server.services()
             try {
-                await userService.removeSession(hashedAccessToken)
+                await userService.removeSession(hashedSessionToken)
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,

backend/lib/routes/user/validatesession.js

             exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
         },
         handler: async function (request, h) {
-            const hashedAccessToken = request.payload
+            const hashedSessionToken = request.payload
             const { userService, profileService } = request.server.services()
             try {
                 const validatedSessionToken =
-                    userService.validateSession(hashedAccessToken)
+                    userService.validateSession(hashedSessionToken)
                 const user = await userService.findByUserEmail(
                     validatedSessionToken.email,
                 )

backend/lib/routes/user/verifyactivesession.js

                 ).find(hashedToken => {
                     return hashedToken === hash
                 })
-                if (!hashToMatch.length) {
+                console.log('hashToMatch :=>', hashToMatch)
+                if (!hashToMatch?.length) {
                     throw Error('hashToMatch Not Found!')
                 }
                 const now = Date.now()

backend/lib/services/user.js

      * @param {HashedSessionToken} hashedSessionToken
      * @returns {PayloadFromActiveSessions}
      */
-    validateSession(hashedAccessToken) {
-        const userSession = this.activeSessions[hashedAccessToken]
+    validateSession(hashedSessionToken) {
+        const userSession = this.activeSessions[hashedSessionToken]
         if (!userSession) {
             throw new Error(
                 'hashedSessionToken not in activeSessions registry!',
         if (!userSession.emailWasRespondedTo) {
             throw new Error('email was never responded to!')
         }
-        const accessToken = userSession.accessToken
-        const accessTokenIsValid = this.validateToken(accessToken)
+        const sessionToken = userSession.sessionToken
+        const sessionTokenIsValid = this.validateToken(sessionToken)
         return {
-            ...accessTokenIsValid.payload,
-            accessToken: this.activeSessions[hashedAccessToken].accessToken,
+            ...sessionTokenIsValid.payload,
+            sessionToken: this.activeSessions[hashedSessionToken].sessionToken,
         }
     }
-    removeSession(hashedAccessToken) {
-        const userSession = this.activeSessions[hashedAccessToken]
+    removeSession(hashedSessionToken) {
+        const userSession = this.activeSessions[hashedSessionToken]
         if (!userSession) {
             throw new Error(
                 'hashedSessionToken not in activeSessions registry!',
             )
         } else {
-            delete this.activeSessions[hashedAccessToken]
+            delete this.activeSessions[hashedSessionToken]
         }
     }
     /**
      * @ returns {Object}
      */
     async emailSent(userCredentials) {
-        const hashedAccessToken = await this.hashToken(
-            userCredentials.accessToken,
+        const hashedSessionToken = await this.hashToken(
+            userCredentials.sessionToken,
         )
-        if (Object.keys(this.activeSessions).includes(hashedAccessToken)) {
+        if (Object.keys(this.activeSessions).includes(hashedSessionToken)) {
             return new Error('session already in cache!!')
         }
         // Set expiration time for ten minutes from now
         const duration = 600000
 
-        this.activeSessions[hashedAccessToken] = {
+        this.activeSessions[hashedSessionToken] = {
             email: userCredentials.email,
             name: userCredentials.name,
             seeking: userCredentials.seeking,
-            accessToken: userCredentials.accessToken,
+            sessionToken: userCredentials.sessionToken,
             expiration: Date.now() + duration,
             emailWasRespondedTo: false,
-            sessionToken: null,
+            accessToken: null,
         }
 
         const sendSmtpEmail = {
             templateId: 2,
             params: {
                 // TODO: Change this in production...
-                link: `localhost:3000/verify/${hashedAccessToken}`,
+                link: `localhost:3000/verify/${hashedSessionToken}`,
             },
         }
 

frontend/src/components/onboarding/Auth.vue

                 password: userPass.val,
             })
             await this.createProfileForNewUser(newUserId, this.responses)
-            const accessToken = await this.getAccessToken({
+            const sessionToken = await this.getSessionToken({
                 ...this.answered,
             })
             const sessionInfo = await authenticator.sendAuthEmail({
                 ...this.answered,
-                accessToken: accessToken,
+                sessionToken: sessionToken,
             })
-            document.cookie = `siimee_access=${sessionInfo.hashedAccessToken}; max-age=600; path=/; secure`
+            document.cookie = `siimee_session=${sessionInfo.hashedSessionToken}; max-age=600; path=/; secure`
         } catch (err) {
             // TODO: render an error page in this component displaying which
             // error occurred and how to reach out to staff
                     'User has not answered minimum amount of questions to create profile',
                 )
         },
-        async getAccessToken(payload) {
-            return await authenticator.getAccessToken({
+        async getSessionToken(payload) {
+            return await authenticator.getSessionToken({
                 payload,
             })
         },

frontend/src/router/guards.js

 }
 
 const loginIfToken = async () => {
-    const sessionData = await authenticator.verifySessionCookie('siimee_access')
+    const sessionData = await authenticator.verifySessionCookie(
+        'siimee_session',
+    )
     if (
         sessionData?.profileId &&
-        sessionData?.accessToken &&
+        sessionData?.sessionToken &&
         !currentProfile.isLoggedIn
     ) {
         await currentProfile.login(
             sessionData.profileId,
             WaveUI.instance.notify,
-            sessionData.accessToken,
+            sessionData.sessionToken,
         )
     }
 }

frontend/src/services/auth.service.js

     async verifyAuthSession(hashedToken) {
         return await db.get(`/user/verify/${hashedToken}`)
     }
-    async getAccessToken(req) {
-        return await db.post('/user/getaccess', req, true)
+    async getSessionToken(req) {
+        return await db.post('/user/get-session', req, true)
     }
-    async validateSession(hashedAccessToken) {
-        return await db.post('/user/validatesession', hashedAccessToken, true)
+    async validateSession(hashedSessionToken) {
+        return await db.post('/user/validatesession', hashedSessionToken, true)
     }
     async authenticateLoginCredentials(credentials) {
         return await db.post('/user/login', credentials)
     }
-    async removeSession(hashedAccessToken) {
-        return await db.post('/user/removesession', hashedAccessToken, true)
+    async removeSession(hashedSessionToken) {
+        return await db.post('/user/removesession', hashedSessionToken, true)
     }
     grabStoredCookie(cookieKey) {
         const cookies = document.cookie.split('; ').reduce((prev, current) => {

frontend/src/views/HomeView.vue

             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
-            const hashedAccessToken =
-                authenticator.grabStoredCookie('siimee_access')
+            const hashedSessionToken =
+                authenticator.grabStoredCookie('siimee_session')
             const removedSession = await authenticator.removeSession(
-                hashedAccessToken,
+                hashedSessionToken,
             )
             if (removedSession.error)
                 console.error('ERROR :=>', removedSession.error)
-            document.cookie = `siimee_access=''; max-age=0; path=/; secure`
+            document.cookie = `siimee_session=''; max-age=0; path=/; secure`
             this.$router.push('/onboarding')
         },
         // this can be placed in utils/notification.js

frontend/src/views/LoginView.vue

             // emailSentSuccessfully: emailSent.wasSuccessfull,
             const sessionInfo = await authenticator.sendAuthEmail({
                 ...credentials.answered,
-                accessToken: credentials.jwt,
+                sessionToken: credentials.jwt,
             })
             if (sessionInfo.emailSentSuccessfully) {
                 this.emailSentSuccessfully = true
             }
-            document.cookie = `siimee_access=${sessionInfo.hashedAccessToken}; max-age=600; path=/; secure`
+            document.cookie = `siimee_session=${sessionInfo.hashedSessionToken}; max-age=600; path=/; secure`
         },
     },
 }

frontend/src/views/OnboardingView.vue

         this.survey = await surveyFactory.createSurvey()
         try {
             const sessionData =
-                await authenticator.verifySessionCookie('siimee_access')
+                await authenticator.verifySessionCookie('siimee_session')
             if (sessionData) {
                 await currentProfile.login(
                     sessionData.profileId,
                     this.$waveui.notify,
-                    sessionData.accessToken,
+                    sessionData.sessionToken,
                 )
                 this.responses = this.formatResponses(
                     currentProfile._profile.responses,
                 )
                 currentProfile._profile.responses = this.responses
                 try {
-                    await authenticator.verifySessionCookie('siimee_access')
+                    await authenticator.verifySessionCookie('siimee_session')
                 } catch (err) {
                     this.currentStep = 0
                     this.goToStep(this.currentStep)