graphql 2.4.3 → 2.5.2

data/lib/graphql/execution/interpreter.rb

@@ -23,7 +23,7 @@ module GraphQL
         # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
           queries = query_options.map do |opts|
-            case opts
+            query = case opts
             when Hash
               schema.query_class.new(schema, nil, **opts)
             when GraphQL::Query
@@ -31,11 +31,15 @@ module GraphQL
             else
               raise "Expected Hash or GraphQL::Query, not #{opts.class} (#{opts.inspect})"
             end
+            query
           end
 
+          return GraphQL::EmptyObjects::EMPTY_ARRAY if queries.empty?
+
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          trace = multiplex.current_trace
           Fiber[:__graphql_current_multiplex] = multiplex
-          multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
+          trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
@@ -44,7 +48,10 @@ module GraphQL
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
+            trace.begin_analyze_multiplex(multiplex, multiplex_analyzers)
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
+            trace.end_analyze_multiplex(multiplex, multiplex_analyzers)
+
             begin
               # Since this is basically the batching context,
               # share it for a whole multiplex
@@ -53,11 +60,13 @@ module GraphQL
               results = []
               queries.each_with_index do |query, idx|
                 if query.subscription? && !query.subscription_update?
-                  query.context.namespace(:subscriptions)[:events] = []
+                  subs_namespace = query.context.namespace(:subscriptions)
+                  subs_namespace[:events] = []
+                  subs_namespace[:subscriptions] = {}
                 end
                 multiplex.dataloader.append_job {
                   operation = query.selected_operation
-                  result = if operation.nil? || !query.valid? || query.context.errors.any?
+                  result = if operation.nil? || !query.valid? || !query.context.errors.empty?
                     NO_OPERATION
                   else
                     begin
@@ -100,12 +109,12 @@ module GraphQL
               # Then, find all errors and assign the result to the query object
               results.each_with_index do |data_result, idx|
                 query = queries[idx]
-                if (events = query.context.namespace(:subscriptions)[:events]) && events.any?
+                if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
                   schema.subscriptions.write_subscription(query, events)
                 end
                 # Assign the result so that it can be accessed in instrumentation
                 query.result_values = if data_result.equal?(NO_OPERATION)
-                  if !query.valid? || query.context.errors.any?
+                  if !query.valid? || !query.context.errors.empty?
                     # A bit weird, but `Query#static_errors` _includes_ `query.context.errors`
                     { "errors" => query.static_errors.map(&:to_h) }
                   else
@@ -114,7 +123,7 @@ module GraphQL
                 else
                   result = {}
 
-                  if query.context.errors.any?
+                  if !query.context.errors.empty?
                     error_result = query.context.errors.map(&:to_h)
                     result["errors"] = error_result
                   end

data/lib/graphql/execution/multiplex.rb

@@ -32,14 +32,10 @@ module GraphQL
         @queries = queries
         @queries.each { |q| q.multiplex = self }
         @context = context
-        @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
-        # Support `context: {backtrace: true}`
-        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-          @tracers << GraphQL::Backtrace::Tracer
-        end
         @max_complexity = max_complexity
+        @current_trace = context[:trace] ||= schema.new_trace(multiplex: self)
       end
     end
   end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a __DirectiveLocation describes one such possible adjacencies."
 
       GraphQL::Schema::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location, value_method: false)
       end
       introspection true
     end

data/lib/graphql/invalid_name_error.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module GraphQL
-  class InvalidNameError < GraphQL::ExecutionError
+  class InvalidNameError < GraphQL::Error
     attr_reader :name, :valid_regex
     def initialize(name, valid_regex)
       @name = name

data/lib/graphql/invalid_null_error.rb

@@ -2,33 +2,23 @@
 module GraphQL
   # Raised automatically when a field's resolve function returns `nil`
   # for a non-null field.
-  class InvalidNullError < GraphQL::RuntimeTypeError
+  class InvalidNullError < GraphQL::Error
     # @return [GraphQL::BaseType] The owner of {#field}
     attr_reader :parent_type
 
     # @return [GraphQL::Field] The field which failed to return a value
     attr_reader :field
 
-    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
-    attr_reader :value
+    # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
+    attr_reader :ast_node
 
-    def initialize(parent_type, field, value)
+    def initialize(parent_type, field, ast_node)
       @parent_type = parent_type
       @field = field
-      @value = value
+      @ast_node = ast_node
       super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end
 
-    # @return [Hash] An entry for the response's "errors" key
-    def to_h
-      { "message" => message }
-    end
-
-    # @deprecated always false
-    def parent_error?
-      false
-    end
-
     class << self
       attr_accessor :parent_class
 

data/lib/graphql/language/cache.rb

@@ -5,12 +5,25 @@ require 'digest/sha2'
 
 module GraphQL
   module Language
