graphql 2.3.4 → 2.3.6

data/lib/graphql/execution/interpreter/runtime.rb

@@ -65,16 +65,6 @@ module GraphQL
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
-        def tap_or_each(obj_or_array)
-          if obj_or_array.is_a?(Array)
-            obj_or_array.each do |item|
-              yield(item, true)
-            end
-          else
-            yield(obj_or_array, false)
-          end
-        end
-
         # This _begins_ the execution. Some deferred work
         # might be stored up in lazies.
         # @return [void]
@@ -84,7 +74,8 @@ module GraphQL
           root_type = schema.root_type_for_operation(root_op_type)
           runtime_object = root_type.wrap(query.root_value, context)
           runtime_object = schema.sync_lazy(runtime_object)
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false)
+          is_eager = root_op_type == "mutation"
+          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager)
           st = get_current_runtime_state
           st.current_result = @response
 
@@ -93,17 +84,9 @@ module GraphQL
             @response = nil
           else
             call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              gathered_selections = gather_selections(runtime_object, root_type, root_operation.selections)
-              # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
-              # require isolation during execution (because of runtime directives). In that case,
-              # make a new, isolated result hash for writing the result into. (That isolated response
-              # is eventually merged back into the main response)
-              #
-              # Otherwise, `gathered_selections` is a hash of selections which can be
-              # directly evaluated and the results can be written right into the main response hash.
-              tap_or_each(gathered_selections) do |selections, is_selection_array|
+              each_gathered_selections(@response) do |selections, is_selection_array|
                 if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false)
+                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager)
                   final_response = @response
                 else
                   selection_response = @response
@@ -112,12 +95,10 @@ module GraphQL
 
                 @dataloader.append_job {
                   evaluate_selections(
-                    root_op_type == "mutation",
                     selections,
                     selection_response,
                     final_response,
                     nil,
-                    nil,
                   )
                 }
               end
@@ -126,6 +107,17 @@ module GraphQL
           nil
         end
 
+        def each_gathered_selections(response_hash)
+          gathered_selections = gather_selections(response_hash.graphql_application_value, response_hash.graphql_result_type, response_hash.graphql_selections)
+          if gathered_selections.is_a?(Array)
+            gathered_selections.each do |item|
+              yield(item, true)
+            end
+          else
+            yield(gathered_selections, false)
+          end
+        end
+
         def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = {})
           selections.each do |node|
             # Skip gathering this if the directive says so
@@ -138,7 +130,7 @@ module GraphQL
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
               # use an array to hold all selections,
-              # otherise, use the single node to represent the selection
+              # otherwise, use the single node to represent the selection
               if selections
                 # This field was already selected at least once,
                 # add this node to the list of selections
@@ -203,7 +195,7 @@ module GraphQL
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
         # @return [void]
-        def evaluate_selections(is_eager_selection, gathered_selections, selections_result, target_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
+        def evaluate_selections(gathered_selections, selections_result, target_result, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state ||= get_current_runtime_state
           runtime_state.current_result_name = nil
           runtime_state.current_result = selections_result
@@ -218,7 +210,7 @@ module GraphQL
             gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
               @dataloader.append_job {
                 evaluate_selection(
-                  result_name, field_ast_nodes_or_ast_node, is_eager_selection, selections_result, parent_object
+                  result_name, field_ast_nodes_or_ast_node, selections_result
                 )
                 finished_jobs += 1
                 if target_result && finished_jobs == enqueued_jobs
@@ -228,7 +220,7 @@ module GraphQL
               # Field resolution may pause the fiber,
               # so it wouldn't get to the `Resolve` call that happens below.
               # So instead trigger a run from this outer context.
-              if is_eager_selection
+              if selections_result.graphql_is_eager
                 @dataloader.clear_cache
                 @dataloader.run
                 @dataloader.clear_cache
@@ -239,7 +231,7 @@ module GraphQL
         end
 
         # @return [void]
-        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, is_eager_field, selections_result, parent_object) # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_result) # rubocop:disable Metrics/ParameterLists
           return if selections_result.graphql_dead
           # As a performance optimization, the hash key will be a `Node` if
           # there's only one selection of the field. But if there are multiple
@@ -266,28 +258,27 @@ module GraphQL
             owner_object = field_defn.owner.wrap(owner_object, context)
           end
 
-          return_type = field_defn.type
           if !field_defn.any_arguments?
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type.non_null?, runtime_state
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
             end
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
               runtime_state = get_current_runtime_state # This might be in a different fiber
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, result_name, selections_result, runtime_state)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, runtime_state)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
-            return_type_non_null = return_type.non_null?
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              return_type_non_null = field_defn.type.non_null?
               continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
             end
