graphql 1.12.18 → 1.12.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5d1cfa93dc97adf13e461a45a00899f5ecc3e27d66c54c33d1a319b027665b78
-  data.tar.gz: 5d8cf2b669619dd15058400e15342ff225ba02716c5d8c9959c74260d4f51b32
+  metadata.gz: fee883bb45ad2391215f85a31ceec2f69b19c07c138708f002643c2fdf4c8a19
+  data.tar.gz: 925fb0e6f0acbb8ceddb79ad2eec4e8cfcd73bdf5cb51ad708dd1d7ebb491e2d
 SHA512:
-  metadata.gz: d7ff04a88e0ae883c382aa6559b52c38dbbc7d513537aaf506e89dd7880c227b6b032f7329c1c9e7b0fb9692b3e0e6fdbaac9df9fc82e536fb1e12b9cff2f65c
-  data.tar.gz: 3276674be3f8b0eb05d5c8904cad3ef20697bf5b9efcb133bd7c283d7bd704d52cd75f87a46f6c1fd988faf6c439c796d186280f4e397f8dc5184ae7d17c333b
+  metadata.gz: 480aba657ba456d83bc543132f730b56444068a8a14c054c5f7f98a3d7c87179d23d843cc862b4ba8388bdf020fcb3f231c4513a93c824cc7ce15e61a9160c67
+  data.tar.gz: 5744a84a14e922b2b26984986351cab87e41da464b985b1b28d53c7c42a921b5dd53cadca09c8a1679a2af1f7ee40dd42894e32bee373b88c8c2fe6fa917a1e9

data/lib/generators/graphql/object_generator.rb

@@ -12,7 +12,8 @@ module Graphql
     #
     # Add the Node interface with `--node`.
     class ObjectGenerator < TypeGeneratorBase
-      desc "Create a GraphQL::ObjectType with the given name and fields"
+      desc "Create a GraphQL::ObjectType with the given name and fields." \
+      "If the given type name matches an existing ActiveRecord model, the generated type will automatically include fields for the models database columns."
       source_root File.expand_path('../templates', __FILE__)
 
       argument :custom_fields,

data/lib/generators/graphql/relay.rb

@@ -32,20 +32,28 @@ module Graphql
 
   # Return a string UUID for `object`
   def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    object_id = object.to_global_id.to_s
+    # Remove this redundant prefix to make IDs shorter:
+    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
+    encoded_id = Base64.urlsafe_encode64(object_id)
+    # Remove the "=" padding
+    encoded_id = encoded_id.sub(/=+/, "")
+    # Add a type hint
+    type_hint = type_definition.graphql_name.first
+    "\#{type_hint}_\#{encoded_id}"
   end
 
   # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
+  def self.object_from_id(encoded_id_with_hint, query_ctx)
+    # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
+    # Split off the type hint
+    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
+    # Decode the ID
+    id = Base64.urlsafe_decode64(encoded_id)
+    # Rebuild it for Rails then find the object:
+    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
+    GlobalID::Locator.locate(full_global_id)
   end
 RUBY
         inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false

data/lib/generators/graphql/templates/schema.erb

@@ -4,11 +4,23 @@ class <%= schema_name %> < GraphQL::Schema
 <% if options[:batch] %>
   # GraphQL::Batch setup:
   use GraphQL::Batch
+<% else %>
+  # For batch-loading (see https://graphql-ruby.org/dataloader/overview.html)
+  use GraphQL::Dataloader
 <% end %>
+  # GraphQL-Ruby calls this when something goes wrong while running a query:
+  def self.type_error(err, context)
+    # if err.is_a?(GraphQL::InvalidNullError)
+    #   # report to your bug tracker here
+    #   return nil
+    # end
+    super
+  end
+
   # Union and Interface Resolution
   def self.resolve_type(abstract_type, obj, ctx)
-    # TODO: Implement this function
-    # to return the correct object type for `obj`
+    # TODO: Implement this method
+    # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
 end

data/lib/graphql/analysis/ast/field_usage.rb

