graphql 1.7.3 → 1.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: '08e688c4046aa3130fe9f427f810356abc25abfc'
-  data.tar.gz: d2896b9042f2bab1dffd256551082168aa52288d
+  metadata.gz: aaf04d88628e6882277fdb587a521473684283ad
+  data.tar.gz: ca64d47b1f78982847287ece1bc2b387daa08f4e
 SHA512:
-  metadata.gz: 624eb16565591d5df45dc69df9dc5cc7fa6b97ca9ff4d3745427df47e979a15e889458689f1e52d9f8a553b0974f738cb2cff703d1fc98dcc25cfbffee36f408
-  data.tar.gz: 0421334ac91f05b8a0adf48199b811eb81efbcfd4a0c543bf3ff58248e9db3c4c1ba036d5cbeffca69fcb12e10d07e88fa0cf9896cbfd081b884da5d62f5aa8c
+  metadata.gz: f860526de9a1c6c6e9ab4cca863231c64308a7d84f349a4b7adc7da9ac3c2ec29ca2e7d8c484fa04f46b1ae34c9560b15553a9e1c6844a0c19756028b0615f59
+  data.tar.gz: 306aad45f5e563c920e4ce3d18a5ffc940d72a1522ef11e7427fc6f7634e21f6025c2335e917a9c076463ba7532fa91fcf291f77c87fc0e57ab6221fdefe8b70

data/lib/graphql.rb

@@ -35,8 +35,8 @@ module GraphQL
   # Turn a query string or schema definition into an AST
   # @param graphql_string [String] a GraphQL query string or schema definition
   # @return [GraphQL::Language::Nodes::Document]
-  def self.parse(graphql_string)
-    parse_with_racc(graphql_string)
+  def self.parse(graphql_string, tracer: GraphQL::Tracing::NullTracer)
+    parse_with_racc(graphql_string, tracer: tracer)
   end
 
   # Read the contents of `filename` and parse them as GraphQL
@@ -47,8 +47,8 @@ module GraphQL
     parse_with_racc(content, filename: filename)
   end
 
-  def self.parse_with_racc(string, filename: nil)
-    GraphQL::Language::Parser.parse(string, filename: filename)
+  def self.parse_with_racc(string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+    GraphQL::Language::Parser.parse(string, filename: filename, tracer: tracer)
   end
 
   # @return [Array<GraphQL::Language::Token>]
@@ -92,6 +92,7 @@ require "graphql/name_validator"
 require "graphql/introspection"
 require "graphql/language"
 require "graphql/analysis"
+require "graphql/tracing"
 require "graphql/execution"
 require "graphql/relay"
 require "graphql/schema"
@@ -99,6 +100,7 @@ require "graphql/schema/loader"
 require "graphql/schema/printer"
 
 require "graphql/analysis_error"
+require "graphql/coercion_error"
 require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
 require "graphql/invalid_name_error"
@@ -113,5 +115,4 @@ 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,7 +5,7 @@ module GraphQL
 
     # @return [void]
     def analyze_multiplex(multiplex, analyzers)
-      GraphQL::Tracing.trace("analyze_multiplex", { multiplex: multiplex }) do
+      multiplex.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?
@@ -37,7 +37,7 @@ 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: [])
-      GraphQL::Tracing.trace("analyze_query", { query: query }) do
+      query.trace("analyze_query", { query: query }) do
         reducer_states = analyzers.map { |r| ReducerState.new(r, query) } + multiplex_states
 
         irep = query.internal_representation

data/lib/graphql/backtrace.rb

@@ -24,6 +24,7 @@ module GraphQL
     def_delegators :to_a, :each, :[]
 
     def self.enable
+      warn("GraphQL::Backtrace.enable is deprecated, add `use GraphQL::Backtrace` to your schema definition instead.")
       GraphQL::Tracing.install(Backtrace::Tracer)
       nil
     end
@@ -33,6 +34,10 @@ module GraphQL
       nil
     end
 
+    def self.use(schema_defn)
+      schema_defn.tracer(self::Tracer)
+    end
+
     def initialize(context, value: nil)
       @table = Table.new(context, value: value)
     end

data/lib/graphql/coercion_error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module GraphQL
+  class CoercionError < GraphQL::Error
+  end
+end

data/lib/graphql/define/type_definer.rb

@@ -6,13 +6,13 @@ module GraphQL
     # Passed into initialization blocks, eg {ObjectType#initialize}, {Field#initialize}
     class TypeDefiner
       include Singleton
