:recycle: small tweaks | comments | etc

frontend/src/router/guards.js

 }
 
 const loginIfToken = async () => {
-    const sessionData = await authenticator.verifySessionCookie()
+    const sessionData = await authenticator.checkSessionValid()
     if (
         sessionData?.profileId &&
-        sessionData?.sessionToken &&
-        !currentProfile.isLoggedIn
+        sessionData?.sessionToken
     ) {
         await currentProfile.login(
             sessionData.profileId,
 }
 
 const checkLoginStatus = async (destination, nextCb) => {
-    await loginIfToken()
+    if(!currentProfile.isLoggedIn) {
+        await loginIfToken()
+    }
     log(destination)
     if (DEV_MODE) {
         nextCb()
     } else if (
-        destination.meta.requiresCompleteProfile &&
-        !currentProfile.isLoggedIn &&
-        !currentProfile.isComplete
+        !currentProfile.isLoggedIn
     ) {
-        nextCb('/onboarding')
+        nextCb('/login')
     } else if (
         destination.meta.requiresCompleteProfile &&
-        destination.meta.requiresAuth &&
-        !currentProfile.isLoggedIn
+        destination.meta.requiresAuth
     ) {
-        nextCb('/login')
+        nextCb('/onboarding')
     } else {
         nextCb()
     }

frontend/src/services/auth.service.js

 import { db } from '../utils/db.js'
 
 class Authenticator {
-    async sendEmail(answered) {
-        return await db.post('/user/send-email/', answered)
+    async sendEmail(credentials) {
+        return await db.post('/user/send-email/', credentials)
     }
+    /** Check for session has not expired; Confirm session from email. */
     async verifySession(hashedToken) {
         let verification
         try {
     async createToken(req) {
         return await db.post('/user/token', req, true)
     }
-    async validateSession() {
+    /** Check for session existence in backend */
+    async #validateSession() {
         const hashedSessionToken = this.grabStoredSessionToken()
         let validation
         try {
             )
         return cookies[cookieKey]
     }
-    async verifySessionCookie() {
-        const validatedToken = await this.validateSession()
+    async checkSessionValid() {
+        const validatedToken = await this.#validateSession()
         if (validatedToken.error)
             return console.error('ERROR :=>', validatedToken.error)
         return validatedToken

frontend/src/views/LoginView.vue

     }),
     methods: {
         async login() {
-            const loginCredentials = {
-                user_email: this.form.email,
-                password: this.form.password,
-            }
             const credentials =
-                await authenticator.authenticateLoginCredentials(
-                    loginCredentials,
-                )
+                await authenticator.authenticateLoginCredentials({
+                    user_email: this.form.email,
+                    password: this.form.password,
+                })
             // emailSentSuccessfully: emailSent.wasSuccessfull,
             const sessionInfo = await authenticator.sendEmail({
                 ...credentials.answered,

frontend/src/views/OnboardingView.vue

         // TODO: Troubleshoot bug where not all responses are returned at SurveyCompleteView
         this.survey = await surveyFactory.createSurvey()
         try {
-            const sessionData = await authenticator.verifySessionCookie()
+            const sessionData = await authenticator.checkSessionValid()
             if (sessionData) {
                 this.responses = this.formatResponses(
                     currentProfile._profile.responses,
                 )
                 currentProfile._profile.responses = this.responses
                 try {
-                    await authenticator.verifySessionCookie()
+                    await authenticator.checkSessionValid()
                 } catch (err) {
                     this.currentStep = 0
                     this.goToStep(this.currentStep)

frontend/src/views/VerifyView.vue

         hash = this.$route.params.hashedToken
         try {
             if (!hash) throw new Error('URL contains no hash!')
-            const verifiedFromUrlHash = await this.verifyActiveSession(hash)
-            console.log('verifiedFromUrlHash :>> ', verifiedFromUrlHash)
-            const sessionData = await authenticator.verifySessionCookie()
-            if (!sessionData)
-                throw new Error(`Could not verify session from cookie.`)
+            const sessionData = await authenticator.verifySession(hash)
+            if (!sessionData.hashesMatch)
+                throw new Error('Hash is not in activeSessions!')
 
+            await authenticator.checkSessionValid()
             currentProfile.login(
                 sessionData.profileId,
                 this.$waveui.notify,
             console.error(err)
         }
         this.$router.push('/')
-    },
-    methods: {
-        async verifyActiveSession(hashedToken) {
-            const sessionData = await authenticator.verifySession(hashedToken)
-            if (!sessionData.hashesMatch)
-                throw new Error('Hash is not in activeSessions!')
-            return sessionData
-        },
-    },
+    }
 }
 </script>