@@ -326,7 +317,8 @@ module GraphQL
                   # to the keyword args hash _before_ freezing everything.
                   extra_args[:argument_details] = :__arguments_add_self
                 when :parent
-                  extra_args[:parent] = parent_object
+                  parent_result = selection_result.graphql_parent
+                  extra_args[:parent] = parent_result&.graphql_application_value&.object
                 else
                   extra_args[extra] = field_defn.fetch_extra(extra, context)
                 end
@@ -337,11 +329,11 @@ module GraphQL
               resolved_arguments.keyword_arguments
             end
 
-            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)
+            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)
           end
         end
 
-        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           runtime_state.current_field = field_defn
           runtime_state.current_arguments = resolved_arguments
           runtime_state.current_result_name = result_name
@@ -384,7 +376,8 @@ module GraphQL
             end
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
               owner_type = selection_result.graphql_result_type
-              continue_value = continue_value(inner_result, field_defn, return_type_non_null, ast_node, result_name, selection_result)
+              return_type = field_defn.type
+              continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
               if HALT != continue_value
                 was_scoped = runtime_state.was_authorized_by_scope_items
                 runtime_state.was_authorized_by_scope_items = nil
@@ -395,7 +388,7 @@ module GraphQL
           # If this field is a root mutation field, immediately resolve
           # all of its child fields before moving on to the next root mutation field.
           # (Subselections of this mutation will still be resolved level-by-level.)
-          if is_eager_field
+          if selection_result.graphql_is_eager
             Interpreter::Resolve.resolve_all([field_result], @dataloader)
           end
         end
@@ -607,21 +600,11 @@ module GraphQL
             after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_object, runtime_state|
               continue_value = continue_value(inner_object, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null)
+                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
-
-                gathered_selections = gather_selections(continue_value, current_type, next_selections)
-                # There are two possibilities for `gathered_selections`:
-                # 1. All selections of this object should be evaluated together (there are no runtime directives modifying execution).
-                #    This case is handled below, and the result can be written right into the main `response_hash` above.
-                #    In this case, `gathered_selections` is a hash of selections.
-                # 2. Some selections of this object have runtime directives that may or may not modify execution.
-                #    That part of the selection is evaluated in an isolated way, writing into a sub-response object which is
-                #    eventually merged into the final response. In this case, `gathered_selections` is an array of things to run in isolation.
-                #    (Technically, it's possible that one of those entries _doesn't_ require isolation.)
-                tap_or_each(gathered_selections) do |selections, is_selection_array|
+                each_gathered_selections(response_hash) do |selections, is_selection_array|
                   if is_selection_array
-                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null)
+                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false)
                     final_result = response_hash
                   else
                     this_result = response_hash
@@ -629,11 +612,9 @@ module GraphQL
                   end
 
                   evaluate_selections(
-                    false,
                     selections,
                     this_result,
                     final_result,
-                    owner_object.object,
                     runtime_state,
                   )
                 end
@@ -644,7 +625,7 @@ module GraphQL
             # This is true for objects, unions, and interfaces
             use_dataloader_job = !inner_type.unwrap.kind.input?
             inner_type_non_null = inner_type.non_null?
-            response_list = GraphQLResultArray.new(result_name, current_type, response_list, selection_result, is_non_null)
+            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false)
             set_result(selection_result, result_name, response_list, true, is_non_null)
             idx = nil
             list_value = begin
@@ -654,10 +635,10 @@ module GraphQL
                 idx += 1
                 if use_dataloader_job
                   @dataloader.append_job do
-                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state)
+                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                   end
                 else
-                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state)
+                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state)
                 end
               end
 
@@ -688,7 +669,7 @@ module GraphQL
           end
         end
 
-        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
@@ -696,7 +677,7 @@ module GraphQL
             after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list, runtime_state: runtime_state) do |inner_inner_value, runtime_state|
               continue_value = continue_value(inner_inner_value, field, inner_type_non_null, ast_node, this_idx, response_list)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list, was_scoped, runtime_state)
+                continue_field(continue_value, owner_type, field, inner_type, ast_node, response_list.graphql_selections, false, owner_object, arguments, this_idx, response_list, was_scoped, runtime_state)
               end
             end
           end

data/lib/graphql/execution/interpreter.rb

@@ -20,7 +20,7 @@ module GraphQL
         # @param queries [Array<GraphQL::Query, Hash>]
         # @param context [Hash]
         # @param max_complexity [Integer, nil]
