:sparkles: added ability to send responses and creat new profile

backend/lib/models/profile.js

     }
     static get joiSchema() {
         return Joi.object({
-            profile_id: Joi.number().required(),
+            profile_id: Joi.number(),
+            user_id: Joi.number(),
         })
     }
 }

backend/lib/models/response.js

     }
     static get joiSchema() {
         return Joi.object({
-            response_id: Joi.number().required(),
+            response_id: Joi.number(),
+            profile_id: Joi.number(),
+            response_key_id: Joi.number(),
+            val: Joi.string(),
         })
     }
 }

backend/lib/plugins/profile.js

 const ProfileService = require('../services/profile')
 
 const ProfileProfilesRoute = require('../routes/profile/profiles')
+const ProfileCreateRoute = require('../routes/profile/create')
 
 module.exports = {
     name: 'profile-plugin',
         server.registerService(ProfileService)
 
         await server.route(ProfileProfilesRoute)
+        await server.route(ProfileCreateRoute)
     },
 }

backend/lib/routes/profile/create.js

+'use strict'
+
+const Joi = require('joi')
+
+const pluginConfig = {
+    handlerType: 'profile',
+    docs: {
+        description: 'Create profile',
+        notes: 'Create a profile associated with this user',
+    },
+}
+
+const validators = {
+    /** Validate the header (cookie check) */
+    // headers: true,
+
+    /** Validate the route params (/active/{thing}) */
+    params: Joi.object({ user_id: Joi.number() }),
+
+    /** Validate the route query (/active/{thing}?limit=10&offset=10) */
+    // query: true,
+    /** Validate the incoming payload (POST method) */
+    payload: Joi.array().items(
+        Joi.object({
+            response_key_id: Joi.number().required(),
+            val: Joi.string().required(),
+        }),
+    ),
+}
+
+const responseSchemas = {
+    response: Joi.object({
+        profile_id: Joi.number(),
+        user_id: Joi.number(),
+    }),
+}
+
+module.exports = {
+    method: 'POST',
+    path: '/{user_id}/create',
+    options: {
+        ...pluginConfig.docs,
+        tags: ['api'],
+        /** Protect this route with authentication? */
+        auth: false,
+
+        handler: async function (request) {
+            const { profileService } = request.services()
+            const userId = request.params.user_id
+
+            /** Grab payload info */
+            const res = request.payload
+
+            const profile = await profileService.saveResponsesCreateProfileFor(
+                userId,
+                res,
+            )
+            try {
+                return {
+                    ok: true,
+                    handler: pluginConfig.handlerType,
+                    data: profile,
+                }
+            } catch (err) {
+                return {
+                    ok: false,
+                    handler: pluginConfig.handlerType,
+                    data: { error: `${err}` },
+                }
+            }
+        },
+
+        /** Validate based on validators object */
+        validate: {
+            ...validators,
+            failAction: 'log',
+        },
+
+        /** Validate the server response */
+        response: {
+            schema: Joi.object({
+                ok: Joi.bool(),
+                handler: Joi.string(),
+                data: responseSchemas.response,
+            }),
+        },
+    },
+}

backend/lib/services/profile.js

      * @param {Array} responses
      * @returns
      */
-    async saveProfile(userId, responses, txn) {
-        console.warn(userId, responses, txn)
+    async saveResponsesCreateProfileFor(userId, responses, txn) {
+        const { Profile, Response } = this.server.models()
+
+        const profile = await Profile.query(txn).insert({
+            user_id: userId,
+        })
+        for (const responseToSave of responses) {
+            const responseInfo = {
+                profile_id: profile.id,
+                response_key_id: responseToSave.response_key_id,
+                val: responseToSave.val,
+            }
+            await Response.query(txn).insert(responseInfo)
+        }
+        //** Work around for HAPI returning profile_id as id */
+        return { user_id: profile.user_id, profile_id: profile.id }
     }
     /**
      * Delete a profile

backend/server/manifest.js

-const Dotenv = require('dotenv');
-const Confidence = require('@hapipal/confidence');
-const Inert = require('@hapi/inert');
-const Vision = require('@hapi/vision');
-const Schwifty = require('@hapipal/schwifty');
-const HapiSwagger = require('hapi-swagger');
+const Dotenv = require('dotenv')
+const Confidence = require('@hapipal/confidence')
+const Inert = require('@hapi/inert')
+const Vision = require('@hapi/vision')
+const Schwifty = require('@hapipal/schwifty')
+const HapiSwagger = require('hapi-swagger')
 
 /** Pull .env into process.env */
-Dotenv.config({ path: `${__dirname}/.env` });
+Dotenv.config({ path: `${__dirname}/.env` })
 
 /** Glue manifest as a confidence store */
 module.exports = new Confidence.Store({
             $default: {
                 $param: 'API_PORT',
                 $coerce: 'number',
-                $default: process.env.API_PORT
+                $default: process.env.API_PORT,
             },
-            test: { $value: undefined }         // Let the server find an open port
+            test: { $value: undefined }, // Let the server find an open port
         },
         debug: {
             $filter: 'NODE_ENV',
             $default: {
                 log: ['error', 'start'],
-                request: ['error']
+                request: ['error'],
             },
             production: {
-                request: ['implementation']
-            }
-        }
+                request: ['implementation'],
+            },
+        },
     },
     register: {
         plugins: [
-
             /** Main app */
             {
                 plugin: '../lib',
                 routes: {
-                    prefix: '/api'
+                    prefix: '/api',
                 },
                 options: {
                     jwtKey: {
                         $filter: 'NODE_ENV',
                         $default: {
                             $param: 'APP_SECRET',
-                            $default: 'app-secret'
+                            $default: 'app-secret',
                         },
                         // Use .env file in production
                         production: {
-                            $param: 'APP_SECRET'
-                        }
-                    }
-                }
+                            $param: 'APP_SECRET',
+                        },
+                    },
+                },
             },
 
             /** Documentaion plugins */
-            Inert, Vision,
+            Inert,
+            Vision,
             {
                 plugin: HapiSwagger,
                 options: {
-                    info: { title: 'Test API Documentation' }
-                }
+                    info: { title: 'Test API Documentation' },
+                },
             },
             /** Model and knex integration */
             {
                             client: process.env.DB_TYPE,
                             useNullAsDefault: true,
                             connection: {
-                                host : process.env.DB_HOST,
-                                user : process.env.DB_USER,
-                                password : process.env.DB_ROOT_PASSWORD,
-                                database : process.env.DB_NAME
-                            }
-                        }
+                                host: process.env.DB_HOST,
+                                user: process.env.DB_USER,
+                                password: process.env.DB_ROOT_PASSWORD,
+                                database: process.env.DB_NAME,
+                            },
+                        },
                     },
                     production: {
-                        migrateOnStart: false
-                    }
-                }
-            }
-        ]
-    }
+                        migrateOnStart: false,
+                    },
+                },
+            },
+        ],
+    },
 })
-