graphql 2.2.17 → 2.5.16

data/lib/graphql/analysis/visitor.rb

@@ -0,0 +1,280 @@
+# 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:, timeout:)
+        @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]
+        @timeout_time = if timeout
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) + timeout
+        else
+          Float::INFINITY
+        end
+        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
+
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+      # 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|
+            a.on_enter_#{node_type}(node, parent, self)
+          rescue AnalysisError => err
+            @rescued_errors << err
+          end
+        end
+
+        def call_on_leave_#{node_type}(node, parent)
+          @analyzers.each do |a|
+            a.on_leave_#{node_type}(node, parent, self)
+          rescue AnalysisError => err
+            @rescued_errors << err
+          end
+        end
+
+        RUBY
+      end
+      # rubocop:enable Development/NoEvalCop
+
+      def on_operation_definition(node, parent)
+        check_timeout
+        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_inline_fragment(node, parent)
+        check_timeout
+        object_type = if node.type
+          @types.type(node.type.name)
+        else
+          @object_types.last
+        end
+        @object_types.push(object_type)
+        @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)
+        @object_types.pop
+        @path.pop
+      end
+
+      def on_field(node, parent)
+        check_timeout
+        @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)
+        check_timeout
+        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)
+        check_timeout
+        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)
+        check_timeout
+        @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.empty? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
+      end
+
+      def check_timeout
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) > @timeout_time
+          raise GraphQL::Analysis::TimeoutError
+        end
+      end
+    end
+  end
+end

data/lib/graphql/analysis.rb

@@ -1,2 +1,96 @@
 # 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"
+module GraphQL
+  module Analysis
+    AST = self
+
+    class TimeoutError < AnalysisError
+      def initialize(...)
+        super("Timeout on validation of query")
+      end
+    end
+
+    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.empty?
+
+          analyzers_to_run.select!(&:visit?)
+          if !analyzers_to_run.empty?
+            visitor = GraphQL::Analysis::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run,
+              timeout: query.validate_timeout_remaining,
+            )
+
+            visitor.visit
+
+            if !visitor.rescued_errors.empty?
+              return visitor.rescued_errors
+            end
+          end
+
+          query_analyzers.map(&:result)
+        else
+          []
+        end
+      end
+    rescue TimeoutError => err
+      [err]
+    rescue GraphQL::UnauthorizedError, GraphQL::ExecutionError
+      # 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/autoload.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module GraphQL
+  # @see GraphQL::Railtie for automatic Rails integration
+  module Autoload
+    # Register a constant named `const_name` to be loaded from `path`.
+    # This is like `Kernel#autoload` but it tracks the constants so they can be eager-loaded with {#eager_load!}
+    # @param const_name [Symbol]
+    # @param path [String]
+    # @return [void]
+    def autoload(const_name, path)
+      @_eagerloaded_constants ||= []
+      @_eagerloaded_constants << const_name
+
+      super const_name, path
+    end
+
+    # Call this to load this constant's `autoload` dependents and continue calling recursively
+    # @return [void]
+    def eager_load!
+      @_eager_loading = true
+      if @_eagerloaded_constants
+        @_eagerloaded_constants.each { |const_name| const_get(const_name) }
+        @_eagerloaded_constants = nil
+      end
+      nil
+    ensure
+      @_eager_loading = false
+    end
+
+    private
+
+    # @return [Boolean] `true` if GraphQL-Ruby is currently eager-loading its constants
+    def eager_loading?
+      @_eager_loading ||= false
+    end
+  end
+end

data/lib/graphql/backtrace/table.rb

@@ -36,7 +36,93 @@ module GraphQL
       private
 
       def rows
