:recycle: adding more detailed responses for membership endpoints | adding some comments and renaming things too

backend/lib/routes/membership/active.js

             const membershipType = request.query.type
 
             const profileId = request.params.profile_id
-            const groupings = await membershipService.findGroupingsById(
+            const groupings = await membershipService.findGroupingsByProfileId(
                 profileId,
                 membershipType
             )

backend/lib/routes/membership/join.js

 }
 
 const validators = {
-    join: {
-        payload: Joi.object({
-            profile_id: Joi.number().required(),
-            target_id: Joi.number().allow(null),
-            grouping_id: Joi.number().allow(null),
-            grouping_name: Joi.string().allow(null),
-            grouping_type: Joi.string().allow(null),
-            role: Joi.string(),
-        }),
-    },
+    payload: Joi.object({
+        profile_id: Joi.number().required(),
+        target_id: Joi.number().allow(null),
+        grouping_id: Joi.number().allow(null),
+        grouping_name: Joi.string().allow(null),
+        grouping_type: Joi.string().allow(null),
+        role: Joi.string(),
+    }),
+}
+
+const responseSchemas = {
+    response: Joi.object({
+        memberships: Joi.array().items(),
+        hasMatch: Joi.boolean()
+    }),
+    error: Joi.object({
+        error: Joi.string(),
+    }),
 }
 
 module.exports = {
          * @param {*} h
          * @returns {object}
          */
-        handler: async function (request) {
+        handler: async function (request, h) {
             try {
-                const { membershipService } = request.services()
+                const { membershipService } = request.server.services()
 
                 /** Grab payload info */
                 const res = request.payload
                 /** Default to participant role */
                 const role = res.role ? res.role : 'participant'
 
+                console.log('---')
                 /** User membership service method to create membership */
                 const memberships = await membershipService.joinGrouping(
                     res.profile_id,
                     groupingToWrite,
                     role,
                 )
-
-                return {
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: {
-                        memberships,
-                        hasMatch: memberships.every(
-                            membership => membership.is_active == true,
-                        ),
-                    },
-                }
+                console.log(memberships)
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: {
+                            memberships,
+                            hasMatch: memberships.every(
+                                membership => membership.is_active == true,
+                            ),
+                        },
+                    })
+                    .code(200)
             } catch (err) {
-                return {
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
             }
         },
-        validate: validators.join,
+
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log'
+        },
+
+        /** Validate the server response */
         response: {
-            schema: Joi.object({
-                ok: Joi.bool(),
-                handler: Joi.string(),
-                data: Joi.object(),
-            }),
-            failAction: 'log',
+            status: {
+                200: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.response,
+                }),
+                409: Joi.object({
+                    ok: Joi.bool(),
+                    handler: Joi.string(),
+                    data: responseSchemas.error,
+                }),
+            },
         },
     },
 }

backend/lib/services/membership.js

      * @param {number} profileId
      * @returns {Array} List of all grouping_ids for user
      */
