:recycle: more mock responses | semi-broken stable marriage | must score BEFORE match duh

backend/db/mock.js

         { response_id: 97, profile_id: 13, response_key_id: 16, val: '96701' },
         { response_id: 98, profile_id: 14, response_key_id: 16, val: '90452' },
         { response_id: 99, profile_id: 15, response_key_id: 16, val: '90025' },
+        {
+            response_id: 100,
+            profile_id: 8,
+            response_key_id: 0,
+            val: '160',
+        },
+        {
+            response_id: 101,
+            profile_id: 8,
+            response_key_id: 1,
+            val: '140',
+        },
+        {
+            response_id: 102,
+            profile_id: 8,
+            response_key_id: 2,
+            val: '180',
+        },
+        {
+            response_id: 103,
+            profile_id: 8,
+            response_key_id: 3,
+            val: '120',
+        },
+        {
+            response_id: 104,
+            profile_id: 8,
+            response_key_id: 4,
+            val: '140',
+        },
+        {
+            response_id: 105,
+            profile_id: 8,
+            response_key_id: 5,
+            val: '120',
+        },
+        {
+            response_id: 106,
+            profile_id: 8,
+            response_key_id: 6,
+            val: '120',
+        },
+        {
+            response_id: 107,
+            profile_id: 8,
+            response_key_id: 7,
+            val: '120',
+        },
+        {
+            response_id: 108,
+            profile_id: 8,
+            response_key_id: 8,
+            val: '140',
+        },
+        {
+            response_id: 109,
+            profile_id: 8,
+            response_key_id: 9,
+            val: '200',
+        },
+        {
+            response_id: 110,
+            profile_id: 8,
+            response_key_id: 10,
+            val: '200',
+        },
+        {
+            response_id: 111,
+            profile_id: 8,
+            response_key_id: 11,
+            val: '160',
+        },
+        {
+            response_id: 112,
+            profile_id: 9,
+            response_key_id: 0,
+            val: '180',
+        },
+        {
+            response_id: 113,
+            profile_id: 9,
+            response_key_id: 1,
+            val: '200',
+        },
+        {
+            response_id: 114,
+            profile_id: 9,
+            response_key_id: 2,
+            val: '120',
+        },
+        {
+            response_id: 115,
+            profile_id: 9,
+            response_key_id: 3,
+            val: '140',
+        },
+        {
+            response_id: 116,
+            profile_id: 9,
+            response_key_id: 4,
+            val: '180',
+        },
+        {
+            response_id: 117,
+            profile_id: 9,
+            response_key_id: 5,
+            val: '180',
+        },
+        {
+            response_id: 118,
+            profile_id: 9,
+            response_key_id: 6,
+            val: '120',
+        },
+        {
+            response_id: 119,
+            profile_id: 9,
+            response_key_id: 7,
+            val: '140',
+        },
+        {
+            response_id: 120,
+            profile_id: 9,
+            response_key_id: 8,
+            val: '180',
+        },
+        {
+            response_id: 121,
+            profile_id: 9,
+            response_key_id: 9,
+            val: '140',
+        },
+        {
+            response_id: 122,
+            profile_id: 9,
+            response_key_id: 10,
+            val: '160',
+        },
+        {
+            response_id: 123,
+            profile_id: 9,
+            response_key_id: 11,
+            val: '180',
+        },
+        {
+            response_id: 124,
+            profile_id: 10,
+            response_key_id: 0,
+            val: '160',
+        },
+        {
+            response_id: 125,
+            profile_id: 10,
+            response_key_id: 1,
+            val: '140',
+        },
+        {
+            response_id: 126,
+            profile_id: 10,
+            response_key_id: 2,
+            val: '140',
+        },
+        {
+            response_id: 127,
+            profile_id: 10,
+            response_key_id: 3,
+            val: '200',
+        },
+        {
+            response_id: 128,
+            profile_id: 10,
+            response_key_id: 4,
+            val: '180',
+        },
+        {
+            response_id: 129,
+            profile_id: 10,
+            response_key_id: 5,
+            val: '200',
+        },
+        {
+            response_id: 130,
+            profile_id: 10,
+            response_key_id: 6,
+            val: '160',
+        },
+        {
+            response_id: 131,
+            profile_id: 10,
+            response_key_id: 7,
+            val: '200',
+        },
+        {
+            response_id: 132,
+            profile_id: 10,
+            response_key_id: 8,
+            val: '120',
+        },
+        {
+            response_id: 133,
+            profile_id: 10,
+            response_key_id: 9,
+            val: '180',
+        },
+        {
+            response_id: 134,
+            profile_id: 10,
+            response_key_id: 10,
+            val: '120',
+        },
+        {
+            response_id: 135,
+            profile_id: 10,
+            response_key_id: 11,
+            val: '200',
+        },
+        {
+            response_id: 136,
+            profile_id: 11,
+            response_key_id: 0,
+            val: '140',
+        },
+        {
+            response_id: 137,
+            profile_id: 11,
+            response_key_id: 1,
+            val: '180',
+        },
+        {
+            response_id: 138,
+            profile_id: 11,
+            response_key_id: 2,
+            val: '160',
+        },
+        {
+            response_id: 139,
+            profile_id: 11,
+            response_key_id: 3,
+            val: '160',
+        },
+        {
+            response_id: 140,
+            profile_id: 11,
+            response_key_id: 4,
+            val: '140',
+        },
+        {
+            response_id: 141,
+            profile_id: 11,
+            response_key_id: 5,
+            val: '140',
+        },
+        {
+            response_id: 142,
+            profile_id: 11,
+            response_key_id: 6,
+            val: '120',
+        },
+        {
+            response_id: 143,
+            profile_id: 11,
+            response_key_id: 7,
+            val: '140',
+        },
+        {
+            response_id: 144,
+            profile_id: 11,
+            response_key_id: 8,
+            val: '120',
+        },
+        {
+            response_id: 145,
+            profile_id: 11,
+            response_key_id: 9,
+            val: '120',
+        },
+        {
+            response_id: 146,
+            profile_id: 11,
+            response_key_id: 10,
+            val: '200',
+        },
+        {
+            response_id: 147,
+            profile_id: 11,
+            response_key_id: 11,
+            val: '140',
+        },
+        {
+            response_id: 148,
+            profile_id: 12,
+            response_key_id: 0,
+            val: '200',
+        },
+        {
+            response_id: 149,
+            profile_id: 12,
+            response_key_id: 1,
+            val: '160',
+        },
+        {
+            response_id: 150,
+            profile_id: 12,
+            response_key_id: 2,
+            val: '200',
+        },
+        {
+            response_id: 151,
+            profile_id: 12,
+            response_key_id: 3,
+            val: '140',
+        },
+        {
+            response_id: 152,
+            profile_id: 12,
+            response_key_id: 4,
+            val: '180',
+        },
+        {
+            response_id: 153,
+            profile_id: 12,
+            response_key_id: 5,
+            val: '200',
+        },
+        {
+            response_id: 154,
+            profile_id: 12,
+            response_key_id: 6,
+            val: '200',
+        },
+        {
+            response_id: 155,
+            profile_id: 12,
+            response_key_id: 7,
+            val: '180',
+        },
+        {
+            response_id: 156,
+            profile_id: 12,
+            response_key_id: 8,
+            val: '140',
+        },
+        {
+            response_id: 157,
+            profile_id: 12,
+            response_key_id: 9,
+            val: '140',
+        },
+        {
+            response_id: 158,
+            profile_id: 12,
+            response_key_id: 10,
+            val: '180',
+        },
+        {
+            response_id: 159,
+            profile_id: 12,
+            response_key_id: 11,
+            val: '160',
+        },
+        {
+            response_id: 160,
+            profile_id: 13,
+            response_key_id: 0,
+            val: '120',
+        },
+        {
+            response_id: 161,
+            profile_id: 13,
+            response_key_id: 1,
+            val: '180',
+        },
+        {
+            response_id: 162,
+            profile_id: 13,
+            response_key_id: 2,
+            val: '160',
+        },
+        {
+            response_id: 163,
+            profile_id: 13,
+            response_key_id: 3,
+            val: '120',
+        },
+        {
+            response_id: 164,
+            profile_id: 13,
+            response_key_id: 4,
+            val: '140',
+        },
+        {
+            response_id: 165,
+            profile_id: 13,
+            response_key_id: 5,
+            val: '140',
+        },
+        {
+            response_id: 166,
+            profile_id: 13,
+            response_key_id: 6,
+            val: '140',
+        },
+        {
+            response_id: 167,
+            profile_id: 13,
+            response_key_id: 7,
+            val: '160',
+        },
+        {
+            response_id: 168,
+            profile_id: 13,
+            response_key_id: 8,
+            val: '180',
+        },
+        {
+            response_id: 169,
+            profile_id: 13,
+            response_key_id: 9,
+            val: '200',
+        },
+        {
+            response_id: 170,
+            profile_id: 13,
+            response_key_id: 10,
+            val: '180',
+        },
+        {
+            response_id: 171,
+            profile_id: 13,
+            response_key_id: 11,
+            val: '160',
+        },
+        {
+            response_id: 172,
+            profile_id: 14,
+            response_key_id: 0,
+            val: '160',
+        },
+        {
+            response_id: 173,
+            profile_id: 14,
+            response_key_id: 1,
+            val: '140',
+        },
+        {
+            response_id: 174,
+            profile_id: 14,
+            response_key_id: 2,
+            val: '140',
+        },
+        {
+            response_id: 175,
+            profile_id: 14,
+            response_key_id: 3,
+            val: '160',
+        },
+        {
+            response_id: 176,
+            profile_id: 14,
+            response_key_id: 4,
+            val: '200',
+        },
+        {
+            response_id: 177,
+            profile_id: 14,
+            response_key_id: 5,
+            val: '120',
+        },
+        {
+            response_id: 178,
+            profile_id: 14,
+            response_key_id: 6,
+            val: '160',
+        },
+        {
+            response_id: 179,
+            profile_id: 14,
+            response_key_id: 7,
+            val: '160',
+        },
+        {
+            response_id: 180,
+            profile_id: 14,
+            response_key_id: 8,
+            val: '160',
+        },
+        {
+            response_id: 181,
+            profile_id: 14,
+            response_key_id: 9,
+            val: '120',
+        },
+        {
+            response_id: 182,
+            profile_id: 14,
+            response_key_id: 10,
+            val: '180',
+        },
+        {
+            response_id: 183,
+            profile_id: 14,
+            response_key_id: 11,
+            val: '180',
+        },
+        {
+            response_id: 184,
+            profile_id: 15,
+            response_key_id: 0,
+            val: '160',
+        },
+        {
+            response_id: 185,
+            profile_id: 15,
+            response_key_id: 1,
+            val: '140',
+        },
+        {
+            response_id: 186,
+            profile_id: 15,
+            response_key_id: 2,
+            val: '140',
+        },
+        {
+            response_id: 187,
+            profile_id: 15,
+            response_key_id: 3,
+            val: '160',
+        },
+        {
+            response_id: 188,
+            profile_id: 15,
+            response_key_id: 4,
+            val: '200',
+        },
+        {
+            response_id: 189,
+            profile_id: 15,
+            response_key_id: 5,
+            val: '120',
+        },
+        {
+            response_id: 190,
+            profile_id: 15,
+            response_key_id: 6,
+            val: '160',
+        },
+        {
+            response_id: 191,
+            profile_id: 15,
+            response_key_id: 7,
+            val: '160',
+        },
+        {
+            response_id: 192,
+            profile_id: 15,
+            response_key_id: 8,
+            val: '160',
+        },
+        {
+            response_id: 193,
+            profile_id: 15,
+            response_key_id: 9,
+            val: '120',
+        },
+        {
+            response_id: 194,
+            profile_id: 15,
+            response_key_id: 10,
+            val: '180',
+        },
+        {
+            response_id: 195,
+            profile_id: 15,
+            response_key_id: 11,
+            val: '180',
+        },
     ],
     memberships: [
         {

backend/lib/routes/profile/match.js

         handler: async function (request, h) {
             const { profileService } = request.services()
             const postMatchYins = await profileService.calcMatches()
-            console.log(postMatchYins)
             try {
-                if(!postMatchYins){
+                if (!postMatchYins) {
                     throw new RangeError('Unable to match profiles')
                 }
-                
-                return h.response({
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: postMatchYins,
-                }).code(200)
+
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: postMatchYins,
+                    })
+                    .code(200)
             } catch (err) {
-                return h.response({
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }).code(409)
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
             }
         },
 
                     handler: Joi.string(),
                     data: responseSchemas.error,
                 }),
