graphql 1.11.6 → 1.13.19

data/lib/graphql/execution/interpreter.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+require "fiber"
 require "graphql/execution/interpreter/argument_value"
 require "graphql/execution/interpreter/arguments"
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
-require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
 require "graphql/execution/interpreter/resolve"
 require "graphql/execution/interpreter/handles_raw_value"
@@ -18,16 +18,19 @@ module GraphQL
       def execute(_operation, _root_type, query)
         runtime = evaluate(query)
         sync_lazies(query: query)
-        runtime.final_value
+        runtime.final_result
       end
 
       def self.use(schema_class)
-        schema_class.interpreter = true
-        schema_class.query_execution_strategy(GraphQL::Execution::Interpreter)
-        schema_class.mutation_execution_strategy(GraphQL::Execution::Interpreter)
-        schema_class.subscription_execution_strategy(GraphQL::Execution::Interpreter)
-        schema_class.add_subscription_extension_if_necessary
-        GraphQL::Schema::Object.include(HandlesRawValue)
+        if schema_class.interpreter?
+          definition_line = caller(2, 1).first
+          GraphQL::Deprecation.warn("GraphQL::Execution::Interpreter is now the default; remove `use GraphQL::Execution::Interpreter` from the schema definition (#{definition_line})")
+        else
+          schema_class.query_execution_strategy(self)
+          schema_class.mutation_execution_strategy(self)
+          schema_class.subscription_execution_strategy(self)
+          schema_class.add_subscription_extension_if_necessary
+        end
       end
 
       def self.begin_multiplex(multiplex)
@@ -53,7 +56,7 @@ module GraphQL
 
       def self.finish_query(query, _multiplex)
         {
-          "data" => query.context.namespace(:interpreter)[:runtime].final_value
+          "data" => query.context.namespace(:interpreter)[:runtime].final_result
         }
       end
 
@@ -63,10 +66,7 @@ module GraphQL
         # Although queries in a multiplex _share_ an Interpreter instance,
         # they also have another item of state, which is private to that query
         # in particular, assign it here:
-        runtime = Runtime.new(
-          query: query,
-          response: HashResponse.new,
-        )
+        runtime = Runtime.new(query: query)
         query.context.namespace(:interpreter)[:runtime] = runtime
 
         query.trace("execute_query", {query: query}) do
@@ -87,11 +87,11 @@ module GraphQL
         final_values = queries.map do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]
           # it might not be present if the query has an error
-          runtime ? runtime.final_value : nil
+          runtime ? runtime.final_result : nil
         end
         final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
-          Interpreter::Resolve.resolve_all(final_values)
+          Interpreter::Resolve.resolve_all(final_values, multiplex.dataloader)
         end
         queries.each do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]
@@ -109,7 +109,7 @@ module GraphQL
         def initialize(value:, path:, field:)
           message = "Failed to build a GraphQL list result for field `#{field.path}` at path `#{path.join(".")}`.\n".dup
 
-          message << "Expected `#{value.inspect}` to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
+          message << "Expected `#{value.inspect}` (#{value.class}) to implement `.each` to satisfy the GraphQL return type `#{field.type.to_type_signature}`.\n"
 
           if field.connection?
             message << "\nThis field was treated as a Relay-style connection; add `connection: false` to the `field(...)` to disable this behavior."

data/lib/graphql/execution/lazy.rb

@@ -48,7 +48,11 @@ module GraphQL
           end
         end
 
-        if @value.is_a?(StandardError)
+        # `SKIP` was made into a subclass of `GraphQL::Error` to improve runtime performance
+        # (fewer clauses in a hot `case` block), but now it requires special handling here.
+        # I think it's still worth it for the performance win, but if the number of special
+        # cases grows, then maybe it's worth rethinking somehow.
+        if @value.is_a?(StandardError) && @value != GraphQL::Execution::Execute::SKIP
           raise @value
         else
           @value

data/lib/graphql/execution/lookahead.rb

@@ -254,14 +254,14 @@ module GraphQL
             subselections_on_type = selections_on_type
             if (t = ast_selection.type)
               # Assuming this is valid, that `t` will be found.
