graphql 2.3.5 → 2.3.11

data/lib/graphql/analysis/visitor.rb

@@ -0,0 +1,283 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    # Depth first traversal through a query AST, calling AST analyzers
+    # along the way.
+    #
+    # The visitor is a special case of GraphQL::Language::StaticVisitor, visiting
+    # only the selected operation, providing helpers for common use cases such
+    # as skipped fields and visiting fragment spreads.
+    #
+    # @see {GraphQL::Analysis::Analyzer} AST Analyzers for queries
+    class Visitor < GraphQL::Language::StaticVisitor
+      def initialize(query:, analyzers:)
+        @analyzers = analyzers
+        @path = []
+        @object_types = []
+        @directives = []
+        @field_definitions = []
+        @argument_definitions = []
+        @directive_definitions = []
+        @rescued_errors = []
+        @query = query
+        @schema = query.schema
+        @types = query.types
+        @response_path = []
+        @skip_stack = [false]
+        super(query.selected_operation)
+      end
+
+      # @return [GraphQL::Query] the query being visited
+      attr_reader :query
+
+      # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
+      attr_reader :object_types
+
+      # @return [Array<GraphQL::AnalysisError]
+      attr_reader :rescued_errors
+
+      def visit
+        return unless @document
+        super
+      end
+
+      # Visit Helpers
+
+      # @return [GraphQL::Execution::Interpreter::Arguments] Arguments for this node, merging default values, literal values and query variables
+      # @see {GraphQL::Query#arguments_for}
+      def arguments_for(ast_node, field_definition)
+        @query.arguments_for(ast_node, field_definition)
+      end
+
+      # @return [Boolean] If the visitor is currently inside a fragment definition
+      def visiting_fragment_definition?
+        @in_fragment_def
+      end
+
+      # @return [Boolean] If the current node should be skipped because of a skip or include directive
+      def skipping?
+        @skipping
+      end
+
+      # @return [Array<String>] The path to the response key for the current field
+      def response_path
+        @response_path.dup
+      end
+
+      # Visitor Hooks
+      [
+        :operation_definition, :fragment_definition,
+        :inline_fragment, :field, :directive, :argument, :fragment_spread
+      ].each do |node_type|
+        module_eval <<-RUBY, __FILE__, __LINE__
+        def call_on_enter_#{node_type}(node, parent)
+          @analyzers.each do |a|
+            begin
+              a.on_enter_#{node_type}(node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
+          end
+        end
+
+        def call_on_leave_#{node_type}(node, parent)
+          @analyzers.each do |a|
+            begin
+              a.on_leave_#{node_type}(node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
+          end
+        end
+
+        RUBY
+      end
+
+      def on_operation_definition(node, parent)
+        object_type = @schema.root_type_for_operation(node.operation_type)
+        @object_types.push(object_type)
+        @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
+        call_on_enter_operation_definition(node, parent)
+        super
+        call_on_leave_operation_definition(node, parent)
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_fragment_definition(node, parent)
+        on_fragment_with_type(node) do
+          @path.push("fragment #{node.name}")
+          @in_fragment_def = false
+          call_on_enter_fragment_definition(node, parent)
+          super
+          @in_fragment_def = false
+          call_on_leave_fragment_definition(node, parent)
+        end
+      end
+
+      def on_inline_fragment(node, parent)
+        on_fragment_with_type(node) do
+          @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
+          @skipping = @skip_stack.last || skip?(node)
+          @skip_stack << @skipping
+
+          call_on_enter_inline_fragment(node, parent)
+          super
+          @skipping = @skip_stack.pop
+          call_on_leave_inline_fragment(node, parent)
+        end
+      end
+
+      def on_field(node, parent)
+        @response_path.push(node.alias || node.name)
+        parent_type = @object_types.last
+        # This could be nil if the previous field wasn't found:
+        field_definition = parent_type && @types.field(parent_type, node.name)
+        @field_definitions.push(field_definition)
+        if !field_definition.nil?
+          next_object_type = field_definition.type.unwrap
+          @object_types.push(next_object_type)
+        else
+          @object_types.push(nil)
+        end
+        @path.push(node.alias || node.name)
+
+        @skipping = @skip_stack.last || skip?(node)
+        @skip_stack << @skipping
+
+        call_on_enter_field(node, parent)
+        super
+        @skipping = @skip_stack.pop
+        call_on_leave_field(node, parent)
+        @response_path.pop
+        @field_definitions.pop
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_directive(node, parent)
+        directive_defn = @schema.directives[node.name]
+        @directive_definitions.push(directive_defn)
+        call_on_enter_directive(node, parent)
+        super
+        call_on_leave_directive(node, parent)
+        @directive_definitions.pop
+      end
+
+      def on_argument(node, parent)
+        argument_defn = if (arg = @argument_definitions.last)
+          arg_type = arg.type.unwrap
+          if arg_type.kind.input_object?
+            @types.argument(arg_type, node.name)
+          else
+            nil
+          end
+        elsif (directive_defn = @directive_definitions.last)
+          @types.argument(directive_defn, node.name)
+        elsif (field_defn = @field_definitions.last)
+          @types.argument(field_defn, node.name)
+        else
+          nil
+        end
+
+        @argument_definitions.push(argument_defn)
+        @path.push(node.name)
+        call_on_enter_argument(node, parent)
+        super
+        call_on_leave_argument(node, parent)
+        @argument_definitions.pop
+        @path.pop
+      end
+
+      def on_fragment_spread(node, parent)
+        @path.push("... #{node.name}")
+        @skipping = @skip_stack.last || skip?(node)
+        @skip_stack << @skipping
+
+        call_on_enter_fragment_spread(node, parent)
+        enter_fragment_spread_inline(node)
+        super
+        @skipping = @skip_stack.pop
+        leave_fragment_spread_inline(node)
+        call_on_leave_fragment_spread(node, parent)
+        @path.pop
+      end
+
+      # @return [GraphQL::BaseType] The current object type
+      def type_definition
+        @object_types.last
+      end
+
+      # @return [GraphQL::BaseType] The type which the current type came from
+      def parent_type_definition
+        @object_types[-2]
+      end
+
+      # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
+      def field_definition
+        @field_definitions.last
+      end
+
+      # @return [GraphQL::Field, nil] The GraphQL field which returned the object that the current field belongs to
+      def previous_field_definition
+        @field_definitions[-2]
+      end
+
+      # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
+      def directive_definition
+        @directive_definitions.last
+      end
+
+      # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
+      def argument_definition
+        @argument_definitions.last
+      end
+
+      # @return [GraphQL::Argument, nil] The previous GraphQL argument
+      def previous_argument_definition
+        @argument_definitions[-2]
+      end
+
+      private
+
+      # Visit a fragment spread inline instead of visiting the definition
+      # by itself.
+      def enter_fragment_spread_inline(fragment_spread)
+        fragment_def = query.fragments[fragment_spread.name]
+
+        object_type = if fragment_def.type
+          @types.type(fragment_def.type.name)
+        else
+          object_types.last
+        end
+
+        object_types << object_type
+
+        on_fragment_definition_children(fragment_def)
+      end
+
+      # Visit a fragment spread inline instead of visiting the definition
+      # by itself.
+      def leave_fragment_spread_inline(_fragment_spread)
+        object_types.pop
+      end
+
+      def skip?(ast_node)
+        dir = ast_node.directives
+        dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
+      end
+
+      def on_fragment_with_type(node)
+        object_type = if node.type
+          @types.type(node.type.name)
+        else
+          @object_types.last
+        end
+        @object_types.push(object_type)
+        yield(node)
+        @object_types.pop
+        @path.pop
+      end
+    end
+  end
+end

