:truck: Renamed variables/functions as a refactor

backend/lib/plugins/user.js

 const UserSignupRoute = require('../routes/user/signup')
 const UserEmailRoute = require('../routes/user/email.js')
 const UserVerifyEmailRoute = require('../routes/user/verifyemail.js')
-const UserGenerateJWTRoute = require('../routes/user/generatejwt.js')
-const UserValidateJWTRoute = require('../routes/user/validatejwt.js')
-const UserCheckCache = require('../routes/user/check-cache.js')
+const UserGetJWTRoute = require('../routes/user/getjwt.js')
+const UserValidateSessionRoute = require('../routes/user/validatesession.js')
+const UserCheckEmailRegistry = require('../routes/user/check-email-registry.js')
 const UserByEmail = require('../routes/user/user-by-email.js')
 const UserPassword = require('../routes/user/authentication')
 
         await server.route(UserProfilesListRoute)
         await server.route(UserEmailRoute)
         await server.route(UserVerifyEmailRoute)
-        await server.route(UserGenerateJWTRoute)
-        await server.route(UserValidateJWTRoute)
-        await server.route(UserCheckCache)
+        await server.route(UserGetJWTRoute)
+        await server.route(UserValidateSessionRoute)
+        await server.route(UserCheckEmailRegistry)
         await server.route(UserByEmail)
         await server.route(UserPassword)
     },

backend/lib/routes/user/check-cache.js → backend/lib/routes/user/check-email-registry.js

     handlerType: 'email',
     docs: {
         get: {
-            description: 'checks if user email is in cache',
-            notes: 'Checks if user email is in email cache and returns boolean',
+            description: 'checks if user email is registered in memory',
+            notes: 'Checks if user email is in application state and returns boolean',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/checkcache/',
+    path: '/checkemailregistry/',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
             const { userService } = request.server.services()
             const userEmail = request.payload
             try {
-                const emailIsInCache = await userService.checkEmailCache(
+                const emailIsRegistered = await userService.checkEmailRegistry(
                     userEmail,
                 )
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { emailIsInCache: emailIsInCache },
+                    data: emailIsRegistered,
                 }
             } catch (err) {
                 return {
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: Joi.object(),
-            }).label('email_res'),
+                data: Joi.bool(),
+            }).label('email_registry_res'),
             failAction: 'log',
         },
     },

backend/lib/routes/user/generatejwt.js → backend/lib/routes/user/getjwt.js

     handlerType: 'email',
     docs: {
         get: {
-            description: 'generates jwt after verifying email',
-            notes: 'Generates jwt after validating email',
+            description: 'gets jwt after verifying email',
+            notes: 'Gets jwt after validating email',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/generatejwt',
+    path: '/getjwt',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { jwt: token },
+                    data: token,
                 }
             } catch (err) {
                 return {
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: Joi.object(),
-            }).label('generate_jwt_res'),
+                data: Joi.string(),
+            }).label('get_jwt_res'),
             failAction: 'log',
         },
     },

backend/lib/routes/user/validatejwt.js → backend/lib/routes/user/validatesession.js

     handlerType: 'jwt',
     docs: {
         get: {
-            description: 'validates jwt for each step of survey',
-            notes: 'validates jwt for each step of survey',
+            description: 'validates session token for each step of survey',
+            notes: 'validates session token for each step of survey',
         },
     },
 }
 
 module.exports = {
     method: 'GET',
-    path: '/validatejwt/{jwt}',
+    path: '/validatesession/{sessionToken}',
     // method: 'GET' sessionToken in header ?
-    // path: '/validatesession/{sessionToken}'
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         auth: false,
         cors: true,
         handler: async function (request, h) {
-            const jwt = request.params.jwt
+            const sessionToken = request.params.sessionToken
             const { userService } = request.server.services()
-            const jwtIsValid = userService.validateToken(jwt)
+            const sessionTokenIsValid = userService.validateToken(sessionToken)
             try {
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
                     data: {
-                        isValid: jwtIsValid.isValid,
-                        payload: jwtIsValid.payload,
+                        isValid: sessionTokenIsValid.isValid,
+                        payload: sessionTokenIsValid.payload,
                     },
                 }
             } catch (err) {
                 ok: Joi.bool(),
                 handler: Joi.string(),
                 data: Joi.object(),
-            }).label('validate_jwt_res'),
+            }).label('validate_session_res'),
             failAction: 'log',
         },
     },

backend/lib/services/user.js

         return passwordRow ? passwordRow.token : null
     }
 
