:gears: migrating filtering logic to backend in new filter plugin

backend/lib/index.js

 const ProfilePlugin = require('./plugins/profile')
 const NotificationPlugin = require('./plugins/notification')
 const HealthPlugin = require('./plugins/health')
+const FilterPlugin = require('./plugins/filter')
 
 /**
  * A Hapi server instance
         await server.register(HealthPlugin, {
             routes: { prefix: '/health' },
         })
+
+        await server.register(FilterPlugin, {
+            routes: { prefix: '/filter' },
+        })
     },
 }

backend/lib/plugins/filter.js

+const FilterRoute = require('../routes/filter/get')
+
+module.exports = {
+    name: 'filter-plugin',
+    version: '1.0.0',
+    register: async(server, options) => {
+        await server.route(FilterRoute)
+    },
+}

backend/lib/routes/filter/get.js

+'use strict'
+
+const Joi = require('joi')
+const apiSchema = require('../../schemas/api')
+const errorSchema = require('../../schemas/errors')
+const filterSchema = require('../../schemas/filter')
+const profileSchema = require('../../schemas/profiles')
+
+const pluginConfig = {
+    handlerType: 'filter',
+    docs: {
+        description: 'Filter match pool',
+        notes: 'Returns filtered subset of match pool'
+    }
+}
+
+const validators = {
+    query: Joi.object({
+        match_pool: Joi.array().items(profileSchema.single),
+        distance: Joi.string(),
+        presence: Joi.string()
+    })
+}
+
+const responseSchemas = {
+    filteredMatchPool: filterSchema.matchPool, // array of profiles
+    error: errorSchema.single
+}
+
+module.exports = {
+    method: 'GET',
+    path: '/',
+    options:{
+        ...pluginConfig.docs,
+        tags: ['api'],
+        auth: false,
+        cors: true,
+        handler: async function (request, h) {
+            const { filterService } = request.server.services()
+            let matchPool = request.query.match_pool
+            matchPool = filterService.byDistance(matchPool, request.query.distance)
+            matchPool = filterService.byPresence(matchPool, request.query.presence)
+      
+            try {
+                return h.response(({
+                    ok:true,
+                    handler: pluginConfig.handlerType,
+                    data: matchPool
+                })).code(200)
+            } catch (err) {
+                return h
+                    .response({
+                        ok: false,
+                        handler: pluginConfig.handlerType,
+                        data: {error: `${err}`}
+                    })
+                    .code(409)
+            }
+        },
+        validate: {
+            ...validators,
+            failAction: 'log'
+        },
+
+        response: {
+            status: {
+                200: apiSchema.single
+                    .append({
+                        data: responseSchemas.filteredMatchPool,
+                    })
+                    .label('api_single_res'),
+                409: apiSchema.single
+                    .append({
+                        data: responseSchemas.error,
+                    })
+                    .label('error_single_res'),
+            },
+        },
+    },
+}

backend/lib/schemas/filter.js

+'use strict'
+
+const Joi = require('joi')
+const profileSchema = require('./profiles')
+
+module.exports = { 
+    matchPool: Joi.array().items(profileSchema.single).label('matchPool')
+}

backend/lib/services/filter.js

         return zipcoder.getZipCodeFromProfile(profile) ? true : false
     })
 }
-const byMaxDistance = (profileList, max) => {
+const byDistance = (profileList, max) => {
     return profileList.filter(profile => {
         const profileDistance = Math.floor(parseFloat(profile.distance) * 100)
         const adjustedMaxDistance = Math.floor(parseFloat(max) * 100)
 module.exports = {
     byProfileType,
     byNullZip,
-    byMaxDistance,
+    byDistance,
     byDuration,
     byPresence,
     byCertifications,

backend/lib/services/profile/index.js

             distanceUnit,
             userZip,
         )
-        matchPool = filter.byMaxDistance(matchPool, maxDistance)
+        matchPool = filter.byDistance(matchPool, maxDistance)
         matchPool = filter.byDuration(matchPool, duration)
         matchPool = filter.byPresence(matchPool, presence)
         matchPool = filter.byCertifications(matchPool, certifications)
         await this._setTagLookup()
         let associations = groupingId
             ? await TagAssociation.query()
-                  .where('grouping_id', groupingId)
-                  .andWhere('profile_id', profileId)
+                .where('grouping_id', groupingId)
+                .andWhere('profile_id', profileId)
             : await TagAssociation.query().andWhere('profile_id', profileId)
         return associations
             .map(assoc => ({