Fix loads-only Interface type check

Author: rmosolgo

lib/graphql/schema/member/has_arguments.rb

@@ -370,8 +370,8 @@ def authorize_application_object(argument, id, context, loaded_application_objec
                   end
 
                   passes_possible_types_check = if context.types.loadable?(arg_loads_type, context)
-                    if arg_loads_type.kind.union?
-                      # This union is used in `loads:` but not otherwise visible to this query
+                    if arg_loads_type.kind.abstract?
+                      # This union/interface is used in `loads:` but not otherwise visible to this query
                       context.types.loadable_possible_types(arg_loads_type, context).include?(application_object_type)
                     else
                       true

lib/graphql/schema/warden.rb

@@ -237,11 +237,17 @@ def loadable?(type, _ctx)
           (type.respond_to?(:interfaces) ? interfaces(type).all? { |i| loadable?(i, _ctx) } : true)
       end
 
-      def loadable_possible_types(union_type, _ctx)
+      # This abstract type was determined to be used for `loads` only.
+      # All its possible types are valid possibilities here -- no filtering.
+      def loadable_possible_types(abstract_type, _ctx)
         @loadable_possible_types ||= read_through do |t|
-          t.possible_types # unfiltered
+          if t.is_a?(Class) # union
+            t.possible_types
+          else
+            @schema.possible_types(abstract_type)
+          end
         end
-        @loadable_possible_types[union_type]
+        @loadable_possible_types[abstract_type]
       end
 
       # @return [GraphQL::BaseType, nil] The type named `type_name`, if it exists (else `nil`)

spec/graphql/schema/interface_spec.rb

@@ -699,4 +699,72 @@ def pet(name:)
       assert_nil int2.comment
     end
   end
+
+  describe "when used as loads" do
+    class InterfaceLoadsSchema < GraphQL::Schema
+      module Sharpenable
+        include GraphQL::Schema::Interface
+        field :is_sharp, Boolean
+      end
+
+      class Pencil < GraphQL::Schema::Object
+        implements Sharpenable
+        field :color, String
+      end
+
+      class Chisel < GraphQL::Schema::Object
+        implements Sharpenable
+        field :width, Float
+      end
+
+      class Mallet < GraphQL::Schema::Object
+        field :weight, Float
+      end
+
+      class Tool < GraphQL::Schema::Union
+        possible_types(Mallet, Chisel, Pencil)
+      end
+
+      class Query < GraphQL::Schema::Object
+        field :tool, Tool do
+          argument :id, ID, loads: Sharpenable, as: :sharpenable_object
+        end
+
+        def tool(sharpenable_object:)
+          sharpenable_object
+        end
+      end
+
+      query(Query)
+      if ADD_WARDEN
+        use GraphQL::Schema::Warden
+      else
+        use GraphQL::Schema::Visibility
+      end
+
+      def self.resolve_type(abs_type, obj, ctx)
+        obj[:object_type]
+      end
+
+      def self.object_from_id(id, ctx)
+        case id
+        when "chisel"
+          { width: 5, is_sharp: true, object_type: Chisel }
+        when "pencil"
+          { color: "gray", is_sharp: false, object_type: Pencil }
+        when "mallet"
+          { weight: 16, object_type: Mallet }
+        else
+          nil
+        end
+      end
+    end
+
+    it "typechecks the loaded object" do
+      assert_equal({ "tool" => { "__typename" => "Chisel" } }, InterfaceLoadsSchema.execute("{ tool(id: \"chisel\") { __typename } }")["data"])
+      assert_equal({ "tool" => { "__typename" => "Pencil" } }, InterfaceLoadsSchema.execute("{ tool(id: \"pencil\") { __typename } }")["data"])
+
+      assert_equal(["No object found for `id: \"mallet\"`"], InterfaceLoadsSchema.execute("{ tool(id: \"mallet\") { __typename } }")["errors"].map {|e| e["message"]})
+    end
+  end
 end