-    async checkEmailCache(userEmail) {
+    async checkEmailRegistry(userEmail) {
         const hashedEmail = await hashEmail(userEmail)
         const now = Date.now()
         // hashedEmail needs to be derived by email, salt
         const expiration = this.hashedEmails[hashedEmail]
         console.log('this.hashedEmails :=>', this.hashedEmails)
-        const emailIsInCache = Object.keys(this.hashedEmails).includes(
+        const emailIsRegistered = Object.keys(this.hashedEmails).includes(
             hashedEmail,
         )
         const emailIsExpired = now > expiration ? true : false
-        console.log('emailIsInCache :=>', emailIsInCache)
+        console.log('emailIsRegistered :=>', emailIsRegistered)
         console.log('emailIsExpired :=>', emailIsExpired)
-        if (emailIsInCache && !emailIsExpired) {
+        if (emailIsRegistered && !emailIsExpired) {
             return true
         } else {
             // try {

frontend/src/components/onboarding/Auth.vue

             })
             const newUserId = newUser.user_id
             await createProfileForUserId(newUserId, this.responses)
-            // TODO: rename getJwt
-            const jwt = await this.authenticator.generateJwt({
+            const jwt = await this.authenticator.getJwt({
                 ...this.answered,
                 expiration: 60 * 10,
             })

frontend/src/services/auth.service.js

         const emailWasSent = await db.post('/user/sendemail/', answered)
         return emailWasSent
     }
-    async checkEmailCache(email) {
-        const emailIsInCache = await db.post('/user/checkcache/', email)
-        return emailIsInCache.emailIsInCache
+    async checkIfEmailIsRegistered(email) {
+        const emailIsRegistered = await db.post(
+            '/user/checkemailregistry/',
+            email,
+        )
+        return emailIsRegistered
     }
     async verifyAuthEmail(hashedEmail) {
         const isVerified = await db.get(`/user/verify/${hashedEmail}`)
         return isVerified.hashesMatch
     }
-    // TODO: rename getJwt()
-    async generateJwt(req) {
-        const response = await db.post('/user/generatejwt', req)
+    async getJwt(req) {
+        const jwt = await db.post('/user/getjwt', req)
         // TODO: Move token into repsonse.headers
         // return response.headers ?
-        return response.jwt
+        return jwt
     }
 
-    // validateSession(sessionToken)
-    async validateJwt(jwt) {
-        const validateJwt = await db.get(`/user/validatejwt/${jwt}`)
-        return validateJwt
+    async validateSession(sessionToken) {
+        const validateSession = await db.get(
+            `/user/validatesession/${sessionToken}`,
+        )
+        return validateSession
     }
 }
 

frontend/src/views/OnboardingView.vue

         survey: null,
         invalidResponse: false,
         userEmail: null,
-        emailIsInCache: false,
+        emailIsRegistered: false,
         authenticator: {},
     }),
     async created() {
         this.survey = await surveyFactory.createSurvey()
         this.authenticator = new Authenticator()
         // TODO: Consider switch/case() depending on what tokens exist/are valid...
-        sessionToken = this.grabCookie('siimee_session_onboarding')
+        sessionToken = this.grabStoredCookie('siimee_session')
+        console.log('sessionToken :=>', sessionToken)
         // if (!sessionToken) {
         //     //
         // }
-        accessToken = this.grabCookie('siimee_access_onboarding')
+        // accessToken = this.grabStoredCookie('siimee_access_onboarding')
         // if (!accessToken) {
         //     // blow up
         // }
-        const sessionData = await this.authenticator.validateJwt(sessionToken)
-        // NOTE: Left off here, INCOMPLETE, no ACCESS TOKEN yet, crazy amount of logic here...
-        if (sessionData.isValid && !accessToken) {
+        const sessionData = await this.authenticator.validateSession(
+            sessionToken,
+        )
+        console.log('sessionData :=>', sessionData)
+        // if (sessionData.isValid && !accessToken) {
+        if (sessionData.isValid) {
             this.userEmail = sessionData.payload.email
-            // this.emailIsRegistered
-            this.emailIsInCache = await this.authenticator.checkEmailCache(
-                this.userEmail,
-            )
+            this.emailIsRegistered =
+                await this.authenticator.checkIfEmailIsRegistered(
+                    this.userEmail,
+                )
         }
         // TODO: EVERY ROUTE WE HIT AFTER THIS HAS TO BE AUTHENTICATED
         // ACCESS TOKEN WORKS
-        if (this.emailIsInCache) {
+        if (this.emailIsRegistered) {
             const user = await fetchUserByEmail(this.userEmail)
             const userId = user.user_id
             const profilesFromUserId = await fetchProfilesByUserId(userId)
                 profileId = profilesFromUserId[0].profile_id
                 this.currentProfileId = profileId
             }
+            // if (!profileId) {
+            // throw new Error
+            // }
             const profile = await fetchProfileByProfileId(profileId)
             profile.responses.forEach(response => {
                 this.responses.push({
         async goToStep(num) {
             this.currentStep = num
         },
-        // TODO: Rename this method, grab cookie from where?
-        // grabStoredCookie(cookieKey)
-        grabCookie(cookieKey) {
+        grabStoredCookie(cookieKey) {
             const cookies = document.cookie
                 .split('; ')
                 .reduce((prev, current) => {

frontend/src/views/VerifyView.vue

 
         // TODO: Refactor to not nest, use try/catch/throw
         if (sessionToken) {
-            // TODO: rename
-            // const accessToken = await this.authenticator.validateSession(sessionToken)
-            // hits backend route and the backend route has to be /validateSession/
+            // NOTE: hits backend route and the backend route has to be /validateSession/
             // if backend route succeeds, gives you access token
-            const accessToken = await this.authenticator.validateJwt(
+            const accessToken = await this.authenticator.validateSession(
                 sessionToken,
             )
             // TODO: isValid logic needs to live on back end
                 : undefined
         },
         async generateAccessToken() {
-            const accessJwt = await this.authenticator.generateJwt({
+            const accessJwt = await this.authenticator.getJwt({
                 ...this.answers,
                 expiration: 60 * 3, // testing for now... extend to 1 hour?
             })