:recycle: fixing login form | returning profiles for user from api | logging in before setting profile_id

backend/lib/routes/user/login.js

         ...pluginConfig.opts,
         handler: async function (request, h) {
             try {
-                const { userService } = request.services()
+                const { userService, profileService } =
+                    request.server.services()
                 const res = request.payload
-
                 // Callback to use as transaction
                 const login = async txn => {
                     return await userService.login(
                 }
 
                 // Bound context from your plugin server declaration
-                const user = await h.context.transaction(login)
-
-                const token = userService.createToken(user)
-
+                const userAuth = await h.context.transaction(login)
+                const token = userService.createToken(userAuth)
                 const response = h.response('success')
-                console.log('response :>> ', response)
-                response.header('Authorization', token)
-                response.state('token', token, pluginConfig.cookieOpts)
+
+                const email = userAuth.user_email
+                const user = await userService.findByEmail(email)
+                const type = user.is_poster == 1 ? 'poster' : 'seeker'
+                const profiles = await profileService.getCompleteProfilesFor(
+                    user.user_id,
+                    type,
+                )
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { user_email: user.user_email, jwtToken: token },
+                    data: {
+                        profiles,
+                        user_email: user.user_email,
+                        jwtToken: token,
+                    },
                 }
             } catch (err) {
                 console.error(err)
                     data: Joi.object({
                         user_email: Joi.string(),
                         jwtToken: Joi.string(),
+                        profiles: Joi.array(),
                     }),
                 }).label('login_res'),
                 409: Joi.object({

backend/lib/services/profile/index.js

     async getCompleteProfilesFor(userId, type) {
         const { Profile } = this.server.models()
         await this._setTagLookup()
-
+        console.log('userId :>> ', userId)
         const dedupedProfileIds = await this._getProfileIdsForUserId(userId)
 
         const profilesEntries = await Profile.query()
         await this._setTagLookup()
         let associations = groupingId
             ? await TagAssociation.query()
-                .where('grouping_id', groupingId)
-                .andWhere('profile_id', profileId)
+                  .where('grouping_id', groupingId)
+                  .andWhere('profile_id', profileId)
             : await TagAssociation.query().andWhere('profile_id', profileId)
         return associations
             .map(assoc => ({

backend/lib/services/user.js

         }
     }
 
+    /**
+     * Use knex to find users with email column
+     * @param {string} email
+     * @param {*} txn
+     * @returns
+     */
+    async findByEmail(email) {
+        const { User } = this.server.models()
+
+        return await User.query()
+            .throwIfNotFound()
+            .first()
+            .where({ user_email: email })
+    }
+
     /**
      * Use knex to find users with id column
      * @param {number} id
      */
     async login({ email, password }, txn) {
         const { User, Auth } = this.server.models()
-
         const user = await Auth.query(txn)
             .throwIfNotFound()
             .first()

frontend/src/App.vue

 <template lang="pug">
-w-app 
+w-app
     TopNav(@on-open='openDrawer = !openDrawer')
 
     w-drawer(v-model='openDrawer')
          * using the login form
          */
         if (DEV_MODE) {
+            this.autoLogin()
+        }
+    },
+    methods: {
+        async autoLogin() {
             console.info('===============================================')
             console.info('-                   SIIMEE                    -')
             console.info('-----------------------------------------------')
             console.info('[Siimee App]: Starting application...')
             console.info('-----------------------------------------------')
             await this.setPid(DEV_PID)
-        }
-    },
-    methods: {
+        },
         /**
          * Sync up this components state with
          * the currentProfile handler
          */
-        async setPid(profileId) {
+        async setPid(form) {
             if (currentProfile.isLoggedIn) {
                 currentProfile.logout()
             }
 
-            await currentProfile.login(profileId, this.$waveui.notify)
             console.log('---')
+            const { profiles } = await currentProfile.login(
+                form.email,
+                form.password,
+            )
 
             /**
              * Default to the HomeView and alter as needed (side-effects!)
              */
-            const toRoute = { name: 'HomeView' }
+            let toRoute = { name: 'HomeView' }
+
+            if (profiles.length) {
+                const profile = profiles[0]
+                await currentProfile.setup(
+                    profile.profile_id,
+                    this.$waveui.notify,
+                )
+            } else {
+                console.warn(
+                    `[Login] No profiles associated with ${form.email}`,
+                )
+                toRoute = { name: 'OnboardingView' }
+            }
+
             this.$router.push(toRoute)
         },
     },

frontend/src/entities/survey/survey.js

         /**  Fields */
         this.steps = [...questionSteps] // ! required
         this.aspectQuestions = _formatAspectQuestions(this.steps)
-        console.log('this.aspectQuestions: ', JSON.stringify(this.aspectQuestions))
+        // console.log('this.aspectQuestions: ', JSON.stringify(this.aspectQuestions))
     }
 
     isValid() {

frontend/src/router/guards.js

 
 const DEV_MODE = import.meta.env.VITE_DEV == 'true'
 
-async function log(to) {
+const log = async to => {
     if (DEV_MODE) {
         if (!currentProfile.isLoggedIn || !currentProfile.isComplete) {
             console.info(
     log(destination)
     if (DEV_MODE) {
         nextCb()
-    } else if (
-        destination.meta.requiresCompleteProfile &&
-        !currentProfile.isLoggedIn &&
-        !currentProfile.isComplete
-    ) {
-        nextCb('onboarding')
     } else if (
         destination.meta.requiresCompleteProfile &&
         destination.meta.requiresAuth &&
         !currentProfile.isLoggedIn
     ) {
         nextCb('login')
+    } else if (
+        destination.meta.requiresCompleteProfile &&
+        !currentProfile.isLoggedIn &&
+        !currentProfile.isComplete
+    ) {
+        nextCb('onboarding')
     } else {
         nextCb()
     }

frontend/src/services/login.service.js

     fetchProfileByProfileId,
     Chatter,
     StonkAlert,
+    loginUser,
 } from '../services/index.js'
 import { surveyFactory } from '../utils/index.js'
 
      * @param {number} profileId
      * @returns {number} stored reactive id
      */
-    async login(profileId, cb) {
-        this._loading.value = true
+    async login(email, password) {
         // First check if profile exists
-        console.warn('[Login Service warn]: Logging in:', profileId)
-
+        console.warn('[Login Service warn]: Logging in:', email)
+        const res = await loginUser({ email, password })
+        if (res) {
+            console.warn(`[Login Service warn] Logging in: Succeeded!`)
+        }
+        return res
+    }
+    async setup(profileId, cb) {
         // TODO: You can probably use this call to get responses, groupings and tags
+        this._loading.value = true
         this._profile = await fetchProfileByProfileId(profileId)
         this.id.value = this._profile.profile_id
 

frontend/src/services/user.service.js

 import { db } from '../utils/db.js'
+const SERVICE = 'user'
 
 /**
  * Signup a new user
         user_email: user.email,
         is_poster: user.seeking == 'position' ? 0 : 1,
     }
-    return await db.post(`/user/signup`, payload)
+    return await db.post(`/${SERVICE}/signup`, payload)
 }
 
-export { signupUser }
+const loginUser = async ({ email, password }) => {
+    return await db.post(`/${SERVICE}/login`, { user_email: email, password })
+}
+export { signupUser, loginUser }

frontend/src/utils/db.js

 const domain = 'localhost'
+const gui_port = 3000
 const port = 3001
 const httpProtocol = `http`
 const prefix = 'api'
-const remote = `${httpProtocol}://${domain}:${port}/${prefix}`
+const backend_host = `${domain}:${port}`
+const host = `${domain}:${gui_port}`
+const origin = `${httpProtocol}://${host}/`
+const remote = `${httpProtocol}://${backend_host}/${prefix}`
+const referrer = origin
 
 const headerTemplate = {
     method: null,
         // 'Content-Type': 'application/x-www-form-urlencoded',
     },
     redirect: 'manual', // manual, *follow, error
+    host,
+    origin,
+    referrer,
     referrerPolicy: 'no-referrer', // no-referrer, *no-referrer-when-downgrade, origin, origin-when-cross-origin, same-origin, strict-origin, strict-origin-when-cross-origin, unsafe-url
     body: null, // body data type must match "Content-Type" header
 }

frontend/src/utils/survey.js

     image: 'FormInput',
     // distance: 'FormInput',
     blurb: 'FormInput',
-    aspects: 'Aspects'
+    aspects: 'Aspects',
 }
 /**
  * Make a step from match or step information
             }
             const responseKeyLike = formatStep(match, step)
             const withComponent = associateWithComponent(responseKeyLike)
-            console.log('withComponent :>> ', withComponent)
+            // console.log('withComponent :>> ', withComponent)
             return withComponent
         })
-        // temporary extra condition in filter 
+        // temporary extra condition in filter
         let unseen = this.questionsFromDb.filter(
-            q => !seenIds.includes(q.response_key_id) && [1,2,3,4,5,6].includes(q.response_key_id),
+            q =>
+                !seenIds.includes(q.response_key_id) &&
+                [1, 2, 3, 4, 5, 6].includes(q.response_key_id),
         )
         return [...stepsInCommon, ...unseen]
     }

frontend/src/views/LoginView.vue

 <template lang="pug">
 main.view--login
-
     article.pa12
         form
-            w-input.mb4(label="User E-mail" tile outline v-model="form.profileId" inner-icon-left='icon-envelope')
-            w-input(label="Password" type="password" tile outline inner-icon-left='icon-eye')
+            w-input.mb4(
+                inner-icon-left='icon-envelope'
+                label='User E-mail'
+                outline
+                tile
+                v-model='form.email'
+            )
+            w-input(
+                inner-icon-left='icon-eye'
+                label='Password'
+                outline
+                tile
+                v-model='form.password'
+            )
 
             //- Emit up an event so we can sync App pid with currentProfile.id
-            w-button.xs12.mt12(@click="$emit('updatePid', form.profileId)" type="submit") submit
+            w-button.xs12.mt12(
+                @click.prevent.stop='$emit("updatePid", form)'
+                type='submit'
+            ) submit
 </template>
 
 <script>
 export default {
     data: () => ({
         form: {
-            profileId: null,
+            email: null,
+            password: null,
         },
     }),
 }