:recycle: integrating entity system with db connector | integrating entity schemas with entity system | moved some docs | added grouping, survey, and response entities | altered Joi standard import

frontend/src/App.vue

 import { profileForm } from '@/utils/forms'
 import { Connector } from '@/utils/db'
 
+import { fetchProfilesByUserId } from '@/services'
+
 import helloWorld from '@/components/HelloWorld.vue'
 import card from '@/components/card.vue'
 import form from '@/components/form.vue'
         }
         onMounted(compileForm)
 
-        return { 
+        const t = async () => {
+            const tempProfiles = await fetchProfilesByUserId(1)
+            console.log(tempProfiles)
+        }
+        t()
+        return {
             cards,
             remove,
             completedForm

frontend/src/components/HelloWorld.vue

     state: 'lollipop',
     zip: 90002
 })
-console.log(state.profile)
-console.log(state.profile.isValid())
+// console.log(state.profile)
+// console.log(state.profile.isValid())
 </script>
 
 <style lang="postcss">

frontend/src/entities/grouping/grouping.js

+/** @module entities/grouping */
+
+import { _baseRecord } from '..'
+import { groupingSchema } from './grouping.schema'
+
+/** Class representing a grouping */
+class Grouping extends _baseRecord {
+    /**
+     * Create the grouping.
+     * @extends _baseRecord
+     * @param {string} email
+     * @param {object} grouping - spread destructured args
+     * @return {Grouping} the grouping instance object
+     */
+    constructor({ ...grouping }) {
+        super()
+
+        this.type = this.constructor.name.toLowerCase()
+
+        /**  Fields */
+        this.groupingId = groupingId
+        this.groupingName = groupingName
+        this.groupingType = groupingType
+
+        return this
+    }
+    /**
+     * validate this record
+     * @return {boolean} is it valid or not?
+     */
+    isValid() {
+        const validate = groupingSchema.validate(this)
+
+        /**
+         * Log out some useful error messages
+         * TODO: Send validate.error to logging error handler
+         */
+        if(validate.error) {
+            console.error(
+                `error: ${validate.error} - ${this.type} validation`
+            )
+        }
+
+        /** validate(this) always returns something so force it to a bool */
+        return !validate.error ? true : false
+    }
+}
+
+export { Grouping }

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

+/** @module entities/groupingSchema */
+import Joi from 'joi'
+
+/**
+ * grouping schema object
+ * uses the module system to use common fields
+ * but sets fields with our validation types
+ * @constructor
+*/
+const groupingSchema = {
+    type: 'object',
+    properties: Joi.object().keys({
+        /** _baseRecord fields */
+        createdAt: Joi.string(),
+        _id: Joi.string(),
+        lastUpdatedAt: Joi.string(),
+        type: Joi.string(),
+
+        /** our fields */
+        groupingId: Joi.number().required(),
+        groupingName: Joi.string().required(),
+        groupingType: Joi.string().required()
+    }),
+    /** fields required before saving */
+    required: [ 'groupingId', 'groupingName', 'groupingType' ],
+    validate(instance) {
+        return this.properties.validate(instance)
+    }
+}
+
+export { groupingSchema }

frontend/src/entities/grouping/index.js

+export * from './grouping'
+export * from './grouping.schema'

frontend/src/entities/index.js

 export * from './_modules'
 
-/** Single instance of your schema handler */
-import Joi from 'joi'
-
-export { Joi }
-
 /** Your different entities */
+export * from './response'
 export * from './profile'
+export * from './survey'
+export * from './grouping'
 

frontend/src/entities/profile/profile.js

 /** @module entities/profile */
-
-import { _baseRecord, allModules, Joi } from '..'
+import { _baseRecord, allModules } from '..'
 import { profileSchema } from './profile.schema'
 
 /** Class representing a profile */
      * @param {object} profile - spread destructured args
      * @return {Profile} the profile instance object
      */
