:recycle: adding in user relation | simplifying scoring service

backend/lib/models/profile.js

 const Schwifty = require('@hapipal/schwifty')
 const Joi = require('joi')
 const Response = require('./response')
+const User = require('./user')
 
 module.exports = class Profile extends Schwifty.Model {
     static get tableName() {
                     to: 'profiles.profile_id',
                 },
             },
+            user: {
+                relation: Schwifty.Model.BelongsToOneRelation,
+                modelClass: User,
+                join: {
+                    from: 'users.user_id',
+                    to: 'profiles.user_id',
+                },
+            },
         }
     }
     static get joiSchema() {

backend/lib/services/profile.js

 const scoreResponses = (seeker, potentialMatch) => {
     if (seeker.responses.length != potentialMatch.responses.length)
         return {
-            error: `complete responses for profile: ${seeker.profile_id} unqeual to profile: ${potentialMatch.profile_id}`,
+            error: `complete responses for profile: ${seeker.profile_id} unqeual to profile: ${potentialMatch.profile_id} | ${seeker.responses.length}:${potentialMatch.responses.length}`,
         }
 
     const checkValCb = res => {
         ) * magic,
     )
 }
-const userTypes = {
-    seeker: 'seeker',
-    poster: 'poster',
-}
 
 /**
  * Class to hold our retrieved profile information
      * @returns {Array} Ordered and scored Profiles
      */
     async scoreProfilesFor(userId) {
-        const { User } = this.server.models(['user'])
         const { Profile } = this.server.models()
 
-        const user = await User.query().findOne('user_id', userId)
+        // Our User Profile to score for
         const userProfile = await Profile.query()
             .findOne('user_id', userId)
             .withGraphFetched('responses')
-        const isPosterOpposite = user.is_poster == 1 ? 0 : 1
-        const userType = Object.keys(userTypes)[isPosterOpposite]
+            .withGraphFetched('user')
+
+        const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
+
+        // Find all Profiles that are NOT of our userProfile.type
+        // ie. If userProfile.type == seeker, then find: poster
+        let profileIdsOfOppositeType = await Profile.query()
+            .withGraphFetched('responses')
+            .withGraphFetched('user')
 
-        const profileIdsOfOppositeType = await Profile.query().withGraphFetched(
-            'responses',
+        // TODO: Let Objection optimize this
+        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(
+            profile => profile.user.is_poster == isPosterOpposite,
         )
 
-        return profileIdsOfOppositeType.map(profile => ({
+        const scored = profileIdsOfOppositeType.map(profile => ({
             profile_id: profile.profile_id,
-            score: scoreResponses(
-                userProfile,
-                new CompleteProfile(profile, userType),
-            ),
+            score: scoreResponses(userProfile, profile),
         }))
+        return scored.sort((a, b) => a.score - b.score)
     }
 }