data/lib/graphql/analysis.rb

@@ -1,2 +1,93 @@
 # frozen_string_literal: true
-require "graphql/analysis/ast"
+require "graphql/analysis/visitor"
+require "graphql/analysis/analyzer"
+require "graphql/analysis/field_usage"
+require "graphql/analysis/query_complexity"
+require "graphql/analysis/max_query_complexity"
+require "graphql/analysis/query_depth"
+require "graphql/analysis/max_query_depth"
+require "timeout"
+
+module GraphQL
+  module Analysis
+    AST = self
+    module_function
+    # Analyze a multiplex, and all queries within.
+    # Multiplex analyzers are ran for all queries, keeping state.
+    # Query analyzers are ran per query, without carrying state between queries.
+    #
+    # @param multiplex [GraphQL::Execution::Multiplex]
+    # @param analyzers [Array<GraphQL::Analysis::Analyzer>]
+    # @return [Array<Any>] Results from multiplex analyzers
+    def analyze_multiplex(multiplex, analyzers)
+      multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
+
+      multiplex.current_trace.analyze_multiplex(multiplex: multiplex) do
+        query_results = multiplex.queries.map do |query|
+          if query.valid?
+            analyze_query(
+              query,
+              query.analyzers,
+              multiplex_analyzers: multiplex_analyzers
+            )
+          else
+            []
+          end
+        end
+
+        multiplex_results = multiplex_analyzers.map(&:result)
+        multiplex_errors = analysis_errors(multiplex_results)
+
+        multiplex.queries.each_with_index do |query, idx|
+          query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+        end
+        multiplex_results
+      end
+    end
+
+    # @param query [GraphQL::Query]
+    # @param analyzers [Array<GraphQL::Analysis::Analyzer>]
+    # @return [Array<Any>] Results from those analyzers
+    def analyze_query(query, analyzers, multiplex_analyzers: [])
+      query.current_trace.analyze_query(query: query) do
+        query_analyzers = analyzers
+          .map { |analyzer| analyzer.new(query) }
+          .tap { _1.select!(&:analyze?) }
+
+        analyzers_to_run = query_analyzers + multiplex_analyzers
+        if analyzers_to_run.any?
+
+          analyzers_to_run.select!(&:visit?)
+          if analyzers_to_run.any?
+            visitor = GraphQL::Analysis::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run
+            )
+
+            # `nil` or `0` causes no timeout
+            Timeout::timeout(query.validate_timeout_remaining) do
+              visitor.visit
+            end
+
+            if visitor.rescued_errors.any?
+              return visitor.rescued_errors
+            end
+          end
+
+          query_analyzers.map(&:result)
+        else
+          []
+        end
+      end
+    rescue Timeout::Error
+      [GraphQL::AnalysisError.new("Timeout on validation of query")]
+    rescue GraphQL::UnauthorizedError
+      # This error was raised during analysis and will be returned the client before execution
+      []
+    end
+
+    def analysis_errors(results)
+      results.flatten.tap { _1.select! { |r| r.is_a?(GraphQL::AnalysisError) } }
+    end
+  end
+end

