graphql 1.6.8 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '056695dd78098e5adfe501785c8e7e111cb8bc2d'
-  data.tar.gz: 5ef5aa896020c5b149c1960a5e870d8f13e4a2f8
+  metadata.gz: 143f5c1d1fd648361bc54f779e9e160d5953a439
+  data.tar.gz: a17369262755499d3adfa17be3465ac4d68e6c97
 SHA512:
-  metadata.gz: 50d4e93b57572c9a3cce63468b0e6b23daca8f61a97120e5899613018c1bdfc4fe9ecade9b8906e4243c383a55f636b37d066e52d14310c002911e7e7c3c086f
-  data.tar.gz: 63d326d4a3ea184e7840308d6841afb7af3336d570f9d8362ffdad5d0e351016e0d67c72bf9ec62e3629a5ce768bf4fe1b92bc0873b7effa47b37aa3f370f7f9
+  metadata.gz: d9d383e0fcb02bd527c830c157ce0e6b97a8f3b552f75d6e6be28f51f82296168bfea5e81f4e06463d706d2dc264095aa38b048d35e3afc432379b5482d6afd7
+  data.tar.gz: a22957f865c6145c04af2f68b1810f799caa873a60cc3788607505c63be52fbaa9f393a9bf2809a85e64e5625efbe83ceeab2642f7c29ef4d952c1391c9ac3e7

data/lib/graphql.rb

@@ -87,6 +87,7 @@ require "graphql/id_type"
 require "graphql/int_type"
 require "graphql/string_type"
 require "graphql/directive"
+require "graphql/name_validator"
 
 require "graphql/introspection"
 require "graphql/language"
@@ -100,6 +101,7 @@ require "graphql/schema/printer"
 require "graphql/analysis_error"
 require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
+require "graphql/invalid_name_error"
 require "graphql/unresolved_type_error"
 require "graphql/string_encoding_error"
 require "graphql/query"
@@ -109,4 +111,7 @@ require "graphql/version"
 require "graphql/compatibility"
 require "graphql/function"
 require "graphql/filter"
+require "graphql/subscriptions"
 require "graphql/parse_error"
+require "graphql/tracing"
+require "graphql/backtrace"

data/lib/graphql/analysis/analyze_query.rb

@@ -5,20 +5,22 @@ module GraphQL
 
     # @return [void]
     def analyze_multiplex(multiplex, analyzers)
-      reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
-      query_results = multiplex.queries.map do |query|
-        if query.valid?
-          analyze_query(query, query.analyzers, multiplex_states: reducer_states)
-        else
-          []
+      GraphQL::Tracing.trace("analyze_multiplex", { multiplex: multiplex }) do
+        reducer_states = analyzers.map { |r| ReducerState.new(r, multiplex) }
+        query_results = multiplex.queries.map do |query|
+          if query.valid?
+            analyze_query(query, query.analyzers, multiplex_states: reducer_states)
+          else
+            []
+          end
         end
-      end
 
-      multiplex_results = reducer_states.map(&:finalize_reducer)
-      multiplex_errors = analysis_errors(multiplex_results)
+        multiplex_results = reducer_states.map(&:finalize_reducer)
+        multiplex_errors = analysis_errors(multiplex_results)
 
-      multiplex.queries.each_with_index do |query, idx|
-        query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+        multiplex.queries.each_with_index do |query, idx|
+          query.analysis_errors = multiplex_errors + analysis_errors(query_results[idx])
+        end
       end
       nil
     end
@@ -35,15 +37,17 @@ module GraphQL
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers, multiplex_states: [])
-      reducer_states = analyzers.map { |r| ReducerState.new(r, query) } + multiplex_states
+      GraphQL::Tracing.trace("analyze_query", { query: query }) do
+        reducer_states = analyzers.map { |r| ReducerState.new(r, query) } + multiplex_states
 
-      irep = query.internal_representation
+        irep = query.internal_representation
 
-      irep.operation_definitions.each do |name, op_node|
-        reduce_node(op_node, reducer_states)
-      end
+        irep.operation_definitions.each do |name, op_node|
+          reduce_node(op_node, reducer_states)
+        end
 
-      reducer_states.map(&:finalize_reducer)
+        reducer_states.map(&:finalize_reducer)
+      end
     end
 
     private

