:sparkles: reformatted /api/membership return to include complete profiles with grouping

backend/lib/models/grouping.js

 const Schwifty = require('@hapipal/schwifty')
 const groupingSchema = require('../schemas/groupings')
+const User = require('./user')
+const Profile = require('./profile')
 
 module.exports = class Grouping extends Schwifty.Model {
     static get tableName() {
         return 'groupings'
     }
+    static get relationMappings() {
+        return {
+            profiles: {
+                relation: Schwifty.Model.ManyToManyRelation,
+                modelClass: Profile,
+                join: {
+                    from: 'groupings.grouping_id',
+                    through: {
+                        from: 'memberships.grouping_id',
+                        to: 'memberships.profile_id'
+                    },
+                    to: 'profiles.profile_id'
+                },
+            },
+        }
+    }
     static get joiSchema() {
         return groupingSchema.single
     }

backend/lib/routes/membership/active.js

 
 const responseSchemas = {
     single: groupingSchema.single,
-    list: groupingSchema.list,
+    list: groupingSchema.listWithProfiles,
     error: errorSchema.single
 }
 
         auth: false,
         cors: true,
         handler: async function (request, h) {
-            const { membershipService } = request.services()
+            const { membershipService, profileService } = request.server.services()
             const membershipType = request.query.type
 
             const profileId = request.params.profile_id
-            const groupings = await membershipService.findGroupingsByProfileId(
+            let groupings = await membershipService.findGroupingsByProfileId(
                 profileId,
                 membershipType
             )
+            
+            /**
+             * Heavily process the result by storing just a profile_id
+             * and attach complete profiles
+             */
+            let pIds = groupings.reduce((ids, grouping) => {
+                grouping.profiles.forEach(p => { 
+                    if(p.profile_id == profileId) return
+                    ids.push(p.profile_id)
+                    grouping.profile = p.profile_id
+                })
+                delete grouping.profiles
+                return ids
+            }, [])
+            
+            /** Assemble complete profiles to reference and pass */
+            const completedProfiles = await profileService.getProfilesFor(pIds, 'participant', false)
+            const reformattedGroupings = groupings.map(g => {
+                completedProfiles.forEach(p => {
+                    g.profile = g.profile == p.profile_id ? p : g.profile
+                })
+                return g
+            })
+
             try {
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: groupings,
+                    data: reformattedGroupings
                 }
             } catch (err) {
                 return {

backend/lib/routes/profile/queue.js

             //     await profileService.getProfilesFor(queueIds),
             // )
             if(include_profile) {
-                res.data = await profileService.getProfilesFor(queueIds)
+                res.data = await profileService.getProfilesFor(queueIds, 'participant', false)
             }
             try {
                 return h.response(res).code(200)
             } catch (err) {
                 return h.response({
-                    ok:false,
+                    ok: false,
                     handler: pluginConfig.handlerType,
                     data: { error: `${err}`}
                 }).code(409)

backend/lib/schemas/groupings.js

     grouping_type: Joi.string(),
 }).label('grouping_single')
 
+const singleWithProfile = Joi.object({
+    grouping_id: Joi.number(),
+    grouping_name: Joi.string(),
+    grouping_type: Joi.string(),
+    profile: Joi.object()
+}).label('grouping_single_with_profile')
+
 module.exports = {
     single: singleGrouping,
-    list: Joi.array().items(singleGrouping).label('grouping_list')
+    singleWithProfile,
+    list: Joi.array().items(singleGrouping).label('grouping_list'),
+    listWithProfiles: Joi.array().items(singleWithProfile).label('grouping_list_with_profiles')
 }

backend/lib/services/membership.js

         } else if(active == 'any') {
             allMemberships = await Membership.query()
                 .where({ profile_id: profileId })
-        } else {
-            allMemberships = await Membership.query()
+            } else {
+                allMemberships = await Membership.query()
                 .where({ profile_id: profileId })
                 .where({ is_active: true })
         }
         /** Grab just the Groupings this id has a Membership for */
         return await Grouping.query()
             .whereIn('grouping_id', dedupedGroupings)
+            .withGraphFetched('profiles')
     }
 
     async _groupingIdsInCommon(profileId, targetId) {

backend/lib/services/profile.js

         })
     }
 
-    async getProfilesFor(profileIdArray, type) {
+    async getProfilesFor(profileIdArray, type, includeResponses = true) {
         const { Profile } = this.server.models()
         // profilesEntries is profiles in database row order 
-        const profilesEntries = await Profile.query()
+        const profilesEntries = includeResponses ? await Profile.query()
             .whereIn('profile_id', profileIdArray)
             .withGraphFetched('responses')
-            .withGraphFetched('user')
+            .withGraphFetched('user') : await Profile.query()
+            .whereIn('profile_id', profileIdArray)
+            .withGraphFetched('user') 
 
         // taking the info from profilesEntries
         // to repack into completeProfiles
         profileIdArray.forEach(pid => {
             profilesEntries.forEach(entry => {
                 if (entry.profile_id == pid) {
-                    completeProfiles.push(new CompleteProfile(entry, type))
+                    const complete = new CompleteProfile(entry, type)
+                    if(!includeResponses) {
+                        delete complete['responses']
+                    }
+                    completeProfiles.push(complete)
                 }
             })
         })