-        # @return [Array<Hash>] One result per query
+        # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
           queries = query_options.map do |opts|
             case opts
@@ -40,7 +40,7 @@ module GraphQL
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)

data/lib/graphql/language/nodes.rb

@@ -274,6 +274,8 @@ module GraphQL
           ]
 
           def generate_initialize
+            return if method_defined?(:marshal_load, false) # checking for `:initialize` doesn't work right
+
             scalar_method_names = @scalar_methods
             # TODO: These probably should be scalar methods, but `types` returns an array
             [:types, :description].each do |extra_method|
@@ -392,16 +394,6 @@ module GraphQL
 
       # A single selection in a GraphQL query.
       class Field < AbstractNode
-        scalar_methods :name, :alias
-        children_methods({
-          arguments: GraphQL::Language::Nodes::Argument,
-          selections: GraphQL::Language::Nodes::Field,
-          directives: GraphQL::Language::Nodes::Directive,
-        })
-
-        # @!attribute selections
-        #   @return [Array<Nodes::Field>] Selections on this object (or empty array if this is a scalar field)
-
         def initialize(name: nil, arguments: NONE, directives: NONE, selections: NONE, field_alias: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
           @name = name
           @arguments = arguments || NONE
@@ -428,24 +420,19 @@ module GraphQL
           @line, @col, @filename, @name, @arguments, @directives, @selections, @alias = values
         end
 
-        # Override this because default is `:fields`
-        self.children_method_name = :selections
-      end
-
-      # A reusable fragment, defined at document-level.
-      class FragmentDefinition < AbstractNode
-        scalar_methods :name, :type
+        scalar_methods :name, :alias
         children_methods({
+          arguments: GraphQL::Language::Nodes::Argument,
           selections: GraphQL::Language::Nodes::Field,
           directives: GraphQL::Language::Nodes::Directive,
         })
 
-        self.children_method_name = :definitions
-        # @!attribute name
-        #   @return [String] the identifier for this fragment, which may be applied with `...#{name}`
+        # Override this because default is `:fields`
+        self.children_method_name = :selections
+      end
 
-        # @!attribute type
-        #   @return [String] the type condition for this fragment (name of type which it may apply to)
+      # A reusable fragment, defined at document-level.
+      class FragmentDefinition < AbstractNode
         def initialize(name: nil, type: nil, directives: NONE, selections: NONE, filename: nil, pos: nil, source: nil, line: nil, col: nil)
           @name = name
           @type = type
@@ -469,6 +456,14 @@ module GraphQL
         def marshal_load(values)
           @line, @col, @filename, @name, @type, @directives, @selections = values
         end
+
+        scalar_methods :name, :type
+        children_methods({
+          selections: GraphQL::Language::Nodes::Field,
+          directives: GraphQL::Language::Nodes::Directive,
+        })
+
+        self.children_method_name = :definitions
       end
 
       # Application of a named fragment in a selection

data/lib/graphql/language/parser.rb

@@ -379,7 +379,12 @@ module GraphQL
             v_loc = pos
             description = if at?(:STRING); string_value; end
             defn_loc = pos
-            enum_value = parse_enum_name
+            # Any identifier, but not true, false, or null
+            enum_value = if at?(:TRUE) || at?(:FALSE) || at?(:NULL)
+              expect_token(:IDENTIFIER)
+            else
+              parse_name
+            end
             v_directives = parse_directives
             list << EnumValueDefinition.new(pos: v_loc, definition_pos: defn_loc, description: description, name: enum_value, directives: v_directives, filename: @filename, source: self)
           end
@@ -615,9 +620,6 @@ module GraphQL
         when :ON
           advance_token
           "on"
-        when :DIRECTIVE
-          advance_token
-          "directive"
         when :EXTEND
           advance_token
           "extend"
@@ -634,15 +636,6 @@ module GraphQL
         end
       end
 
-      # Any identifier, but not true, false, or null
-      def parse_enum_name
-        if at?(:TRUE) || at?(:FALSE) || at?(:NULL)
-          expect_token(:IDENTIFIER)
-        else
-          parse_name
-        end
-      end
-
       def parse_type_name
         TypeName.new(pos: pos, name: parse_name, filename: @filename, source: self)
       end
@@ -733,6 +726,54 @@ module GraphQL
           loc = pos
           advance_token
           VariableIdentifier.new(pos: loc, name: parse_name, filename: @filename, source: self)
+        when :SCHEMA
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "schema", filename: @filename, source: self)
+        when :SCALAR
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "scalar", filename: @filename, source: self)
+        when :IMPLEMENTS
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "implements", filename: @filename, source: self)
+        when :INTERFACE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "interface", filename: @filename, source: self)
+        when :UNION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "union", filename: @filename, source: self)
+        when :ENUM
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "enum", filename: @filename, source: self)
+        when :INPUT
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "input", filename: @filename, source: self)
+        when :DIRECTIVE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "directive", filename: @filename, source: self)
+        when :TYPE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "type", filename: @filename, source: self)
+        when :QUERY
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "query", filename: @filename, source: self)
+        when :MUTATION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "mutation", filename: @filename, source: self)
+        when :SUBSCRIPTION
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "subscription", filename: @filename, source: self)
+        when :FRAGMENT
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "fragment", filename: @filename, source: self)
+        when :REPEATABLE
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "repeatable", filename: @filename, source: self)
+        when :ON
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "on", filename: @filename, source: self)
+        when :EXTEND
+          advance_token
+          Nodes::Enum.new(pos: pos, name: "extend", filename: @filename, source: self)
         else
           expect_token(:VALUE)
         end