-      # rubocop:disable Style/MethodName
+      # rubocop:disable Naming/MethodName
       def Int;      GraphQL::INT_TYPE;      end
       def String;   GraphQL::STRING_TYPE;   end
       def Float;    GraphQL::FLOAT_TYPE;    end
       def Boolean;  GraphQL::BOOLEAN_TYPE;  end
       def ID;       GraphQL::ID_TYPE;       end
-      # rubocop:enable Style/MethodName
+      # rubocop:enable Naming/MethodName
 
       # Make a {ListType} which wraps the input type
       #

data/lib/graphql/execution/execute.rb

@@ -29,7 +29,7 @@ module GraphQL
         module_function
 
         def resolve_root_selection(query)
-          GraphQL::Tracing.trace("execute_query", query: query) do
+          query.trace("execute_query", query: query) do
             operation = query.selected_operation
             op_type = operation.operation_type
             root_type = query.root_type_for_operation(op_type)
@@ -42,12 +42,13 @@ module GraphQL
           end
         end
 
-        def lazy_resolve_root_selection(result, query: nil, queries: nil)
-          if query.nil? && queries.length == 1
-            query = queries[0]
+        def lazy_resolve_root_selection(result, query: nil, multiplex: nil)
+          if query.nil? && multiplex.queries.length == 1
+            query = multiplex.queries[0]
           end
 
-          GraphQL::Tracing.trace("execute_query_lazy", {queries: queries, query: query}) do
+          tracer = (query || multiplex)
+          tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do
             GraphQL::Execution::Lazy.resolve(result)
           end
         end
@@ -67,7 +68,7 @@ module GraphQL
               irep_node: child_irep_node,
             )
 