-            }
+            },
         },
     },
 }

backend/lib/routes/profile/respond.js

 'use strict'
 
 const Joi = require('joi')
-const profile = require('../../plugins/profile')
 
 const pluginConfig = {
     handlerType: 'profile',
     // headers: true,
 
     /** Validate the route params (/active/{thing}) */
-    params: Joi.object({ 
-        profile_id: Joi.number()
+    params: Joi.object({
+        profile_id: Joi.number(),
     }),
 
     /** Validate the route query (/active/{thing}?limit=10&offset=10) */
-    query: Joi.object({ 
+    query: Joi.object({
         response_key_id: Joi.number(),
-        val: Joi.string()
-    })
+        val: Joi.string(),
+    }),
     /** Validate the incoming payload (POST method) */
     // payload: responseSchemas.responses,
 }
 
         handler: async function (request, h) {
             const { profileService } = request.services()
-            
+
             const profileId = request.params.profile_id
             const responseToSave = {
                 profile_id: profileId,
                 response_key_id: request.query.response_key_id,
-                val: request.query.val
+                val: request.query.val,
             }
-            const allResponses = await profileService.saveResponseForProfile(profileId, responseToSave)
-            
+            const allResponses = await profileService.saveResponseForProfile(
+                profileId,
+                responseToSave,
+            )
+
             try {
                 // profileService.saveResponseForProfile() will return null if it exists
-                if(!allResponses){
+                if (!allResponses) {
                     throw new RangeError('Response already exists')
                 }
 
-                return h.response({
-                    ok: true,
-                    handler: pluginConfig.handlerType,
-                    data: allResponses,
-                }).code(201)
+                return h
+                    .response({
+                        ok: true,
+                        handler: pluginConfig.handlerType,
+                        data: allResponses,
+                    })
+                    .code(201)
             } catch (err) {
-                return h.response({
-                    ok: false,
-                    handler: pluginConfig.handlerType,
-                    data: { error: `${err}` },
-                }).code(409)
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: { error: `${err}` },
+                    })
+                    .code(409)
             }
         },
 

backend/lib/services/profile.js

 const Schmervice = require('@hapipal/schmervice')
 const cosineSimilarity = require('compute-cosine-similarity')
 const haversine = require('haversine')
-const { profiles } = require('../../db/mock')
-
-const rand = max => {
-    return Math.floor(Math.random() * max) < 1
-        ? 1
-        : Math.floor(Math.random() * max)
-}
 
 const runMatch = (allYins, allYangs) => {
     balanceSides(allYins, allYangs)
-    
+    console.log(allYins.length, ':', allYangs.length)
     // You only need to engage from one side
     engageEveryone(allYins)
 
-    allYins.forEach(yin => yin.clearPlaceholderMatches())
-    allYangs.forEach(yang => yang.clearPlaceholderMatches())
-
     console.log('---')
 }
-const engageEveryone = allYinsOrYangs => {
+const engageEveryone = allYins => {
     let done
     do {
+        console.log('rerunning...')
         done = true
-        allYinsOrYangs.forEach(yinOrYang => {
-            if (!yinOrYang.otp) {
+        allYins.forEach(yin => {
+            // Keep matching if no true pairing is found
+            console.log(yin.realId, yin.otp?.realId)
+            if (!yin.otp) {
                 done = false
-                const yangOrYin = yinOrYang.getNextCandidate()
-                if (!yangOrYin.otp || yangOrYin.prefers(yinOrYang)) {
-                    yinOrYang.engageTo(yangOrYin)
+                const yang = yin.getNextCandidate()
+                if (!yang.otp || yang.prefers(yin)) {
+                    yin.engageTo(yang)
                 }
+            } else {
+                console.log(yin.otp.realId)
             }
         })
     } while (!done)
         this.matchQueue = matchQueue?.length ? matchQueue : []
         this.fOrder = []
     }
-    clearPlaceholderMatches(){
-        this.matchQueue = this.matchQueue.filter(
-            match => match.realId == false,
-        )
+    clearPlaceholderMatches() {
+        this.matchQueue = this.matchQueue.filter(match => match.realId == false)
         this.fOrder = this.fOrder.filter(
             potentialFiance => potentialFiance.realId == false,
         )
             this.otp = null
         }
     }
-    rank(p) {
-        for (let i = 0; i < this.matchQueue.length; i++) {
-            if (this.matchQueue[i] === p) {
-                return i
-            }
-        }
-        return this.matchQueue.length + 1
+    rank(id) {
+        const idQueue = this.matchQueue.map(
+            profileFacade => profileFacade.realId,
+        )
+        return idQueue.includes(id)
+            ? idQueue.indexOf(id)
+            : this.matchQueue.length + 1
     }
     prefers(p) {
-        return this.rank(p) < this.rank(this.otp)
+        return this.rank(p.realId) < this.rank(this.otp.realId)
     }
     getNextCandidate() {
         if (this.matchCandidateIndex >= this.matchQueue.length) return null
-        return this.matchQueue[this.matchCandidateIndex++]
+        this.matchCandidateIndex = this.matchCandidateIndex + 1
+        return this.matchQueue[this.matchCandidateIndex - 1]
     }
     engageTo(p) {
-        if (p.otp) { p.otp.otp = null }
+        if (p.otp) {
+            p.otp.otp = null
+        }
+        if (this.otp) {
+            this.otp.otp = null
+        }
+
         p.otp = this
         p.fOrder.unshift(this)
-        if (this.otp) { this.otp.otp = null }
+
         this.otp = p
         this.fOrder.unshift(p)
+        console.log(
+            'partners pref: ',
+            this.otp.matchQueue.map(f => f.realId).indexOf(this.realId) + 1,
+            'choice',
+        )
     }
 }
 
             // ...profile,
             profile_id: profile.profile_id,
             score: scoreResponses(userProfile, profile),
-            distance: profile.distance
+            distance: profile.distance,
         }
     })
 }
-/** 
-     * Grab the zip code string
-    */
- const getZipCodeFromProfile = (profile) => {
+/**
+ * Grab the zip code string
+ */
+const getZipCodeFromProfile = profile => {
     // There should only be one zip code entry per profile
-    let zip = profile.responses.filter(response => response.response_key_id == 16)[0]
+    let zip = profile.responses.filter(
+        response => response.response_key_id == 16,
+    )[0]
     const responseIndexForZip = profile.responses.indexOf(zip)
-    if(responseIndexForZip >= 0) {
+    if (responseIndexForZip >= 0) {
         profile.responses.splice(responseIndexForZip, 1)
     }
     return zip.val
         let allResponses = await Response.query().where({
             profile_id: profileId,
         })
-        const matchingResponses = allResponses.filter(response => response.response_key_id == responseToSave.response_key_id)
-        
+        const matchingResponses = allResponses.filter(
+            response =>
+                response.response_key_id == responseToSave.response_key_id,
+        )
+
         // ?:Maybe bad idea
-        if(matchingResponses.length > 0) { return null }
+        if (matchingResponses.length > 0) {
+            return null
+        }
 
         await await Response.query().insert(responseToSave)
         return allResponses
 
         return await Profile.query().delete().where('profile_id', profileId)
     }
-    
+
     /**
      * Score a profile
      * @param {number} profileId
      */
     async scoreProfilesFor(profileId, maxDistance, distanceUnit) {
         const { Profile } = this.server.models()
-        
+
         // Our User Profile to score for
         const userProfile = await Profile.query()
             .findOne('profile_id', profileId)
             .withGraphFetched('responses')
             .withGraphFetched('user')
-            
+
         // Move unneeded responses
         const userZip = getZipCodeFromProfile(userProfile)
 
         let profileIdsOfOppositeType = await Profile.query()
             .withGraphFetched('responses')
             .withGraphFetched('user')
-        
+
         // TODO: Let Objection optimize this
         const isPosterOpposite = userProfile.user.is_poster == 1 ? 0 : 1
-        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(profile => profile.user.is_poster == isPosterOpposite)
-        
-        const profilePlusDistance = await Promise.all(profileIdsOfOppositeType.map(async profile => {
-            const targetZip = getZipCodeFromProfile(profile)
-            const distance = await this._compareDistance(userZip, targetZip, distanceUnit)
-            return {
-                ...profile,
-                distance: [distance.toFixed(2), distanceUnit]
-            }
-        }))
+        profileIdsOfOppositeType = profileIdsOfOppositeType.filter(
+            profile => profile.user.is_poster == isPosterOpposite,
+        )
+
+        const profilePlusDistance = await Promise.all(
+            profileIdsOfOppositeType.map(async profile => {
+                const targetZip = getZipCodeFromProfile(profile)
+                const distance = await this._compareDistance(
+                    userZip,
+                    targetZip,
+                    distanceUnit,
+                )
+                return {
+                    ...profile,
+                    distance: [distance.toFixed(2), distanceUnit],
+                }
+            }),
+        )
 
-        const distanceFilteredProfiles = filterByDistance(profilePlusDistance, maxDistance)
+        const distanceFilteredProfiles = filterByDistance(
+            profilePlusDistance,
+            maxDistance,
+        )
 
-        const scoredProfilesWithDistance = scoreAll(distanceFilteredProfiles, userProfile)
+        const scoredProfilesWithDistance = scoreAll(
+            distanceFilteredProfiles,
+            userProfile,
+        )
 
         // Order by score
         return scoredProfilesWithDistance.sort((a, b) => a.score - b.score)
     }
     async calcMatches() {
         const { Profile } = this.server.models()
-        
+
         // Grab all profiles with matchQueues
-        let allProfiles = await Profile.query()
-            .withGraphFetched('user')
-        
+        let allProfiles = await Profile.query().withGraphFetched('user')
+
         // !:FAKE Score everyone
-        allProfiles = allProfiles.map(profile => {
-            // Copy the profile and add a queue
-            const profilePlusFakeScore = {
-                ...profile,
-                queue: []
-            }
-            // Generate a random order of profile_ids 1:7
-            while (profilePlusFakeScore.queue.length < 4) {
-                profilePlusFakeScore.queue.push(rand(4))
-                profilePlusFakeScore.queue = [...new Set(profilePlusFakeScore.queue)]
-            }
-            //Instantiate a profile facade for each id for matching
-            profilePlusFakeScore.queue = profilePlusFakeScore.queue.map(randId => new ProfileFacade(randId))
-            
-            return profilePlusFakeScore
+        // const profileIds = allProfiles.map(profile => profile.profile_id)
+        const scoredProfileQueuesById = {}
+        for (let profile of allProfiles) {
+            const profileQueue = await this.scoreProfilesFor(
+                profile.profile_id,
+                10000,
+                'mile',
+            )
+            scoredProfileQueuesById[profile.profile_id] = profileQueue.map(
+                profile => profile.profile_id,
+            )
+        }
+        const allProfileFacadesWithQueue = allProfiles.map(profile => {
+            const profileFacadeQueue = scoredProfileQueuesById[
+                profile.profile_id
+            ].map(id => {
+                const subQueue = scoredProfileQueuesById[id].map(
+                    id => new ProfileFacade(id),
+                )
+                return new ProfileFacade(id, subQueue)
+            })
+            return new ProfileFacade(profile.profile_id, profileFacadeQueue)
         })
-        // ! FAKE -- END
+        // // ! FAKE -- END
+
+        const seekerIds = allProfiles
+            .filter(profile => profile.user.is_poster == 0)
+            .map(profile => profile.profile_id)
+        const posterIds = allProfiles
+            .filter(profile => profile.user.is_poster == 1)
+            .map(profile => profile.profile_id)
+
+        const yins = seekerIds.map(id => allProfileFacadesWithQueue[id])
+        const yangs = posterIds.map(id => allProfileFacadesWithQueue[id])
 
-        const seekers = allProfiles.filter(profile => profile.user.is_poster == 0)
-        const posters = allProfiles.filter(profile => profile.user.is_poster == 1)
-        const yins = seekers.map(profile => new ProfileFacade(profile.profile_id, profile.queue))
-        const yangs = posters.map(profile => new ProfileFacade(profile.profile_id, profile.queue))
         runMatch(yins, yangs)
         return yins
     }
     async _latLonForZip(zipCode) {
         const { ZipCode } = this.server.models()
 
-        const zipInfo = await ZipCode.query().findOne('zip_code_id', parseInt(zipCode))
-        const latitude = parseFloat(zipInfo.latitude)
-        const longitude =  parseFloat(zipInfo.longitude)
-        
-        return { latitude, longitude }
+        const zipInfo = await ZipCode.query().findOne(
+            'zip_code_id',
+            parseInt(zipCode),
+        )
+        if (!zipInfo) {
+            console.log(zipCode)
+        }
+
+        return {
+            latitude: parseFloat(zipInfo.latitude),
+            longitude: parseFloat(zipInfo.longitude),
+        }
     }
     /**
      * Get the distance between two zipcodes
      * @param {number} distance in miles
      */
     async _compareDistance(start_zip, end_zip, distanceUnit) {
-        if(!start_zip || !end_zip) return
-        
+        if (!start_zip || !end_zip) return
+
         const start = await this._latLonForZip(start_zip)
         const end = await this._latLonForZip(end_zip)
-        
+
         return haversine(start, end, { unit: distanceUnit })
     }
 }