graphql 1.11.6 → 1.11.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1b6e1d6fb5063c843becb61784cb776964a380af5a2fc5a98054d2554ddf4caa
-  data.tar.gz: c41027cdf69f8c07bed157075c70e95936f3d26922f0b1d38f7759352a35ab43
+  metadata.gz: edd6b4edae07b6c52383810319efb2cdd19a8f818639dda22c79308620330274
+  data.tar.gz: '09869b52706e249e6e41282e9e06243547db556d42410c4e2d0cb9abf00d7e3f'
 SHA512:
-  metadata.gz: 3dc4e13b30d51c32775785b9ed4a11940bc2cb541866877e6eef48bc621956700ddf057c597d2bc5a9fa09ca863e01ba84295e414e488e22ee03b94c28bc4003
-  data.tar.gz: 70f5ba8c04e13b83af431db1e8edea297a3c43acc6f6356668094349b577fe7de4e8cdb029aaf8ce70cc243664915ac7dac38612badd0acb720ce57464769cec
+  metadata.gz: d5c8e1b96dea2f3ac9c8c93639e6b0c9763984c9af6ca09201ef89bfbbfd2ff61cd622417d04f5624fb6c679822d8a58c1a148c5139e1e1e51bf03eb5aaaaa4a
+  data.tar.gz: 07c12d4dd5b50d5b36a3c8e298ae663969e203ce6103c449ec0b599c5960c145b34dd9c023986c5d3cb2f0d6169b5395530bca6d07985152fb12505dc1af6036

data/lib/generators/graphql/object_generator.rb

@@ -40,6 +40,8 @@ module Graphql
         case type_expression
         when "Text"
           ["String", null]
+        when "Decimal"
+          ["Float", null]
         when "DateTime", "Datetime"
           ["GraphQL::Types::ISO8601DateTime", null]
         when "Date"

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

@@ -14,18 +14,33 @@ module GraphQL
         # This hash is the one used at runtime.
         #
         # @return [Hash<Symbol, Object>]
-        attr_reader :keyword_arguments
+        def keyword_arguments
+          @keyword_arguments ||= begin
+            kwargs = {}
+            argument_values.each do |name, arg_val|
+              kwargs[name] = arg_val.value
+            end
+            kwargs
+          end
+        end
 
-        def initialize(keyword_arguments:, argument_values:)
-          @keyword_arguments = keyword_arguments
+        # @param argument_values [nil, Hash{Symbol => ArgumentValue}]
+        def initialize(argument_values:)
           @argument_values = argument_values
+          @empty = argument_values.nil? || argument_values.empty?
         end
 
         # @return [Hash{Symbol => ArgumentValue}]
-        attr_reader :argument_values
+        def argument_values
+          @argument_values ||= {}
+        end
+
+        def empty?
+          @empty
+        end
 
-        def_delegators :@keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
-        def_delegators :@argument_values, :each_value
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :argument_values, :each_value
 
         def inspect
           "#<#{self.class} @keyword_arguments=#{keyword_arguments.inspect}>"

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

@@ -29,11 +29,16 @@ module GraphQL
 
         private
 