-            field_result = GraphQL::Tracing.trace("execute_field", { context: field_ctx }) do
+            field_result = field_ctx.trace("execute_field", { context: field_ctx }) do
               resolve_field(
                 object,
                 field_ctx

data/lib/graphql/execution/lazy/resolve.rb

@@ -37,7 +37,7 @@ module GraphQL
           else
             Lazy.new {
               acc.each_with_index { |ctx, idx|
-                acc[idx] = GraphQL::Tracing.trace("execute_field_lazy", { context: ctx }) do
+                acc[idx] = ctx.trace("execute_field_lazy", { context: ctx }) do
                   ctx.value.value
                 end
               }

data/lib/graphql/execution/multiplex.rb

@@ -27,11 +27,19 @@ module GraphQL
       # @api private
       NO_OPERATION = {}.freeze
 
+      include Tracing::Traceable
+
       attr_reader :context, :queries, :schema
       def initialize(schema:, queries:, context:)
         @schema = schema
         @queries = queries
         @context = context
+        # TODO remove support for global tracers
+        @tracers = schema.tracers + GraphQL::Tracing.tracers + (context[:tracers] || [])
+        # Support `context: {backtrace: true}`
+        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
+          @tracers << GraphQL::Backtrace::Tracer
+        end
       end
 
       class << self
@@ -47,7 +55,7 @@ module GraphQL
         # @return [Array<Hash>] One result per query
         def run_queries(schema, queries, context: {}, max_complexity: schema.max_complexity)
           multiplex = self.new(schema: schema, queries: queries, context: context)
-          GraphQL::Tracing.trace("execute_multiplex", { multiplex: multiplex }) do
+          multiplex.trace("execute_multiplex", { multiplex: multiplex }) do
             if has_custom_strategy?(schema)
               if queries.length != 1
                 raise ArgumentError, "Multiplexing doesn't support custom execution strategies, run one query at a time instead"
@@ -58,7 +66,7 @@ module GraphQL
               end
             else
               with_instrumentation(multiplex, max_complexity: max_complexity) do
-                run_as_multiplex(queries)
+                run_as_multiplex(multiplex)
               end
             end
           end
@@ -66,14 +74,15 @@ module GraphQL
 
         private
 
-        def run_as_multiplex(queries)
+        def run_as_multiplex(multiplex)
+          queries = multiplex.queries
           # Do as much eager evaluation of the query as possible
           results = queries.map do |query|
             begin_query(query)
           end
 
           # Then, work through lazy results in a breadth-first way
-          GraphQL::Execution::Execute::ExecutionFunctions.lazy_resolve_root_selection(results, { queries: queries })
+          GraphQL::Execution::Execute::ExecutionFunctions.lazy_resolve_root_selection(results, { multiplex: multiplex })
 
           # Then, find all errors and assign the result to the query object
           results.each_with_index.map do |data_result, idx|

data/lib/graphql/execution_error.rb

@@ -11,8 +11,12 @@ module GraphQL
     # response which corresponds to this error.
     attr_accessor :path
 
-    def initialize(message, ast_node: nil)
+    # @return [Hash] Optional data for error objects
+    attr_accessor :options
+
+    def initialize(message, ast_node: nil, options: nil)
       @ast_node = ast_node
+      @options = options
       super(message)
     end
 
@@ -32,6 +36,9 @@ module GraphQL
       if path
         hash["path"] = path
       end
+      if options
+        hash.merge!(options)
+      end
       hash
     end
   end

data/lib/graphql/language/parser.rb

@@ -14,19 +14,20 @@ module GraphQL
 
 module_eval(<<'...end parser.y/module_eval...', 'parser.y', 356)
 
-def initialize(query_string, filename:)
+def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
   @filename = filename
+  @tracer = tracer
 end
 
 def parse_document
   @document ||= begin
     # Break the string into tokens
-    GraphQL::Tracing.trace("lex", {query_string: @query_string}) do
+    @tracer.trace("lex", {query_string: @query_string}) do
       @tokens ||= GraphQL.scan(@query_string)
     end
     # From the tokens, build an AST
-    GraphQL::Tracing.trace("parse", {query_string: @query_string}) do
+    @tracer.trace("parse", {query_string: @query_string}) do
       if @tokens.none?
         make_node(:Document, definitions: [], filename: @filename)
       else
@@ -36,8 +37,8 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil)
-  self.new(query_string, filename: filename).parse_document
+def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+  self.new(query_string, filename: filename, tracer: tracer).parse_document
 end
 
 private

data/lib/graphql/language/parser.y

@@ -354,19 +354,20 @@ end
 
 ---- inner ----
 
-def initialize(query_string, filename:)
+def initialize(query_string, filename:, tracer: Tracing::NullTracer)
   @query_string = query_string
   @filename = filename
+  @tracer = tracer
 end
 
 def parse_document
   @document ||= begin
     # Break the string into tokens
-    GraphQL::Tracing.trace("lex", {query_string: @query_string}) do
+    @tracer.trace("lex", {query_string: @query_string}) do
       @tokens ||= GraphQL.scan(@query_string)
     end
     # From the tokens, build an AST
-    GraphQL::Tracing.trace("parse", {query_string: @query_string}) do
+    @tracer.trace("parse", {query_string: @query_string}) do
       if @tokens.none?
         make_node(:Document, definitions: [], filename: @filename)
       else
@@ -376,8 +377,8 @@ def parse_document
   end
 end
 
-def self.parse(query_string, filename: nil)
-  self.new(query_string, filename: filename).parse_document
+def self.parse(query_string, filename: nil, tracer: GraphQL::Tracing::NullTracer)
+  self.new(query_string, filename: filename, tracer: tracer).parse_document
 end
 
 private

data/lib/graphql/query.rb

@@ -15,6 +15,7 @@ require "graphql/query/validation_pipeline"
 module GraphQL
   # A combination of query string and {Schema} instance which can be reduced to a {#result}.
   class Query
+    include Tracing::Traceable
     extend GraphQL::Delegate
 
     class OperationNameMissingError < GraphQL::ExecutionError
@@ -55,6 +56,8 @@ module GraphQL
     # @return [String, nil]
     attr_reader :operation_name
 
+    attr_reader :tracers
+
     # Prepare query `query_string` on `schema`
     # @param schema [GraphQL::Schema]
     # @param query_string [String]
@@ -75,6 +78,12 @@ module GraphQL
       @fragments = nil
       @operations = nil
       @validate = validate
+      # TODO: remove support for global tracers
+      @tracers = schema.tracers + GraphQL::Tracing.tracers + (context ? context.fetch(:tracers, []) : [])
+      # Support `ctx[:backtrace] = true` for wrapping backtraces
+      if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
+        @tracers << GraphQL::Backtrace::Tracer
+      end
 
       @analysis_errors = []
       if variables.is_a?(String)
@@ -266,7 +275,7 @@ module GraphQL
       parse_error = nil
       @document ||= begin
         if query_string
-          GraphQL.parse(query_string)
+          GraphQL.parse(query_string, tracer: self)
         end
       rescue GraphQL::ParseError => err
         parse_error = err

data/lib/graphql/query/context.rb

@@ -161,6 +161,7 @@ module GraphQL
 
       class FieldResolutionContext
         include SharedMethods
+        include Tracing::Traceable
         extend GraphQL::Delegate
 
         attr_reader :irep_node, :field, :parent_type, :query, :schema, :parent, :key, :type
@@ -178,6 +179,7 @@ module GraphQL
           # This is needed constantly, so set it ahead of time:
           @query = context.query
           @schema = context.schema
+          @tracers = @query.tracers
         end
 
         def path

data/lib/graphql/relay/relation_connection.rb

@@ -131,7 +131,7 @@ module GraphQL
 
         if after
           offset = (relation_offset(@sliced_nodes) || 0) + offset_from_cursor(after)
-          @sliced_nodes = @sliced_nodes.offset(offset) if after
+          @sliced_nodes = @sliced_nodes.offset(offset)
         end
 
         if before && after

data/lib/graphql/scalar_type.rb

@@ -34,6 +34,30 @@ module GraphQL
   #     coerce_result ->(value, ctx) { value.to_f }
   #   end
   #
+  #
+  # You can customize the error message for invalid input values by raising a `GraphQL::CoercionError` within `coerce_input`:
+  #
+  # @example raising a custom error message
+  #   TimeType = GraphQL::ScalarType.define do
+  #     name "Time"
+  #     description "Time since epoch in seconds"
+  #
+  #     coerce_input ->(value, ctx) do
+  #       begin
+  #         Time.at(Float(value))
+  #       rescue ArgumentError
+  #         raise GraphQL::CoercionError, "cannot coerce `#{value.inspect}` to Float"
+  #       end
+  #     end
+  #
+  #     coerce_result ->(value, ctx) { value.to_f }
+  #   end
+  #
+  # This will result in the message of the `GraphQL::CoercionError` being used in the error response:
+  #
+  # @example custom error response
+  # {"message"=>"cannot coerce `"2"` to Float", "locations"=>[{"line"=>3, "column"=>9}], "fields"=>["arg"]}
+  #
   class ScalarType < GraphQL::BaseType
     accepts_definitions :coerce, :coerce_input, :coerce_result
     ensure_defined :coerce_non_null_input, :coerce_result

data/lib/graphql/schema.rb

@@ -70,7 +70,8 @@ module GraphQL
       multiplex_analyzer: ->(schema, analyzer) { schema.multiplex_analyzers << analyzer },
       middleware: ->(schema, middleware) { schema.middleware << middleware },
       lazy_resolve: ->(schema, lazy_class, lazy_value_method) { schema.lazy_methods.set(lazy_class, lazy_value_method) },
-      rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)}
+      rescue_from: ->(schema, err_class, &block) { schema.rescue_from(err_class, &block)},
+      tracer: ->(schema, tracer) { schema.tracers.push(tracer) }
 
     attr_accessor \
       :query, :mutation, :subscription,
