graphql 2.6.2 → 2.6.5

data/lib/graphql/execution/field_resolve_step.rb

@@ -49,12 +49,16 @@ module GraphQL
       end
 
       def value
+        return nil if @selections_step.killed
         query = @selections_step.query
-        query.current_trace.begin_execute_field(@field_definition, @arguments, @field_results, query)
+        set_current_field
+        query.current_trace.begin_execute_field(@field_definition, @field_results, @arguments, query)
         sync(@field_results)
-        query.current_trace.end_execute_field(@field_definition, @arguments, @field_results, query, @field_results)
+        query.current_trace.end_execute_field(@field_definition, @field_results, @arguments, query, @field_results)
         @runner.add_step(self)
         true
+      ensure
+        set_current_field(nil)
       end
 
       def sync(lazy)
@@ -76,6 +80,9 @@ module GraphQL
       end
 
       def call
+        return nil if @selections_step.killed
+        set_current_field if @field_definition
+
         if @enqueued_authorization
           enqueue_next_steps
         elsif @finish_extension_idx
@@ -94,26 +101,68 @@ module GraphQL
         else
           raise
         end
+      ensure
+        set_current_field(nil)
       end
 
-      def add_graphql_error(err)
+      def add_graphql_error(result, key, err, return_type: @field_definition.type)
         err.path = path
         if err.ast_node.nil?
           err.ast_nodes = ast_nodes
         end
-        @selections_step.query.context.add_error(err)
+        @runner.add_finalizer(@selections_step.query, result, key, err)
+        if !err.is_a?(GraphQL::Execution::Skip)
+          field_type = return_type
+          should_propagate_null = field_type.non_null?
+          while (should_propagate_null == false && field_type.kind.wraps?)
+            field_type = field_type.of_type
+            should_propagate_null = field_type.non_null?
+          end
+          if should_propagate_null
+            propagate_nulls
+          end
+        end
         err
       end
 
+      def propagate_nulls
+        propagating_null = true
+        highest_nulled_depth = path.size
+        highest_list_depth = nil
+        current_field_step = self
+        while current_field_step
+          return_type = current_field_step.field_definition.type
+          if propagating_null && return_type.non_null?
+            highest_nulled_depth = current_field_step.path.size
+          else
+            propagating_null = false
+          end
+
+          if return_type.list?
+            highest_list_depth = current_field_step.path.size
+          end
+
+          current_field_step = current_field_step.selections_step.field_resolve_step
+        end
+
+        if highest_list_depth.nil? || highest_nulled_depth <= highest_list_depth
+          kill_field_step = self
+          while kill_field_step && highest_nulled_depth <= kill_field_step.path.size
+            kill_field_step.selections_step.killed = true
+            kill_field_step = kill_field_step.selections_step.field_resolve_step
+          end
+        end
+      end
+
       def build_errors_result(errors, single_error)
         first_error = errors.nil? ? single_error : errors.pop
-        @field_results = error_instance_array(@selections_step.objects.size, first_error)
+        @field_results = [first_error]
+        @results = [@selections_step.results.first]
         if errors
           errors.each do |e|
-            add_graphql_error(e)
+            add_graphql_error(@results.first, key, e)
           end
         end
-        @results ||= @selections_step.results
         build_results
       end
 
@@ -121,6 +170,7 @@ module GraphQL
         query = @selections_step.query
         field_name = @ast_node.name
         @field_definition = query.types.field(@parent_type, field_name) || raise(GraphQL::Error, "No field definition found for #{@parent_type.to_type_signature}.#{ast_node.name} (at #{@ast_node.position})")
+        set_current_field
         @arguments, errors = @runner.input_values[query].argument_values(@field_definition, @ast_node.arguments, self) # rubocop:disable Development/ContextIsPassedCop
         if errors
           build_errors_result(errors, nil)
@@ -131,6 +181,8 @@ module GraphQL
             @field_results.nil? # Make sure the arguments flow didn't already call through
           execute_field
         end
+      ensure
+        set_current_field(nil)
       end
 
       # Used for compatibility in Schema::Subscription
@@ -217,7 +269,7 @@ module GraphQL
                   authorized_results << @results[i]
                 end
               rescue GraphQL::ExecutionError => exec_err
-                add_graphql_error(exec_err)
+                add_graphql_error(@results[i], key, exec_err)
               end
             end
             i += 1
@@ -235,7 +287,7 @@ module GraphQL
           @was_scoped = true
         end
 
-        query.current_trace.begin_execute_field(@field_definition, @arguments, authorized_objects, query)
+        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
 
         if @runner.uses_runtime_directives
           if @ast_nodes.nil? || @ast_nodes.size == 1