+        NO_ARGUMENTS = {}.freeze
+
         NO_VALUE_GIVEN = Object.new
 
         def prepare_args_hash(ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value
           when Hash
+            if ast_arg_or_hash_or_value.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.each do |k, v|
               args_hash[k] = prepare_args_hash(v)
@@ -42,6 +47,9 @@ module GraphQL
           when Array
             ast_arg_or_hash_or_value.map { |v| prepare_args_hash(v) }
           when GraphQL::Language::Nodes::Field, GraphQL::Language::Nodes::InputObject, GraphQL::Language::Nodes::Directive
+            if ast_arg_or_hash_or_value.arguments.empty?
+              return NO_ARGUMENTS
+            end
             args_hash = {}
             ast_arg_or_hash_or_value.arguments.each do |arg|
               v = prepare_args_hash(arg.value)

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

@@ -47,8 +47,7 @@ module GraphQL
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
-          set_interpreter_context(:current_object, query.root_value)
-          set_interpreter_context(:current_path, path)
+          set_all_interpreter_context(query.root_value, nil, nil, path)
           object_proxy = authorized_new(root_type, query.root_value, context, path)
           object_proxy = schema.sync_lazy(object_proxy)
           if object_proxy.nil?
@@ -118,9 +117,10 @@ module GraphQL
           end
         end
 
+        NO_ARGS = {}.freeze
+
         def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
-          set_interpreter_context(:current_object, owner_object)
-          set_interpreter_context(:current_path, path)
+          set_all_interpreter_context(owner_object, nil, nil, path)
           selections_by_name = {}
           gather_selections(owner_object, owner_type, selections, selections_by_name)
           selections_by_name.each do |result_name, field_ast_nodes_or_ast_node|
@@ -159,8 +159,7 @@ module GraphQL
             # to propagate `null`
             set_type_at_path(next_path, return_type)
             # Set this before calling `run_with_directives`, so that the directive can have the latest path
-            set_interpreter_context(:current_path, next_path)
-            set_interpreter_context(:current_field, field_defn)
+            set_all_interpreter_context(nil, field_defn, nil, next_path)
 
             context.scoped_context = scoped_context
             object = owner_object
@@ -171,44 +170,50 @@ module GraphQL
 
             begin
               kwarg_arguments = arguments(object, field_defn, ast_node)
-            rescue GraphQL::ExecutionError => e
+            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => e
               continue_value(next_path, e, owner_type, field_defn, return_type.non_null?, ast_node)
               next
             end
 
             after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
-              if resolved_arguments.is_a? GraphQL::ExecutionError
+              case resolved_arguments
+              when GraphQL::ExecutionError, GraphQL::UnauthorizedError
                 continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node)
                 next
               end
 