-    constructor({ email, ...profile }) {
+    constructor({ email, ...profileData }) {
         super()
 
         this.type = this.constructor.name.toLowerCase()
         this.email = email // ! required
 
         /** Pass destructured data to the module system */
-        Object.assign(this, allModules.location(profile))
+        Object.assign(this, profileData)
 
         return this
     }

frontend/src/entities/profile/profile.schema.js

 /** @module entities/profileSchema */
-import { allModules, Joi } from '..'
+import Joi from 'joi'
+import { allModules, responseSchema } from '..'
 
 /**
  * profile schema object
         email: Joi.string().email({
             minDomainSegments: 2,
             tlds: { allow: ['com', 'net'] }
-        }).required(),
+        }),
+
+        /** fields that should match backend service*/
+        user_id: Joi.number(),
+        profile_id: Joi.number(),
+        responses: Joi.array().items(
+            responseSchema
+        ), // response entity schema goes here
+        user_type: Joi.string(),
 
         /** tricky module system fields */
         ...allModules.location({
         })
     }),
     /** fields required before saving */
-    required: [ 'email' ],
+    required: [ ],
     validate(instance) {
         return this.properties.validate(instance)
     }

frontend/src/entities/response/index.js

+export * from './response.schema'

frontend/src/entities/response/response.schema.js

+/** @module entities/responseSchema */
+import Joi from 'joi'
+
+/**
+ * response schema object
+*/
+const responseSchema = Joi.object({
+    profile_id: Joi.number(),
+    response_id: Joi.number(),
+    response_key_id: Joi.number(),
+    val:  Joi.string(),
+})
+
+export { responseSchema }

frontend/src/entities/survey/index.js

+export * from './survey'
+export * from './survey.schema'

frontend/src/entities/survey/survey.schema.js

+/** @module entities/surveySchema */
+import Joi from 'joi'
+import { allModules } from '..'
+
+/**
+ * membership schema object
+ * uses the module system to use common fields
+ * but sets fields with our validation types
+ * @constructor
+*/
+const surveySchema = {
+    type: 'object',
+    properties: Joi.object().keys({
+        /** _baseRecord fields */
+        createdAt: Joi.string(),
+        _id: Joi.string(),
+        lastUpdatedAt: Joi.string(),
+        type: Joi.string(),
+
+        /** our fields */
+        email: Joi.string().email({
+            minDomainSegments: 2,
+            tlds: { allow: ['com', 'net'] }
+        }).required(),
+    }),
+    /** fields required before saving */
+    required: [ 'email' ],
+    validate(instance) {
+        return this.properties.validate(instance)
+    }
+}
+
+export { surveySchema }

frontend/src/services/index.js

+export * from './profile.service'

frontend/src/services/profile.service.js

+import { db } from '../utils/db'
+import { Profile } from '../entities/profile'
+
+/**
+ * Get a single Profile from the database and
+ * create a class from the data and
+ * validate the incoming
+ * @param {number} userId
+ */
+const fetchProfilesByUserId = async userId => {
+    const profilesForUserId = await db.get(`/user/${userId}/profiles`)
+    const profileInstances = []
+    profilesForUserId.map(profileData => {
+        const profile = new Profile(profileData)
+        if(profile.isValid()) {
+            profileInstances.push(profile)
+        }
+    })
+    return profileInstances
+}
+
+export { fetchProfilesByUserId }

frontend/src/utils/db.js

 const domain = 'localhost'
 const port = 3001
-const remote = `http://${domain}:${port}/api`
+const httpProtocol = `http`
+const prefix = 'api'
+const remote = `${httpProtocol}://${domain}:${port}/${prefix}`
 
 const headerTemplate = {
     method: null,
 
 class Connector {
     constructor() {
-        this.db = null
+        this.apiPrefix = prefix
     }
     async get(endpoint) {
         const header = headerTemplate
         header.method = 'GET'
         try {
+            console.log(`${remote}${endpoint}`)
             let res = await fetch(`${remote}${endpoint}`, header)
             if (!res.ok) {
                 throw Error(res.statusText)
             const jsonRes = await res.json()
             return jsonRes.data
         } catch (error) {
-            console.log(error)
+            console.error(error)
         }
     }
     async put(endpoint, entry) {
     /** !: DEV ONLY */
     // async removeAll() { }
 }
-
-export { Connector }
+const db = new Connector()
+export { Connector, db }