data/lib/graphql/argument.rb

@@ -96,7 +96,11 @@ module GraphQL
 
     NO_DEFAULT_VALUE = Object.new
     # @api private
-    def self.from_dsl(name, type = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
+    def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)
+      if type_or_argument.is_a?(GraphQL::Argument)
+        return type_or_argument.redefine(name: name.to_s)
+      end
+
       argument = if block_given?
         GraphQL::Argument.define(&block)
       else
@@ -104,7 +108,7 @@ module GraphQL
       end
 
       argument.name = name.to_s
-      type && argument.type = type
+      type_or_argument && argument.type = type_or_argument
       description && argument.description = description
       if default_value != NO_DEFAULT_VALUE
         argument.default_value = default_value

data/lib/graphql/backtrace.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require "graphql/backtrace/inspect_result"
+require "graphql/backtrace/table"
+require "graphql/backtrace/traced_error"
+require "graphql/backtrace/tracer"
+module GraphQL
+  # Wrap unhandled errors with {TracedError}.
+  #
+  # {TracedError} provides a GraphQL backtrace with arguments and return values.
+  # The underlying error is available as {TracedError#cause}.
+  #
+  # WARNING: {.enable} is not threadsafe because {GraphQL::Tracing.install} is not threadsafe.
+  #
+  # @example toggling backtrace annotation
+  #   # to enable:
+  #   GraphQL::Backtrace.enable
+  #   # later, to disable:
+  #   GraphQL::Backtrace.disable
+  #
+  class Backtrace
+    include Enumerable
+    extend GraphQL::Delegate
+
+    def_delegators :to_a, :each, :[]
+
+    def self.enable
+      GraphQL::Tracing.install(Backtrace::Tracer)
+      nil
+    end
+
+    def self.disable
+      GraphQL::Tracing.uninstall(Backtrace::Tracer)
+      nil
+    end
+
+    def initialize(context, value: nil)
+      @table = Table.new(context, value: value)
+    end
+
+    def inspect
+      @table.to_table
+    end
+
+    alias :to_s :inspect
+
+    def to_a
+      @table.to_backtrace
+    end
+  end
+end

data/lib/graphql/backtrace/inspect_result.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+# test_via: ../backtrace.rb
+module GraphQL
+  class Backtrace
+    module InspectResult
+      module_function
+
+      def inspect(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,120 @@
+# frozen_string_literal: true
+# test_via: ../backtrace.rb
+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 GraphQL::Query::Context::FieldResolutionContext
+          ctx = context_entry
+          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
+          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
+          field_alias = ctx.ast_node.alias
+          rows << [
+            "#{position}",
+            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
+            ctx.object.inspect,
+            ctx.irep_node.arguments.to_h.inspect,
+            Backtrace::InspectResult.inspect(top && @override_value ? @override_value : ctx.value),
+          ]
+
+          build_rows(ctx.parent, rows: rows)
+        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
+          rows << [
+            "#{position}",
+            "#{op_type}#{op_name ? " #{op_name}" : ""}",
+            query.root_value.inspect,
+            query.variables.to_h.inspect,
+            Backtrace::InspectResult.inspect(query.context.value),
+          ]
+        else
+          raise "Unexpected get_rows subject #{context_entry.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/traced_error.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+# test_via: ../backtrace.rb
+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,50 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module Tracer
+      module_function
+
+      # Implement the {GraphQL::Tracing} API.
+      def trace(key, metadata)
+        push_data = case key
+        when "lex", "parse"
+          # No context here, don't have a query yet
+          nil
+        when "execute_multiplex", "analyze_multiplex"
+          metadata[:multiplex].queries
+        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
+          metadata[:query] || metadata[:queries]
+        when "execute_field", "execute_field_lazy"
+          metadata[:context]
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data
+          execution_context = Thread.current[:graphql_execution_context] ||= []
+          if key == "execute_multiplex"
+            execution_context.clear
+            execution_context.push(push_data)
+            begin
+              yield
+            rescue StandardError => err
+              # This is an unhandled error from execution,
+              # Re-raise it with a GraphQL trace.
+              raise TracedError.new(err, execution_context.last)
+            ensure
+              execution_context.clear
+            end
+          else
+            execution_context.push(push_data)
+            res = yield
+            execution_context.pop
+            res
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end