@@ -15,8 +15,12 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
-
-          extract_deprecated_arguments(visitor.query.arguments_for(node, visitor.field_definition).argument_values)
+          arguments = visitor.query.arguments_for(node, visitor.field_definition)
+          # If there was an error when preparing this argument object,
+          # then this might be an error or something:
+          if arguments.respond_to?(:argument_values)
+            extract_deprecated_arguments(arguments.argument_values)
+          end
         end
 
         def result

data/lib/graphql/dataloader/source.rb

@@ -6,7 +6,11 @@ module GraphQL
       # Called by {Dataloader} to prepare the {Source}'s internal state
       # @api private
       def setup(dataloader)
+        # These keys have been requested but haven't been fetched yet
         @pending_keys = []
+        # These keys have been passed to `fetch` but haven't been finished yet
+        @fetching_keys = []
+        # { key => result }
         @results = {}
         @dataloader = dataloader
       end
@@ -64,29 +68,46 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync
+        pending_keys = @pending_keys.dup
         @dataloader.yield
+        iterations = 0
+        while pending_keys.any? { |k| !@results.key?(k) }
+          iterations += 1
+          if iterations > 1000
+            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_keys}), but they still weren't loaded. There is likely a circular dependency."
+          end
+          @dataloader.yield
+        end
+        nil
       end
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        @pending_keys.any?
+        !@pending_keys.empty?
       end
 
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]
       def run_pending_keys
+        if !@fetching_keys.empty?
+          @pending_keys -= @fetching_keys
+        end
         return if @pending_keys.empty?
         fetch_keys = @pending_keys.uniq
+        @fetching_keys.concat(fetch_keys)
         @pending_keys = []
         results = fetch(fetch_keys)
         fetch_keys.each_with_index do |key, idx|
           @results[key] = results[idx]
         end
+        nil
       rescue StandardError => error
         fetch_keys.each { |key| @results[key] = error }
       ensure
-        nil
+        if fetch_keys
+          @fetching_keys -= fetch_keys
+        end
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -116,6 +137,13 @@ module GraphQL
       # @return [Object] The result from {#fetch} for `key`.
       # @api private
       def result_for(key)
+        if !@results.key?(key)
+          raise <<-ERR
+Invariant: fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})
+
+This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
+ERR
+        end
         result = @results[key]
 
         raise result if result.class <= StandardError

data/lib/graphql/deprecation.rb

@@ -3,11 +3,7 @@
 module GraphQL
   module Deprecation
     def self.warn(message)
-      if defined?(ActiveSupport::Deprecation)
-        ActiveSupport::Deprecation.warn(message)
-      else
-        Kernel.warn(message)
-      end
+      Kernel.warn(message)
     end
   end
 end

data/lib/graphql/integer_encoding_error.rb

@@ -12,9 +12,25 @@ module GraphQL
     # The value which couldn't be encoded
     attr_reader :integer_value
 
-    def initialize(value)
+    # @return [GraphQL::Schema::Field] The field that returned a too-big integer
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
       @integer_value = value