@@ -310,7 +362,7 @@ module GraphQL
           @field_results = resolve_batch(authorized_objects, ctx, @arguments)
         end
 
-        query.current_trace.end_execute_field(@field_definition, @arguments, authorized_objects, query, @field_results)
+        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
 
         if any_lazy_results?
           @runner.dataloader.lazy_at_depth(path.size, self)
@@ -322,12 +374,12 @@ module GraphQL
           end
         end
       rescue GraphQL::ExecutionError => err
-        add_graphql_error(err)
+        build_errors_result(nil, err)
       rescue StandardError => stderr
         begin
           @selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
         rescue GraphQL::ExecutionError => err
-          add_graphql_error(err)
+          add_graphql_error(@results[0], key, err)
         end
       end
 
@@ -449,13 +501,13 @@ module GraphQL
       end
 
       def finish_leaf_result(result_h, key, field_result, return_type, ctx)
-        final_field_result = build_leaf_result(field_result, return_type, ctx, false)
+        final_field_result = build_leaf_result(result_h, key, field_result, return_type, ctx, false)
 
         @directive_finalizers&.each { |f| @runner.add_finalizer(ctx.query, result_h, key, f) }
         result_h[@key] = final_field_result
       end
 
-      def build_leaf_result(field_result, return_type, ctx, is_from_array)
+      def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array)
         if field_result.nil?
           if return_type.non_null?
             add_non_null_error(is_from_array)
@@ -464,7 +516,7 @@ module GraphQL
           end
         elsif field_result.is_a?(Finalizer)
           if field_result.is_a?(GraphQL::RuntimeError)
-            add_graphql_error(field_result)
+            add_graphql_error(result_h, result_key, field_result, return_type: return_type)
           else
             field_result.path = path
             @runner.add_finalizer(ctx.query, result_h, key, field_result)
@@ -475,7 +527,11 @@ module GraphQL
           end
 
           inner_type = return_type.of_type
-          field_result.map { |item| build_leaf_result(item, inner_type, ctx, true) }
+          result_a = Array.new(field_result.size)
+          field_result.each_with_index do |item, idx|
+            result_a[idx] = build_leaf_result(result_a, idx, item, inner_type, ctx, true)
+          end
+          result_a
         else
           return_type.coerce_result(field_result, ctx)
         end