+    # This cache is used by {GraphQL::Language::Parser.parse_file} when it's enabled.
+    #
+    # With Rails, parser caching may enabled by setting `config.graphql.parser_cache = true` in your Rails application.
+    #
+    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new("some_dir")`.
+    # This will create a directory (`tmp/cache/graphql` by default) that stores a cache of parsed files.
+    #
+    # Much like [bootsnap](https://github.com/Shopify/bootsnap), the parser cache needs to be cleaned up manually.
+    # You will need to clear the cache directory for each new deployment of your application.
+    # Also note that the parser cache will grow as your schema is loaded, so the cache directory must be writable.
+    #
+    # @see GraphQL::Railtie for simple Rails integration
     class Cache
       def initialize(path)
         @path = path
       end
 
       DIGEST = Digest::SHA256.new << GraphQL::VERSION
+
       def fetch(filename)
         hash = DIGEST.dup << filename
         begin

data/lib/graphql/language/document_from_schema_definition.rb

@@ -52,7 +52,7 @@ module GraphQL
 
       def build_object_type_node(object_type)
         ints = @types.interfaces(object_type)
-        if ints.any?
+        if !ints.empty?
           ints.sort_by!(&:graphql_name)
           ints.map! { |iface| build_type_name_node(iface) }
         end
@@ -247,7 +247,7 @@ module GraphQL
       end
 
       def build_argument_nodes(arguments)
-        if arguments.any?
+        if !arguments.empty?
           nodes = arguments.map { |arg| build_argument_node(arg) }
           nodes.sort_by!(&:name)
           nodes
@@ -271,7 +271,7 @@ module GraphQL
         all_types = @types.all_types
         type_nodes = build_type_definition_nodes(all_types)
 
-        if (ex_t = schema.extra_types).any?
+        if !(ex_t = schema.extra_types).empty?
           dummy_query = Class.new(GraphQL::Schema::Object) do
             graphql_name "DummyQuery"
             (all_types + ex_t).each_with_index do |type, idx|
@@ -346,10 +346,11 @@ module GraphQL
       end
 
       def definition_directives(member, directives_method)
-        dirs = if !member.respond_to?(directives_method) || member.directives.empty?
+        if !member.respond_to?(directives_method) || member.directives.empty?
           EmptyObjects::EMPTY_ARRAY
         else
-          member.public_send(directives_method).map do |dir|
+          visible_directives = member.public_send(directives_method).select { |dir| @types.directive_exists?(dir.graphql_name) }
+          visible_directives.map! do |dir|
             args = []
             dir.arguments.argument_values.each_value do |arg_value| # rubocop:disable Development/ContextIsPassedCop -- directive instance method
               arg_defn = arg_value.definition
@@ -373,9 +374,9 @@ module GraphQL
               arguments: args
             )
           end
-        end
 
-        dirs
+          visible_directives
+        end
       end
 
       attr_reader :schema, :always_include_schema,

data/lib/graphql/language/lexer.rb

@@ -13,17 +13,21 @@ module GraphQL
         @pos = nil
         @max_tokens = max_tokens || Float::INFINITY
         @tokens_count = 0
+        @finished = false
       end
 
-      def eos?
-        @scanner.eos?
+      def finished?
+        @finished
       end
 
       attr_reader :pos, :tokens_count
 
       def advance
         @scanner.skip(IGNORE_REGEXP)
-        return false if @scanner.eos?
+        if @scanner.eos?
+          @finished = true
+          return false
+        end
         @tokens_count += 1
         if @tokens_count > @max_tokens
           raise_parse_error("This query is too large to execute.")
@@ -72,7 +76,10 @@ module GraphQL
             # Check for a matched decimal:
             @scanner[1] ? :FLOAT : :INT
           else
-            raise_parse_error("Expected a number, but it was malformed (#{@string[@pos].inspect})")
+            # Attempt to find the part after the `-`
+            value = @scanner.scan(/-\s?[a-z0-9]*/i)
+            invalid_byte_for_number_error_message = "Expected type 'number', but it was malformed#{value.nil? ? "" : ": #{value.inspect}"}."
+            raise_parse_error(invalid_byte_for_number_error_message)
           end
         when ByteFor::ELLIPSIS
           if @string.getbyte(@pos + 1) != 46 || @string.getbyte(@pos + 2) != 46

data/lib/graphql/language/nodes.rb

@@ -141,6 +141,8 @@ module GraphQL
         end
 
         class << self
+          # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
           # Add a default `#visit_method` and `#children_method_name` using the class name
           def inherited(child_class)
             super
@@ -343,6 +345,7 @@ module GraphQL
               RUBY
             end
           end
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

data/lib/graphql/language/parser.rb

