:construction: Achieved basic login upon verification from email

backend/lib/routes/user/validatesession.js

                 )
                 // TODO: handle user with multiple profiles...
                 const profileId = profiles[0].profile_id
-                const responses = []
-                profiles[0].responses.forEach(response => {
-                    responses.push({
-                        response_key_id: response.response_key_id,
-                        val: response.val,
-                    })
-                })
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
                     data: {
                         ...validatedSessionToken,
                         profileId: profileId,
-                        responses: responses,
                     },
                 }
             } catch (err) {

backend/lib/services/matchqueue.js

      * @param {number} profileId
      * @returns {array} MatchQueue
      */
-    async getQueue(profileId, limit, offset=0) {
+    async getQueue(profileId, limit, offset = 0) {
         const { MatchQueue } = this.server.models()
-        if(typeof limit==='undefined') {
+        if (typeof limit === 'undefined') {
             return await MatchQueue.query()
                 .where('profile_id', profileId)
                 .where('is_deleted', 0)

frontend/src/App.vue

             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
-            // TODO: grab JWT from cookie and add JWT as third argument here
-            // (see views/OnboardingView.vue)
             await currentProfile.login(profileId, this.$waveui.notify)
             console.log('---')
 

frontend/src/components/onboarding/Auth.vue

 </template>
 
 <script>
-import { Authenticator } from '../../services/auth.service.js'
+import { authenticator } from '../../services/auth.service.js'
 import { createProfileForUserId } from '../../services/profile.service'
 import { signupUser } from '../../services/user.service.js'
 
         },
     },
     emits: ['update-answers'],
-    data: () => ({
-        authenticator: {},
-    }),
     async created() {
         // Establishes New User And Sends Auth Email
-        this.authenticator = new Authenticator()
         try {
             this.doesUserHaveMinResponses(this.responses)
             const userPass = this.responses.find(
                 ...this.answered,
             })
             console.log('accessToken :=>', accessToken)
-            const sessionInfo = await this.authenticator.sendAuthEmail({
+            const sessionInfo = await authenticator.sendAuthEmail({
                 ...this.answered,
                 accessToken: accessToken,
             })
                 )
         },
         async getAccessToken(payload) {
-            return await this.authenticator.getAccessToken({
+            return await authenticator.getAccessToken({
                 payload,
             })
         },

frontend/src/router/guards.js

-import { currentProfile } from '../services'
-
+import { currentProfile, authenticator } from '../services'
+import WaveUI from '../../node_modules/wave-ui/src/wave-ui/core'
 const DEV_MODE = import.meta.env.VITE_DEV == 'true'
 
 async function log(to) {
     }
 }
 
-const checkLoginStatus = (destination, nextCb) => {
+const grabStoredCookie = cookieKey => {
+    const cookies = document.cookie.split('; ').reduce((prev, current) => {
+        const [name, ...value] = current.split('=')
+        prev[name] = value.join('=')
+        return prev
+    }, {})
+    const cookieVal = cookieKey in cookies ? cookies[`${cookieKey}`] : undefined
+    return cookieVal
+}
+
+const verifySession = async () => {
+    const hashedAccessToken = grabStoredCookie('siimee_access')
+    if (!hashedAccessToken)
+        return console.warn('WARNING :=> accessToken is not defined')
+    const validatedToken = await authenticator.validateSession(
+        hashedAccessToken,
+    )
+    if (validatedToken.error) {
+        console.error('ERROR :=>', validatedToken.error)
+    } else {
+        return validatedToken
+    }
+}
+
+const loginIfToken = async () => {
+    const sessionData = await verifySession()
+    if (
+        sessionData?.profileId &&
+        sessionData?.accessToken &&
+        !currentProfile.isLoggedIn
+    ) {
+        await currentProfile.login(
+            sessionData.profileId,
+            WaveUI.notify,
+            sessionData.accessToken,
+        )
+    }
+}
+
+const checkLoginStatus = async (destination, nextCb) => {
+    await loginIfToken()
     log(destination)
     if (DEV_MODE) {
         nextCb()

frontend/src/services/auth.service.js

         return await db.post('/user/validatesession', hashedAccessToken, true)
     }
 }
+const authenticator = new Authenticator()
 
-export { Authenticator }
+export { authenticator, Authenticator }

frontend/src/views/OnboardingView.vue

 import stepViews from '@/components/onboarding'
 import SurveyCompleteView from './SurveyCompleteView.vue'
 let hashedAccessToken = null
-// TODO: remove once currentProfile from services is fully enforced
-let currentProfileId = null
 
 export default {
     name: 'OnboardingView',
         this.survey = await surveyFactory.createSurvey()
         this.authenticator = new Authenticator()
         hashedAccessToken = this.grabStoredCookie('siimee_access')
+        console.log('currentProfile.isLoggedIn :=>', currentProfile.isLoggedIn)
         try {
             const sessionData = await this.verifySession(hashedAccessToken)
-            currentProfileId = sessionData.profileId
             await currentProfile.login(
-                currentProfileId,
+                sessionData.profileId,
                 this.$waveui.notify,
                 sessionData.accessToken,
             )
-            // TODO: responses can now be gotten from currentProfile.responses
-            // TODO: assign token to currentProfile object?
-            console.log('currentProfile :=>', currentProfile)
-            // TODO: create a boolean toggle on currentProfile that determines
-            // whether user has returned to survey from HomeView?
-            this.$router.push('/')
-
-            this.responses = sessionData.responses
+            this.responses = this.formatResponses(
+                currentProfile._profile.responses,
+            )
             this.currentStep = this.responses.length + 3
             this.goToStep(this.currentStep)
         } catch (err) {
                 return validatedToken
             }
         },
+        formatResponses(responses) {
+            return responses.map(response => {
+                return {
+                    response_key_id: response.response_key_id,
+                    val: response.val,
+                }
+            })
+        },
         async updateAnswers(payload) {
             if (payload) {
                 const k = payload.question.survey_stage
                 this.responses.push(response)
                 if (k === 'aspects') return
             }
-            // NOTE: If user has finished minimum profile creation,
-            // Adds survey answers to responses table and verifies tokens on each step
-            // TODO: currentProfileId can now be gotten from currentProfile.responses
-            if (currentProfileId) {
+            if (currentProfile._profile?.profile_id) {
                 await surveyFactory.addNewSurveyAnswer(
                     this.responses[this.responses.length - 1],
-                    currentProfileId,
+                    currentProfile._profile.profile_id,
                 )
                 try {
                     await this.verifySession(hashedAccessToken)

frontend/src/views/VerifyView.vue

 </template>
 
 <script>
-import { Authenticator } from '../services/auth.service.js'
+import { currentProfile, authenticator } from '../services'
 let hash = null
 let hashedAccessToken = null
 export default {
     name: 'VerifyView',
-    data: () => ({
-        authenticator: {},
-    }),
     async created() {
-        this.authenticator = new Authenticator()
         hash = this.$route.params.hashedToken
         hashedAccessToken = this.grabCookie('siimee_access')
         try {
             this.isHashInUrl(hash)
             await this.doesAccessTokenExist(hashedAccessToken)
             await this.verifyActiveSession(hash)
-            await this.isSessionTokenValid(hash)
+            const sessionData = await this.isSessionTokenValid(hash)
+            await currentProfile.login(
+                sessionData.profileId,
+                this.$waveui.notify,
+                sessionData.accessToken,
+            )
         } catch (err) {
             console.error(err)
         }
-        // TODO: push to Home instead
-        this.$router.push('/onboarding')
+        this.$router.push('/')
     },
     methods: {
         grabCookie(cookieKey) {
                 throw new Error('accessToken not in cookie store!')
         },
         async verifyActiveSession(hashedToken) {
-            const sessionData = await this.authenticator.verifyAuthSession(
+            const sessionData = await authenticator.verifyAuthSession(
                 hashedToken,
             )
             if (!sessionData.hashesMatch)
                 throw new Error('Hash is not in activeSessions!')
         },
         async isSessionTokenValid(hash) {
-            const sessionTokenIsValid =
-                await this.authenticator.validateSession(hash)
+            const sessionTokenIsValid = await authenticator.validateSession(
+                hash,
+            )
             if (sessionTokenIsValid.error) {
                 throw new Error(sessionTokenIsValid.error)
-            }
+            } else return sessionTokenIsValid
         },
     },
 }