-      super("Integer out of bounds: #{value}. \nConsider using ID or GraphQL::Types::BigInt instead.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Integer out of bounds: #{value}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". Consider using ID or GraphQL::Types::BigInt instead."
+      super(message)
     end
   end
 end

data/lib/graphql/language/nodes.rb

@@ -197,7 +197,16 @@ module GraphQL
               else
                 module_eval <<-RUBY, __FILE__, __LINE__
                   def children
-                    @children ||= (#{children_of_type.keys.map { |k| "@#{k}" }.join(" + ")}).freeze
+                    @children ||= begin
+                      if #{children_of_type.keys.map { |k| "@#{k}.any?" }.join(" || ")}
+                        new_children = []
+                        #{children_of_type.keys.map { |k| "new_children.concat(@#{k})" }.join("; ")}
+                        new_children.freeze
+                        new_children
+                      else
+                        NO_CHILDREN
+                      end
+                    end
                   end
                 RUBY
               end

data/lib/graphql/pagination/connections.rb

@@ -70,23 +70,42 @@ module GraphQL
         wrappers = context ? context.namespace(:connections)[:all_wrappers] : all_wrappers
         impl = wrapper_for(items, wrappers: wrappers)
 
-        if impl.nil?
-          raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
+        if impl
+          impl.new(
+            items,
+            context: context,
+            parent: parent,
+            field: field,
+            max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
+            first: arguments[:first],
+            after: arguments[:after],
+            last: arguments[:last],
+            before: arguments[:before],
+            arguments: arguments,
+            edge_class: edge_class_for_field(field),
+          )
+        else
+          begin
+            connection_class = GraphQL::Relay::BaseConnection.connection_for_nodes(items)
+            if parent.is_a?(GraphQL::Schema::Object)
+              parent = parent.object
+            end
+            connection_class.new(
+              items,
+              arguments,
+              field: field,
+              max_page_size: field.max_page_size,
+              parent: parent,
+              context: context,
+            )
+          rescue RuntimeError => err
+            if err.message.include?("No connection implementation to wrap")
+              raise ImplementationMissingError, "Couldn't find a connection wrapper for #{items.class} during #{field.path} (#{items.inspect})"
+            else
+              raise err
+            end
+          end
         end
-
-        impl.new(
-          items,
-          context: context,
-          parent: parent,
-          field: field,
-          max_page_size: field.has_max_page_size? ? field.max_page_size : context.schema.default_max_page_size,
-          first: arguments[:first],
-          after: arguments[:after],
-          last: arguments[:last],
-          before: arguments[:before],
-          arguments: arguments,
-          edge_class: edge_class_for_field(field),
-        )
       end
 
       # use an override if there is one

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, timeout: @schema.validate_timeout)
+          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/schema/directive.rb

@@ -116,6 +116,10 @@ module GraphQL
         @arguments = self.class.coerce_arguments(nil, arguments, Query::NullContext)
       end
 
+      def graphql_name
+        self.class.graphql_name
+      end
+
       LOCATIONS = [
         QUERY =                  :QUERY,
         MUTATION =               :MUTATION,

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

@@ -254,11 +254,17 @@ module GraphQL
                       if authed
                         application_object
                       else
-                        raise GraphQL::UnauthorizedError.new(
+                        err = GraphQL::UnauthorizedError.new(
                           object: application_object,
                           type: class_based_type,
                           context: context,
                         )
+                        if self.respond_to?(:unauthorized_object)
+                          err.set_backtrace(caller)
+                          unauthorized_object(err)
+                        else
+                          raise err
+                        end
                       end
                     end
                   else

data/lib/graphql/schema/resolver.rb

@@ -160,6 +160,16 @@ module GraphQL
         end
       end
 
+      # Called when an object loaded by `loads:` fails the `.authorized?` check for its resolved GraphQL object type.
+      #
+      # By default, the error is re-raised and passed along to {{Schema.unauthorized_object}}.
+      #
+      # Any value returned here will be used _instead of_ of the loaded object.
+      # @param err [GraphQL::UnauthorizedError]
+      def unauthorized_object(err)
+        raise err
+      end
+
       private
 
       def load_arguments(args)

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to specifically reject values that respond to `.blank?` and respond truthy for that method.
+      #
+      # @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)
+          @message = message
+          super(**default_options)
+          @allow_blank = allow_blank.nil? ? allow_blank_positional : allow_blank
+        end
+
+        def validate(_object, _context, value)
+          if value.respond_to?(:blank?) && value.blank?
+            if (value.nil? && @allow_null) || @allow_blank
+              # pass
+            else
+              @message
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Schema
+    class Validator
+      # Use this to specifically reject or permit `nil` values (given as `null` from GraphQL).
+      #
+      # @example require a non-null value for an argument if it is provided
+      #   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)
+          @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
+          end
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -38,7 +38,10 @@ module GraphQL
         end
 
         def validate(_object, _context, value)
-          if (@with_pattern && !value.match?(@with_pattern)) ||
+          if permitted_empty_value?(value)
+            # Do nothing
+          elsif value.nil? ||
+              (@with_pattern && !value.match?(@with_pattern)) ||
               (@without_pattern && value.match?(@without_pattern))
             @message
           end

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

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

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

@@ -43,11 +43,13 @@ module GraphQL
         end
 
         def validate(_object, _context, value)
-          if @maximum && value.length > @maximum
+          return if permitted_empty_value?(value) # pass in this case
+          length = value.nil? ? 0 : value.length
+          if @maximum && length > @maximum
             partial_format(@too_long, { count: @maximum })
-          elsif @minimum && value.length < @minimum
+          elsif @minimum && length < @minimum
             partial_format(@too_short, { count: @minimum })
-          elsif @is && value.length != @is
+          elsif @is && length != @is
             partial_format(@wrong_length, { count: @is })
           end
         end

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

@@ -32,6 +32,7 @@ module GraphQL
             equal_to: nil, other_than: nil,
             odd: nil, even: nil, within: nil,
             message: "%{validated} must be %{comparison} %{target}",
+            null_message: Validator::AllowNullValidator::MESSAGE,
             **default_options
           )
 
@@ -45,11 +46,16 @@ module GraphQL
           @even = even
           @within = within
           @message = message
+          @null_message = null_message
           super(**default_options)
         end
 
         def validate(object, context, value)
-          if @greater_than && value <= @greater_than
+          if permitted_empty_value?(value)
+            # pass in this case
+          elsif value.nil? # @allow_null is handled in the parent class
+            @null_message
+          elsif @greater_than && value <= @greater_than
             partial_format(@message, { comparison: "greater than", target: @greater_than })
           elsif @greater_than_or_equal_to && value < @greater_than_or_equal_to
             partial_format(@message, { comparison: "greater than or equal to", target: @greater_than_or_equal_to })

data/lib/graphql/schema/validator.rb

@@ -7,7 +7,6 @@ module GraphQL
       # @return [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>]
       attr_reader :validated
 
-      # TODO should this implement `if:` and `unless:` ?
       # @param validated [GraphQL::Schema::Argument, GraphQL::Schema::Field, GraphQL::Schema::Resolver, Class<GraphQL::Schema::InputObject>] The argument or argument owner this validator is attached to
       # @param allow_blank [Boolean] if `true`, then objects that respond to `.blank?` and return true for `.blank?` will skip this validation
       # @param allow_null [Boolean] if `true`, then incoming `null`s will skip this validation
@@ -25,26 +24,6 @@ module GraphQL
         raise GraphQL::RequiredImplementationMissingError, "Validator classes should implement #validate"
       end
 
-      # This is called by the validation system and eventually calls {#validate}.
-      # @api private
-      def apply(object, context, value)
-        if value.nil?
-          if @allow_null
-            nil # skip this
-          else
-            "%{validated} can't be null"
-          end
-        elsif value.respond_to?(:blank?) && value.blank?
-          if @allow_blank
-            nil # skip this
-          else
-            "%{validated} can't be blank"
-          end
-        else
-          validate(object, context, value)
-        end
-      end
-
       # This is like `String#%`, but it supports the case that only some of `string`'s
       # values are present in `substitutions`
       def partial_format(string, substitutions)
@@ -55,6 +34,12 @@ module GraphQL
         string
       end
 
+      # @return [Boolean] `true` if `value` is `nil` and this validator has `allow_null: true` or if value is `.blank?` and this validator has `allow_blank: true`
+      def permitted_empty_value?(value)
+        (value.nil? && @allow_null) ||
+          (@allow_blank && value.respond_to?(:blank?) && value.blank?)
+      end
+
       # @param schema_member [GraphQL::Schema::Field, GraphQL::Schema::Argument, Class<GraphQL::Schema::InputObject>]
       # @param validates_hash [Hash{Symbol => Hash}, Hash{Class => Hash} nil] A configuration passed as `validates:`
       # @return [Array<Validator>]
@@ -62,6 +47,24 @@ module GraphQL
         if validates_hash.nil? || validates_hash.empty?
           EMPTY_ARRAY
         else
+          validates_hash = validates_hash.dup
+          allow_null = validates_hash.delete(:allow_null)
+          allow_blank = validates_hash.delete(:allow_blank)
+
+          # This could be {...}.compact on Ruby 2.4+
+          default_options = {}
+          if !allow_null.nil?
+            default_options[:allow_null] = allow_null
+          end
+          if !allow_blank.nil?
+            default_options[:allow_blank] = allow_blank
+          end
+
+          # allow_nil or allow_blank are the _only_ validations:
+          if validates_hash.empty?
+            validates_hash = default_options
+          end
+
           validates_hash.map do |validator_name, options|
             validator_class = case validator_name
             when Class
@@ -69,7 +72,11 @@ module GraphQL
             else
               all_validators[validator_name] || raise(ArgumentError, "unknown validation: #{validator_name.inspect}")
             end
-            validator_class.new(validated: schema_member, **options)
+            if options.is_a?(Hash)
+              validator_class.new(validated: schema_member, **(default_options.merge(options)))
+            else
+              validator_class.new(options, validated: schema_member, **default_options)
+            end
           end
         end
       end
@@ -122,10 +129,10 @@ module GraphQL
 
         validators.each do |validator|
           validated = as || validator.validated
-          errors = validator.apply(object, context, value)
+          errors = validator.validate(object, context, value)
           if errors &&
-            (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
-            (errors.is_a?(String))
+              (errors.is_a?(Array) && errors != EMPTY_ARRAY) ||
+              (errors.is_a?(String))
             if all_errors.frozen? # It's empty
               all_errors = []
             end
@@ -161,3 +168,7 @@ require "graphql/schema/validator/exclusion_validator"
 GraphQL::Schema::Validator.install(:exclusion, GraphQL::Schema::Validator::ExclusionValidator)
 require "graphql/schema/validator/required_validator"
 GraphQL::Schema::Validator.install(:required, GraphQL::Schema::Validator::RequiredValidator)
+require "graphql/schema/validator/allow_null_validator"
+GraphQL::Schema::Validator.install(:allow_null, GraphQL::Schema::Validator::AllowNullValidator)
+require "graphql/schema/validator/allow_blank_validator"
+GraphQL::Schema::Validator.install(:allow_blank, GraphQL::Schema::Validator::AllowBlankValidator)

data/lib/graphql/static_validation/error.rb

@@ -32,8 +32,10 @@ module GraphQL
 
       private
 
+      attr_reader :nodes
+
       def locations
-        @nodes.map do |node|
+        nodes.map do |node|
           h = {"line" => node.line, "column" => node.col}
           h["filename"] = node.filename if node.filename
           h

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

@@ -10,6 +10,7 @@ module GraphQL
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
       NO_ARGS = {}.freeze
+
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
 
@@ -17,24 +18,47 @@ module GraphQL
         super
         @visited_fragments = {}
         @compared_fragments = {}
+        @conflict_count = 0
       end
 
       def on_operation_definition(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       def on_field(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       private
 
+      def field_conflicts
+        @field_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :field, field_name: field)
+        end
+      end
+
+      def arg_conflicts
+        @arg_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :argument, field_name: field)
+        end
+      end
+
+      def setting_errors
+        @field_conflicts = nil
+        @arg_conflicts = nil
+
+        yield
+        # don't initialize these if they weren't initialized in the block:
+        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
+        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
+      end
+
       def conflicts_within_selection_set(node, parent_type)
         return if parent_type.nil?
 
-        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: [])
+        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: nil)
 
         # (A) Find find all conflicts "within" the fields of this selection set.
         find_conflicts_within(fields)
@@ -174,15 +198,21 @@ module GraphQL
         response_keys.each do |key, fields|
           next if fields.size < 2
           # find conflicts within nodes
-          for i in 0..fields.size - 1
-            for j in i + 1..fields.size - 1
+          i = 0
+          while i < fields.size
+            j = i + 1
+            while j < fields.size
               find_conflict(key, fields[i], fields[j])
+              j += 1
             end
+            i += 1
           end
         end
       end
 
       def find_conflict(response_key, field1, field2, mutually_exclusive: false)
+        return if @conflict_count >= context.max_errors
+
         node1 = field1.node
         node2 = field2.node
 
@@ -191,28 +221,21 @@ module GraphQL
 
         if !are_mutually_exclusive
           if node1.name != node2.name
-            errored_nodes = [node1.name, node2.name].sort.join(" or ")
-            msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            add_error(GraphQL::StaticValidation::FieldsWillMergeError.new(
-              msg,
-              nodes: [node1, node2],
-              path: [],
-              field_name: response_key,
-              conflicts: errored_nodes
-            ))
+            conflict = field_conflicts[response_key]
+
+            conflict.add_conflict(node1, node1.name)
+            conflict.add_conflict(node2, node2.name)
+
+            @conflict_count += 1
           end
 
           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: conflicts
-            ))
+            conflict = arg_conflicts[response_key]
+
+            conflict.add_conflict(node1, GraphQL::Language.serialize(serialize_field_args(node1)))
+            conflict.add_conflict(node2, GraphQL::Language.serialize(serialize_field_args(node2)))
+
+            @conflict_count += 1
           end
         end
 
