:construction: Cleaned up logic from created into methods on Auth and Verification

backend/lib/routes/user/signup.js

                     })
                     .code(201)
             } catch (err) {
+                console.error('ERROR :=>', err)
                 return h
                     .response({
                         ok: false,

backend/lib/routes/user/validatesession.js

                 return {
                     ok: false,
                     handler: pluginConfig.handlerType,
-                    data: err.message,
+                    data: { error: err.message },
                 }
             }
         },

backend/lib/services/profile/index.js

      */
     async saveResponsesCreateProfileFor(userId, responses, txn) {
         const { Profile, Response } = this.server.models()
-
-        const profile = await Profile.query(txn).insert({
-            user_id: userId,
-        })
-        for (const responseToSave of responses) {
-            const convertedResponse = this._convertResponse(responseToSave)
-            const responseInfo = {
-                profile_id: profile.id,
-                response_key_id: convertedResponse.response_key_id,
-                val: convertedResponse.val,
+        try {
+            const profile = await Profile.query(txn).insert({
+                user_id: userId,
+            })
+            for (const responseToSave of responses) {
+                const convertedResponse = this._convertResponse(responseToSave)
+                const responseInfo = {
+                    profile_id: profile.id,
+                    response_key_id: convertedResponse.response_key_id,
+                    val: convertedResponse.val,
+                }
+                await Response.query(txn).insert(responseInfo)
             }
-            await Response.query(txn).insert(responseInfo)
+            //** Work around for HAPI returning profile_id as id */
+            return { user_id: profile.user_id, profile_id: profile.id }
+        } catch (err) {
+            throw new Error(err)
         }
-        //** Work around for HAPI returning profile_id as id */
-        return { user_id: profile.user_id, profile_id: profile.id }
     }
 
     /** Update responses in place

frontend/src/components/onboarding/Auth.vue

 .wait-message
     p.verify-message Thanks for signing up!
     p.verify-message We'll just need you to verify your email address to continue. Please check your email!
-    w-button.ma1.grow(
-        @click='handleSubmit'
-    ) TEST BUTTON
 </template>
 
 <script>
     props: {
         question: {
             required: true,
-            type: String,
-            default: 'authenticated question!!',
+            type: Object,
+            default: () => {},
         },
         answered: {
-            type: String,
-            default: '',
+            type: Object,
+            default: () => {},
         },
         responses: {
-            type: String,
-            default: '',
+            type: Object,
+            default: () => {},
         },
         survey: {
             required: true,
     async created() {
         // Establishes New User And Sends Auth Email
         this.authenticator = new Authenticator()
-        if (this.survey.hasMinResponsesToCreateProfile(this.responses)) {
+        try {
+            this.doesUserHaveMinResponses(this.responses)
             const userPass = this.responses.find(
                 response => response.response_key_id === 9,
             )
-            const newUser = await signupUser({
+            const newUserId = await this.signupNewUser({
                 ...this.answered,
                 password: userPass.val,
             })
-            const newUserId = newUser.user_id
-            await createProfileForUserId(newUserId, this.responses)
-            const jwt = await this.authenticator.getJwt({
+            await this.createProfileForNewUser(newUserId, this.responses)
+            const sessionToken = await this.getSessionToken({
                 ...this.answered,
-                expires: 60 * 3,
             })
-            document.cookie = `siimee_session=${jwt}; max-age=600; path=/; secure`
+            document.cookie = `siimee_session=${sessionToken}; max-age=600; path=/; secure`
             await this.authenticator.sendAuthEmail(this.answered)
-        } else {
-            console.error('ERROR :=>')
+        } catch (err) {
+            // TODO: redirect to an error page displaying which
+            // error occurred and how to reach out to staff??
+            console.error('ERROR :=>', err)
         }
     },
     methods: {
-        // TODO: remove test button above and use a watcher instead to emit this
-        handleSubmit() {
-            const payload = {
-                question: this.question,
+        doesUserHaveMinResponses(responses) {
+            if (!this.survey.hasMinResponsesToCreateProfile(responses))
+                throw new Error(
+                    'User has not answered minimum amount of questions to create profile',
+                )
+        },
+        async getSessionToken(payload) {
+            return await this.authenticator.getJwt({
+                payload,
+                expires: 60 * 3,
+            })
+        },
+        async signupNewUser(userInfo) {
+            const newUser = await signupUser(userInfo)
+            if (!newUser || newUser.error) {
+                throw new Error(
+                    'Error occured when signing up new User :=>',
+                    newUser.error,
+                )
+            } else return newUser.user_id
+        },
+        async createProfileForNewUser(userId, responses) {
+            try {
+                await createProfileForUserId(userId, responses)
+            } catch (err) {
+                throw new Error(err)
             }
-            this.$emit('update-answers', payload)
         },
     },
 }

frontend/src/components/onboarding/QuestionResponse.vue

             type: Object,
             required: true,
         },
-        currentSteps: {
+        currentStep: {
             type: Number,
             required: true,
         },

frontend/src/services/auth.service.js

         const isVerified = await db.get(`/user/verify/${hashedEmail}`)
         return isVerified.hashesMatch
     }
-
     async getJwt(req) {
-        // TODO: Clean up, should be able to use TOJ's db.post function,
-        // may need custon db.postWithHeaders() func or something like that...
-        const response = await fetch('http://localhost:3001/api/user/getjwt', {
-            method: 'POST',
-            mode: 'cors',
-            cache: 'no-cache',
-            credentials: 'omit',
-            headers: {
-                'Content-Type': 'application/json',
-            },
-            redirect: 'manual',
-            referrerPolicy: 'no-referrer',
-            body: JSON.stringify({ payload: req, expires: 600 }),
-        }).then(response => {
-            return response
-        })
-        console.log('response.headers :=>', response.headers)
-        // TODO: consider cleaner way to convert headers into JS Object
-        const getHeaders = headers => {
-            const headerObj = {}
-            const keys = headers.keys()
-            let header = keys.next()
-            while (header.value) {
-                headerObj[header.value] = headers.get(header.value)
-                header = keys.next()
-            }
-            return headerObj
-        }
-        const headerObj = getHeaders(response.headers)
-        return headerObj['authorization']
+        const responseHeaders = await db.post('/user/getjwt', req, true)
+        return responseHeaders
     }
-
     async validateSession(sessionToken) {
         const validateSession = await db.get(
             `/user/validatesession/${sessionToken}`,

frontend/src/utils/db.js

         }
         return header
     }
-    async _tryFetch({ endpoint, header }) {
+    async _tryFetch({ endpoint, header }, returnHeaders = false) {
         try {
             const res = await fetch(`${remote}${endpoint}`, header)
             if (!res.ok) {
                 throw Error(res.statusText)
             }
-            const jsonRes = await res.json()
-            return jsonRes.data
+            if (returnHeaders) {
+                return res.headers
+            } else {
+                const jsonRes = await res.json()
+                return jsonRes.data
+            }
         } catch (error) {
             console.error(`[API Util]: ${error}\nroute:`, endpoint)
         }
             header: this._makeHeader({ method: this._verbs.get }),
         })
     }
-    async post(endpoint, payload = {}) {
+    async post(endpoint, payload = {}, returnHeaders = false) {
         return await this._tryFetch({
             endpoint,
             header: this._makeHeader({ method: this._verbs.post, payload }),
+            returnHeaders,
         })
     }
     async patch(endpoint, payload = {}) {

frontend/src/views/OnboardingView.vue

         }
         // if (sessionData && !accessToken) {
         if (sessionData) {
-            this.userEmail = sessionData.email
+            this.userEmail = sessionData.payload.email
             this.emailIsRegistered =
                 await this.authenticator.checkIfEmailIsRegistered(
                     this.userEmail,

frontend/src/views/VerifyView.vue

     data: () => ({
         authenticator: {},
         answers: {},
+        hash: undefined,
+        sessionToken: undefined,
+        accessToken: undefined,
     }),
     async created() {
         this.authenticator = new Authenticator()
-        const hashEmail = this.$route.params.email
-
-        const hashesMatch = await this.authenticator.verifyAuthEmail(hashEmail)
-        const sessionToken = this.grabCookie('siimee_session')
-        // TODO: Refactor, see methods below
-        // if (!hashesMatch) {
-        //     throw new Error('no record of hashed email in cache')
-        //     this.$router.push('/onboarding')
-        // }
-
-        // TODO: THIS NEEDS TO BE SENT OVER TO verifyAuthEmail(hashEmail) in the headers
-        // TODO: Refactor, see methods below
-        // if (!sessionToken) {
-        //     throw new Error('token doesn't exist)
-        //     this.$router.push('/onboarding')
-        // } else {}
-
-        // TODO: Refactor to not nest, use try/catch/throw
-        if (sessionToken) {
-            const validatedSessionToken =
-                await this.authenticator.validateSession(sessionToken)
-            if (validatedSessionToken && hashesMatch) {
-                // TODO: What payload does accessToken need in first param to getJwt?
-                const accessToken = await this.authenticator.getJwt({
-                    ...sessionToken,
-                    expires: 60 * 3,
-                })
-                document.cookie = `siimee_access=${accessToken}; max-age=600; path=/; secure`
-                this.$router.push('/onboarding')
-            }
-        } else {
-            console.error('ERROR :=>')
+        this.hash = this.$route.params.email
+        this.sessionToken = this.grabCookie('siimee_session')
+        try {
+            this.isHashInUrl(this.hash)
+            this.doesEmailMatch(this.hash)
+            this.doesSessionTokenExist(this.sessionToken)
+            const sessionTokenIsValid = this.isSessionTokenValid(
+                this.sessionToken,
+            )
+            if (sessionTokenIsValid)
+                document.cookie = `siimee_access=${this.accessToken}; max-age=600; path=/; secure`
+        } catch (err) {
+            console.error(err)
         }
+        this.$router.push('/onboarding')
     },
     methods: {
         grabCookie(cookieKey) {
                 ? cookies[`${cookieKey}`]
                 : undefined
         },
-        async generateAccessToken() {
-            const accessJwt = await this.authenticator.getJwt({
-                ...this.answers,
+        async getAccessToken(payload) {
+            return await this.authenticator.getJwt({
+                payload,
                 expires: 60 * 3,
             })
-            return accessJwt
         },
-        // async doesEmailMatch() {},
-        // async doesTokenExist() {},
-        // async isTokenValid() {},
+        isHashInUrl(hash) {
+            if (!hash) throw new Error('URL contains no hash!')
+        },
+        async doesEmailMatch(hashEmail) {
+            const hashesMatch = await this.authenticator.verifyAuthEmail(
+                hashEmail,
+            )
+            if (!hashesMatch) throw new Error('Hash is not in registry!')
+        },
+        async doesSessionTokenExist(sessionToken) {
+            if (!sessionToken)
+                throw new Error('sessionToken not in cookie store!')
+        },
+        async isSessionTokenValid(sessionToken) {
+            const sessionTokenIsValid =
+                await this.authenticator.validateSession(sessionToken)
+            if (sessionTokenIsValid.error) {
+                throw new Error(sessionTokenIsValid.error)
+            } else {
+                // TODO: Does accessToken need sessionToken data?
+                this.accessToken = await this.getAccessToken(this.sessionToken)
+            }
+        },
     },
 }
 </script>