-    async _getGroupIdsForProfileId(profileId, type) {
+    async _getGroupingIdsForProfileId(profileId, type) {
         const { Membership } = this.server.models()
 
         /** Grab every Membership associated with this id */
         let allMemberships
-        console.log()
+
         if(type) {
             allMemberships = await Membership.query()
                 .where({ profile_id: profileId })
                 .where({ profile_id: profileId })
                 .where({ is_active: true })
         }
-        
+
         /** Copy a list of the just the Groupings */
         const groupingIdsToGrab = allMemberships.map(
             membership => membership.grouping_id,
 
     /**
      * Internal method to create a new grouping
-     * @param {*} groupingToTry
+     * @param {object} groupingToTry from payload data
      * @param {*} txn
-     * @returns
+     * @returns {Grouping} created db record
      */
     async _createGrouping(groupingToTry, txn) {
         const { Grouping } = this.server.models()
         }
         return await Grouping.query(txn).insert(groupingInfo)
     }
-
-    async findOrCreateGrouping(groupingToTry) {
+    /**
+     * Tries to grab a grouping_id from payload data
+     * or returns grouping_id from a newly created record
+     * @param {object} groupingToTry from payload data
+     * @returns {number} grouping_id from payload or created record
+     */
+    async findOrCreateGroupingFromPayload(groupingToTry) {
         let idToReturn = groupingToTry.grouping_id
         if (!idToReturn) {
             /** ?: For some reason this returns the key id */
      * @param {number} profileId
      * @returns {Array}
      */
-    async findGroupingsById(profileId, type) {
+    async findGroupingsByProfileId(profileId, type) {
         const { Grouping } = this.server.models()
 
-        const dedupedGroupings = await this._getGroupIdsForProfileId(profileId, type)
+        const dedupedGroupings = await this._getGroupingIdsForProfileId(profileId, type)
 
         /** Grab just the Groupings this id has a Membership for */
         return await Grouping.query()
-            .throwIfNotFound()
             .whereIn('grouping_id', dedupedGroupings)
     }
 
     async _groupingIdsInCommon(profileId, targetId) {
-        const dedupedUserGroupingIds = await this._getGroupIdsForProfileId(
+        const dedupedUserGroupingIds = await this._getGroupingIdsForProfileId(
             profileId,
         )
-        const dedupedTargetGroupingIds = await this._getGroupIdsForProfileId(
+        const dedupedTargetGroupingIds = await this._getGroupingIdsForProfileId(
             targetId,
         )
 
         }
     }
 
-    async attemptMatch(profileId, targetId) {
-        const { Membership } = this.server.models()
-
-        /** If both people have groups in common */
-        const matchingGroupingIds = await this._groupingIdsInCommon(
-            profileId,
-            targetId,
-        )
-
-        if (matchingGroupingIds.length) {
-            /** Grab all memberships associated with groupingIds */
-            const memberships = await Membership.query().whereIn(
-                'grouping_id',
-                matchingGroupingIds,
-            )
-
-            /** Set membership as active only if the user initiates it */
-            await this._patchMembership(memberships, profileId, {
-                is_active: true,
-            })
-
-            /** Make a new query to get updated information */
-            return await Membership.query().whereIn(
-                'grouping_id',
-                matchingGroupingIds,
-            )
-        }
-    }
 
     /**
      * Check for grouping membership then add membership record and set to active
             )
         } else {
             /**
-             * If both have NO grouping in common create a membership
-             * for both to new group but set membership as inactive for target
+             * If both have NO grouping in common, create a membership
+             * for both and add to a new grouping but
+             * set membership as inactive for target
              * */
-            /** Check if the grouping exists and if NOT creat it */
-            const groupingId = await this.findOrCreateGrouping(groupingToWrite)
 
-            const userMembership = await Membership.query(txn).insert({
-                profile_id: profileId,
+            /** Check if the grouping exists and if NOT create it */
+            const groupingId = await this.findOrCreateGroupingFromPayload(groupingToWrite)
+            const membershipDetailsInCommon = {
                 grouping_id: groupingId,
                 membership_type: role,
                 can_edit: false,
+            }
+
+            const userMembership = await Membership.query(txn).insert({
+                profile_id: profileId,
+                ...membershipDetailsInCommon,
                 is_active: true,
             })
 
             const targetMembership = await Membership.query(txn).insert({
-                profile_id: profileId,
-                grouping_id: groupingId,
-                membership_type: role,
-                can_edit: false,
+                profile_id: targetId,
+                ...membershipDetailsInCommon,
                 is_active: false,
             })
 
     async leaveGrouping(profileId, groupingId) {
         const { Membership } = this.server.models()
 
-        const dedupedGroupings = await this._getGroupIdsForProfileId(profileId)
+        const dedupedGroupings = await this._getGroupingIdsForProfileId(profileId)
 
         /** Do NOTHING if NOT in Grouping */
         if (!dedupedGroupings.includes(groupingId)) return