fix(Schema#resolve_type) also thread Query::Context through type resolution

Author: rmosolgo

guides/defining_your_schema.md

@@ -51,16 +51,15 @@ CoffeeType = GraphQL::ObjectType.define do
 end
 ```
 
-In order for your schema to expose members of an interface, it must be able to determine the GraphQL type for a given Ruby object. `InterfaceType` has a default `resolve_type` definition, or you can provide your own. Here's the default:
+In order for your schema to expose members of an interface, it must be able to determine the GraphQL type for a given Ruby object. You must define `resolve_type` in your schema:
 
 ```ruby
-BeverageInterface = GraphQL::InterfaceType.define do
+MySchema = GraphQL::Schema.define do
  # ...
  resolve_type -> (object, ctx) {
+   # for example, look up types by class name
    type_name = object.class.name
-   # you can access the interface's `possible_types` inside the proc
-   possible_types = ctx.schema.possible_types(self)
-   possible_types.find {|t| t.name == type_name}
+   MySchema.types[type_name]
  }
 end
 ```
@@ -77,18 +76,7 @@ MediaSearchResultUnion = GraphQL::UnionType.define do
 end
 ```
 
-In order to expose a union, you must also define how the concrete type of each object can be determined. `UnionType` provides a default, shown here:
-
-```ruby
-MediaSearchResultUnion = GraphQL::UnionType.define do
-  # This is the default if you don't provide a custom `resolve_type` proc:
-  resolve_type -> (object, ctx) {
-    type_name = object.class.name
-    # You can access the union's `possible_types` inside the proc
-    possible_types.find {|t| t.name == type_name}
-  }
-end
-```
+In order to expose a union, you must also define how the concrete type of each object can be determined. This is defined with `Schema`'s `resolve_type` function (see Interface docs).
 
 ### Enum Types
 
@@ -379,13 +367,13 @@ end
 Access `type.metadata` later:
 
 ```ruby
-SearchResultUnion = GraphQL::Union.define do
+MySchema = GraphQL::Schema.define do
   # ...
   # Use the type's declared `resolves_to_class_names`
   # to figure out if `obj` is a member of that type
   resolve_type -> (obj, ctx) {
     class_name = obj.class.name
-    possible_types.find { |type| type.metadata[:resolves_to_class_names].include?(class_name) }
+    MySchema.types.values.find { |type| type.metadata[:resolves_to_class_names].include?(class_name) }
   }
 end
 ```

lib/graphql/base_type.rb

@@ -56,7 +56,7 @@ def legacy_resolve_type(object, ctx)
         if @resolve_type_proc
           resolve_type(object, ctx)
         else
-          ctx.schema.resolve_type(object)
+          ctx.schema.resolve_type(object, ctx)
         end
       end
 

lib/graphql/object_type.rb

@@ -1,12 +1,5 @@
 module GraphQL
-  # An object type has _fields_ which expose values from your application.
-  # The fields are _typed_. Fields may return object types (including the same object type).
-  #
-  # See {GraphQL::Field} for details about defining fields.
-  #
-  # Objects which fulfill many of the same fields may implement _interfaces_, see {GraphQL::InterfaceType}.
-  #
-  # ObjectTypes which occur in the same place in the schema may be grouped in a {GraphQL::UnionType}.
+  # This type exposes fields on an object.
   #
   # @example defining a type for your IMDB clone
   #   MovieType = GraphQL::ObjectType.define do

lib/graphql/schema.rb

@@ -199,9 +199,9 @@ def execution_strategy_for_operation(operation)
     # Determine the GraphQL type for a given object.
     # This is required for unions and interfaces (include Relay's node interface)
     # @return [GraphQL::ObjectType] The type for exposing `object` in GraphQL
-    def resolve_type(object)
+    def resolve_type(object, ctx)
       ensure_defined
-      type_result = @resolve_type_proc.call(object)
+      type_result = @resolve_type_proc.call(object, ctx)
       if type_result.nil?
         nil
       elsif !type_result.is_a?(GraphQL::BaseType)

spec/graphql/query/serial_execution/value_resolution_spec.rb

@@ -31,7 +31,7 @@
 
     GraphQL::Schema.define do
       query(query_root)
-      resolve_type -> (obj) { nil }
+      resolve_type -> (obj, ctx) { nil }
     end
   }
 

spec/graphql/schema_spec.rb

@@ -24,15 +24,15 @@
   describe "#resolve_type" do
     describe "when the return value is nil" do
       it "returns nil" do
-        result = StarWarsSchema.resolve_type(123)
+        result = StarWarsSchema.resolve_type(123, nil)
         assert_equal(nil, result)
       end
     end
 
     describe "when the return value is not a BaseType" do
       it "raises an error " do
         err = assert_raises(RuntimeError) {
-          StarWarsSchema.resolve_type(:test_error)
+          StarWarsSchema.resolve_type(:test_error, nil)
         }
         assert_includes err.message, "not_a_type (Symbol)"
       end

spec/support/dairy_app.rb

@@ -342,7 +342,7 @@ def self.create(type:, data:)
 
   rescue_from(NoSuchDairyError) { |err| err.message  }
 
-  resolve_type -> (obj) {
+  resolve_type -> (obj, ctx) {
     DummySchema.types[obj.class.name]
   }
 end

spec/support/star_wars_schema.rb

@@ -205,7 +205,7 @@ def upcased_parent_name
   query(QueryType)
   mutation(MutationType)
   node_identification(NodeIdentification)
-  resolve_type -> (object) {
+  resolve_type -> (object, ctx) {
     if object == :test_error
       :not_a_type
     elsif object.is_a?(Base)