-              on_type = @query.schema.get_type(t.name).type_class
+              on_type = @query.get_type(t.name).type_class
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
             find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = @query.fragments[ast_selection.name] || raise("Invariant: Can't look ahead to nonexistent fragment #{ast_selection.name} (found: #{@query.fragments.keys})")
             # Again, assuming a valid AST
-            on_type = @query.schema.get_type(frag_defn.type.name).type_class
+            on_type = @query.get_type(frag_defn.type.name).type_class
             subselections_on_type = subselections_by_type[on_type] ||= {}
             find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
           else

data/lib/graphql/execution/multiplex.rb

@@ -29,11 +29,13 @@ module GraphQL
 
       include Tracing::Traceable
 
-      attr_reader :context, :queries, :schema, :max_complexity
+      attr_reader :context, :queries, :schema, :max_complexity, :dataloader
       def initialize(schema:, queries:, context:, max_complexity:)
         @schema = schema
         @queries = queries
+        @queries.each { |q| q.multiplex = self }
         @context = context
+        @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -72,6 +74,24 @@ module GraphQL
           end
         end
 
+        # @param query [GraphQL::Query]
+        def begin_query(results, idx, query, multiplex)
+          operation = query.selected_operation
+          result = if operation.nil? || !query.valid? || query.context.errors.any?
+            NO_OPERATION
+          else
+            begin
+              # These were checked to be the same in `#supports_multiplexing?`
+              query.schema.query_execution_strategy.begin_query(query, multiplex)
+            rescue GraphQL::ExecutionError => err
+              query.context.errors << err
+              NO_OPERATION
+            end
+          end
+          results[idx] = result
+          nil
+        end
+
         private
 
         def run_as_multiplex(multiplex)
@@ -79,20 +99,28 @@ module GraphQL
           multiplex.schema.query_execution_strategy.begin_multiplex(multiplex)
           queries = multiplex.queries
           # Do as much eager evaluation of the query as possible
-          results = queries.map do |query|
-            begin_query(query, multiplex)
+          results = []
+          queries.each_with_index do |query, idx|
+            multiplex.dataloader.append_job { begin_query(results, idx, query, multiplex) }
           end
 
+          multiplex.dataloader.run
+
           # Then, work through lazy results in a breadth-first way
-          multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          multiplex.dataloader.append_job {
+            multiplex.schema.query_execution_strategy.finish_multiplex(results, multiplex)
+          }
+          multiplex.dataloader.run
 
           # Then, find all errors and assign the result to the query object
-          results.each_with_index.map do |data_result, idx|
+          results.each_with_index do |data_result, idx|
             query = queries[idx]
             finish_query(data_result, query, multiplex)
             # Get the Query::Result, not the Hash
-            query.result
+            results[idx] = query.result
           end
+
+          results
         rescue Exception
           # TODO rescue at a higher level so it will catch errors in analysis, too
           # Assign values here so that the query's `@executed` becomes true
@@ -100,23 +128,6 @@ module GraphQL
           raise
         end
 
-        # @param query [GraphQL::Query]
-        # @return [Hash] The initial result (may not be finished if there are lazy values)
-        def begin_query(query, multiplex)
-          operation = query.selected_operation
-          if operation.nil? || !query.valid? || query.context.errors.any?
-            NO_OPERATION
-          else
-            begin
-              # These were checked to be the same in `#supports_multiplexing?`
-              query.schema.query_execution_strategy.begin_query(query, multiplex)
-            rescue GraphQL::ExecutionError => err
-              query.context.errors << err
-              NO_OPERATION
-            end
-          end
-        end
-
         # @param data_result [Hash] The result for the "data" key, if any
         # @param query [GraphQL::Query] The query which was run
         # @return [Hash] final result of this query, including all values and errors
@@ -140,10 +151,15 @@ module GraphQL
 
             result
           end
+          if query.context.namespace?(:__query_result_extensions__)
+            query.result_values["extensions"] = query.context.namespace(:__query_result_extensions__)
+          end
         end
 
         # use the old `query_execution_strategy` etc to run this query
         def run_one_legacy(schema, query)