@@ -224,7 +247,9 @@ module GraphQL
       end
 
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
-        return if field1.definition.nil? || field2.definition.nil?
+        return if field1.definition.nil? ||
+          field2.definition.nil? ||
+          (field1.node.selections.empty? && field2.node.selections.empty?)
 
         return_type1 = field1.definition.type.unwrap
         return_type2 = field2.definition.type.unwrap
@@ -304,6 +329,7 @@ module GraphQL
         if node.selections.empty?
           NO_SELECTIONS
         else
+          parents ||= []
           fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents, fields: [], fragment_spreads: [])
           response_keys = fields.group_by { |f| f.node.alias || f.node.name }
           [response_keys, fragment_spreads]

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

@@ -3,12 +3,33 @@ module GraphQL
   module StaticValidation
     class FieldsWillMergeError < StaticValidation::Error
       attr_reader :field_name
-      attr_reader :conflicts
+      attr_reader :kind
+
+      def initialize(kind:, field_name:)
+        super(nil)
 
-      def initialize(message, path: nil, nodes: [], field_name:, conflicts:)
-        super(message, path: path, nodes: nodes)
         @field_name = field_name
-        @conflicts = conflicts
+        @kind = kind
+        @conflicts = []
+      end
+
+      def message
+        "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
+      end
+
+      def path
+        []
+      end
+
+      def conflicts
+        @conflicts.join(' or ')
+      end
+
+      def add_conflict(node, conflict_str)
+        return if nodes.include?(node)
+
+        @nodes << node
+        @conflicts << conflict_str
       end
 
       # A hash representation of this Message

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

