:construction: Finished saving responses from survey to database

backend/lib/routes/profile/insert.js

 const pluginConfig = {
     handlerType: 'profile',
     docs: {
-        description: 'Insert profile',
-        notes: 'Insert new profile responses',
+        description: 'Insert responses',
+        notes: 'Insert new responses',
     },
 }
 
 const responseSchemas = {
-    response: surveyResponseSchema.list,
+    response: surveyResponseSchema.single,
     error: errorSchema.single,
 }
 
 
 module.exports = {
     method: 'POST',
-    path: '/{profile_id}/insert/{response_id?}',
+    path: '/{profile_id}/insert/{response_key_id?}',
     options: {
         ...pluginConfig.docs,
         tags: ['api'],
         /** Protect this route with authentication? */
         auth: false,
+        cors: true,
 
         handler: async function (request, h) {
             const { profileService } = request.services()
-            const profileId = request.params.profile_id
-
             /** Grab payload info */
             const res = request.payload
-            console.log('res :=>', res)
 
             try {
-                const allResponses = profileService.saveResponseForProfile(profileId, res)
+                const insertedResponse = await profileService.insertSingleResponseForProfile(res)
 
-                if (!allResponses) {
-                    throw new RangeError('Response not inserted')
+                if (!insertedResponse) {
+                    throw new Error('Response not inserted')
                 }
 
                 return h
                     .response({
                         ok: true,
                         handler: pluginConfig.handlerType,
-                        data: allResponses,
+                        data: insertedResponse,
                     })
                     .code(200)
             } catch (err) {

backend/lib/services/profile/index.js

 const profiler = require('./profiler')
 const scoring = require('./scorer')
 const zipcoder = require('./zipcoder')
+const { response } = require('@hapi/hapi/lib/validation')
 
 module.exports = class ProfileService extends Schmervice.Service {
     constructor(...args) {
         return [...new Set(profileIdsToGrab)]
     }
 
+    /**
+     * Convert indexes to actual score values
+     * Using using the input and converting to index
+     * of the generated possible prescore array in config
+     */
+    _convertResponse(responseToSave) {
+        if (scoring._isScorableResponse(responseToSave.response_key_id)) {
+            // Convert -3 to 0, 0 to 3, 3 to 6
+            const offset = (config.scoreVals.length - 1) / 2
+            const scoreFromInput = parseInt(responseToSave.val) + offset
+            const scoreFromConfig = config.scoreVals.indexOf(scoreFromInput)
+            if (scoreFromConfig < 0) {
+                console.error('score not found in possible config responses')
+            }
+            responseToSave.val = scoreFromConfig.toString()
+        }
+        return responseToSave
+    }
+
     async getProfile(profileId) {
         const { Profile } = this.server.models()
         await this._setTagLookup()
             user_id: userId,
         })
         for (const responseToSave of responses) {
-            /**
-             * Convert indexes to actual score values
-             * Using using the input and converting to index
-             * of the generated possible prescore array in config
-             * DUPLICATE:See saveResponseForProfile() line 343
-             */
-            let convertedResponse = responseToSave
-            if (scoring._isScorableResponse(responseToSave.response_key_id)) {
-                // Convert -3 to 0, 0 to 3, 3 to 6
-                const offset = (config.scoreVals.length - 1) / 2
-                const indexFromInput = parseInt(responseToSave.val) + offset
-                convertedResponse.val =
-                    config.scoreVals[indexFromInput].toString()
-            }
-
+            const convertedResponse = this._convertResponse(responseToSave)
             const responseInfo = {
                 profile_id: profile.id,
                 response_key_id: convertedResponse.response_key_id,
         })
     }
 
+    async insertSingleResponseForProfile(responseToSave) {
+        const { Response } = this.server.models()
+        const convertedResponse = this._convertResponse(responseToSave)
+        const savedResponse = await Response.query().insert(convertedResponse)
+        delete savedResponse.id
+        return savedResponse
+    }
+
     /** Add response
      * @param {Object} response to save
      * @returns {null} updated responses
                 .delete()
                 .whereIn('response_key_id', alreadyAnswered)
         }
-
-        /**
-         * Convert indexes to actual score values
-         * Using using the input and converting to index
-         * of the generated possible prescore array in config
-         */
-        let convertedResponse = responseToSave
-        if (scoring._isScorableResponse(responseToSave.response_key_id)) {
-            // Convert -3 to 0, 0 to 3, 3 to 6
-            const offset = (config.scoreVals.length - 1) / 2
-            const scoreFromInput = parseInt(responseToSave.val) + offset
-            const scoreFromConfig = config.scoreVals.indexOf(scoreFromInput)
-            if (scoreFromConfig < 0) {
-                console.error('score not found in possible config responses')
-            }
-            convertedResponse.val = scoreFromConfig.toString()
-        }
-
+        const convertedResponse = this._convertResponse(responseToSave)
         await Response.query().insert(convertedResponse)
         return allResponses
     }

frontend/src/services/survey.service.js

     return withResponses
 }
 
-const insertNewSurveyResponses = async (surveyResponses, profileId) => {
-    surveyResponses.forEach(responseKeyIdwithVal => {
-        const keyId = responseKeyIdwithVal.response_key_id
-        const val = responseKeyIdwithVal.val
+const insertNewSurveyResponse = async (surveyResponse, profileId) => {
+        const keyId = surveyResponse.response_key_id
+        const val = surveyResponse.val
         // POST
         // TODO: create this route on the backend
-        db.post(`/profile/${profileId}/insert/${keyId}`, [
+        db.post(`/profile/${profileId}/insert/${keyId}`,
             {
                 profile_id: profileId,
-                reponse_key_id: keyId,
+                response_key_id: keyId,
                 val: val,
             }
-        ])
-    })
+        )
 }
 
 // similar to this
 
 export {
     fetchQuestions,
-    insertNewSurveyResponses,
+    insertNewSurveyResponse,
     updateSurveyByProfileId,
     scoreSurveyByProfileId,
     fetchResponsesByProfileId,

frontend/src/utils/survey.js

 import { Survey } from '../entities/index.js'
-import { fetchQuestions, insertNewSurveyResponses } from '../services/index.js'
+import { fetchQuestions, insertNewSurveyResponse } from '../services/index.js'
 import { splash, possible, surveyStages, allSteps } from './lang.js'
 
 class SurveyFactory {
             console.error(err)
         }
     }
-    async addNewSurveyAnswers(responses, profileId) {
+    async addNewSurveyAnswer(responses, profileId) {
         try {
-            this.responsesFromDb = await insertNewSurveyResponses(responses, profileId)
+            this.responsesFromDb = await insertNewSurveyResponse(responses, profileId)
             return this.responsesFromDb
         }
         catch (err) {

frontend/src/views/OnboardingView.vue

                 // save endpoint here
                 // start with utils/surve.js
                 if (this.currentProfileId) {
-                    surveyFactory.addNewSurveyAnswers(this.responses, this.currentProfileId)
+                    surveyFactory.addNewSurveyAnswer(this.responses[this.responses.length - 1], this.currentProfileId)
                 }
 
                 // creates a user in db as long as name, email, and seeking are defined