data/lib/graphql/current.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # This module exposes Fiber-level runtime information.
+  #
+  # It won't work across unrelated fibers, although it will work in child Fibers.
+  #
+  # @example Setting Up ActiveRecord::QueryLogs
+  #
+  #   config.active_record.query_log_tags = [
+  #     :namespaced_controller,
+  #     :action,
+  #     :job,
+  #     # ...
+  #     {
+  #       # GraphQL runtime info:
+  #       current_graphql_operation: -> { GraphQL::Current.operation_name },
+  #       current_graphql_field: -> { GraphQL::Current.field&.path },
+  #       current_dataloader_source: -> { GraphQL::Current.dataloader_source_class },
+  #       # ...
+  #     },
+  #   ]
+  #
+  module Current
+    # @return [String, nil] Comma-joined operation names for the currently-running {Multiplex}. `nil` if all operations are anonymous.
+    def self.operation_name
+      if (m = Fiber[:__graphql_current_multiplex])
+        m.context[:__graphql_current_operation_name] ||= begin
+          names = m.queries.map { |q| q.selected_operation_name }
+          if names.all?(&:nil?)
+            nil
+          else
+            names.join(",")
+          end
+        end
+      else
+        nil
+      end
+    end
+
+    # @see GraphQL::Field#path for a string identifying this field
+    # @return [GraphQL::Field, nil] The currently-running field, if there is one.
+    def self.field
+      Thread.current[:__graphql_runtime_info]&.values&.first&.current_field
+    end
+
+    # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.
+    def self.dataloader_source_class
+      Fiber[:__graphql_current_dataloader_source]&.class
+    end
+  end
+end

