:construction: Set up separate routes for session/access token creation

backend/lib/plugins/user.js

 const UserSignupRoute = require('../routes/user/signup')
 const UserEmailRoute = require('../routes/user/email.js')
 const UserVerifyEmailRoute = require('../routes/user/verifyemail.js')
-const UserGetJWTRoute = require('../routes/user/getjwt.js')
+const UserGetSessionRoute = require('../routes/user/getsession.js')
+const UserGetAccessRoute = require('../routes/user/getaccess.js')
 const UserValidateSessionRoute = require('../routes/user/validatesession.js')
 const UserCheckEmailRegistry = require('../routes/user/check-email-registry.js')
 const UserByEmail = require('../routes/user/user-by-email.js')
         await server.route(UserProfilesListRoute)
         await server.route(UserEmailRoute)
         await server.route(UserVerifyEmailRoute)
-        await server.route(UserGetJWTRoute)
+        await server.route(UserGetSessionRoute)
+        await server.route(UserGetAccessRoute)
         await server.route(UserValidateSessionRoute)
         await server.route(UserCheckEmailRegistry)
         await server.route(UserByEmail)

backend/lib/routes/user/getjwt.js → backend/lib/routes/user/getaccess.js

 const Joi = require('joi')
 
 const pluginConfig = {
-    handlerType: 'email',
+    handlerType: 'authentication',
     docs: {
         get: {
-            description: 'gets jwt after verifying email',
-            notes: 'Gets jwt after validating email',
+            description: 'gets access token for authentication',
+            notes: 'Gets access token for authentication',
         },
     },
 }
 
 module.exports = {
     method: 'POST',
-    path: '/getjwt',
+    path: '/getaccess',
     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
         handler: async function (request, h) {
             const { userService } = request.server.services()
             const res = request.payload
-            const token = await userService.createToken(res)
+            const token = await userService.createToken({
+                ...res,
+                // NOTE: Set Expiration Time for Access Token Here
+                expires: 60 * 3,
+            })
             try {
                 const response = h.response({
                     ok: true,
         },
         response: {
             // TODO: change back to accommodate new h.response return values
-            schema: Joi.any().label('get_jwt_res'),
+            schema: Joi.any().label('get_access_res'),
             failAction: 'log',
         },
     },

backend/lib/routes/user/getsession.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'authentication',
+    docs: {
+        get: {
+            description: 'gets session token for authentication',
+            notes: 'Gets session token for authentication',
+        },
+    },
+}
+
+module.exports = {
+    method: 'POST',
+    path: '/getsession',
+    options: {
+        ...pluginConfig.docs.get,
+        tags: ['api'],
+        auth: false,
+        cors: {
+            headers: ['Authorization'],
+            exposedHeaders: ['Authorization', 'Access-Control-Expose-Headers'],
+        },
+        handler: async function (request, h) {
+            const { userService } = request.server.services()
+            const res = request.payload
+            const token = await userService.createToken({
+                ...res,
+                // NOTE: Set Expiration Time for Session Token Here
+                expires: 60 * 3,
+            })
+            try {
+                const response = h.response({
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: token,
+                })
+                response.header('Authorization', token)
+                return response
+            } catch (err) {
+                return {
+                    ok: false,
+                    handler: pluginConfig.handlerType,
+                    data: {
+                        error: err,
+                    },
+                }
+            }
+        },
+        validate: {
+            failAction: 'log',
+        },
+        response: {
+            // TODO: change back to accommodate new h.response return values
+            schema: Joi.any().label('get_session_res'),
+            failAction: 'log',
+        },
+    },
+}

backend/lib/routes/user/validatesession.js

     options: {
         ...pluginConfig.docs.get,
         tags: ['api'],
-        auth: false,
+        auth: false, // set to jwt strategy
         cors: true,
         handler: async function (request, h) {
             const sessionToken = request.params.sessionToken

backend/lib/services/user.js

      * @param {User} user
      * @returns {Token}
      */
-    // TODO: Put this logic in the routes, NOT here
-    // createSessionToken(user, payload)
-    // createAccessToken()
-    //
     createToken(data) {
         const key = this.server.registrations['main-app-plugin'].options.jwtKey
         const obj = {}
      * @param {User} user
      * @returns {Token}
      */
+    // TODO: Move this ino the auth strategies
     validateToken(token) {
-        const key = this.server.registrations['main-app-plugin'].options.jwtKey
+        const key = this.server.registrations['main-app-plugin'].options.jwtKey // mysecret
         try {
             return JWT.verify(token, key)
         } catch (err) {

frontend/src/components/onboarding/Auth.vue

                 )
         },
         async getSessionToken(payload) {
-            return await this.authenticator.getJwt({
+            return await this.authenticator.getSessionToken({
                 payload,
-                expires: 60 * 3,
             })
         },
         async signupNewUser(userInfo) {

frontend/src/services/auth.service.js

         const isVerified = await db.get(`/user/verify/${hashedEmail}`)
         return isVerified.hashesMatch
     }
-    async getJwt(req) {
-        return await db.post('/user/getjwt', req, true)
+    async getSessionToken(req) {
+        return await db.post('/user/getsession', req, true)
+    }
+    async getAccessToken(req) {
+        return await db.post('/user/getaccess', req, true)
     }
     async validateSession(sessionToken) {
         return await db.get(`/user/validatesession/${sessionToken}`)

frontend/src/views/OnboardingView.vue

 import SurveyCompleteView from './SurveyCompleteView.vue'
 let sessionToken = null
 let accessToken = null
-// import savesurveybyprofileid - call it on submit
-// paginate to save every steps answers
 
 /* BRIAN'S NOTE: 
 I'll need help here. The logic is getting confusing.
             anotherhashedEmailString: expiration_in_milliseconds,
         }
 
+        TODO: jwt, hashedEmail, cookie expiration should be the same
     3.  The session, access tokens all have jwt expirations as well as cookie expirations
 
     4.  Additionally, we have an expiration on each hashedEmail string...
         }
         // TODO: EVERY ROUTE WE HIT AFTER THIS HAS TO BE AUTHENTICATED
         // ACCESS TOKEN WORKS
+        // START PROTECTING ALL ROUTES
         if (this.emailIsRegistered) {
             const user = await fetchUserByEmail(this.userEmail)
             const userId = user.user_id

frontend/src/views/VerifyView.vue

         },
         // QUESTION: This will likely be needed in OnboardingView.vue
         async getAccessToken(payload) {
-            const accessToken = await this.authenticator.getJwt({
+            const accessToken = await this.authenticator.getAccessToken({
                 payload,
-                expires: 60 * 3,
             })
             document.cookie = `siimee_access=${accessToken}; max-age=600; path=/; secure`
         },