data/lib/graphql/query/validation_pipeline.rb

@@ -100,10 +100,10 @@ module GraphQL
           # Depending on the analysis engine, we must use different analyzers
           # remove this once everything has switched over to AST analyzers
           if max_depth
-            qa << GraphQL::Analysis::AST::MaxQueryDepth
+            qa << GraphQL::Analysis::MaxQueryDepth
           end
           if max_complexity
-            qa << GraphQL::Analysis::AST::MaxQueryComplexity
+            qa << GraphQL::Analysis::MaxQueryComplexity
           end
           qa
         else

data/lib/graphql/query.rb

@@ -222,7 +222,7 @@ module GraphQL
     end
 
     # Get the result for this query, executing it once
-    # @return [Hash] A GraphQL response, with `"data"` and/or `"errors"` keys
+    # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
         Execution::Interpreter.run_all(@schema, [self], context: @context)

data/lib/graphql/rubocop/graphql/base_cop.rb

@@ -9,7 +9,7 @@ module GraphQL
 
         # Return the source of `send_node`, but without the keyword argument represented by `pair_node`
         def source_without_keyword_argument(send_node, pair_node)
-          # work back to the preceeding comma
+          # work back to the preceding comma
           first_pos = pair_node.location.expression.begin_pos
           end_pos = pair_node.location.expression.end_pos
           node_source = send_node.source_range.source

data/lib/graphql/schema/addition.rb

@@ -12,7 +12,7 @@ module GraphQL
         @possible_types = {}
         @types = {}
         @union_memberships = {}
-        @references = Hash.new { |h, k| h[k] = [] }
+        @references = Hash.new { |h, k| h[k] = Set.new }
         @arguments_with_default_values = []
         add_type_and_traverse(new_types)
       end
@@ -20,7 +20,7 @@ module GraphQL
       private
 
       def references_to(thing, from:)
-        @references[thing] << from
+        @references[thing].add(from)
       end
 
       def get_type(name)
@@ -95,7 +95,7 @@ module GraphQL
             # It's a union with possible_types
             # Replace the item by class name
             owner.assign_type_membership_object_type(type)
-            @possible_types[owner.graphql_name] = owner.possible_types
+            @possible_types[owner] = owner.possible_types
           elsif type.kind.interface? && (owner.kind.object? || owner.kind.interface?)
             new_interfaces = []
             owner.interfaces.each do |int_t|
@@ -110,7 +110,7 @@ module GraphQL
             end
             owner.implements(*new_interfaces)
             new_interfaces.each do |int|
-              pt = @possible_types[int.graphql_name] ||= []
+              pt = @possible_types[int] ||= []
               if !pt.include?(owner) && owner.is_a?(Class)
                 pt << owner
               end
@@ -126,6 +126,7 @@ module GraphQL
           @types[type.graphql_name] = type
         when GraphQL::Schema::Field, GraphQL::Schema::Argument
           orig_type = owner.type
+          unwrapped_t = type
           # Apply list/non-null wrapper as needed
           if orig_type.respond_to?(:of_type)
             transforms = []
@@ -142,6 +143,7 @@ module GraphQL
             transforms.reverse_each { |t| type = type.public_send(t) }
           end
           owner.type = type
+          references_to(unwrapped_t, from: owner)
         else
           raise "Unexpected update: #{owner.inspect} #{type.inspect}"
         end
@@ -164,7 +166,9 @@ module GraphQL
           @directives << type
           type.all_argument_definitions.each do |arg|
             arg_type = arg.type.unwrap