data/lib/graphql/dataloader/async_dataloader.rb

@@ -21,6 +21,7 @@ module GraphQL
         manager = spawn_fiber do
           while first_pass || job_fibers.any?
             first_pass = false
+            fiber_vars = get_fiber_variables
 
             while (f = (job_fibers.shift || spawn_job_fiber))
               if f.alive?
@@ -34,6 +35,7 @@ module GraphQL
             next_job_fibers.clear
 
             Sync do |root_task|
+              set_fiber_variables(fiber_vars)
               while source_tasks.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
                 while (task = source_tasks.shift || spawn_source_task(root_task, sources_condition))
                   if task.alive?

data/lib/graphql/dataloader/source.rb

@@ -186,8 +186,11 @@ This key should have been loaded already. This is a bug in GraphQL::Dataloader,
 ERR
         end
         result = @results[key]
-
-        raise result if result.class <= StandardError
+        if result.is_a?(StandardError)
+          # Dup it because the rescuer may modify it.
+          # (This happens for GraphQL::ExecutionErrors, at least)
+          raise result.dup
+        end
 
         result
       end

data/lib/graphql/dataloader.rb

@@ -271,7 +271,10 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
-          pending_sources.each(&:run_pending_keys)
+          pending_sources.each do |source|
+            Fiber[:__graphql_current_dataloader_source] = source
+            source.run_pending_keys
+          end
         end
       end
     end

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

@@ -8,22 +8,17 @@ module GraphQL
           @query = query
           @dataloader = query.context.dataloader
           @storage = Hash.new do |h, argument_owner|
-            args_by_parent = if argument_owner.arguments_statically_coercible?
+            h[argument_owner] = if argument_owner.arguments_statically_coercible?
               shared_values_cache = {}
               Hash.new do |h2, ignored_parent_object|
                 h2[ignored_parent_object] = shared_values_cache
-              end
+              end.compare_by_identity
             else
               Hash.new do |h2, parent_object|
-                args_by_node = {}
-                args_by_node.compare_by_identity
-                h2[parent_object] = args_by_node
-              end
+                h2[parent_object] = {}.compare_by_identity
+              end.compare_by_identity
             end
-            args_by_parent.compare_by_identity
-            h[argument_owner] = args_by_parent
-          end
-          @storage.compare_by_identity
+          end.compare_by_identity
         end
 
         def fetch(ast_node, argument_owner, parent_object)

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

@@ -53,8 +53,7 @@ module GraphQL
             end
           end
           # { Class => Boolean }
-          @lazy_cache = {}
-          @lazy_cache.compare_by_identity
+          @lazy_cache = {}.compare_by_identity
         end
 
         def final_result
@@ -160,9 +159,9 @@ module GraphQL
               case node
               when GraphQL::Language::Nodes::InlineFragment
                 if node.type
-                  type_defn = schema.get_type(node.type.name, context)
+                  type_defn = query.types.type(node.type.name)
 
-                  if query.warden.possible_types(type_defn).include?(owner_type)
+                  if query.types.possible_types(type_defn).include?(owner_type)
                     result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
                     if !result.equal?(next_selections)
                       selections_to_run = result
@@ -177,8 +176,8 @@ module GraphQL
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
-                type_defn = query.get_type(fragment_def.type.name)
-                if query.warden.possible_types(type_defn).include?(owner_type)
+                type_defn = query.types.type(fragment_def.type.name)
+                if query.types.possible_types(type_defn).include?(owner_type)
                   result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                   if !result.equal?(next_selections)
                     selections_to_run = result
@@ -245,7 +244,7 @@ module GraphQL
           end
           field_name = ast_node.name
           owner_type = selections_result.graphql_result_type
-          field_defn = query.warden.get_field(owner_type, field_name)
+          field_defn = query.types.field(owner_type, field_name)
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           runtime_state = get_current_runtime_state
@@ -579,7 +578,7 @@ module GraphQL
                 resolved_value = value
               end
 
