:recycle: added missing files; whoops | using grouping schema to validate incoming membership records

backend/lib/routes/membership/active.js

         tags: ['api'],
         /** Protect this route with authentication? */
         auth: false,
-
+        cors: true,
         handler: async function (request, h) {
             const { membershipService } = request.services()
             const membershipType = request.query.type

backend/lib/routes/user/list-profiles.js

         tags: ['api'],
         /** Protect this route with authentication? */
         auth: false,
-
+        cors: true,
         handler: async function (request, h) {
             const { userService, profileService } = request.server.services()
             const userId = request.params.user_id

frontend/src/App.vue

 import { profileForm } from '@/utils/forms'
 import { Connector } from '@/utils/db'
 
-import { fetchProfilesByUserId } from '@/services'
+import {
+    fetchProfilesByUserId,
+    fetchMembershipsByProfileId,
+} from '@/services'
 
 import helloWorld from '@/components/HelloWorld.vue'
 import card from '@/components/card.vue'
 
         const t = async () => {
             const tempProfiles = await fetchProfilesByUserId(1)
-            console.log(tempProfiles)
+            const groupings = []
+            for(let p of tempProfiles) {
+                const memberships = await fetchMembershipsByProfileId(p.profile_id)
+                groupings.push(memberships)
+            }
+            console.log(groupings)
         }
         t()
         return {

frontend/src/entities/grouping/grouping.js

 /** Class representing a grouping */
 class Grouping extends _baseRecord {
     /**
-     * Create the grouping.
+     * Create the grouping based on membership
      * @extends _baseRecord
-     * @param {string} email
-     * @param {object} grouping - spread destructured args
+     * @param {object} membership - spread destructured args
      * @return {Grouping} the grouping instance object
      */
-    constructor({ ...grouping }) {
+    constructor({ ...membership }) {
         super()
 
         this.type = this.constructor.name.toLowerCase()
 
-        /**  Fields */
-        this.groupingId = groupingId
-        this.groupingName = groupingName
-        this.groupingType = groupingType
+        /** Pass destructured data to the module system */
+        Object.assign(this, membership)
 
         return this
     }

frontend/src/entities/grouping/grouping.schema.js

         type: Joi.string(),
 
         /** our fields */
-        groupingId: Joi.number().required(),
-        groupingName: Joi.string().required(),
-        groupingType: Joi.string().required()
+        grouping_id: Joi.number().required(),
+        grouping_name: Joi.string(),
+        grouping_type: Joi.string()
     }),
     /** fields required before saving */
-    required: [ 'groupingId', 'groupingName', 'groupingType' ],
+    required: [ 'grouping_id', 'grouping_name', 'grouping_type' ],
     validate(instance) {
         return this.properties.validate(instance)
     }

frontend/src/services/grouping.service.js

+import { db } from '../utils/db'
+import { Grouping } from '../entities'
+
+/**
+ * Get Memberships associated with a single Profile from the database and
+ * create a class from the data and
+ * validate the incoming against the schema
+ * @param {number} profileId
+ * @returns {array} instantiated Profile objects (see: /entites/profile)
+ */
+const fetchMembershipsByProfileId = async profileId => {
+    const membershipsForProfileId = await db.get(`/membership/${profileId}`)
+    const validGroupingInstances = []
+    for(let membership of membershipsForProfileId) {
+        const grouping = new Grouping(membership)
+        if(grouping.isValid()) {
+            validGroupingInstances.push(grouping)
+        }
+    }
+    return validGroupingInstances
+}
+
+export { fetchMembershipsByProfileId }

frontend/src/services/index.js

-export * from './profile.service'
+export * from './profile.service'
+export * from './grouping.service'

frontend/src/services/profile.service.js

 import { Profile } from '../entities/profile'
 
 /**
- * Get a single Profile from the database and
+ * Get Profiles associated with a single user from the database and
  * create a class from the data and
- * validate the incoming
+ * validate the incoming against the schema
  * @param {number} userId
+ * @returns {array} instantiated Profile objects (see: /entites/profile)
  */
 const fetchProfilesByUserId = async userId => {
     const profilesForUserId = await db.get(`/user/${userId}/profiles`)
-    const profileInstances = []
-    profilesForUserId.map(profileData => {
+    const validProfileInstances = []
+    for(let profileData of profilesForUserId) {
         const profile = new Profile(profileData)
         if(profile.isValid()) {
-            profileInstances.push(profile)
+            validProfileInstances.push(profile)
         }
-    })
-    return profileInstances
+    }
+    return validProfileInstances
 }
 
 export { fetchProfilesByUserId }