-        @rows ||= build_rows(@context, rows: [HEADERS], top: true)
+        @rows ||= begin
+          query = @context.query
+          query_ctx = @context
+          runtime_inst = query_ctx.namespace(:interpreter_runtime)[:runtime]
+          result = runtime_inst.instance_variable_get(:@response)
+          rows = []
+          result_path = []
+          last_part = nil
+          path = @context.current_path
+          path.each do |path_part|
+            value = value_at(runtime_inst, result_path)
+
+            if result_path.empty?
+              name = query.selected_operation.operation_type || "query"
+              if (n = query.selected_operation_name)
+                name += " #{n}"
+              end
+              args = query.variables
+            else
+              name = result.graphql_field.path
+              args = result.graphql_arguments
+            end
+
+            object = result.graphql_parent ? result.graphql_parent.graphql_application_value : result.graphql_application_value
+            object = object.object.inspect
+
+            rows << [
+              result.ast_node.position.join(":"),
+              name,
+              "#{object}",
+              args.to_h.inspect,
+              inspect_result(value),
+            ]
+
+            result_path << path_part
+            if path_part == path.last
+              last_part = path_part
+            else
+              result = result[path_part]
+            end
+          end
+
+          object = result.graphql_application_value.object.inspect
+          ast_node = nil
+          result.graphql_selections.each do |s|
+            found_ast_node = find_ast_node(s, last_part)
+            if found_ast_node
+              ast_node = found_ast_node
+              break
+            end
+          end
+
+          if ast_node
+            field_defn = query.get_field(result.graphql_result_type, ast_node.name)
+            args = query.arguments_for(ast_node, field_defn).to_h
+            field_path = field_defn.path
+            if ast_node.alias
+              field_path += " as #{ast_node.alias}"
+            end
+
+            rows << [
+              ast_node.position.join(":"),
+              field_path,
+              "#{object}",
+              args.inspect,
+              inspect_result(@override_value)
+            ]
+          end
+
+          rows << HEADERS
+          rows.reverse!
+          rows
+        end
+      end
+
+      def find_ast_node(node, last_part)
+        return nil unless node
+        return node if node.respond_to?(:alias) && node.respond_to?(:name) && (node.alias == last_part || node.name == last_part)
+        return nil unless node.respond_to?(:selections)
+        return nil if node.selections.nil? || node.selections.empty?
+
+        node.selections.each do |child|
+          child_ast_node = find_ast_node(child, last_part)
+          return child_ast_node if child_ast_node
+        end
+
+        nil
       end
 
       # @return [String]
@@ -75,67 +161,44 @@ module GraphQL
         table
       end
 
-      # @return [Array] 5 items for a backtrace table (not `key`)
-      def build_rows(context_entry, rows:, top: false)
-        case context_entry
-        when Backtrace::Frame
-          field_alias = context_entry.ast_node.respond_to?(:alias) && context_entry.ast_node.alias
-          value = if top && @override_value
-            @override_value
-          else
-            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
-          end
-          rows << [
-            "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
-            "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{context_entry.object.object.inspect}",
-            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
-            Backtrace::InspectResult.inspect_result(value),
-          ]
-          if (parent = context_entry.parent_frame)
-            build_rows(parent, rows: rows)
-          else
-            rows
-          end
-        when GraphQL::Query::Context
-          query = context_entry.query
-          op = query.selected_operation
-          if op
-            op_type = op.operation_type
-            position = "#{op.line}:#{op.col}"
-          else
-            op_type = "query"
-            position = "?:?"
-          end
-          op_name = query.selected_operation_name
-          object = query.root_value
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
-          rows << [
-            "#{position}",
-            "#{op_type}#{op_name ? " #{op_name}" : ""}",
-            "#{object.inspect}",
-            query.variables.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(value),
-          ]
-        else
-          raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
-        end
-      end
 
       def value_at(runtime, path)
         response = runtime.final_result
         path.each do |key|
-          if response && (response = response[key])
-            next
-          else
-            break
-          end
+          response && (response = response[key])
         end
         response
       end
+
+      def inspect_result(obj)
+        case obj
+        when Hash
+          "{" +
+            obj.map do |key, val|
+              "#{key}: #{inspect_truncated(val)}"
+            end.join(", ") +
+            "}"
+        when Array
+          "[" +
+            obj.map { |v| inspect_truncated(v) }.join(", ") +
+            "]"
+        else
+          inspect_truncated(obj)
+        end
+      end
+
+      def inspect_truncated(obj)
+        case obj
+        when Hash
+          "{...}"
+        when Array
+          "[...]"
+        when GraphQL::Execution::Lazy
+          "(unresolved)"
+        else
+          "#{obj.inspect}"
+        end
+      end
     end
   end
 end

data/lib/graphql/backtrace.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
-require "graphql/backtrace/inspect_result"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
-require "graphql/backtrace/tracer"
-require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -24,7 +21,7 @@ module GraphQL
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.trace_with(self::Trace)
+      schema_defn.using_backtrace = true
     end
 
     def initialize(context, value: nil)
@@ -40,20 +37,5 @@ module GraphQL
     def to_a
       @table.to_backtrace
     end
-
-    # Used for internal bookkeeping
-    # @api private
-    class Frame
-      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
-      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
-        @path = path
-        @query = query
-        @ast_node = ast_node
-        @field = field
-        @object = object
-        @arguments = arguments
-        @parent_frame = parent_frame
-      end
-    end
   end
 end

data/lib/graphql/current.rb

@@ -0,0 +1,57 @@
+# 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 {Execution::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
+      Fiber[:__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
+
+    # @return [GraphQL::Dataloader::Source, nil] The currently-running source, if there is one
+    def self.dataloader_source
+      Fiber[:__graphql_current_dataloader_source]
+    end
+  end
+end