:sparkles: renaming migrations | creating memberships and groupings

backend/README.md

 Since we can't unseed the database, it's best to destroy the `dev` database and rebuild it.
 
 1. Stop the database by navigating to the project root directory `cd ../` and running `docker-compose down`
-2. Destroy the database volume `docker volume rm siimee_db`. BE CAREFUL.
+2. Destroy the database volume `docker volume rm siimee_siimee_db`. BE CAREFUL.
 3. Restart the database while still at the project root with `docker-compose --env-file ./backend/server/.env up -d`
 4. Recreate schemas and tables but navigating to `./backend` and running `npm run migrate`
 5. Reseed the dummy data with `npm run seed`

backend/lib/models/grouping.js

     static get tableName() { return 'groupings' }
     static get joiSchema() {
         return Joi.object({
-            grouping_id: Joi.number().required(),
+            grouping_id: Joi.number(),
+            grouping_name: Joi.string().required(),
+            grouping_type: Joi.string().required(),
         })
     }
 }

backend/lib/models/membership.js

     static get tableName() { return 'memberships' }
     static get joiSchema() {
         return Joi.object({
-            membership_id: Joi.number().required(),
+            membership_id: Joi.number(),
+            user_id: Joi.number().required(),
+            grouping_id: Joi.number().allow(null),
+            membership_type: Joi.string().required(),
+            can_edit: Joi.boolean().required(),
         })
     }
 }

backend/lib/routes/membership/join.js

 
 const validators = {
     join: {
-        payload: Joi.object()
+        payload: Joi.object({
+            user_id: Joi.number().required(),
+            grouping_id: Joi.number().allow(null),
+            grouping_name: Joi.string().allow(null),
+            grouping_type: Joi.string().allow(null),
+            role: Joi.string(),
+        })
     }
 }
 
         ...pluginConfig.docs,
         tags: ['api'],
         auth: false,
+
+        /**
+         * Join a grouping by creating a membership record
+         * @param {*} request
+         * @param {*} h
+         * @returns {object}
+         */
         handler: async function (request, h) {
             try {
+                const { membershipService } = request.services()
+
+                /** Grab payload info */
+                const res = request.payload
+                const groupingToWrite = {
+                    grouping_id: res.grouping_id,
+                    grouping_name: res.grouping_name,
+                    grouping_type: res.grouping_type
+                }
+                /** Check if the grouping exists and if NOT creat it */
+                const groupingId = await membershipService.findOrCreateGrouping(groupingToWrite)
+
+                /** Default to participant role */
+                const role = res.role ? res.role : 'participant'
+
+                /** User membership service method to create membership */
+                const membership = await membershipService.joinGrouping(res.user_id, groupingId, role)
+
                 return {
                     ok: true,
                     handler: pluginConfig.handlerType,
-                    data: { foo: 'bar' }
+                    data: { membership }
                 }
             }
             catch(err) {
             schema: Joi.object({
                 ok: Joi.bool(),
                 handler: Joi.string(),
-                data: validators.join
+                data: Joi.object()
             }),
             failAction: 'log'
         }

backend/lib/services/display.js

         return { ...user, token }
     }
 
+    /**
+     * List all memberships
+     * @returns
+     */
     membershipList() {
         const { Membership } = this.server.models()
         const memberships = Membership.query()
         server.log(Membership)
-        return [
-            { foo: 'bar', membership_type: 'baz' },
-            { foo: 'buz', membership_type: 'biz' },
-        ]
+        return memberships
     }
 
