:recycle: Incorporated Juan's auth-overpass changes with new refactor

backend/lib/plugins/user.js

 const UserProfilesListRoute = require('../routes/user/list-profiles')
 const UserLoginRoute = require('../routes/user/login')
 const UserSignupRoute = require('../routes/user/signup')
-const UserEmailRoute = require('../routes/user/email.js')
-const UserVerifyActiveRoute = require('../routes/user/verifyactivesession.js')
-const UserGetSessionRoute = require('../routes/user/get-session.js')
-const UserValidateSessionRoute = require('../routes/user/validatesession.js')
-const UserRemoveSessionRoute = require('../routes/user/removesession.js')
+const UserEmailRoute = require('../routes/user/send-email.js')
+const UserVerifyActiveRoute = require('../routes/user/verify-session.js')
+const UserCreateTokenRoute = require('../routes/user/token.js')
+const UserValidateSessionRoute = require('../routes/user/validate-session.js')
+const UserRemoveSessionRoute = require('../routes/user/remove-session.js')
 const UserPassword = require('../routes/user/authentication')
 
 const UserService = require('../services/user')
         await server.route(UserProfilesListRoute)
         await server.route(UserEmailRoute)
         await server.route(UserVerifyActiveRoute)
-        await server.route(UserGetSessionRoute)
+        await server.route(UserCreateTokenRoute)
         await server.route(UserValidateSessionRoute)
         await server.route(UserRemoveSessionRoute)
         await server.route(UserPassword)

backend/lib/routes/user/removesession.js → backend/lib/routes/user/remove-session.js

     docs: {
         get: {
             description: 'removes sessionToken from activeSessions upon logout',
-            notes: 'on logout, activeSessions no longer holds onto user credentials',
+            notes: 'On logout, activeSessions no longer holds onto user credentials',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/removesession',
+    path: '/remove-session',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],

backend/lib/routes/user/email.js → backend/lib/routes/user/send-email.js

 
 module.exports = {
     method: 'POST',
-    path: '/sendemail/',
+    path: '/send-email/',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],

backend/lib/routes/user/get-session.js → backend/lib/routes/user/token.js

     handlerType: 'authentication',
     docs: {
         get: {
-            description: 'gets session token for authentication',
-            notes: 'Gets session token for authentication',
+            description: 'creates session token for authentication',
+            notes: 'Creates session token for authentication',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/get-session',
+    path: '/token',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],

backend/lib/routes/user/validatesession.js → backend/lib/routes/user/validate-session.js

     docs: {
         get: {
             description: 'validates session token for each step of survey',
-            notes: 'validates session token for each step of survey',
+            notes: 'Validates session token for each step of survey',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/validatesession',
+    path: '/validate-session',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],

frontend/src/components/onboarding/Auth.vue

                 password: userPass.val,
             })
             await this.createProfileForNewUser(newUserId, this.responses)
-            const sessionToken = await this.getSessionToken({
+            const sessionToken = await this.createToken({
                 ...this.answered,
             })
-            const sessionInfo = await authenticator.sendAuthEmail({
+            const sessionInfo = await authenticator.sendEmail({
                 ...this.answered,
                 sessionToken: sessionToken,
             })
                     'User has not answered minimum amount of questions to create profile',
                 )
         },
-        async getSessionToken(payload) {
-            return await authenticator.getSessionToken({
+        async createToken(payload) {
+            return await authenticator.createToken({
                 payload,
             })
         },

frontend/src/components/onboarding/QuestionResponse.vue

             type: Number,
             required: true,
         },
-        surveyStepsCount: {
-            type: Number,
+        survey: {
+            type: Object,
             required: true,
+            default: () => {},
         },
     },
     emits: ['update-answers'],
         radioItems: [1, 2, 3, 4, 5],
         answer: null,
         noChoiceMade: null,
+        surveyStepsCount: null,
     }),
+    created() {
+        this.surveyStepsCount = this.survey?.steps.length
+    },
     methods: {
         onUpdate(index) {
             this.noChoiceMade = false

frontend/src/services/auth.service.js

     constructor() {
         this.currentUser = null
     }
-    async sendAuthEmail(answered) {
-        return await db.post('/user/sendemail/', answered)
+    async sendEmail(answered) {
+        return await db.post('/user/send-email/', answered)
     }
-    async verifyAuthSession(hashedToken) {
+    async verifySession(hashedToken) {
         return await db.get(`/user/verify/${hashedToken}`)
     }
-    async getSessionToken(req) {
-        return await db.post('/user/get-session', req, true)
+    async createToken(req) {
+        return await db.post('/user/token', req, true)
     }
     async validateSession(hashedSessionToken) {
-        return await db.post('/user/validatesession', hashedSessionToken, true)
+        return await db.post('/user/validate-session', hashedSessionToken, true)
     }
     async authenticateLoginCredentials(credentials) {
         return await db.post('/user/login', credentials)
     }
     async removeSession(hashedSessionToken) {
-        return await db.post('/user/removesession', hashedSessionToken, true)
+        return await db.post('/user/remove-session', hashedSessionToken, true)
     }
     grabStoredCookie(cookieKey) {
         const cookies = document.cookie.split('; ').reduce((prev, current) => {

frontend/src/views/LoginView.vue

                     loginCredentials,
                 )
             // emailSentSuccessfully: emailSent.wasSuccessfull,
-            const sessionInfo = await authenticator.sendAuthEmail({
+            const sessionInfo = await authenticator.sendEmail({
                 ...credentials.answered,
                 sessionToken: credentials.jwt,
             })

frontend/src/views/OnboardingView.vue

                 :question='step'
                 :responses='responses'
                 :survey='survey'
-                :surveyStepsCount='survey?.steps?.length'
                 @handle-submit='onSubmit'
                 @update-answers='updateAnswers'
                 v-if='step && currentStep == i'

frontend/src/views/VerifyView.vue

                 throw new Error('sessionToken not in cookie store!')
         },
         async verifyActiveSession(hashedToken) {
-            const sessionData = await authenticator.verifyAuthSession(
-                hashedToken,
-            )
+            const sessionData = await authenticator.verifySession(hashedToken)
             if (!sessionData.hashesMatch)
                 throw new Error('Hash is not in activeSessions!')
         },