:bug: fixing transposed pubnub group names by returning grouping from backend

backend/lib/routes/membership/join.js

     response: Joi.object({
         memberships: Joi.array().items(),
         hasMatch: Joi.boolean(),
+        groupings: Joi.array().items(),
     }).label('grouping_membership_list'),
     error: errorSchema.single,
 }
                 // !: You should only be associated with a single company too
 
                 /** User membership service method to create membership */
-                const memberships = await membershipService.joinGrouping(
-                    profileId,
-                    res.target_id,
-                    groupingToWrite,
-                    role,
-                )
+                const { memberships, groupings } =
+                    await membershipService.joinGrouping(
+                        profileId,
+                        res.target_id,
+                        groupingToWrite,
+                        role,
+                    )
                 const hasMatch = memberships.every(
                     membership => membership && membership.is_active == true,
                 )
                         data: {
                             memberships,
                             hasMatch,
+                            groupings,
                         },
                     })
                     .code(200)

backend/lib/services/membership.js

         /** Uncomment to dedupe the list just in case */
         return [...new Set(groupingIdsToGrab)]
     }
-
+    async _getGroupings(groupingIds, txn) {
+        const { Grouping } = this.server.models()
+        return await Grouping.query(txn).whereIn('grouping_id', groupingIds)
+    }
     /**
      * Internal method to create a new grouping
      * @param {object} groupingToTry from payload data
 
         if (matchingGroupingIds.length) {
             /** Grab all memberships associated with groupingIds */
-            const memberships = await Membership.query().whereIn(
+            let memberships = await Membership.query().whereIn(
                 'grouping_id',
                 matchingGroupingIds,
             )
             })
 
             /** Make a new query to get updated information */
-            return await Membership.query().whereIn(
+            memberships = await Membership.query().whereIn(
                 'grouping_id',
                 matchingGroupingIds,
             )
+            const groupings = await this._getGroupings(matchingGroupingIds, txn)
+            return { memberships, groupings }
         } else {
             /**
              * If both have NO grouping in common, create a membership
                 is_active: false,
             })
 
-            return [userMembership, targetMembership]
+            return {
+                memberships: [userMembership, targetMembership],
+                groupings: [],
+            }
         }
     }
 

frontend/src/components/ProfileCardList.vue

         profileId,
         targetId,
     })
+
+    // Reuse old grouping name if theres a match
+    let channel = groupingName
     console.log('membershipMatch :>> ', membershipMatch)
     if (membershipMatch?.hasMatch) {
-        await subscribeToChat(groupingName)
+        const [time, intiator, target] = groupingName.split('_')
+        channel = membershipMatch.groupings[0].grouping_name
+        console.log('channel :>> ', channel)
     }
+    await subscribeToChannel(channel)
     emit('reload')
 }
 
     router.push({ path: `/matches/${pid}` })
 }
 
-const subscribeToChat = async groupingName => {
+const subscribeToChannel = async channelName => {
     // create a chatter reference from the current profile
     const chatter = currentProfile.chatter
     // console.log('mock sender:', pid)
     /**
      * publish a new message to the chatter with the channel and the message & title is optional
      */
-    // You MUST send chatter channels as an array
-    chatter.subscribe([groupingName])
-    const res = await chatter.publish(groupingName, {
+    // You MUST send chatter channels as an array in an object
+    chatter.subscribe({ channels: [channelName] })
+    const res = await chatter.publish(channelName, {
         title: 'New Message',
-        description: `This is the checking to see if we are subscribed to the ${groupingName} channel!`,
+        description: `This is the checking to see if we are subscribed to the ${channelName} channel!`,
     })
     // PubNub response will be a timecode of when the message was published
     console.log('res:', res)

frontend/src/services/chat.service.js

         // ? .await for the groupings to be fetched before subscribing to channels
         await this._setupAllChannels(this.uuid)
         this._listenFor({ listeners: this.listeners })
-        this.subscribe(this.subscriptions)
+        this.subscribe({ channels: this.subscriptions })
     }
     /**
      * Send a message to a channel
      * Facade so we can hide provider specific methods
      * @param {array} channels
      */
-    subscribe(channels) {
+    subscribe({ channels }) {
         providerMethods.subscribe({ channels })
     }
     /**