-    async profile(currentUserId, user, transaction)  {
+    /**
+     *
+     * @param {number} currentUserId
+     * @param {User} user
+     * @param {*} txn
+     * @returns
+     */
+    async profile(currentUserId, user, txn)  {
         const { User } = this.server.models()
         const { toProfile } = internals
 
         const result = await User.fetchGraph(user, `[
             followedBy(currentUser) as following
         ]`, {
-            transaction
+            txn
         }).modifiers({
             currentUser: (builder) => builder.where('Users.id', currentUserId)
         })

backend/lib/services/membership.js

 
 const Schmervice = require('@hapipal/schmervice');
 
+
 module.exports = class MembershipService extends Schmervice.Service {
-    constructor(...args) {
-        super(...args)
+    constructor(...args) { super(...args) }
+
+    /**
+     * Internal method to get list of grouping_ids for this user
+     * @param {number} userId
+     * @returns {Array} List of all grouping_ids for user
+     */
+    async _getGroupIdsForUserId(userId) {
+        const { Membership } = this.server.models()
+
+            /** Grab every Membership associated with this id */
+            const allMemberships = await Membership.query()
+                .where('user_id', userId)
+
+            /** Copy a list of the just the Groupings */
+            const groupingIdsToGrab = allMemberships.map(membership => membership.grouping_id)
+
+            /** Uncomment to dedupe the list just in case */
+            return [...new Set(groupingIdsToGrab)]
     }
-    async findGroupingsById(id) {
-        const { Membership, Grouping } = this.server.models()
 
-        /** Grab every Membership associated with this id */
-        const allMemberships = await Membership.query()
-            .throwIfNotFound()
-            .where('user_id', id)
+    /**
+     * Internal method to create a new grouping
+     * @param {*} groupingToTry
+     * @param {*} txn
+     * @returns
+     */
+    async _createGrouping(groupingToTry, txn) {
+        const { Grouping } = this.server.models()
+        const groupingInfo = {
+            grouping_name: groupingToTry.grouping_name,
+            grouping_type: groupingToTry.grouping_type,
+        }
+        return await Grouping.query(txn)
+            .insert(groupingInfo)
+    }
 
-        /** Copy a list of the just the Groupings */
-        const groupingIdsToGrab = allMemberships.map(membership => membership.grouping_id)
+    async findOrCreateGrouping(groupingToTry) {
+        let idToReturn = groupingToTry.grouping_id
+        if(!idToReturn) {
+            /** ?: For some reason this returns the key id */
+            const grouping = await this._createGrouping(groupingToTry)
+            idToReturn = grouping.id
+        }
+        return idToReturn
+    }
 
-        /** Uncomment to dedupe the list just in case */
-        const dedupedGroupings = [...new Set(groupingIdsToGrab)]
+    /**
+     * Get a list of groupings for user
+     * @param {number} userId
+     * @returns {Array}
+     */
+    async findGroupingsById(userId) {
+        const { Grouping } = this.server.models()
+
+        const dedupedGroupings = await this._getGroupIdsForUserId(userId)
 
         /** Grab just the Groupings this id has a Membership for */
         return await Grouping.query()
             .throwIfNotFound()
             .whereIn('grouping_id', dedupedGroupings)
     }
+
+    /**
+     * Check for grouping membership then add membership record
+     * @param {number} userId
+     * @param {number} groupingId
+     * @param {string} role
+     * @returns
+     */
+    async joinGrouping(userId, groupingId, role, txn) {
+        const { Membership } = this.server.models()
+
+        const dedupedGroupings = await this._getGroupIdsForUserId(userId)
+
+        /** Do NOTHING if already in Grouping */
+        if(dedupedGroupings.includes(groupingId)) return
+
+        console.log(dedupedGroupings)
+        const membershipInfo = {
+            user_id: userId,
+            grouping_id: groupingId,
+            membership_type: role,
+            can_edit: false
+        }
+        console.log(membershipInfo)
+        return await Membership.query(txn)
+            .insert(membershipInfo)
+    }
+
+    /**
+     * Remove membership record based on grouping_id
+     * @param {number} userId
+     * @param {number} groupingId
+     * @returns
+     */
+    async leaveGrouping(userId, groupingId) {
+        const { Membership } = this.server.models()
+
+        const dedupedGroupings = await this._getGroupIdsForUserId(userId)
+
+        /** Do NOTHING if NOT in Grouping */
+        if(!dedupedGroupings.includes(groupingId)) return
+
+        return await Membership.query()
+            .delete()
+            .where('grouping_id', groupingId)
+    }
 }

backend/lib/services/user.js

             aud: 'urn:audience:test',
             iss: 'urn:issuer:test',
             email: user.user_email
-        },
-        {
+        }, {
             key: key,
             algorithm: 'HS256'
         }, {

backend/server/index.js

 const Glue = require('@hapi/glue');
 const Exiting = require('exiting');
 const Manifest = require('./manifest');
-
+/**
+ * Our main app server
+ * @param {boolean} start
+ * @returns {Server}
+ */
 exports.deployment = async ({ start } = {}) => {
     const manifest = Manifest.get('/', process.env)
     const server = await Glue.compose(manifest, { relativeTo: __dirname })