@@ -16,6 +16,8 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
+        args = defn.arguments
+        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = defn.arguments.each_value
           .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }

data/lib/graphql/static_validation/validation_context.rb

@@ -15,7 +15,8 @@ module GraphQL
       extend Forwardable
 
       attr_reader :query, :errors, :visitor,
-        :on_dependency_resolve_handlers
+        :on_dependency_resolve_handlers,
+        :max_errors
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 

data/lib/graphql/string_encoding_error.rb

@@ -1,10 +1,20 @@
 # frozen_string_literal: true
 module GraphQL
   class StringEncodingError < GraphQL::RuntimeTypeError
-    attr_reader :string
-    def initialize(str)
+    attr_reader :string, :field, :path
+    def initialize(str, context:)
       @string = str
-      super("String \"#{str}\" was encoded as #{str.encoding}! GraphQL requires an encoding compatible with UTF-8.")
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "String #{str.inspect} was encoded as #{str.encoding}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      message << ". GraphQL requires an encoding compatible with UTF-8."
+      super(message)
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -53,6 +53,36 @@ module GraphQL
 
       class << self
         private
+
+        # This method does not support cyclic references in the Hash,
+        # nor does it support Hashes whose keys are not sortable
+        # with respect to their peers ( cases where a <=> b might throw an error )
+        def deep_sort_hash_keys(hash_to_sort)
+          raise ArgumentError.new("Argument must be a Hash") unless hash_to_sort.is_a?(Hash)
+          hash_to_sort.keys.sort.map do |k|
+            if hash_to_sort[k].is_a?(Hash)
+              [k, deep_sort_hash_keys(hash_to_sort[k])]
+            elsif hash_to_sort[k].is_a?(Array)
+              [k, deep_sort_array_hashes(hash_to_sort[k])]
+            else
+              [k, hash_to_sort[k]]
+            end
+          end.to_h
+        end
+
+        def deep_sort_array_hashes(array_to_inspect)
+          raise ArgumentError.new("Argument must be an Array") unless array_to_inspect.is_a?(Array)
+          array_to_inspect.map do |v|
+            if v.is_a?(Hash)
+              deep_sort_hash_keys(v)
+            elsif v.is_a?(Array)
+              deep_sort_array_hashes(v)
+            else
+              v
+            end
+          end
+        end
+
         def stringify_args(arg_owner, args)
           arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
           case args