@@ -110,7 +110,7 @@ module GraphQL
           # Only ignored characters is not a valid document
           raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @graphql_str)
         end
-        while !@lexer.eos?
+        while !@lexer.finished?
           defns << definition
         end
         Document.new(pos: 0, definitions: defns, filename: @filename, source: self)
@@ -161,7 +161,7 @@ module GraphQL
               expect_token(:VAR_SIGN)
               var_name = parse_name
               expect_token(:COLON)
-              var_type = self.type
+              var_type = self.type || raise_parse_error("Missing type definition for variable: $#{var_name}")
               default_value = if at?(:EQUALS)
                 advance_token
                 value
@@ -488,26 +488,33 @@ module GraphQL
       end
 
       def type
-        type = case token_name
+        parsed_type = case token_name
         when :IDENTIFIER
           parse_type_name
         when :LBRACKET
           list_type
+        else
+          nil
         end
 
-        if at?(:BANG)
-          type = Nodes::NonNullType.new(pos: pos, of_type: type, source: self)
+        if at?(:BANG) && parsed_type
+          parsed_type = Nodes::NonNullType.new(pos: pos, of_type: parsed_type, source: self)
           expect_token(:BANG)
         end
-        type
+        parsed_type
       end
 
       def list_type
         loc = pos
         expect_token(:LBRACKET)
-        type = Nodes::ListType.new(pos: loc, of_type: self.type, source: self)
+        inner_type = self.type
+        parsed_list_type = if inner_type
+          Nodes::ListType.new(pos: loc, of_type: inner_type, source: self)
+        else
+          nil
+        end
         expect_token(:RBRACKET)
-        type
+        parsed_list_type
       end
 
       def parse_operation_type

data/lib/graphql/language/printer.rb

@@ -92,7 +92,7 @@ module GraphQL
         print_string("@")
         print_string(directive.name)
 
-        if directive.arguments.any?
+        if !directive.arguments.empty?
           print_string("(")
           directive.arguments.each_with_index do |a, i|
             print_argument(a)
@@ -117,7 +117,7 @@ module GraphQL
           print_string(": ")
         end
         print_string(field.name)
-        if field.arguments.any?
+        if !field.arguments.empty?
           print_string("(")
           field.arguments.each_with_index do |a, i|
             print_argument(a)
@@ -182,7 +182,7 @@ module GraphQL
           print_string(operation_definition.name)
         end
 
-        if operation_definition.variables.any?
+        if !operation_definition.variables.empty?
           print_string("(")
           operation_definition.variables.each_with_index do |v, i|
             print_variable_definition(v)
@@ -230,7 +230,7 @@ module GraphQL
 
         extension ? print_string("extend schema") : print_string("schema")
 
-        if schema.directives.any?
+        if !schema.directives.empty?
           schema.directives.each do |dir|
             print_string("\n  ")
             print_node(dir)
@@ -332,7 +332,7 @@ module GraphQL
         extension ? print_string("extend ") : print_description_and_comment(interface_type)
         print_string("interface ")
         print_string(interface_type.name)
-        print_implements(interface_type) if interface_type.interfaces.any?
+        print_implements(interface_type) if !interface_type.interfaces.empty?
         print_directives(interface_type.directives)
         print_field_definitions(interface_type.fields)
       end
@@ -342,7 +342,7 @@ module GraphQL
         print_string("union ")
         print_string(union_type.name)
         print_directives(union_type.directives)
-        if union_type.types.any?
+        if !union_type.types.empty?
           print_string(" = ")
           i = 0
           union_type.types.each do |t|
@@ -360,7 +360,7 @@ module GraphQL
         print_string("enum ")
         print_string(enum_type.name)
         print_directives(enum_type.directives)
-        if enum_type.values.any?
+        if !enum_type.values.empty?
           print_string(" {\n")
           enum_type.values.each.with_index do |value, i|
             print_description(value, indent: "  ", first_in_block: i == 0)
@@ -401,7 +401,7 @@ module GraphQL
         print_string("directive @")
         print_string(directive.name)
 
-        if directive.arguments.any?
+        if !directive.arguments.empty?
           print_arguments(directive.arguments)
         end
 

data/lib/graphql/language/static_visitor.rb

@@ -22,39 +22,6 @@ module GraphQL
         end
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_methods(ast_node_class)
-        node_method = ast_node_class.visit_method
-        children_of_type = ast_node_class.children_of_type
-        child_visit_method = :"#{node_method}_children"
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          # The default implementation for visiting an AST node.
-          # It doesn't _do_ anything, but it continues to visiting the node's children.
-          # To customize this hook, override one of its make_visit_methods (or the base method?)
-          # in your subclasses.
-          #
-          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-          # @return [void]
-          def #{node_method}(node, parent)
-            #{
-              if method_defined?(child_visit_method)
-                "#{child_visit_method}(node)"
-              elsif children_of_type
-                children_of_type.map do |child_accessor, child_class|
-                  "node.#{child_accessor}.each do |child_node|
-                    #{child_class.visit_method}(child_node, node)
-                  end"
-                end.join("\n")
-              else
-                ""
-              end
-            }
-          end
-        RUBY
-      end
-
       def on_document_children(document_node)
         document_node.children.each do |child_node|
           visit_method = child_node.visit_method