@@ -517,6 +573,7 @@ module GraphQL
               query.current_trace.objects(obj_type, next_objects, ctx)
               @runner.add_step(SelectionsStep.new(
                 path: path,
+                field_resolve_step: self,
                 parent_type: obj_type,
                 selections: @next_selections,
                 objects: next_objects,
@@ -529,6 +586,7 @@ module GraphQL
             query.current_trace.objects(@static_type, @all_next_objects, ctx)
             @runner.add_step(SelectionsStep.new(
               path: path,
+              field_resolve_step: self,
               parent_type: @static_type,
               selections: @next_selections,
               objects: @all_next_objects,
@@ -549,7 +607,15 @@ module GraphQL
 
       def add_non_null_error(is_from_array)
         err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
-        @runner.schema.type_error(err, @selections_step.query.context)
+        nn_result = @runner.schema.type_error(err, @selections_step.query.context)
+        if nn_result.nil?
+          propagate_nulls
+        end
+        nn_result
+      end
+
+      def set_current_field(new_value = @field_definition)
+        Fiber[:__graphql_current_field] = new_value
       end
 
       private
@@ -563,7 +629,7 @@ module GraphQL
           end
         elsif field_result.is_a?(Finalizer)
           graphql_result[key] = if field_result.is_a?(GraphQL::RuntimeError)
-            add_graphql_error(field_result)
+            add_graphql_error(graphql_result, key, field_result)
           else
             field_result.path = path
             @runner.add_finalizer(@selections_step.query, graphql_result, key, field_result)

data/lib/graphql/execution/finalize.rb

@@ -33,14 +33,15 @@ module GraphQL
 
           targets.each_with_index do |target, idx|
             if target.is_a?(Hash)
-              if target[key].equal?(err)
+              value_at_key = target[key]
+              if value_at_key.equal?(err)
                 tf = @finalizers[target] ||= {}.compare_by_identity
                 tf[key] = err
                 @finalizers_count += 1
-              elsif (arr = target[key]).is_a?(Array)
-                arr.each_with_index do |el, idx|
+              elsif value_at_key.is_a?(Array)
+                value_at_key.each_with_index do |el, idx|
                   if el.equal?(err)
-                    tf = @finalizers[arr] ||= {}.compare_by_identity
+                    tf = @finalizers[value_at_key] ||= {}.compare_by_identity
                     tf[idx] = err
                     @finalizers_count += 1
                   end
@@ -117,7 +118,7 @@ module GraphQL
               @current_exec_path << key
               @current_result_path << key
 
-              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{static_type.to_type_signature}.#{ast_selection.name}")
+              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{parent_type.to_type_signature}.#{ast_selection.name}")
               result_type = field_defn.type
               if (result_type_non_null = result_type.non_null?)
                 result_type = result_type.of_type
@@ -150,16 +151,18 @@ module GraphQL
           when Language::Nodes::InlineFragment
             static_type_at_result = @static_type_at[result_h]
             if static_type_at_result && (
-                (t = ast_selection.type).nil? ||
+              (t = ast_selection.type).nil? ||
                 @runner.type_condition_applies?(@query.context, static_type_at_result, t.name)
               )
               result_h = check_object_result(result_h, parent_type, ast_selection.selections)
+              return nil if result_h.nil?
             end
           when Language::Nodes::FragmentSpread
             fragment_defn = @query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
             static_type_at_result = @static_type_at[result_h]
             if static_type_at_result && @runner.type_condition_applies?(@query.context, static_type_at_result, fragment_defn.type.name)
               result_h = check_object_result(result_h, parent_type, fragment_defn.selections)
+              return nil if result_h.nil?
             end
           end
         end
@@ -168,9 +171,7 @@ module GraphQL
       end
 
       def check_list_result(result_arr, inner_type, ast_selections)
-        inner_type_non_null = false
-        if inner_type.non_null?
-          inner_type_non_null = true
+        if (inner_type_non_null = inner_type.non_null?)
           inner_type = inner_type.of_type
         end
 

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

@@ -30,7 +30,10 @@ module GraphQL
               @storage[argument_owner][parent_object][ast_node] = resolved_args
             end
           end
+        end
 
+        def cached_arguments_for(ast_node, argument_owner)
+          @storage[argument_owner][nil][ast_node]
         end
 
         # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments

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

@@ -492,12 +492,6 @@ module GraphQL
               end
             end
           end
-          # 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 selection_result.graphql_is_eager
-            @dataloader.run
-          end
         end
 
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)

data/lib/graphql/execution/load_argument_step.rb

@@ -14,6 +14,7 @@ module GraphQL
       end
 
       def value
+        @field_resolve_step.set_current_field
         schema = @field_resolve_step.runner.schema
         @loaded_value = schema.sync_lazy(@loaded_value)
         assign_value
@@ -34,9 +35,12 @@ module GraphQL
           @loaded_value = ex_err
         end
         assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       def call
+        @field_resolve_step.set_current_field
         context = @field_resolve_step.selections_step.query.context
         @loaded_value = begin
           @load_receiver.load_and_authorize_application_object(@argument_definition, @argument_value, context)
@@ -64,6 +68,8 @@ module GraphQL
           ex_err
         end
         assign_value
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       private

data/lib/graphql/execution/prepare_object_step.rb

@@ -19,6 +19,7 @@ module GraphQL
       end
 
       def value
+        @field_resolve_step.set_current_field
         if @authorized_value
           query = @field_resolve_step.selections_step.query
           query.current_trace.begin_authorized(@resolved_type, @object, query.context)
@@ -36,9 +37,12 @@ module GraphQL
           ctx.query.current_trace.end_resolve_type(st, @object, ctx, @resolved_type)
         end
         @runner.add_step(self)
+      ensure
+        @field_resolve_step.set_current_field(nil)
       end
 
       def call
+        @field_resolve_step.set_current_field
         case @next_step
         when :resolve_type
           static_type = @field_resolve_step.static_type
@@ -65,6 +69,12 @@ module GraphQL
         else
           raise ArgumentError, "This is a bug, unknown step: #{@next_step.inspect}"
         end
+      ensure
+        @field_resolve_step.set_current_field(nil)
+      end
+
+      def add_field_error(err)
+        @field_resolve_step.add_graphql_error(@graphql_result, @key, err)
       end
 
       def authorize
@@ -90,13 +100,13 @@ module GraphQL
           create_result
         end
       rescue GraphQL::RuntimeError => err
-        @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+        @graphql_result[@key] = add_field_error(err)
       rescue StandardError => err
         query ||= @field_resolve_step.selections_step.query
         begin
           query.handle_or_reraise(err, field: @field_resolve_step.field_definition, arguments: @field_resolve_step.arguments, object: @object) # rubocop:disable Development/ContextIsPassedCop
         rescue GraphQL::RuntimeError => err
-          @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+          @graphql_result[@key] = add_field_error(err)
         end
       end
 
@@ -114,13 +124,13 @@ module GraphQL
             elsif @is_non_null
               @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
             else
-              @graphql_result[@key] = @field_resolve_step.add_graphql_error(@authorization_error)
+              @graphql_result[@key] = add_field_error(@authorization_error)
             end
           rescue GraphQL::RuntimeError => err
             if @is_non_null
               @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
             else
-              @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+              @graphql_result[@key] = add_field_error(err)
             end
           end
         end

data/lib/graphql/execution/runner.rb

@@ -116,7 +116,7 @@ module GraphQL
             query.context.add_error(err)
           end
 
-          trace.execute_query_lazy(query: nil, multiplex: @multiplex) do
+          trace.execute_query_lazy(query: @multiplex.queries.size == 1 ? @multiplex.queries.first : nil, multiplex: @multiplex) do
             while (next_isolated_steps = isolated_steps.shift)
               next_isolated_steps.each do |step|
                 add_step(step)
@@ -298,6 +298,7 @@ module GraphQL
           if query.query?
             isolated_steps[0] << SelectionsStep.new(
               parent_type: root_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: objects,
               results: [data],
@@ -317,6 +318,7 @@ module GraphQL
               isolated_steps << [SelectionsStep.new(
                 clobber: false, # `data` is being shared among several selections steps
                 parent_type: root_type,
+                field_resolve_step: field_resolve_step,
                 selections: field_resolve_step.ast_nodes || Array(field_resolve_step.ast_node),
                 objects: objects,
                 results: [data],
@@ -332,6 +334,7 @@ module GraphQL
             end
             isolated_steps[0] << SelectionsStep.new(
               parent_type: root_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: objects,
               results: [data],
@@ -355,6 +358,7 @@ module GraphQL
           results << { "data" => data }
           isolated_steps[0] << SelectionsStep.new(
             parent_type: resolved_type,
+            field_resolve_step: nil,
             selections: selected_operation.selections,
             objects: objects,
             results: [data],
@@ -372,6 +376,7 @@ module GraphQL
             results << { "data" => list_result }
             isolated_steps[0] << SelectionsStep.new(
               parent_type: inner_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: root_value,
               results: list_result,
@@ -420,6 +425,7 @@ module GraphQL
         selections = partial.ast_nodes
         dummy_ss = SelectionsStep.new(
           parent_type: nil,
+          field_resolve_step: nil,
           selections: selections,
           objects: nil,
           results: nil,

data/lib/graphql/execution/selections_step.rb

@@ -2,8 +2,9 @@
 module GraphQL
   module Execution
     class SelectionsStep
-      def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
+      def initialize(parent_type:, field_resolve_step:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
         @path = path
+        @field_resolve_step = field_resolve_step
         @parent_type = parent_type
         @selections = selections
         @runner = runner
@@ -12,10 +13,13 @@ module GraphQL
         @query = query
         @graphql_objects = nil
         @all_selections = nil
+        @killed = false
         @clobber = clobber
       end
 
-      attr_reader :path, :query, :objects, :results
+      attr_reader :path, :query, :objects, :results, :field_resolve_step
+
+      attr_accessor :killed
 
       def graphql_objects
         @graphql_objects ||= @objects.map do |obj|

data/lib/graphql/execution_error.rb

@@ -26,6 +26,10 @@ module GraphQL
     end
 
     def finalize_graphql_result(query, result_data, key)
+      add_this_error = !query.context.errors.any? { |e| e.eql?(self) }
+      if add_this_error
+        query.context.add_error(self)
+      end
       if ast_node.is_a?(GraphQL::Language::Nodes::Directive)
         # This is for backwards compatibility ... what does the spec say?
         result_data.delete(key)

data/lib/graphql/language.rb

@@ -47,13 +47,19 @@ module GraphQL
     def self.escape_single_quoted_newlines(query_str)
       scanner = StringScanner.new(query_str)
       inside_single_quoted_string = false
+      inside_triple_quoted_string = false
       new_query_str = nil
       while !scanner.eos?
-        if scanner.skip(/(?:\\"|[^"\n\r]|""")+/m)
+        if scanner.skip('"""')
+          inside_triple_quoted_string = !inside_triple_quoted_string
+          new_query_str && (new_query_str << scanner.matched)
+        elsif scanner.skip(/(?:\\"|[^"\n\r])+/m)
           new_query_str && (new_query_str << scanner.matched)
         elsif scanner.skip('"')
           new_query_str && (new_query_str << '"')
-          inside_single_quoted_string = !inside_single_quoted_string
+          if !inside_triple_quoted_string
+            inside_single_quoted_string = !inside_single_quoted_string
+          end
         elsif scanner.skip("\n")
           if inside_single_quoted_string
             new_query_str ||= query_str[0, scanner.pos - 1]

data/lib/graphql/schema/argument.rb

@@ -94,7 +94,7 @@ module GraphQL
         end
 
         if required == :nullable
-          self.owner.validates(required: { argument: arg_name })
+          self.owner.validates(required: { argument: @keyword })
         end
 
         if definition_block

data/lib/graphql/schema/interface.rb

@@ -101,7 +101,7 @@ module GraphQL
             end
 
             child_class.ancestors.reverse_each do |ancestor|
-              if ancestor.const_defined?(:ResolverMethods)
+              if ancestor != child_class && ancestor <= GraphQL::Schema::Interface && ancestor.const_defined?(:ResolverMethods, false)
                 child_class.extend(ancestor::ResolverMethods)
               end
             end

data/lib/graphql/schema/introspection_system.rb

@@ -105,11 +105,13 @@ module GraphQL
       end
 
       def load_constant(class_name)
-        const = @custom_namespace.const_get(class_name)
+        const = begin
+          @custom_namespace.const_get(class_name)
+        rescue NameError
+          # Dup the built-in so that the cached fields aren't shared
+          @built_in_namespace.const_get(class_name)
+        end
         dup_type_class(const)
-      rescue NameError
-        # Dup the built-in so that the cached fields aren't shared
-        dup_type_class(@built_in_namespace.const_get(class_name))
       end
 
       def get_fields_from_class(class_sym:)
@@ -133,23 +135,6 @@ module GraphQL
           end
         end
       end
-
-      class PerFieldProxyResolve
-        def initialize(object_class:, inner_resolve:)
-          @object_class = object_class
-          @inner_resolve = inner_resolve
-        end
-
-        def call(obj, args, ctx)
-          query_ctx = ctx.query.context
-          # Remove the QueryType wrapper
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          wrapped_object = @object_class.wrap(obj, query_ctx)
-          @inner_resolve.call(wrapped_object, args, ctx)
-        end
-      end
     end
   end
 end

data/lib/graphql/schema/printer.rb

@@ -58,8 +58,8 @@ module GraphQL
           end
         end
         schema = Class.new(GraphQL::Schema) {
-          use GraphQL::Schema::Visibility
           query(query_root)
+          use GraphQL::Schema::Visibility
           def self.visible?(member, _ctx)
             member.graphql_name != "Root"
           end

data/lib/graphql/schema/validator/allow_blank_validator.rb

@@ -8,7 +8,7 @@ module GraphQL
       # @example Require a non-empty string for an argument
       #   argument :name, String, required: true, validate: { allow_blank: false }
       class AllowBlankValidator < Validator
-        def initialize(allow_blank_positional, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
+        def initialize(allow_blank_positional = nil, allow_blank: nil, message: "%{validated} can't be blank", **default_options)
           @message = message
           super(**default_options)
           @allow_blank = allow_blank.nil? ? allow_blank_positional : allow_blank
@@ -16,10 +16,10 @@ module GraphQL
 
         def validate(_object, _context, value)
           if value.respond_to?(:blank?) && value.blank?
-            if (value.nil? && @allow_null) || @allow_blank
+            if (value.nil? && validation_parameter(@allow_null)) || validation_parameter(@allow_blank)
               # pass
             else
-              @message
+              validation_parameter(@message)
             end
           end
         end

data/lib/graphql/schema/validator/allow_null_validator.rb

@@ -9,15 +9,15 @@ module GraphQL
       #   argument :name, String, required: false, validates: { allow_null: false }
       class AllowNullValidator < Validator
         MESSAGE = "%{validated} can't be null"
-        def initialize(allow_null_positional, allow_null: nil, message: MESSAGE, **default_options)
+        def initialize(allow_null_positional = nil, allow_null: nil, message: MESSAGE, **default_options)
           @message = message
           super(**default_options)
           @allow_null = allow_null.nil? ? allow_null_positional : allow_null
         end
 
         def validate(_object, _context, value)
-          if value.nil? && !@allow_null
-            @message
+          if value.nil? && !validation_parameter(@allow_null)
+            validation_parameter(@message)
           end
         end
       end

data/lib/graphql/schema/validator/exclusion_validator.rb

@@ -23,8 +23,8 @@ module GraphQL
         def validate(_object, _context, value)
           if permitted_empty_value?(value)
             # pass
-          elsif @in_list.include?(value)
-            @message
+          elsif validation_parameter(@in_list).include?(value)
+            validation_parameter(@message)
           end
         end
       end