graphql 1.12.10 → 1.13.4

data/lib/graphql/execution/interpreter.rb

@@ -4,7 +4,6 @@ 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"
@@ -19,7 +18,7 @@ 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)
@@ -57,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
 
@@ -67,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
@@ -91,7 +87,7 @@ 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

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

@@ -35,7 +35,7 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @context[:dataloader] = @dataloader = @schema.dataloader_class.new
+        @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
         # Support `context: {backtrace: true}`
         if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
@@ -151,6 +151,9 @@ 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

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/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/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_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/introspection/directive_type.rb

@@ -10,7 +10,7 @@ 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 :description, String
       field :locations, [GraphQL::Schema::LateBoundType.new("__DirectiveLocation")], null: false
       field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: false do
         argument :include_deprecated, Boolean, required: false, default_value: false

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 :description, String
       field :args, [GraphQL::Schema::LateBoundType.new("__InputValue")], null: 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

@@ -10,8 +10,8 @@ module GraphQL
 
       field :types, [GraphQL::Schema::LateBoundType.new("__Type")], "A list of all types supported by this server.", null: 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 :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
 
       def types
@@ -31,7 +31,7 @@ module GraphQL
       end
 
       def directives
-        context.schema.directives.values
+        @context.warden.directives
       end
 
       private

data/lib/graphql/introspection/type_type.rb

@@ -12,20 +12,20 @@ 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
+      field :description, String
+      field :fields, [GraphQL::Schema::LateBoundType.new("__Field")] 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")]
+      field :possible_types, [GraphQL::Schema::LateBoundType.new("__Type")]
+      field :enum_values, [GraphQL::Schema::LateBoundType.new("__EnumValue")] 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")]  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
@@ -50,8 +50,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/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: '')

data/lib/graphql/language/document_from_schema_definition.rb

@@ -34,6 +34,7 @@ module GraphQL
           schema: @schema,
           context: schema_context,
         )
+        schema_context.warden = @warden
       end
 
       def document
@@ -87,6 +88,7 @@ module GraphQL
       def build_interface_type_node(interface_type)
         GraphQL::Language::Nodes::InterfaceTypeDefinition.new(
           name: interface_type.graphql_name,
+          interfaces: warden.interfaces(interface_type).sort_by(&:graphql_name).map { |type| build_type_name_node(type) },
           description: interface_type.description,
           fields: build_field_nodes(warden.fields(interface_type)),
           directives: directives(interface_type),
@@ -194,10 +196,14 @@ module GraphQL
         when "INPUT_OBJECT"
           GraphQL::Language::Nodes::InputObject.new(
             arguments: default_value.to_h.map do |arg_name, arg_value|
-              arg_type = type.arguments.fetch(arg_name.to_s).type
+              args = @warden.arguments(type)
+              arg = args.find { |a| a.keyword.to_s == arg_name.to_s }
+              if arg.nil?
+                raise ArgumentError, "No argument definition on #{type.graphql_name} for argument: #{arg_name.inspect} (expected one of: #{args.map(&:keyword)})"
+              end
               GraphQL::Language::Nodes::Argument.new(
-                name: arg_name.to_s,
-                value: build_default_value(arg_value, arg_type)
+                name: arg.graphql_name.to_s,
+                value: build_default_value(arg_value, arg.type)
               )
             end
           )
@@ -295,7 +301,7 @@ module GraphQL
         else
           member.directives.map do |dir|
             args = []
-            dir.arguments.argument_values.each_value do |arg_value|
+            dir.arguments.argument_values.each_value do |arg_value| # rubocop:disable Development/ContextIsPassedCop -- directive instance method
               arg_defn = arg_value.definition
               if arg_defn.default_value? && arg_value.value == arg_defn.default_value
                 next

data/lib/graphql/language/lexer.rb

@@ -3,9 +3,6 @@
 module GraphQL
 module Language
 module Lexer
-if !String.method_defined?(:match?)
-	using GraphQL::StringMatchBackport
-end
 
 def self.tokenize(query_string)
 	run_lexer(query_string)

data/lib/graphql/language/lexer.rl

@@ -121,10 +121,6 @@
 module GraphQL
   module Language
     module Lexer
-      if !String.method_defined?(:match?)
-        using GraphQL::StringMatchBackport
-      end
-
       def self.tokenize(query_string)
         run_lexer(query_string)
       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
@@ -332,7 +341,7 @@ module GraphQL
       #    end
       #  end
       #
-      #  document.to_query_string(printer: VariableSrubber.new)
+      #  document.to_query_string(printer: VariableScrubber.new)
       #
       class Document < AbstractNode
         scalar_methods false
@@ -467,7 +476,6 @@ module GraphQL
         end
       end
 
-
       # A list type definition, denoted with `[...]` (used for variable type definitions)
       class ListType < WrapperType
       end
@@ -618,6 +626,7 @@ module GraphQL
         attr_reader :description
         scalar_methods :name
         children_methods({
+          interfaces: GraphQL::Language::Nodes::TypeName,
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })
@@ -627,6 +636,7 @@ module GraphQL
       class InterfaceTypeExtension < AbstractNode
         scalar_methods :name
         children_methods({
+          interfaces: GraphQL::Language::Nodes::TypeName,
           directives: GraphQL::Language::Nodes::Directive,
           fields: GraphQL::Language::Nodes::FieldDefinition,
         })