@@ -65,12 +95,26 @@ module GraphQL
 
               if arg_defn
                 normalized_arg_name = camelized_arg_name
-                next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
               else
                 normalized_arg_name = arg_name
                 arg_defn = get_arg_definition(arg_owner, normalized_arg_name)
               end
-              next_args[normalized_arg_name] = stringify_args(arg_defn.type, v)
+              arg_base_type = arg_defn.type.unwrap
+              # In the case where the value being emitted is seen as a "JSON"
+              # type, treat the value as one atomic unit of serialization
+              is_json_definition = arg_base_type && arg_base_type <= GraphQL::Types::JSON
+              if is_json_definition
+                sorted_value = if v.is_a?(Hash)
+                  deep_sort_hash_keys(v)
+                elsif v.is_a?(Array)
+                  deep_sort_array_hashes(v)
+                else
+                  v
+                end
+                next_args[normalized_arg_name] = sorted_value.respond_to?(:to_json) ? sorted_value.to_json : sorted_value
+              else
+                next_args[normalized_arg_name] = stringify_args(arg_base_type, v)
+              end
             end
             # Make sure they're deeply sorted
             next_args.sort.to_h

data/lib/graphql/types/int.rb

@@ -25,7 +25,7 @@ module GraphQL
         if value >= MIN && value <= MAX
           value
         else
