Add support for geodistance search to GraphQL

** Why are these changes being introduced:

* We recently added support for a geodistance search to the OpenSearch
  model, and now we need to enable that support within GraphQL.

** Relevant ticket(s):

* https://mitlibraries.atlassian.net/browse/gdt-162

** How does this address that need:

* This defines a Geodistance type, with three fields: a distance (as a
  string), a latitude value (a float), and a longitude value (also a
  float).
* The Geodistance type is then added as an argument of the search field,
  allowing GraphQL consumers to conduct searches geospatially.
* We add three tests to support this functionality:
  - Geospatial search alone
  - Geospatial search combined with a search term
  - Confirming that the geodistance type imposes a requirement for those
    three fields (by omitting the distance parameter)

** Document any side effects to this change:

* This may be the first time we are using Float as a field type in
  GraphQL? It seems that we use String elsewhere even when the input is
  numeric. I'm not sure this is good pracrice, so I wanted to propose
  that we use a float here.

* There are no tests to confirm that the latitude and longitude fields
  are required, as it seems unlikely that this requirement would not be
  met in practice. The distance parameter feels the most likely to be
  omitted.

Author: matt-bernhardt

app/graphql/types/geodistance_type.rb

@@ -0,0 +1,8 @@
+module Types
+  class GeodistanceType < Types::BaseInputObject
+    description 'Search within a certain distance of a given latitude and longitude'
+    argument :distance, String, description: 'Search distance to the location? (include units; i.e. "100km" or "50mi")'
+    argument :latitude, Float, description: 'A decimal between -90.0 and 90.0 (Southern hemisphere is negative)'
+    argument :longitude, Float, description: 'A decimal between -180.0 and 180.0 (Western hemisphere is negative)'
+  end
+end

app/graphql/types/query_type.rb

@@ -41,6 +41,8 @@ def record_id(id:, index:)
       argument :funding_information, String, required: false, default_value: nil,
                                              description: 'Search by funding information; e.g., funding source, ' \
                                                           'award name, etc.'
+      argument :geodistance, GeodistanceType, required: false, default_value: nil,
+                                              description: 'Search within a certain distance of a specific location'
       argument :identifiers, String, required: false, default_value: nil,
                                      description: 'Search by unique indentifier; e.g., ISBN, DOI, etc.'
       argument :locations, String, required: false, default_value: nil, description: 'Search by locations'
@@ -77,10 +79,10 @@ def record_id(id:, index:)
                                                         'for a list of possible values'
     end
 
-    def search(searchterm:, citation:, contributors:, funding_information:, identifiers:, locations:, subjects:,
-               title:, index:, source:, from:, **filters)
-      query = construct_query(searchterm, citation, contributors, funding_information, identifiers, locations,
-                              subjects, title, source, filters)
+    def search(searchterm:, citation:, contributors:, funding_information:, geodistance:, identifiers:, locations:,
+               subjects:, title:, index:, source:, from:, **filters)
+      query = construct_query(searchterm, citation, contributors, funding_information, geodistance, identifiers,
+                              locations, subjects, title, source, filters)
 
       results = Opensearch.new.search(from, query, Timdex::OSClient, highlight_requested?, index)
 
@@ -109,13 +111,14 @@ def inject_hits_fields_into_source(hits)
       modded_sources
     end
 
-    def construct_query(searchterm, citation, contributors, funding_information, identifiers, locations, subjects,
-                        title, source, filters)
+    def construct_query(searchterm, citation, contributors, funding_information, geodistance, identifiers, locations,
+                        subjects, title, source, filters)
       query = {}
       query[:q] = searchterm
       query[:citation] = citation
       query[:contributors] = contributors
       query[:funding_information] = funding_information
+      query[:geodistance] = geodistance
       query[:identifiers] = identifiers
       query[:locations] = locations
       query[:subjects] = subjects

test/controllers/graphql_controller_v2_test.rb

@@ -183,6 +183,75 @@ def setup
     end
   end
 
+  test 'graphqlv2 geodistance search returns results' do
+    VCR.use_cassette('graphqlv2 geodistance') do
+      post '/graphql', params: { query: '{
+                                  search(geodistance: {
+                                    distance: "100000km",
+                                    latitude: 42.3596653,
+                                    longitude: -71.0921384
+                                  }) {
+                                    hits
+                                    records {
+                                      title
+                                    }
+                                  }
+                                }' }
+      assert_equal(200, response.status)
+      json = JSON.parse(response.body)
+
+      assert_nil(json['errors'])
+      assert(json['data']['search']['hits'].positive?)
+    end
+  end
+
+  test 'graphqlv2 geodistance search fails without three required arguments' do
+    post '/graphql', params: { query: '{
+                                search(geodistance: {
+                                  latitude: 42.3596653,
+                                  longitude: -71.0921384
+                                }) {
+                                  hits
+                                  records {
+                                    title
+                                  }
+                                }
+                              }' }
+    assert_equal(200, response.status)
+    json = JSON.parse(response.body)
+
+    assert(json['errors'].length.positive?)
+    assert_equal(
+      "Argument 'distance' on InputObject 'Geodistance' is required. Expected type String!",
+      json['errors'].first['message']
+    )
+  end
+
+  test 'graphqlv2 geodistance search with another argument' do
+    VCR.use_cassette('graphqlv2 geodistance with searchterm') do
+      post '/graphql', params: { query: '{
+                                  search(
+                                    searchterm: "train stations",
+                                    geodistance: {
+                                      distance: "100000km",
+                                      latitude: 42.3596653,
+                                      longitude: -71.0921384
+                                    }
+                                  ) {
+                                    hits
+                                    records {
+                                      title
+                                    }
+                                  }
+                                }' }
+      assert_equal(200, response.status)
+      json = JSON.parse(response.body)
+
+      assert_nil(json['errors'])
+      assert(json['data']['search']['hits'].positive?)
+    end
+  end
+
   test 'graphqlv2 search aggregations' do
     VCR.use_cassette('graphql v2 search data') do
       post '/graphql', params: { query: '{