graphql 0.16.0 → 2.0.15

data/lib/graphql/analysis/ast/visitor.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+module GraphQL
+  module Analysis
+    module AST
+      # Depth first traversal through a query AST, calling AST analyzers
+      # along the way.
+      #
+      # The visitor is a special case of GraphQL::Language::Visitor, visiting
+      # only the selected operation, providing helpers for common use cases such
+      # as skipped fields and visiting fragment spreads.
+      #
+      # @see {GraphQL::Analysis::AST::Analyzer} AST Analyzers for queries
+      class Visitor < GraphQL::Language::Visitor
+        def initialize(query:, analyzers:)
+          @analyzers = analyzers
+          @path = []
+          @object_types = []
+          @directives = []
+          @field_definitions = []
+          @argument_definitions = []
+          @directive_definitions = []
+          @rescued_errors = []
+          @query = query
+          @schema = query.schema
+          @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
+
+        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_analyzers(:on_enter_operation_definition, node, parent)
+          super
+          call_analyzers(: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_analyzers(:on_enter_fragment_definition, node, parent)
+            super
+            @in_fragment_def = false
+            call_analyzers(: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}" : ""}")
+            call_analyzers(:on_enter_inline_fragment, node, parent)
+            super
+            call_analyzers(: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 && @schema.get_field(parent_type, node.name, @query.context)
+          @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_analyzers(:on_enter_field, node, parent)
+          super
+
+          @skipping = @skip_stack.pop
+
+          call_analyzers(: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_analyzers(:on_enter_directive, node, parent)
+          super
+          call_analyzers(: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?
+              arg_type.get_argument(node.name, @query.context)
+            else
+              nil
+            end
+          elsif (directive_defn = @directive_definitions.last)
+            directive_defn.get_argument(node.name, @query.context)
+          elsif (field_defn = @field_definitions.last)
+            field_defn.get_argument(node.name, @query.context)
+          else
+            nil
+          end
+
+          @argument_definitions.push(argument_defn)
+          @path.push(node.name)
+          call_analyzers(:on_enter_argument, node, parent)
+          super
+          call_analyzers(:on_leave_argument, node, parent)
+          @argument_definitions.pop
+          @path.pop
+        end
+
+        def on_fragment_spread(node, parent)
+          @path.push("... #{node.name}")
+          call_analyzers(:on_enter_fragment_spread, node, parent)
+          enter_fragment_spread_inline(node)
+          super
+          leave_fragment_spread_inline(node)
+          call_analyzers(:on_leave_fragment_spread, node, parent)
+          @path.pop
+        end
+
+        def on_abstract_node(node, parent)
+          call_analyzers(:on_enter_abstract_node, node, parent)
+          super
+          call_analyzers(:on_leave_abstract_node, node, parent)
+        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
+            @query.warden.get_type(fragment_def.type.name)
+          else
+            object_types.last
+          end
+
+          object_types << object_type
+
+          fragment_def.selections.each do |selection|
+            visit_node(selection, fragment_def)
+          end
+        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 call_analyzers(method, node, parent)
+          @analyzers.each do |analyzer|
+            begin
+              analyzer.public_send(method, node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
+          end
+        end
+
+        def on_fragment_with_type(node)
+          object_type = if node.type
+            @query.warden.get_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
+end

data/lib/graphql/analysis/ast.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require "graphql/analysis/ast/visitor"
+require "graphql/analysis/ast/analyzer"
+require "graphql/analysis/ast/field_usage"
+require "graphql/analysis/ast/query_complexity"
+require "graphql/analysis/ast/max_query_complexity"
+require "graphql/analysis/ast/query_depth"
+require "graphql/analysis/ast/max_query_depth"
+
+module GraphQL
+  module Analysis
+    module AST
+      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::AST::Analyzer>]
+      # @return [Array<Any>] Results from multiplex analyzers
+      def analyze_multiplex(multiplex, analyzers)
+        multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
+
+        multiplex.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::AST::Analyzer>]
+      # @return [Array<Any>] Results from those analyzers
+      def analyze_query(query, analyzers, multiplex_analyzers: [])
+        query.trace("analyze_query", { query: query }) do
+          query_analyzers = analyzers
+            .map { |analyzer| analyzer.new(query) }
+            .select { |analyzer| analyzer.analyze? }
+
+          analyzers_to_run = query_analyzers + multiplex_analyzers
+          if analyzers_to_run.any?
+            visitor = GraphQL::Analysis::AST::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run
+            )
+
+            visitor.visit
+
+            if visitor.rescued_errors.any?
+              visitor.rescued_errors
+            else
+              query_analyzers.map(&:result)
+            end
+          else
+            []
+          end
+        end
+      end
+
+      def analysis_errors(results)
+        results.flatten.select { |r| r.is_a?(GraphQL::AnalysisError) }
+      end
+    end
+  end
+end

data/lib/graphql/analysis.rb

@@ -1,5 +1,2 @@
-require "graphql/analysis/max_query_complexity"
-require "graphql/analysis/max_query_depth"
-require "graphql/analysis/query_complexity"
-require "graphql/analysis/query_depth"
-require "graphql/analysis/analyze_query"
+# frozen_string_literal: true
+require "graphql/analysis/ast"

data/lib/graphql/analysis_error.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module GraphQL
   class AnalysisError < GraphQL::ExecutionError
   end

data/lib/graphql/backtrace/inspect_result.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module InspectResult
+      module_function
+
+      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(", ") +
+            "]"
+        when Query::Context::SharedMethods
+          if obj.invalid_null?
+            "nil"
+          else
+            inspect_truncated(obj.value)
+          end
+        else
+          inspect_truncated(obj)
+        end
+      end
+
+      def inspect_truncated(obj)
+        case obj
+        when Hash
+          "{...}"
+        when Array
+          "[...]"
+        when Query::Context::SharedMethods
+          if obj.invalid_null?
+            "nil"
+          else
+            inspect_truncated(obj.value)
+          end
+        when GraphQL::Execution::Lazy
+          "(unresolved)"
+        else
+          "#{obj.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/table.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # A class for turning a context into a human-readable table or array
+    class Table
+      MIN_COL_WIDTH = 4
+      MAX_COL_WIDTH = 100
+      HEADERS = [
+        "Loc",
+        "Field",
+        "Object",
+        "Arguments",
+        "Result",
+      ]
+
+      def initialize(context, value:)
+        @context = context
+        @override_value = value
+      end
+
+      # @return [String] A table layout of backtrace with metadata
+      def to_table
+        @to_table ||= render_table(rows)
+      end
+
+      # @return [Array<String>] An array of position + field name entries
+      def to_backtrace
+        @to_backtrace ||= begin
+          backtrace = rows.map { |r| "#{r[0]}: #{r[1]}" }
+          # skip the header entry
+          backtrace.shift
+          backtrace
+        end
+      end
+
+      private
+
+      def rows
+        @rows ||= build_rows(@context, rows: [HEADERS], top: true)
+      end
+
+      # @return [String]
+      def render_table(rows)
+        max = Array.new(HEADERS.length, MIN_COL_WIDTH)
+
+        rows.each do |row|
+          row.each_with_index do |col, idx|
+            col_len = col.length
+            max_len = max[idx]
+            if col_len > max_len
+              if col_len > MAX_COL_WIDTH
+                max[idx] = MAX_COL_WIDTH
+              else
+                max[idx] = col_len
+              end
+            end
+          end
+        end
+
+        table = "".dup
+        last_col_idx = max.length - 1
+        rows.each do |row|
+          table << row.map.each_with_index do |col, idx|
+            max_len = max[idx]
+            if idx < last_col_idx
+              col = col.ljust(max_len)
+            end
+            if col.length > max_len
+              col = col[0, max_len - 3] + "..."
+            end
+            col
+          end.join(" | ")
+          table << "\n"
+        end
+        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
+        end
+        response
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/traced_error.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.
+    class TracedError < GraphQL::Error
+      # @return [Array<String>] Printable backtrace of GraphQL error context
+      attr_reader :graphql_backtrace
+
+      # @return [GraphQL::Query::Context] The context at the field where the error was raised
+      attr_reader :context
+
+      MESSAGE_TEMPLATE = <<-MESSAGE
+Unhandled error during GraphQL execution:
+
+  %{cause_message}
+    %{cause_backtrace}
+    %{cause_backtrace_more}
+Use #cause to access the original exception (including #cause.backtrace).
+
+GraphQL Backtrace:
+%{graphql_table}
+MESSAGE
+
+      # This many lines of the original Ruby backtrace
+      # are included in the message
+      CAUSE_BACKTRACE_PREVIEW_LENGTH = 10
+
+      def initialize(err, current_ctx)
+        @context = current_ctx
+        backtrace = Backtrace.new(current_ctx, value: err)
+        @graphql_backtrace = backtrace.to_a
+
+        cause_backtrace_preview = err.backtrace.first(CAUSE_BACKTRACE_PREVIEW_LENGTH).join("\n    ")
+
+        cause_backtrace_remainder_length = err.backtrace.length - CAUSE_BACKTRACE_PREVIEW_LENGTH
+        cause_backtrace_more = if cause_backtrace_remainder_length < 0
+          ""
+        elsif cause_backtrace_remainder_length == 1
+          "... and 1 more line\n"
+        else
+          "... and #{cause_backtrace_remainder_length} more lines\n"
+        end
+
+        message = MESSAGE_TEMPLATE % {
+          cause_message: err.message,
+          cause_backtrace: cause_backtrace_preview,
+          cause_backtrace_more: cause_backtrace_more,
+          graphql_table: backtrace.inspect,
+        }
+        super(message)
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/tracer.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    # TODO this is not fiber-friendly
+    module Tracer
+      module_function
+
+      # Implement the {GraphQL::Tracing} API.
+      def trace(key, metadata)
+        case key
+        when "lex", "parse"
+          # No context here, don't have a query yet
+          nil
+        when "execute_multiplex", "analyze_multiplex"
+          # No query context yet
+          nil
+        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
+          push_key = []
+          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
+            push_data = query
+            multiplex = query.multiplex
+          elsif (multiplex = metadata[:multiplex])
+            push_data = multiplex.queries.first
+          end
+        when "execute_field", "execute_field_lazy"
+          query = metadata[:query]
+          multiplex = query.multiplex
+          push_key = metadata[:path]
+          parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
+
+          if parent_frame.is_a?(GraphQL::Query)
+            parent_frame = parent_frame.context
+          end
+
+          push_data = Frame.new(
+            query: query,
+            path: push_key,
+            ast_node: metadata[:ast_node],
+            field: metadata[:field],
+            object: metadata[:object],
+            arguments: metadata[:arguments],
+            parent_frame: parent_frame,
+          )
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data && multiplex
+          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+          push_storage[push_key] = push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          multiplex_context = metadata[:multiplex].context
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = multiplex_context[:last_graphql_backtrace_context]
+
+            if potential_context.is_a?(GraphQL::Query::Context) ||
+                potential_context.is_a?(Backtrace::Frame)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
+            end
+          ensure
+            multiplex_context.delete(:graphql_backtrace_contexts)
+            multiplex_context.delete(:last_graphql_backtrace_context)
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end