+          GraphQL::Deprecation.warn "Multiplex.run_one_legacy will be removed from GraphQL-Ruby 2.0, upgrade to the Interpreter to avoid this deprecated codepath: https://graphql-ruby.org/queries/interpreter.html"
+
           query.result_values = if !query.valid?
             all_errors = query.validation_errors + query.analysis_errors + query.context.errors
             if all_errors.any?

data/lib/graphql/field.rb

@@ -5,7 +5,7 @@ module GraphQL
   # @api deprecated
   class Field
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :description, :deprecation_reason,
+    deprecated_accepts_definitions :name, :description, :deprecation_reason,
       :resolve, :lazy_resolve,
       :type, :arguments,
       :property, :hash_key, :complexity,

data/lib/graphql/float_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition
+GraphQL::FLOAT_TYPE = GraphQL::Types::Float.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/function.rb

@@ -2,6 +2,10 @@
 module GraphQL
   # @api deprecated
   class Function
+    def self.inherited(subclass)
+      GraphQL::Deprecation.warn "GraphQL::Function (used for #{subclass}) will be removed from GraphQL-Ruby 2.0, please upgrade to resolvers: https://graphql-ruby.org/fields/resolvers.html"
+    end
+
     # @return [Hash<String => GraphQL::Argument>] Arguments, keyed by name
     def arguments
       self.class.arguments

data/lib/graphql/id_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition
+GraphQL::ID_TYPE = GraphQL::Types::ID.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/input_object_type.rb

@@ -2,7 +2,9 @@
 module GraphQL
   # @api deprecated
   class InputObjectType < GraphQL::BaseType