-              kwarg_arguments = resolved_arguments.keyword_arguments
-
-              field_defn.extras.each do |extra|
-                case extra
-                when :ast_node
-                  kwarg_arguments[:ast_node] = ast_node
-                when :execution_errors
-                  kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
-                when :path
-                  kwarg_arguments[:path] = next_path
-                when :lookahead
-                  if !field_ast_nodes
-                    field_ast_nodes = [ast_node]
+              if resolved_arguments.empty? && field_defn.extras.empty?
+                # We can avoid allocating the `{ Symbol => Object }` hash in this case
+                kwarg_arguments = NO_ARGS
+              else
+                kwarg_arguments = resolved_arguments.keyword_arguments
+
+                field_defn.extras.each do |extra|
+                  case extra
+                  when :ast_node
+                    kwarg_arguments[:ast_node] = ast_node
+                  when :execution_errors
+                    kwarg_arguments[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
+                  when :path
+                    kwarg_arguments[:path] = next_path
+                  when :lookahead
+                    if !field_ast_nodes
+                      field_ast_nodes = [ast_node]
+                    end
+                    kwarg_arguments[:lookahead] = Execution::Lookahead.new(
+                      query: query,
+                      ast_nodes: field_ast_nodes,
+                      field: field_defn,
+                    )
+                  when :argument_details
+                    kwarg_arguments[:argument_details] = resolved_arguments
+                  else
+                    kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                   end
-                  kwarg_arguments[:lookahead] = Execution::Lookahead.new(
-                    query: query,
-                    ast_nodes: field_ast_nodes,
-                    field: field_defn,
-                  )
-                when :argument_details
-                  kwarg_arguments[:argument_details] = resolved_arguments
-                else
-                  kwarg_arguments[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
 
-              set_interpreter_context(:current_arguments, kwarg_arguments)
+              set_all_interpreter_context(nil, nil, kwarg_arguments, nil)
 
               # Optimize for the case that field is selected only once
               if field_ast_nodes.nil? || field_ast_nodes.size == 1
@@ -414,6 +419,21 @@ module GraphQL
           true
         end
 
+        def set_all_interpreter_context(object, field, arguments, path)
+          if object
+            @context[:current_object] = @interpreter_context[:current_object] = object
+          end
+          if field
+            @context[:current_field] = @interpreter_context[:current_field] = field
+          end
+          if arguments
+            @context[:current_arguments] = @interpreter_context[:current_arguments] = arguments
+          end
+          if path
+            @context[:current_path] = @interpreter_context[:current_path] = path
+          end
+        end
+
         # @param obj [Object] Some user-returned value that may want to be batched
         # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
@@ -421,16 +441,10 @@ module GraphQL
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
         def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false, trace: true, &block)
-          set_interpreter_context(:current_object, owner_object)
-          set_interpreter_context(:current_arguments, arguments)
-          set_interpreter_context(:current_path, path)
-          set_interpreter_context(:current_field, field)
+          set_all_interpreter_context(owner_object, field, arguments, path)
           if schema.lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
-              set_interpreter_context(:current_path, path)
-              set_interpreter_context(:current_field, field)
-              set_interpreter_context(:current_object, owner_object)
-              set_interpreter_context(:current_arguments, arguments)
+              set_all_interpreter_context(owner_object, field, arguments, path)
               context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below

data/lib/graphql/integer_decoding_error.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Int` is given an input value outside of 32-bit integer range.
+  #
+  # For really big integer values, consider `GraphQL::Types::BigInt`
+  #
+  # @see GraphQL::Types::Int which raises this error
+  class IntegerDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :integer_value
+
+    def initialize(value)
+      @integer_value = value
+      super("Integer out of bounds: #{value}. \nConsider using GraphQL::Types::BigInt instead.")
+    end
+  end
+end

data/lib/graphql/invalid_null_error.rb

@@ -39,7 +39,7 @@ module GraphQL
       end
 
       def inspect
-        if name.nil? && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
+        if (name.nil? || parent_class.name.nil?) && parent_class.respond_to?(:mutation) && (mutation = parent_class.mutation)
           "#{mutation.inspect}::#{parent_class.graphql_name}::InvalidNullError"
         else
           super

data/lib/graphql/query/context.rb

@@ -167,7 +167,10 @@ module GraphQL
       # @api private
       attr_accessor :scoped_context
 
-      def_delegators :@provided_values, :[]=
+      def []=(key, value)
+        @provided_values[key] = value
+      end
+
       def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)

data/lib/graphql/query/validation_pipeline.rb

@@ -72,7 +72,7 @@ module GraphQL
         elsif @operation_name_error
           @validation_errors << @operation_name_error
         else
-          validation_result = @schema.static_validator.validate(@query, validate: @validate)
+          validation_result = @schema.static_validator.validate(@query, validate: @validate, timeout: @schema.validate_timeout, max_errors: @schema.validate_max_errors)
           @validation_errors.concat(validation_result[:errors])
           @internal_representation = validation_result[:irep]
 

data/lib/graphql/query.rb

@@ -88,6 +88,7 @@ module GraphQL
         schema = schema.graphql_definition
       end
       @schema = schema
+      @interpreter = @schema.interpreter?
       @filter = schema.default_filter.merge(except: except, only: only)
       @context = schema.context_class.new(query: self, object: root_value, values: context)
       @warden = warden
@@ -148,7 +149,9 @@ module GraphQL
       @query_string ||= (document ? document.to_query_string : nil)
     end
 
-    def_delegators :@schema, :interpreter?
+    def interpreter?
+      @interpreter
+    end
 
     def subscription_update?
       @subscription_topic && subscription?

data/lib/graphql/relay/array_connection.rb

@@ -31,8 +31,6 @@ module GraphQL
         end
       end
 
-      private
-
       def first
         @first ||= begin
           capped = limit_pagination_argument(arguments[:first], max_page_size)
@@ -47,6 +45,8 @@ module GraphQL
         @last ||= limit_pagination_argument(arguments[:last], max_page_size)
       end
 
+      private
+
       # apply first / last limit results
       def paged_nodes
         @paged_nodes ||= begin

data/lib/graphql/schema/default_type_error.rb

@@ -8,6 +8,8 @@ module GraphQL
           ctx.errors << type_error
         when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
           raise type_error
+        when GraphQL::IntegerDecodingError
+          nil
         end
       end
     end

data/lib/graphql/schema/field/scope_extension.rb

@@ -4,7 +4,7 @@ module GraphQL
   class Schema
     class Field
       class ScopeExtension < GraphQL::Schema::FieldExtension
-        def after_resolve(value:, context:, **rest)
+        def after_resolve(object:, arguments:, context:, value:, memo:)
           if value.nil?
             value
           else

data/lib/graphql/schema/field.rb

@@ -725,33 +725,42 @@ module GraphQL
         if @extensions.empty?
           yield(obj, args)
         else
-          extended_obj = obj
-          extended_args = args
-
-          memos = []
-          value = run_extensions_before_resolve(memos, obj, args, ctx) do |obj, args|
-            extended_obj = obj
-            extended_args = args
+          # This is a hack to get the _last_ value for extended obj and args,
+          # in case one of the extensions doesn't `yield`.
+          # (There's another implementation that uses multiple-return, but I'm wary of the perf cost of the extra arrays)
+          extended = { args: args, obj: obj, memos: nil }
+          value = run_extensions_before_resolve(obj, args, ctx, extended) do |obj, args|
             yield(obj, args)
           end
 
+          extended_obj = extended[:obj]
+          extended_args = extended[:args]
+          memos = extended[:memos] || EMPTY_HASH
+
           ctx.schema.after_lazy(value) do |resolved_value|
-            @extensions.each_with_index do |ext, idx|
+            idx = 0
+            @extensions.each do |ext|
               memo = memos[idx]
               # TODO after_lazy?
               resolved_value = ext.after_resolve(object: extended_obj, arguments: extended_args, context: ctx, value: resolved_value, memo: memo)
+              idx += 1
             end
             resolved_value
           end
         end
       end
 
-      def run_extensions_before_resolve(memos, obj, args, ctx, idx: 0)
+      def run_extensions_before_resolve(obj, args, ctx, extended, idx: 0)
         extension = @extensions[idx]
         if extension
           extension.resolve(object: obj, arguments: args, context: ctx) do |extended_obj, extended_args, memo|
-            memos << memo
-            run_extensions_before_resolve(memos, extended_obj, extended_args, ctx, idx: idx + 1) { |o, a| yield(o, a) }
+            if memo
+              memos = extended[:memos] ||= {}
+              memos[idx] = memo
+            end
+            extended[:obj] = extended_obj
+            extended[:args] = extended_args
+            run_extensions_before_resolve(extended_obj, extended_args, ctx, extended, idx: idx + 1) { |o, a| yield(o, a) }
           end
         else
           yield(obj, args)

data/lib/graphql/schema/member/has_arguments.rb

@@ -85,70 +85,69 @@ module GraphQL
         # @param context [GraphQL::Query::Context]
         # @return [Hash<Symbol, Object>, Execution::Lazy<Hash>]
         def coerce_arguments(parent_object, values, context)
-          argument_values = {}
-          kwarg_arguments = {}
           # Cache this hash to avoid re-merging it
           arg_defns = self.arguments
 
-          maybe_lazies = []
-          arg_lazies = arg_defns.map do |arg_name, arg_defn|
-            arg_key = arg_defn.keyword
-            has_value = false
-            default_used = false
-            if values.key?(arg_name)
-              has_value = true
-              value = values[arg_name]
-            elsif values.key?(arg_key)
-              has_value = true
-              value = values[arg_key]
-            elsif arg_defn.default_value?
-              has_value = true
-              value = arg_defn.default_value
-              default_used = true
-            end
-
-            if has_value
-              loads = arg_defn.loads
-              loaded_value = nil
-              if loads && !arg_defn.from_resolver?
-                loaded_value = if arg_defn.type.list?
-                  loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
-                  context.schema.after_any_lazies(loaded_values) { |result| result }
-                else
-                  load_application_object(arg_defn, loads, value, context)
-                end
+          if arg_defns.empty?
+            GraphQL::Execution::Interpreter::Arguments.new(argument_values: nil)
+          else
+            argument_values = {}
+            arg_lazies = arg_defns.map do |arg_name, arg_defn|
+              arg_key = arg_defn.keyword
+              has_value = false
+              default_used = false
+              if values.key?(arg_name)
+                has_value = true
+                value = values[arg_name]
+              elsif values.key?(arg_key)
+                has_value = true
+                value = values[arg_key]
+              elsif arg_defn.default_value?
+                has_value = true
+                value = arg_defn.default_value
+                default_used = true
               end
 
-              coerced_value = if loaded_value
-                loaded_value
-              else
-                context.schema.error_handler.with_error_handling(context) do
-                  arg_defn.type.coerce_input(value, context)
+              if has_value
+                loads = arg_defn.loads
+                loaded_value = nil
+                if loads && !arg_defn.from_resolver?
+                  loaded_value = if arg_defn.type.list?
+                    loaded_values = value.map { |val| load_application_object(arg_defn, loads, val, context) }
+                    context.schema.after_any_lazies(loaded_values) { |result| result }
+                  else
+                    load_application_object(arg_defn, loads, value, context)
+                  end
                 end
-              end
 
-              context.schema.after_lazy(coerced_value) do |coerced_value|
-                prepared_value = context.schema.error_handler.with_error_handling(context) do
-                  arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                coerced_value = if loaded_value
+                  loaded_value
+                else
+                  context.schema.error_handler.with_error_handling(context) do
+                    arg_defn.type.coerce_input(value, context)
+                  end
                 end
 
-                kwarg_arguments[arg_key] = prepared_value
-                # TODO code smell to access such a deeply-nested constant in a distant module
-                argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
-                  value: prepared_value,
-                  definition: arg_defn,
-                  default_used: default_used,
-                )
+                context.schema.after_lazy(coerced_value) do |coerced_value|
+                  prepared_value = context.schema.error_handler.with_error_handling(context) do
+                    arg_defn.prepare_value(parent_object, coerced_value, context: context)
+                  end
+
+                  # TODO code smell to access such a deeply-nested constant in a distant module
+                  argument_values[arg_key] = GraphQL::Execution::Interpreter::ArgumentValue.new(
+                    value: prepared_value,
+                    definition: arg_defn,
+                    default_used: default_used,
+                  )
+                end
               end
             end
-          end
 
-          maybe_lazies.concat(arg_lazies)
-          context.schema.after_any_lazies(maybe_lazies) do
-            GraphQL::Execution::Interpreter::Arguments.new(
-              keyword_arguments: kwarg_arguments,
-              argument_values: argument_values,
-            )
+            context.schema.after_any_lazies(arg_lazies) do
+              GraphQL::Execution::Interpreter::Arguments.new(
+                argument_values: argument_values,
+              )
+            end
           end
         end
 

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -105,7 +105,7 @@ module GraphQL
           sig = super
           # Arguments were added at the root, but they should be nested
           sig[:arguments].clear
-          sig[:arguments][:input] = { type: input_type, required: true }
+          sig[:arguments][:input] = { type: input_type, required: true, description: "Parameters for #{graphql_name}" }
           sig
         end
 

data/lib/graphql/schema.rb

@@ -157,7 +157,7 @@ module GraphQL
 
     accepts_definitions \
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :resolve_type, :type_error, :parse_error,
       :error_bubbling,
       :raise_definition_error,
@@ -196,7 +196,7 @@ module GraphQL
     attr_accessor \
       :query, :mutation, :subscription,
       :query_execution_strategy, :mutation_execution_strategy, :subscription_execution_strategy,
-      :max_depth, :max_complexity, :default_max_page_size,
+      :validate_timeout, :validate_max_errors, :max_depth, :max_complexity, :default_max_page_size,
       :orphan_types, :directives,
       :query_analyzers, :multiplex_analyzers, :instrumenters, :lazy_methods,
       :cursor_encoder,
@@ -366,7 +366,7 @@ module GraphQL
       validator_opts = { schema: self }
       rules && (validator_opts[:rules] = rules)
       validator = GraphQL::StaticValidation::Validator.new(**validator_opts)
-      res = validator.validate(query)
+      res = validator.validate(query, timeout: validate_timeout, max_errors: validate_max_errors)
       res[:errors]
     end
 
@@ -950,6 +950,8 @@ module GraphQL
         schema_defn.query = query && query.graphql_definition
         schema_defn.mutation = mutation && mutation.graphql_definition
         schema_defn.subscription = subscription && subscription.graphql_definition
+        schema_defn.validate_timeout = validate_timeout
+        schema_defn.validate_max_errors = validate_max_errors
         schema_defn.max_complexity = max_complexity
         schema_defn.error_bubbling = error_bubbling
         schema_defn.max_depth = max_depth
@@ -1118,14 +1120,15 @@ module GraphQL
             type.possible_types(context: context)
           else
             stored_possible_types = own_possible_types[type.graphql_name]
-            visible_possible_types = stored_possible_types.select do |possible_type|
-              next true unless type.kind.interface?
-              next true unless possible_type.kind.object?
-
-              # Use `.graphql_name` comparison to match legacy vs class-based types.
-              # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
-              possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
-            end if stored_possible_types
+            visible_possible_types = if stored_possible_types && type.kind.interface?
+              stored_possible_types.select do |possible_type|
+                # Use `.graphql_name` comparison to match legacy vs class-based types.
+                # When we don't need to support legacy `.define` types, use `.include?(type)` instead.
+                possible_type.interfaces(context).any? { |interface| interface.graphql_name == type.graphql_name }
+              end
+            else
+              stored_possible_types
+            end
             visible_possible_types ||
               introspection_system.possible_types[type.graphql_name] ||
               (
@@ -1272,6 +1275,31 @@ module GraphQL
         end
       end
 
+      attr_writer :validate_timeout
+
+      def validate_timeout(new_validate_timeout = nil)
+        if new_validate_timeout
+          @validate_timeout = new_validate_timeout
+        elsif defined?(@validate_timeout)
+          @validate_timeout
+        else
+          find_inherited_value(:validate_timeout)
+        end
+      end
+
+      attr_writer :validate_max_errors
+
+      def validate_max_errors(new_validate_max_errors = nil)
+        if new_validate_max_errors
+          @validate_max_errors = new_validate_max_errors
+        elsif defined?(@validate_max_errors)
+          @validate_max_errors
+        else
+          find_inherited_value(:validate_max_errors)
+        end
+      end
+
+
       attr_writer :max_complexity
 
       def max_complexity(max_complexity = nil)

data/lib/graphql/static_validation/all_rules.rb

@@ -34,6 +34,7 @@ module GraphQL
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
       GraphQL::StaticValidation::MutationRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
+      GraphQL::StaticValidation::InputObjectNamesAreUnique,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -205,6 +205,9 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
+        if @context.too_many_errors?
+          throw :too_many_validation_errors
+        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -193,25 +193,26 @@ module GraphQL
           if node1.name != node2.name
             errored_nodes = [node1.name, node2.name].sort.join(" or ")
             msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
               conflicts: errored_nodes
-            )
+            ))
           end
 
-          args = possible_arguments(node1, node2)
-          if args.size > 1
-            msg = "Field '#{response_key}' has an argument conflict: #{args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+          if !same_arguments?(node1, node2)
+            args = [serialize_field_args(node1), serialize_field_args(node2)]
+            conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
+            msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
+            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
               msg,
               nodes: [node1, node2],
               path: [],
               field_name: response_key,
-              conflicts: args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
-            )
+              conflicts: conflicts
+            ))
           end
         end
 
@@ -326,20 +327,19 @@ module GraphQL
         [fields, fragment_spreads]
       end
 
-      def possible_arguments(field1, field2)
+      def same_arguments?(field1, field2)
         # Check for incompatible / non-identical arguments on this node:
-        [field1, field2].map do |n|
-          if n.arguments.any?
-            serialized_args = {}
-            n.arguments.each do |a|
-              arg_value = a.value
-              serialized_args[a.name] = serialize_arg(arg_value)
-            end
-            serialized_args
-          else
-            NO_ARGS
-          end
-        end.uniq
+        arguments1 = field1.arguments
+        arguments2 = field2.arguments
+
+        return false if arguments1.length != arguments2.length
+
+        arguments1.all? do |argument1|
+          argument2 = arguments2.find { |argument| argument.name == argument1.name }
+          return false if argument2.nil?
+
+          serialize_arg(argument1.value) == serialize_arg(argument2.value)
+        end
       end
 
       def serialize_arg(arg_value)
@@ -353,6 +353,14 @@ module GraphQL
         end
       end
 
+      def serialize_field_args(field)
+        serialized_args = {}
+        field.arguments.each do |argument|
+          serialized_args[argument.name] = serialize_arg(argument.value)
+        end
+        serialized_args
+      end
+
       def compared_fragments_key(frag1, frag2, exclusive)
         # Cache key to not compare two fragments more than once.
         # The key includes both fragment names sorted (this way we

data/lib/graphql/static_validation/rules/fragments_are_finite.rb

@@ -7,12 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
               "Fragment #{defn.name} contains an infinite loop",
               nodes: defn.node,
               path: defn.path,
               name: defn.name
-            )
+            ))
           end
         end
       end

data/lib/graphql/static_validation/rules/input_object_names_are_unique.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module InputObjectNamesAreUnique
+      def on_input_object(node, parent)
+        validate_input_fields(node)
+        super
+      end
+
+      private
+
+      def validate_input_fields(node)
+        input_field_defns = node.arguments
+        input_fields_by_name = Hash.new { |h, k| h[k] = [] }
+        input_field_defns.each { |a| input_fields_by_name[a.name] << a }
+
+        input_fields_by_name.each do |name, defns|
+          if defns.size > 1
+            error = GraphQL::StaticValidation::InputObjectNamesAreUniqueError.new(
+              "There can be only one input field named \"#{name}\"",
+              nodes: defns,
+              name: name
+            )
+            add_error(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/input_object_names_are_unique_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class InputObjectNamesAreUniqueError < StaticValidation::Error
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], name:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "inputFieldNotUnique"
+      end
+    end
+  end
+end
+

data/lib/graphql/static_validation/validation_context.rb

@@ -19,10 +19,11 @@ module GraphQL
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query, visitor_class)
+      def initialize(query, visitor_class, max_errors)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
+        @max_errors = max_errors || Float::INFINITY
         @on_dependency_resolve_handlers = []
         @visitor = visitor_class.new(document, self)
       end
@@ -38,6 +39,10 @@ module GraphQL
       def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
+
+      def too_many_errors?
+        @errors.length >= @max_errors
+      end
     end
   end
 end

data/lib/graphql/static_validation/validation_timeout_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ValidationTimeoutError < StaticValidation::Error
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "validationTimeout"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validator.rb

@@ -20,8 +20,11 @@ module GraphQL
 
       # Validate `query` against the schema. Returns an array of message hashes.
       # @param query [GraphQL::Query]
+      # @param validate [Boolean]
+      # @param timeout [Float] Number of seconds to wait before aborting validation. Any positive number may be used, including Floats to specify fractional seconds.
+      # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
-      def validate(query, validate: true)
+      def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.trace("validate", { validate: validate, query: query }) do
           can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis? && query.schema.is_a?(Class)
           errors = if validate == false && can_skip_rewrite
@@ -30,23 +33,34 @@ module GraphQL
             rules_to_use = validate ? @rules : []
             visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class, max_errors)
 
-            # Attach legacy-style rules.
-            # Only loop through rules if it has legacy-style rules
-            unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
-              legacy_rules.each do |rule_class_or_module|
-                if rule_class_or_module.method_defined?(:validate)
-                  rule_class_or_module.new.validate(context)
+            begin
+              # CAUTION: Usage of the timeout module makes the assumption that validation rules are stateless Ruby code that requires no cleanup if process was interrupted. This means no blocking IO calls, native gems, locks, or `rescue` clauses that must be reached.
+              # A timeout value of 0 or nil will execute the block without any timeout.
+              Timeout::timeout(timeout) do
+
+                catch(:too_many_validation_errors) do
+                  # Attach legacy-style rules.
+                  # Only loop through rules if it has legacy-style rules
+                  unless (legacy_rules = rules_to_use - GraphQL::StaticValidation::ALL_RULES).empty?
+                    legacy_rules.each do |rule_class_or_module|
+                      if rule_class_or_module.method_defined?(:validate)
+                        rule_class_or_module.new.validate(context)
+                      end
+                    end
+                  end
+
+                  context.visitor.visit
                 end
               end
+            rescue Timeout::Error
+              handle_timeout(query, context)
             end
 
-            context.visitor.visit
             context.errors
           end
 
-
           irep = if errors.empty? && context
             # Only return this if there are no errors and validation was actually run
             context.visitor.rewrite_document
@@ -60,6 +74,15 @@ module GraphQL
           }
         end
       end
+
+      # Invoked when static validation times out.
+      # @param query [GraphQL::Query]
+      # @param context [GraphQL::StaticValidation::ValidationContext]
+      def handle_timeout(query, context)
+        context.errors << GraphQL::StaticValidation::ValidationTimeoutError.new(
+          "Timeout on validation of query"
+        )
+      end
     end
   end
 end

data/lib/graphql/static_validation.rb

@@ -4,6 +4,7 @@ require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
+require "graphql/static_validation/validation_timeout_error"
 require "graphql/static_validation/literal_validator"
 require "graphql/static_validation/base_visitor"
 require "graphql/static_validation/no_validate_visitor"

data/lib/graphql/tracing/platform_tracing.rb

@@ -95,7 +95,7 @@ module GraphQL
       end
 
       def self.use(schema_defn, options = {})
-        tracer = self.new(options)
+        tracer = self.new(**options)
         schema_defn.instrument(:field, tracer)
         schema_defn.tracer(tracer)
       end

data/lib/graphql/tracing/prometheus_tracing/graphql_collector.rb

@@ -16,7 +16,10 @@ module GraphQL
         end
 
         def collect(object)
-          labels = { key: object['key'], platform_key: object['platform_key'] }
+          default_labels = { key: object['key'], platform_key: object['platform_key'] }
+          custom = object['custom_labels']
+          labels = custom.nil? ? default_labels : default_labels.merge(custom)
+
           @graphql_gauge.observe object['duration'], labels
         end
 

data/lib/graphql/types/int.rb

@@ -9,8 +9,15 @@ module GraphQL
       MIN = -(2**31)
       MAX = (2**31) - 1
 
-      def self.coerce_input(value, _ctx)
-        value.is_a?(Integer) ? value : nil
+      def self.coerce_input(value, ctx)
+        return if !value.is_a?(Integer)
+
+        if value >= MIN && value <= MAX
+          value
+        else
+          err = GraphQL::IntegerDecodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
       end
 
       def self.coerce_result(value, ctx)

data/lib/graphql/types/relay/base_connection.rb

@@ -94,7 +94,8 @@ module GraphQL
             type = nullable ? [@node_type, null: true] : [@node_type]
             field :nodes, type,
               null: nullable,
-              description: "A list of nodes."
+              description: "A list of nodes.",
+              connection: false
           end
         end
 

data/lib/graphql/types/relay/base_edge.rb

@@ -33,7 +33,8 @@ module GraphQL
             if node_type
               @node_type = node_type
               # Add a default `node` field
-              field :node, node_type, null: null, description: "The item at the end of the edge."
+              field :node, node_type, null: null, description: "The item at the end of the edge.",
+                connection: false
             end
             @node_type
           end

data/lib/graphql/types/string.rb

@@ -7,7 +7,13 @@ module GraphQL
 
       def self.coerce_result(value, ctx)
         str = value.to_s
-        str.encoding == Encoding::UTF_8 ? str : str.encode(Encoding::UTF_8)
+        if str.encoding == Encoding::UTF_8
+          str
+        elsif str.frozen?
+          str.encode(Encoding::UTF_8)
+        else
+          str.encode!(Encoding::UTF_8)
+        end
       rescue EncodingError
         err = GraphQL::StringEncodingError.new(str)
         ctx.schema.type_error(err, ctx)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.11.6"
+  VERSION = "1.11.10"
 end

data/lib/graphql.rb

@@ -129,6 +129,7 @@ require "graphql/introspection"
 require "graphql/analysis_error"
 require "graphql/coercion_error"
 require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
 require "graphql/integer_encoding_error"
 require "graphql/string_encoding_error"
 require "graphql/internal_representation"

data/readme.md

@@ -9,7 +9,7 @@
 A Ruby implementation of [GraphQL](https://graphql.org/).
 
 - [Website](https://graphql-ruby.org/)
-- [API Documentation](https://www.rubydoc.info/gems/graphql)
+- [API Documentation](https://www.rubydoc.info/github/rmosolgo/graphql-ruby)
 - [Newsletter](https://tinyletter.com/graphql-ruby)
 
 ## Installation

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.11.6
+  version: 1.11.10
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-29 00:00:00.000000000 Z
+date: 2021-11-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -445,6 +445,7 @@ files:
 - lib/graphql/id_type.rb
 - lib/graphql/input_object_type.rb
 - lib/graphql/int_type.rb
+- lib/graphql/integer_decoding_error.rb
 - lib/graphql/integer_encoding_error.rb
 - lib/graphql/interface_type.rb
 - lib/graphql/internal_representation.rb
@@ -650,6 +651,8 @@ files:
 - lib/graphql/static_validation/rules/fragments_are_on_composite_types_error.rb
 - lib/graphql/static_validation/rules/fragments_are_used.rb
 - lib/graphql/static_validation/rules/fragments_are_used_error.rb
+- lib/graphql/static_validation/rules/input_object_names_are_unique.rb
+- lib/graphql/static_validation/rules/input_object_names_are_unique_error.rb
 - lib/graphql/static_validation/rules/mutation_root_exists.rb
 - lib/graphql/static_validation/rules/mutation_root_exists_error.rb
 - lib/graphql/static_validation/rules/no_definitions_are_present.rb
@@ -676,6 +679,7 @@ files:
 - lib/graphql/static_validation/rules/variables_are_used_and_defined_error.rb
 - lib/graphql/static_validation/type_stack.rb
 - lib/graphql/static_validation/validation_context.rb
+- lib/graphql/static_validation/validation_timeout_error.rb
 - lib/graphql/static_validation/validator.rb
 - lib/graphql/string_encoding_error.rb
 - lib/graphql/string_type.rb
@@ -737,7 +741,7 @@ metadata:
   source_code_uri: https://github.com/rmosolgo/graphql-ruby
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://tinyletter.com/graphql-ruby
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -752,8 +756,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.22
+signing_key:
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []