refactor(Typecast) never check the value, only compare types

Author: rmosolgo

lib/graphql/execution/typecast.rb

@@ -2,10 +2,10 @@ module GraphQL
   module Execution
     # GraphQL object `{value, current_type}` can be cast to `potential_type` when:
     # - `current_type == potential_type`
-    # - `current_type` is a union and it resolves `value` to `potential_type`
-    # - `potential_type` is a union and `current_type` is a member
-    # - `current_type` is an interface and it resolves `value` to `potential_type`
-    # - `potential_type` is an interface and `current_type` implements that interface
+    # - `current_type` is a union and it contains `potential_type`
+    # - `potential_type` is a union and it contains `current_type`
+    # - `current_type` is an interface and `potential_type` implements it
+    # - `potential_type` is an interface and `current_type` implements it
     module Typecast
       # While `value` is exposed by GraphQL as an instance of `current_type`,
       # should it _also_ be treated as an instance of `potential_type`?
@@ -17,16 +17,16 @@ module Typecast
       # @param [GraphQL::BaseType] can `value` be exposed using this type?
       # @param [GraphQL::Query::Context] the context for the current query
       # @return [Boolean] true if `value` be evaluated as a `potential_type`
-      def self.compatible?(value, current_type, potential_type, query_ctx)
+      def self.compatible?(current_type, potential_type, query_ctx)
         if current_type == potential_type
           true
         elsif current_type.kind.union?
-          current_type.resolve_type(value, query_ctx) == potential_type
+          current_type.possible_types.include?(potential_type)
         elsif potential_type.kind.union?
           potential_type.include?(current_type)
-        elsif current_type.kind.interface?
-          current_type.resolve_type(value, query_ctx) == potential_type
-        elsif potential_type.kind.interface?
+        elsif current_type.kind.interface? && potential_type.kind.object?
+          potential_type.interfaces.include?(current_type)
+        elsif potential_type.kind.interface? && current_type.kind.object?
           current_type.interfaces.include?(potential_type)
         else
           false

lib/graphql/query/serial_execution/selection_resolution.rb

@@ -13,7 +13,7 @@ def initialize(target, type, irep_node, execution_context)
 
         def result
           irep_node.children.each_with_object({}) do |(name, irep_node), memo|
-            if GraphQL::Execution::DirectiveChecks.include?(irep_node, execution_context.query) && applies_to_type?(irep_node, type, target)
+            if GraphQL::Execution::DirectiveChecks.include?(irep_node, execution_context.query) && applies_to_type?(irep_node, type)
               field_result = execution_context.strategy.field_resolution.new(
                 irep_node,
                 type,
@@ -27,9 +27,9 @@ def result
 
         private
 
-        def applies_to_type?(irep_node, current_type, value)
+        def applies_to_type?(irep_node, current_type)
           irep_node.definitions.any? { |potential_type, field_defn|
-            GraphQL::Execution::Typecast.compatible?(value, current_type, potential_type, execution_context.query.context)
+            GraphQL::Execution::Typecast.compatible?(current_type, potential_type, execution_context.query.context)
           }
         end
       end

spec/graphql/execution/typecast_spec.rb

@@ -8,42 +8,44 @@
   let(:context) { GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil) }
 
   def compatible?(*args)
-     GraphQL::Execution::Typecast.compatible?(*args)
-   end
+    GraphQL::Execution::Typecast.compatible?(*args)
+  end
+
   it "resolves correctly when both types are the same" do
-    assert compatible?(milk_value, MilkType, MilkType, context)
-    assert !compatible?(milk_value, MilkType, CheeseType, context)
+    assert compatible?(MilkType, MilkType, context)
+
+    assert !compatible?(MilkType, CheeseType, context)
   end
 
   it "resolves a union type to a matching member" do
-    assert compatible?(milk_value, DairyProductUnion, MilkType, context)
-    assert compatible?(cheese_value, DairyProductUnion, CheeseType, context)
+    assert compatible?(DairyProductUnion, MilkType, context)
+    assert compatible?(DairyProductUnion, CheeseType, context)
 
-    assert !compatible?(cheese_value, DairyProductUnion, MilkType, context)
-    assert !compatible?(nil, DairyProductUnion, MilkType, context)
+    assert !compatible?(DairyProductUnion, GraphQL::INT_TYPE, context)
+    assert !compatible?(DairyProductUnion, HoneyType, context)
   end
 
   it "resolves correcty when potential type is UnionType and current type is a member of that union" do
-    assert compatible?(milk_value, MilkType, DairyProductUnion, context)
-    assert compatible?(cheese_value, CheeseType, DairyProductUnion, context)
+    assert compatible?(MilkType, DairyProductUnion, context)
+    assert compatible?(CheeseType, DairyProductUnion, context)
 
-    # assert !compatible?(nil, CheeseType, DairyProductUnion, context)
-    # assert !compatible?(cheese_value, MilkType, DairyProductUnion, context)
+    assert !compatible?(QueryType, DairyProductUnion, context)
+    assert !compatible?(EdibleInterface, DairyProductUnion, context)
   end
 
   it "resolves an object type to one of its interfaces" do
-    assert compatible?(cheese_value, CheeseType, EdibleInterface, context)
-    assert compatible?(milk_value, MilkType, EdibleInterface, context)
+    assert compatible?(CheeseType, EdibleInterface, context)
+    assert compatible?(MilkType, EdibleInterface, context)
 
-    # assert !compatible?(nil, MilkType, EdibleInterface, context)
-    # assert !compatible?(milk_value, CheeseType, EdibleInterface, context)
+    assert !compatible?(QueryType, EdibleInterface, context)
+    assert !compatible?(LocalProductInterface, EdibleInterface, context)
   end
 
   it "resolves an interface to a matching member" do
-    assert compatible?(cheese_value, EdibleInterface, CheeseType, context)
-    assert compatible?(milk_value, EdibleInterface, MilkType, context)
+    assert compatible?(EdibleInterface, CheeseType, context)
+    assert compatible?(EdibleInterface, MilkType, context)
 
-    assert !compatible?(nil, EdibleInterface, MilkType, context)
-    assert !compatible?(cheese_value, EdibleInterface, MilkType, context)
+    assert !compatible?(EdibleInterface, GraphQL::STRING_TYPE, context)
+    assert !compatible?(EdibleInterface, DairyProductInputType, context)
   end
 end