@@ -123,6 +90,41 @@ module GraphQL
         end
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [void]
+          def #{node_method}(node, parent)
+            #{
+              if method_defined?(child_visit_method)
+                "#{child_visit_method}(node)"
+              elsif children_of_type
+                children_of_type.map do |child_accessor, child_class|
+                  "node.#{child_accessor}.each do |child_node|
+                    #{child_class.visit_method}(child_node, node)
+                  end"
+                end.join("\n")
+              else
+                ""
+              end
+            }
+          end
+        RUBY
+      end
+
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -162,6 +164,8 @@ module GraphQL
       ].each do |ast_node_class|
         make_visit_methods(ast_node_class)
       end
+
+      # rubocop:disable Development/NoEvalCop
     end
   end
 end

data/lib/graphql/language/visitor.rb

@@ -61,61 +61,6 @@ module GraphQL
         end
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_methods(ast_node_class)
-        node_method = ast_node_class.visit_method
-        children_of_type = ast_node_class.children_of_type
-        child_visit_method = :"#{node_method}_children"
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          # The default implementation for visiting an AST node.
-          # It doesn't _do_ anything, but it continues to visiting the node's children.
-          # To customize this hook, override one of its make_visit_methods (or the base method?)
-          # in your subclasses.
-          #
-          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
-          def #{node_method}(node, parent)
-            if node.equal?(DELETE_NODE)
-              # This might be passed to `super(DELETE_NODE, ...)`
-              # by a user hook, don't want to keep visiting in that case.
-              [node, parent]
-            else
-              new_node = node
-              #{
-                if method_defined?(child_visit_method)
-                  "new_node = #{child_visit_method}(new_node)"
-                elsif children_of_type
-                  children_of_type.map do |child_accessor, child_class|
-                    "node.#{child_accessor}.each do |child_node|
-                      new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
-                      # Reassign `node` in case the child hook makes a modification
-                      if new_child_and_node.is_a?(Array)
-                        new_node = new_child_and_node[1]
-                      end
-                    end"
-                  end.join("\n")
-                else
-                  ""
-                end
-              }
-
-              if new_node.equal?(node)
-                [node, parent]
-              else
-                [new_node, parent]
-              end
-            end
-          end
-
-          def #{node_method}_with_modifications(node, parent)
-            new_node_and_new_parent = #{node_method}(node, parent)
-            apply_modifications(node, parent, new_node_and_new_parent)
-          end
-        RUBY
-      end
-
       def on_document_children(document_node)
         new_node = document_node
         document_node.children.each do |child_node|
@@ -216,6 +161,63 @@ module GraphQL
         new_node
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+          def #{node_method}(node, parent)
+            if node.equal?(DELETE_NODE)
+              # This might be passed to `super(DELETE_NODE, ...)`
+              # by a user hook, don't want to keep visiting in that case.
+              [node, parent]
+            else
+              new_node = node
+              #{
+                if method_defined?(child_visit_method)
+                  "new_node = #{child_visit_method}(new_node)"
+                elsif children_of_type
+                  children_of_type.map do |child_accessor, child_class|
+                    "node.#{child_accessor}.each do |child_node|
+                      new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+                      # Reassign `node` in case the child hook makes a modification
+                      if new_child_and_node.is_a?(Array)
+                        new_node = new_child_and_node[1]
+                      end
+                    end"
+                  end.join("\n")
+                else
+                  ""
+                end
+              }
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
+              end
+            end
+          end
+
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -256,6 +258,8 @@ module GraphQL
         make_visit_methods(ast_node_class)
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       private
 
       def apply_modifications(node, parent, new_node_and_new_parent)

data/lib/graphql/pagination/connection.rb

@@ -223,7 +223,7 @@ module GraphQL
 
       def detect_was_authorized_by_scope_items
         if @context &&
-            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
             (query_runtime_state = current_runtime_state[@context.query])
           query_runtime_state.was_authorized_by_scope_items
         else

data/lib/graphql/query/context/scoped_context.rb

@@ -60,7 +60,7 @@ module GraphQL
           each_present_path_ctx do |path_ctx|
             if path_ctx.key?(key)
               found_value = path_ctx[key]
-              if other_keys.any?
+              if !other_keys.empty?
                 return found_value.dig(*other_keys)
               else
                 return found_value