@@ -100,6 +101,10 @@ module GraphQL
       GraphQL::Filter.new(except: default_mask)
     end
 
+    # @return [Array<#trace(key, data)>] Tracers applied to every query
+    # @see {Query#tracers} for query-specific tracers
+    attr_reader :tracers
+
     self.default_execution_strategy = GraphQL::Execution::Execute
 
     BUILT_IN_TYPES = Hash[[INT_TYPE, STRING_TYPE, FLOAT_TYPE, BOOLEAN_TYPE, ID_TYPE].map{ |type| [type.name, type] }]
@@ -109,6 +114,7 @@ module GraphQL
     attr_reader :static_validator, :object_from_id_proc, :id_from_object_proc, :resolve_type_proc
 
     def initialize
+      @tracers = []
       @definition_error = nil
       @orphan_types = []
       @directives = DIRECTIVES.reduce({}) { |m, d| m[d.name] = d; m }
@@ -141,7 +147,7 @@ module GraphQL
       @middleware = other.middleware.dup
       @query_analyzers = other.query_analyzers.dup
       @multiplex_analyzers = other.multiplex_analyzers.dup
-
+      @tracers = other.tracers.dup
       @possible_types = GraphQL::Schema::PossibleTypes.new(self)
 
       @lazy_methods = other.lazy_methods.dup
@@ -256,8 +262,17 @@ module GraphQL
       if query_str
         kwargs[:query] = query_str
       end
+      # Some of the query context _should_ be passed to the multiplex, too
+      multiplex_context = if (ctx = kwargs[:context])
+        {
+          backtrace: ctx[:backtrace],
+          tracers: ctx[:tracers],
+        }
+      else
+        {}
+      end
       # Since we're running one query, don't run a multiplex-level complexity analyzer
-      all_results = multiplex([kwargs], max_complexity: nil)
+      all_results = multiplex([kwargs], max_complexity: nil, context: multiplex_context)
       all_results[0]
     end