-              possible_types = query.possible_types(current_type)
+              possible_types = query.types.possible_types(current_type)
               if !possible_types.include?(resolved_type)
                 parent_type = field.owner_type
                 err_class = current_type::UnresolvedTypeError
@@ -727,12 +726,7 @@ module GraphQL
         end
 
         def get_current_runtime_state
-          current_state = Thread.current[:__graphql_runtime_info] ||= begin
-            per_query_state = {}
-            per_query_state.compare_by_identity
-            per_query_state
-          end
-
+          current_state = Thread.current[:__graphql_runtime_info] ||= {}.compare_by_identity
           current_state[@query] ||= CurrentState.new
         end
 

data/lib/graphql/execution/interpreter.rb

@@ -34,13 +34,14 @@ module GraphQL
           end
 
           multiplex = Execution::Multiplex.new(schema: schema, queries: queries, context: context, max_complexity: max_complexity)
+          Fiber[:__graphql_current_multiplex] = multiplex
           multiplex.current_trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
             lazies_at_depth = Hash.new { |h, k| h[k] = [] }
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
-              multiplex_analyzers += [GraphQL::Analysis::AST::MaxQueryComplexity]
+              multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
             end
 
             schema.analysis_engine.analyze_multiplex(multiplex, multiplex_analyzers)
@@ -136,6 +137,7 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
+              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime

data/lib/graphql/execution/lookahead.rb

@@ -108,16 +108,16 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_defn = case field_name
         when String
-          @query.get_field(selected_type, field_name)
+          @query.types.field(selected_type, field_name)
         when Symbol
           # Try to avoid the `.to_s` below, if possible
           all_fields = if selected_type.kind.fields?
-            @query.warden.fields(selected_type)
+            @query.types.fields(selected_type)
           else
             # Handle unions by checking possible
-            @query.warden
+            @query.types
               .possible_types(selected_type)
-              .map { |t| @query.warden.fields(t) }
+              .map { |t| @query.types.fields(t) }
               .tap(&:flatten!)
           end
 
@@ -128,7 +128,7 @@ module GraphQL
             # Symbol#name is only present on 3.0+
             sym_s = field_name.respond_to?(:name) ? field_name.name : field_name.to_s
             guessed_name = Schema::Member::BuildType.camelize(sym_s)
-            @query.get_field(selected_type, guessed_name)
+            @query.types.field(selected_type, guessed_name)
           end
         end
         lookahead_for_selection(next_field_defn, selected_type, arguments)
@@ -144,7 +144,7 @@ module GraphQL
         alias_node = lookup_alias_node(ast_nodes, alias_name)
         return NULL_LOOKAHEAD unless alias_node
 
-        next_field_defn = @query.get_field(selected_type, alias_node.name)
+        next_field_defn = @query.types.field(selected_type, alias_node.name)
 
         alias_arguments = @query.arguments_for(alias_node, next_field_defn)
         if alias_arguments.is_a?(::GraphQL::Execution::Interpreter::Arguments)
@@ -183,7 +183,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = @query.get_field(type, ast_nodes.first.name)
+            field_defn = @query.types.field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -266,7 +266,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = @query.get_field(selected_type, ast_selection.name)
+              field_defn = @query.types.field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -276,14 +276,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.get_type(t.name)
+              on_type = @query.types.type(t.name)
               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 = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
-            on_type = @query.get_type(frag_defn.type.name)
+            on_type = @query.types.type(frag_defn.type.name)
             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/introspection/directive_type.rb

@@ -22,7 +22,7 @@ module GraphQL
       field :is_repeatable, Boolean, method: :repeatable?
 
       def args(include_deprecated:)
-        args = @context.warden.arguments(@object)
+        args = @context.types.arguments(@object)
         args = args.reject(&:deprecation_reason) unless include_deprecated
         args
       end

data/lib/graphql/introspection/entry_points.rb

@@ -15,8 +15,8 @@ module GraphQL
       end
 
       def __type(name:)
-        if context.warden.reachable_type?(name)
-          context.warden.get_type(name)
+        if context.types.reachable_type?(name) && (type = context.types.type(name))
+          type
         elsif (type = context.schema.extra_types.find { |t| t.graphql_name == name })
           type
         else