-    accepts_definitions(
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions(
       :arguments, :mutation,
       input_field: GraphQL::Define::AssignArgument,
       argument: GraphQL::Define::AssignArgument

data/lib/graphql/int_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition
+GraphQL::INT_TYPE = GraphQL::Types::Int.graphql_definition(silence_deprecation_warning: true)

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/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/interface_type.rb

@@ -2,10 +2,12 @@
 module GraphQL
   # @api deprecated
   class InterfaceType < GraphQL::BaseType
-    accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
+    extend Define::InstanceDefinable::DeprecatedDefine
+
+    deprecated_accepts_definitions :fields, :orphan_types, :resolve_type, field: GraphQL::Define::AssignObjectField
 
     attr_accessor :fields, :orphan_types, :resolve_type_proc
-    attr_writer :type_membership_class  
+    attr_writer :type_membership_class
     ensure_defined :fields, :orphan_types, :resolve_type_proc, :resolve_type
 
     def initialize

data/lib/graphql/internal_representation/document.rb

@@ -14,12 +14,12 @@ module GraphQL
       end
 
       def [](key)
-        warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
+        GraphQL::Deprecation.warn "#{self.class}#[] is deprecated; use `operation_definitions[]` instead"
         operation_definitions[key]
       end
 
       def each(&block)
-        warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
+        GraphQL::Deprecation.warn "#{self.class}#each is deprecated; use `operation_definitions.each` instead"
         operation_definitions.each(&block)
       end
     end

data/lib/graphql/internal_representation/rewrite.rb

@@ -60,7 +60,7 @@ module GraphQL
 
       # @return [Hash<String, Node>] Roots of this query
       def operations
-        warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
+        GraphQL::Deprecation.warn "#{self.class}#operations is deprecated; use `document.operation_definitions` instead"
         @document.operation_definitions
       end
 

data/lib/graphql/introspection/directive_location_enum.rb

@@ -6,8 +6,8 @@ module GraphQL
       description "A Directive can be adjacent to many parts of the GraphQL language, "\
                   "a __DirectiveLocation describes one such possible adjacencies."
 
-      GraphQL::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+      GraphQL::Schema::Directive::LOCATIONS.each do |location|
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
       end
       introspection true
     end

data/lib/graphql/introspection/directive_type.rb

@@ -10,15 +10,21 @@ module GraphQL
                   "skipping a field. Directives provide this by describing additional information "\
                     "to the executor."
       field :name, String, null: false, method: :graphql_name
-      field :description, String, null: true
-      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false
+      field :description, String
+      field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false, scope: false
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
+        argument :include_deprecated, Boolean, required: false, default_value: false
+      end
       field :on_operation, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_operation?
       field :on_fragment, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_fragment?
       field :on_field, Boolean, null: false, deprecation_reason: "Use `locations`.", method: :on_field?
 
-      def args
-        @context.warden.arguments(@object)
+      field :is_repeatable, Boolean, method: :repeatable?
+
+      def args(include_deprecated:)
+        args = @context.warden.arguments(@object)
+        args = args.reject(&:deprecation_reason) unless include_deprecated
+        args
       end
     end
   end

data/lib/graphql/introspection/entry_points.rb

@@ -3,8 +3,8 @@ module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
       field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", null: true do
-        argument :name, String, required: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system" do
+        argument :name, String
       end
 
       def __schema

data/lib/graphql/introspection/enum_value_type.rb

@@ -7,9 +7,9 @@ module GraphQL
                   "placeholder for a string or numeric value. However an Enum value is returned in "\
                   "a JSON response as a string."
       field :name, String, null: false
-      field :description, String, null: true
+      field :description, String
       field :is_deprecated, Boolean, null: false
-      field :deprecation_reason, String, null: true
+      field :deprecation_reason, String
 
       def name
         object.graphql_name

data/lib/graphql/introspection/field_type.rb

@@ -6,13 +6,13 @@ module GraphQL
       description "Object and Interface types are described by a list of Fields, each of which has "\
                   "a name, potentially a list of arguments, and a return type."
       field :name, String, null: false
-      field :description, String, null: true
-      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
+      field :description, String
+      field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false, scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
       field :is_deprecated, Boolean, null: false
-      field :deprecation_reason, String, null: true
+      field :deprecation_reason, String
 
       def is_deprecated
         !!@object.deprecation_reason

data/lib/graphql/introspection/input_value_type.rb

@@ -7,11 +7,11 @@ module GraphQL
                   "InputObject are represented as Input Values which describe their type and "\
                   "optionally a default value."
       field :name, String, null: false
-      field :description, String, null: true
+      field :description, String
       field :type, GraphQL::Schema::LateBoundType.new("__Type"), null: false
-      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value.", null: true
+      field :default_value, String, "A GraphQL-formatted string representing the default value for this input value."
       field :is_deprecated, Boolean, null: false
-      field :deprecation_reason, String, null: true
+      field :deprecation_reason, String
 
       def is_deprecated
         !!@object.deprecation_reason
@@ -23,6 +23,12 @@ module GraphQL
           if value.nil?
             'null'
           else
+            if (@object.type.kind.list? || (@object.type.kind.non_null? && @object.type.of_type.kind.list?)) && !value.respond_to?(:map)
+              # This is a bit odd -- we expect the default value to be an application-style value, so we use coerce result below.
+              # But coerce_result doesn't wrap single-item lists, which are valid inputs to list types.
+              # So, apply that wrapper here if needed.
+              value = [value]
+            end
             coerced_default_value = @object.type.coerce_result(value, @context)
             serialize_default_value(coerced_default_value, @object.type)
           end
@@ -48,7 +54,7 @@ module GraphQL
         elsif type.kind.input_object?
           "{" +
             value.map do |k, v|
-              arg_defn = type.arguments[k]
+              arg_defn = type.get_argument(k, context)
               "#{k}: #{serialize_default_value(v, arg_defn.type)}"
             end.join(", ") +
             "}"

data/lib/graphql/introspection/schema_type.rb

@@ -8,11 +8,16 @@ module GraphQL
                   "available types and directives on the server, as well as the entry points for "\
                   "query, mutation, and subscription operations."
 
-      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false
+      field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: false, scope: false
       field :query_type, GraphQL::Schema::LateBoundType.new("__Type"), "The type that query operations will be rooted at.", null: false
-      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at.", null: true
-      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at.", null: true
-      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false
+      field :mutation_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server supports mutation, the type that mutation operations will be rooted at."
+      field :subscription_type, GraphQL::Schema::LateBoundType.new("__Type"), "If this server support subscription, the type that subscription operations will be rooted at."
+      field :directives, [GraphQL::Schema::LateBoundType.new("__Directive")], "A list of all directives supported by this server.", null: false, scope: false
+      field :description, String, resolver_method: :schema_description
+
+      def schema_description
+        context.schema.description
+      end
 
       def types
         @context.warden.reachable_types.sort_by(&:graphql_name)
@@ -31,7 +36,7 @@ module GraphQL
       end
 
       def directives
-        context.schema.directives.values
+        @context.warden.directives
       end
 
       private

data/lib/graphql/introspection/type_type.rb

@@ -12,23 +12,29 @@ module GraphQL
                   "possible at runtime. List and NonNull types compose other types."
 
       field :kind, GraphQL::Schema::LateBoundType.new("__TypeKind"), null: false
-      field :name, String, null: true
-      field :description, String, null: true
-      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], null: true do
+      field :name, String, method: :graphql_name
+      field :description, String
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], null: true
-      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], null: true
-      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], null: true do
+      field :interfaces, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")], scope: false
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")], scope: false do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: true  do
+      field :input_fields, [GraphQL::Schema::LateBoundType.new("__InputValue")], scope: false  do
         argument :include_deprecated, Boolean, required: false, default_value: false
       end
