:bug: Addressed bugs involving validation and groupings

backend/lib/routes/membership/active.js

                 profileId,
                 membershipType,
             )
+            if (!groupings.length) {
+                return {
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: [],
+                }
+            }
             const groupingIds = groupings.map(grouping => grouping.grouping_id)
-            const memberships = await membershipService.findMemberships(
-                groupingIds,
-            )
+            const memberships =
+                await membershipService.findMemberships(groupingIds)
             const profileIds = memberships
                 .filter(membership => membership.profile_id != profileId)
                 .map(membership => membership.profile_id)
 
             /** Assemble complete profiles to reference and pass */
-            const completedProfiles = await profileService.getProfilesFor(
-                profileIds,
-                'participant',
-            )
+            const completedProfiles = !profileIds.length
+                ? []
+                : await profileService.getProfilesFor(profileIds, 'participant')
 
             /**
              * Heavily process the result by storing just a profile_id
              * !: This still assumes only ONE other profile
              * TODO: should be refactored to many other profiles
              */
-            const reformattedGroupings = groupings.map(grouping => {
-                const otherPid = grouping.profiles.find(
-                    p => p.profile_id != profileId,
-                ).profile_id
-                grouping.profile = completedProfiles.find(
-                    p => otherPid == p.profile_id,
-                )
-                grouping.is_paired = _activeGroupingIds(memberships).includes(
-                    grouping.grouping_id,
-                )
-                delete grouping.profiles
-                return grouping
-            })
+            const reformattedGroupings = groupings.length
+                ? groupings.map(grouping => {
+                      const otherPid = grouping.profiles.find(
+                          p => p.profile_id != profileId,
+                      ).profile_id
+                      grouping.profile = completedProfiles.find(
+                          p => otherPid == p.profile_id,
+                      )
+                      grouping.is_paired = _activeGroupingIds(
+                          memberships,
+                      ).includes(grouping.grouping_id)
+                      delete grouping.profiles
+                      return grouping
+                  })
+                : []
 
             /** Grabs revealTags */
             const revealTags = await profileService.getTagsFor(

backend/lib/schemas/profiles.js

     tags: tagSchema.list,
     media: Joi.any(),
     blurb: Joi.any(),
+    image: Joi.any(),
     user_type: Joi.any(),
     user: userSchema.single,
     profile_description: Joi.string().allow(null, ''),

backend/lib/services/profile/index.js

     async getTagsFor(profileId, groupingId, category) {
         const { TagAssociation } = this.server.models()
         await this._setTagLookup()
-        let associations = groupingId
-            ? await TagAssociation.query()
-                  .where('grouping_id', groupingId)
-                  .andWhere('profile_id', profileId)
-            : await TagAssociation.query().andWhere('profile_id', profileId)
-        return associations
-            .map(assoc => ({
-                ...assoc,
-                tag: this.tagLookup[assoc.tag_id],
-            }))
-            .filter(tagWithAssoc => {
-                return category
-                    ? tagWithAssoc.tag.tag_category == category
-                    : true
-            })
+        let associations = []
+        if (!profileId.length || !groupingId.length) {
+            return associations
+        } else {
+            associations = groupingId
+                ? await TagAssociation.query()
+                      .where('grouping_id', groupingId)
+                      .andWhere('profile_id', profileId)
+                : await TagAssociation.query().andWhere('profile_id', profileId)
+            return associations
+                .map(assoc => ({
+                    ...assoc,
+                    tag: this.tagLookup[assoc.tag_id],
+                }))
+                .filter(tagWithAssoc => {
+                    return category
+                        ? tagWithAssoc.tag.tag_category == category
+                        : true
+                })
+        }
     }
 
     /**

frontend/src/components/ProfileCard.vue

  * for both profileId and targetId
  */
 const onPair = async () => {
-    currentProfile._loading = true
+    currentProfile._loading.value = true
     const profileId = currentProfile.id.value
     const targetId = props.card.pid
     await postMembershipByProfileId({
     })
     await currentProfile.updateQueue(profileId, targetId, false)
     await currentProfile.getGroupings()
-    currentProfile._loading = false
+    currentProfile._loading.value = false
 
     let goToRoute = { name: 'HomeView' }
     router.push(goToRoute)
  * and forward back home
  */
 const onPass = async () => {
-    currentProfile._loading = true
+    currentProfile._loading.value = true
     await currentProfile.updateQueue(
         currentProfile.id.value,
         props.card.pid,
         true,
     )
-    currentProfile._loading = false
+    currentProfile._loading.value = false
 
     let goToRoute = { name: 'HomeView' }
     router.push(goToRoute)