-            references_to(arg_type, from: arg)
+            if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+              references_to(arg_type, from: arg)
+            end
             path.push(arg.graphql_name)
             add_type(arg_type, owner: arg, late_types: late_types, path: path)
             path.pop
@@ -187,14 +191,18 @@ module GraphQL
             type.all_field_definitions.each do |field|
               name = field.graphql_name
               field_type = field.type.unwrap
-              references_to(field_type, from: field)
+              if !field_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(field_type, from: field)
+              end
               path.push(name)
               add_type(field_type, owner: field, late_types: late_types, path: path)
               add_directives_from(field)
               field.all_argument_definitions.each do |arg|
                 add_directives_from(arg)
                 arg_type = arg.type.unwrap
-                references_to(arg_type, from: arg)
+                if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                  references_to(arg_type, from: arg)
+                end
                 path.push(arg.graphql_name)
                 add_type(arg_type, owner: arg, late_types: late_types, path: path)
                 path.pop
@@ -209,7 +217,9 @@ module GraphQL
             type.all_argument_definitions.each do |arg|
               add_directives_from(arg)
               arg_type = arg.type.unwrap
-              references_to(arg_type, from: arg)
+              if !arg_type.is_a?(GraphQL::Schema::LateBoundType)
+                references_to(arg_type, from: arg)
+              end
               path.push(arg.graphql_name)
               add_type(arg_type, owner: arg, late_types: late_types, path: path)
               path.pop
@@ -219,7 +229,7 @@ module GraphQL
             end
           end
           if type.kind.union?
-            @possible_types[type.graphql_name] = type.all_possible_types
+            @possible_types[type] = type.all_possible_types
             path.push("possible_types")
             type.all_possible_types.each do |t|
               add_type(t, owner: type, late_types: late_types, path: path)
@@ -234,7 +244,7 @@ module GraphQL
             path.pop
           end
           if type.kind.object?
-            possible_types_for_this_name = @possible_types[type.graphql_name] ||= []
+            possible_types_for_this_name = @possible_types[type] ||= []
             possible_types_for_this_name << type
           end
 
@@ -246,7 +256,7 @@ module GraphQL
                 interface_type = interface_type_membership.abstract_type
                 # We can get these now; we'll have to get late-bound types later
                 if interface_type.is_a?(Module) && type.is_a?(Class)
-                  implementers = @possible_types[interface_type.graphql_name] ||= []
+                  implementers = @possible_types[interface_type] ||= []
                   implementers << type
                 end
               when String, Schema::LateBoundType

data/lib/graphql/schema/argument.rb

@@ -312,10 +312,15 @@ module GraphQL
           context.query.after_lazy(custom_loaded_value) do |custom_value|
             if loads
               if type.list?
-                loaded_values = custom_value.each_with_index.map { |custom_val, idx|
-                  id = coerced_value[idx]
-                  load_method_owner.authorize_application_object(self, id, context, custom_val)
-                }
+                loaded_values = []
+                context.dataloader.run_isolated do
+                  custom_value.each_with_index.map { |custom_val, idx|
+                    id = coerced_value[idx]
+                    context.dataloader.append_job do
+                      loaded_values[idx] = load_method_owner.authorize_application_object(self, id, context, custom_val)
+                    end
+                  }
+                end
                 context.schema.after_any_lazies(loaded_values, &:itself)
               else
                 load_method_owner.authorize_application_object(self, coerced_value, context, custom_loaded_value)
@@ -326,7 +331,16 @@ module GraphQL
           end
         elsif loads
           if type.list?
-            loaded_values = coerced_value.map { |val| load_method_owner.load_and_authorize_application_object(self, val, context) }
+            loaded_values = []
+            # We want to run these list items all together,
+            # but we also need to wait for the result so we can return it :S
+            context.dataloader.run_isolated do
+              coerced_value.each_with_index { |val, idx|
+                context.dataloader.append_job do
+                  loaded_values[idx] = load_method_owner.load_and_authorize_application_object(self, val, context)
+                end
+              }
+            end
             context.schema.after_any_lazies(loaded_values, &:itself)
           else
             load_method_owner.load_and_authorize_application_object(self, coerced_value, context)

data/lib/graphql/schema/directive.rb

@@ -188,6 +188,8 @@ module GraphQL
             assert_has_location(SCALAR)
           elsif @owner < GraphQL::Schema
             assert_has_location(SCHEMA)
+          elsif @owner < GraphQL::Schema::Resolver
+            assert_has_location(FIELD_DEFINITION)
           else
             raise "Unexpected directive owner class: #{@owner}"
           end