-      field :of_type, GraphQL::Schema::LateBoundType.new("__Type"), null: true
+      field :of_type, GraphQL::Schema::LateBoundType.new("__Type")
 
-      def name
-        object.graphql_name
+      field :specified_by_url, String
+
+      def specified_by_url
+        if object.kind.scalar?
+          object.specified_by_url
+        else
+          nil
+        end
       end
 
       def kind
@@ -50,8 +56,8 @@ module GraphQL
       end
 
       def interfaces
-        if @object.kind == GraphQL::TypeKinds::OBJECT
-          @context.warden.interfaces(@object)
+        if @object.kind.object? || @object.kind.interface?
+          @context.warden.interfaces(@object).sort_by(&:graphql_name)
         else
           nil
         end

data/lib/graphql/introspection.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 module GraphQL
   module Introspection
-    def self.query(include_deprecated_args: false)
+    def self.query(include_deprecated_args: false, include_schema_description: false, include_is_repeatable: false, include_specified_by_url: false)
       # The introspection query to end all introspection queries, copied from
       # https://github.com/graphql/graphql-js/blob/master/src/utilities/introspectionQuery.js
       <<-QUERY
 query IntrospectionQuery {
   __schema {
+    #{include_schema_description ? "description" : ""}
     queryType { name }
     mutationType { name }
     subscriptionType { name }
@@ -17,7 +18,8 @@ query IntrospectionQuery {
       name
       description
       locations
-      args {
+      #{include_is_repeatable ? "isRepeatable" : ""}
+      args#{include_deprecated_args ? '(includeDeprecated: true)' : ''} {
         ...InputValue
       }
     }
@@ -27,6 +29,7 @@ fragment FullType on __Type {
   kind
   name
   description
+  #{include_specified_by_url ? "specifiedByUrl" : ""}
   fields(includeDeprecated: true) {
     name
     description

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/language/block_string.rb

@@ -2,16 +2,12 @@
 module GraphQL
   module Language
     module BlockString
-      if !String.method_defined?(:match?)
-        using GraphQL::StringMatchBackport
-      end
-
       # Remove leading and trailing whitespace from a block string.
       # See "Block Strings" in https://github.com/facebook/graphql/blob/master/spec/Section%202%20--%20Language.md
       def self.trim_whitespace(str)
         # Early return for the most common cases:
         if str == ""
-          return ""
+          return "".dup
         elsif !(has_newline = str.include?("\n")) && !(str.start_with?(" "))
           return str
         end
@@ -59,7 +55,7 @@ module GraphQL
         end
 
         # Rebuild the string
-        lines.size > 1 ? lines.join("\n") : (lines.first || "")
+        lines.size > 1 ? lines.join("\n") : (lines.first || "".dup)
       end
 
       def self.print(str, indent: '')