-          err = GraphQL::IntegerEncodingError.new(value)
+          err = GraphQL::IntegerEncodingError.new(value, context: ctx)
           ctx.schema.type_error(err, ctx)
         end
       end

data/lib/graphql/types/string.rb

@@ -15,7 +15,7 @@ module GraphQL
           str.encode!(Encoding::UTF_8)
         end
       rescue EncodingError
-        err = GraphQL::StringEncodingError.new(str)
+        err = GraphQL::StringEncodingError.new(str, context: ctx)
         ctx.schema.type_error(err, ctx)
       end
 

data/lib/graphql/unauthorized_error.rb

@@ -12,7 +12,7 @@ module GraphQL
     attr_reader :type
 
     # @return [GraphQL::Query::Context] the context for the current query
-    attr_reader :context
+    attr_accessor :context
 
     def initialize(message = nil, object: nil, type: nil, context: nil)
       if message.nil? && object.nil? && type.nil?

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.12.18
+  version: 1.12.24
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire:
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-02 00:00:00.000000000 Z
+date: 2022-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -544,6 +544,8 @@ files:
 - lib/graphql/schema/unique_within_type.rb
 - lib/graphql/schema/validation.rb
 - lib/graphql/schema/validator.rb
+- lib/graphql/schema/validator/allow_blank_validator.rb
+- lib/graphql/schema/validator/allow_null_validator.rb
 - lib/graphql/schema/validator/exclusion_validator.rb
 - lib/graphql/schema/validator/format_validator.rb
 - lib/graphql/schema/validator/inclusion_validator.rb
@@ -685,7 +687,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
@@ -700,8 +702,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key:
+rubygems_version: 3.1.6
+signing_key: 
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []