:recycle: Cleaned up cookie/auth logic

frontend/src/components/onboarding/Auth.vue

             const accessToken = await this.getAccessToken({
                 ...this.answered,
             })
-            console.log('accessToken :=>', accessToken)
             const sessionInfo = await authenticator.sendAuthEmail({
                 ...this.answered,
                 accessToken: accessToken,

frontend/src/router/guards.js

     }
 }
 
-// TODO: move to utils/index.js and import to this file, OnboardingView.vue and VerifyView.vue
-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()
+    const sessionData = await authenticator.verifySessionCookie('siimee_access')
     if (
         sessionData?.profileId &&
         sessionData?.accessToken &&

frontend/src/services/auth.service.js

     async removeSession(hashedAccessToken) {
         return await db.post('/user/removesession', hashedAccessToken, true)
     }
+    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
+    }
+    async verifySessionCookie(sessionCookie) {
+        const hashedAccessToken = this.grabStoredCookie(sessionCookie)
+        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 authenticator = new Authenticator()
 

frontend/src/utils/index.js

     return surveyResponses
 }
 
-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
-    }
-}
-
 export {
     validatorMapping,
     surveyFactory,
     randomMedia,
     randomName,
     randomEmail,
-    grabStoredCookie,
-    verifySession,
 }

frontend/src/views/HomeView.vue

             )
             this.fetchedCards.push(...newQueue) // update fetchedCards => recalculate cards
         },
-        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
-        },
         async logout() {
             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
-            const hashedAccessToken = this.grabStoredCookie('siimee_access')
+            const hashedAccessToken =
+                authenticator.grabStoredCookie('siimee_access')
             const removedSession = await authenticator.removeSession(
                 hashedAccessToken,
             )

frontend/src/views/OnboardingView.vue

 import { surveyFactory } from '@/utils'
 import stepViews from '@/components/onboarding'
 import SurveyCompleteView from './SurveyCompleteView.vue'
-let hashedAccessToken = null
 
 export default {
     name: 'OnboardingView',
     }),
     async created() {
         this.survey = await surveyFactory.createSurvey()
-        hashedAccessToken = this.grabStoredCookie('siimee_access')
         try {
-            const sessionData = await this.verifySession(hashedAccessToken)
+            const sessionData = await authenticator.verifySessionCookie(
+                'siimee_access',
+            )
             if (sessionData) {
                 await currentProfile.login(
                     sessionData.profileId,
         async goToStep(num) {
             this.currentStep = num
         },
-        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
-        },
-        async verifySession(hashedAccessToken) {
-            if (!hashedAccessToken)
-                return console.warn('WARNING :=> accessToken is not defined')
-            const validatedToken = await authenticator.validateSession(
-                hashedAccessToken,
-            )
-            if (validatedToken.error) {
-                throw new Error(validatedToken.error)
-            } else {
-                return validatedToken
-            }
-        },
         formatResponses(responses) {
             return responses.map(response => {
                 return {
                 )
                 currentProfile._profile.responses = this.responses
                 try {
-                    await this.verifySession(hashedAccessToken)
+                    await authenticator.verifySessionCookie('siimee_access')
                 } catch (err) {
                     this.currentStep = 0
                     this.goToStep(this.currentStep)

frontend/src/views/VerifyView.vue

     name: 'VerifyView',
     async created() {
         hash = this.$route.params.hashedToken
-        hashedAccessToken = this.grabCookie('siimee_access')
+        hashedAccessToken = authenticator.grabStoredCookie('siimee_access')
         try {
             this.isHashInUrl(hash)
             await this.doesAccessTokenExist(hashedAccessToken)
             await this.verifyActiveSession(hash)
-            const sessionData = await this.isSessionTokenValid(hash)
+            const sessionData = await authenticator.verifySessionCookie(
+                'siimee_access',
+            )
             await currentProfile.login(
                 sessionData.profileId,
                 this.$waveui.notify,
         this.$router.push('/')
     },
     methods: {
-        grabCookie(cookieKey) {
-            const cookies = document.cookie
-                .split('; ')
-                .reduce((prev, current) => {
-                    const [name, ...value] = current.split('=')
-                    prev[name] = value.join('=')
-                    return prev
-                }, {})
-            return `${cookieKey}` in cookies
-                ? cookies[`${cookieKey}`]
-                : undefined
-        },
         isHashInUrl(hash) {
             if (!hash) throw new Error('URL contains no hash!')
         },
             if (!sessionData.hashesMatch)
                 throw new Error('Hash is not in activeSessions!')
         },
-        async isSessionTokenValid(hash) {
-            const sessionTokenIsValid = await authenticator.validateSession(
-                hash,
-            )
-            if (sessionTokenIsValid.error) {
-                throw new Error(sessionTokenIsValid.error)
-            } else return sessionTokenIsValid
-        },
     },
 }
 </script>