:sparkles: adding reveal tag endpoint

backend/lib/plugins/profile.js

 const ProfileQueueRoute = require('../routes/profile/queue')
 const ProfileGetRoute = require('../routes/profile/get')
 const ProfilePatchQueueRoute = require('../routes/profile/patch-queue')
+const TagRevealRoute = require('../routes/tag/reveal')
 
 module.exports = {
     name: 'profile-plugin',
         await server.route(ProfileQueueRoute)
         await server.route(ProfileGetRoute)
         await server.route(ProfilePatchQueueRoute)
+        await server.route(TagRevealRoute)
     },
 }

backend/lib/routes/tag/reveal.js

+'use strict'
+
+const apiSchema = require('../../schemas/api')
+const errorSchema = require('../../schemas/errors')
+const profileSchema = require('../../schemas/profiles')
+const params = require('../../schemas/params')
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'reveal',
+    docs: {
+        description: 'Reveals part of a profile based on tag',
+        notes: 'returns from the Tag Associations Table',
+    },
+}
+
+const responseSchemas = {
+    tags: Joi.array().items(Joi.object()),
+    error: errorSchema.single,
+}
+
+const validators = {
+    params: params.profileId.append({ tag_id: Joi.number() }),
+    payload: Joi.object({
+        profile_id: Joi.number(),
+        membership_id: Joi.string().optional(),
+    }),
+}
+
+module.exports = {
+    method: 'POST',
+    path: '/{profile_id}/reveal/{tag_id}',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { profile_id, tag_id } = request.params
+            const { profileService } = request.server.services()
+
+            const revealedTags = await profileService.revealProfileInfo({
+                profile_id,
+                tag_id,
+                is_deleted: false,
+            })
+            console.log('revealed :', revealedTags)
+
+            try {
+                const tag = profileService.tagLookup[tag_id]
+                if (!tag || tag.tag_category != 'reveal') {
+                    throw `cannot reveal ${tag} tag`
+                }
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: revealedTags,
+                    })
+                    .code(200)
+            } catch (err) {
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
+            }
+        },
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log',
+        },
+
+        /** Validate the server response */
+        response: {
+            status: {
+                200: apiSchema.single
+                    .append({
+                        data: responseSchemas.tags,
+                    })
+                    .label('reveal_res'),
+                409: apiSchema.single
+                    .append({
+                        data: responseSchemas.error,
+                    })
+                    .label('error_single_res'),
+            },
+        },
+    },
+}

backend/lib/services/profile/index.js

         super(...args)
         /** Scores available in the db to map against score indices*/
         this.scoreLookup = {}
-        /** Tags available in the db to map against tagg_associations*/
+        /** Tags available in the db to map against tag_associations*/
         this.tagLookup = {}
         // this.responseKeyLookup = ResponseKey.query()
     }
         const end = await this._latLonForZip(end_zip)
         return haversine(start, end, { unit: distanceUnit })
     }
+
+    /**
+     * Use the db to grab tag associations
+     * by profile and match them to tag types
+     * @param {number} profileId
+     * @param {object}
+     */
+    async _getTagsForProfile(profileId) {
+        const { TagAssociation } = this.server.models()
+        await this._setTagLookup()
+        const associations = await TagAssociation.query().where(
+            'profile_id',
+            profileId,
+        )
+        return associations.map(assoc => {
+            const tagInfo = this.tagLookup[assoc.tag_id]
+            return { ...assoc, tag: tagInfo }
+        })
+    }
+    async revealProfileInfo(association) {
+        const { TagAssociation } = this.server.models()
+        await TagAssociation.query().insert(association)
+        return await this._getTagsForProfile(association.profile_id)
+    }
 }

frontend/src/services/chat.service.js

      * @param {array} channels
      */
     subscribe({ channels }) {
-        console.log('subscribing to:', channels)
         _providerMethods.subscribe({ channels })
     }
     /**