graphql 1.10.1 → 1.13.0

data/lib/generators/graphql/type_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require 'graphql'
 require 'active_support'
@@ -12,7 +13,6 @@ module Graphql
 
       argument :type_name,
         type: :string,
-        required: true,
         banner: "TypeName",
         desc: "Name of this object type (expressed as Ruby or GraphQL)"
 

data/lib/graphql/analysis/analyze_query.rb

@@ -3,6 +3,11 @@ module GraphQL
   module Analysis
     module_function
 
+    def use(schema_class)
+      schema = schema_class.is_a?(Class) ? schema_class : schema_class.target
+      schema.analysis_engine = self
+    end
+
     # @return [void]
     def analyze_multiplex(multiplex, analyzers)
       multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
@@ -38,6 +43,8 @@ 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::Deprecation.warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
+
       query.trace("analyze_query", { query: query }) do
         analyzers_to_run = analyzers.select do |analyzer|
           if analyzer.respond_to?(:analyze?)

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

@@ -7,6 +7,7 @@ module GraphQL
           super
           @used_fields = Set.new
           @used_deprecated_fields = Set.new
+          @used_deprecated_arguments = Set.new
         end
 
         def on_leave_field(node, parent, visitor)
@@ -14,14 +15,36 @@ module GraphQL
           field = "#{visitor.parent_type_definition.graphql_name}.#{field_defn.graphql_name}"
           @used_fields << field
           @used_deprecated_fields << field if field_defn.deprecation_reason
+
+          extract_deprecated_arguments(visitor.query.arguments_for(node, visitor.field_definition).argument_values)
         end
 
         def result
           {
             used_fields: @used_fields.to_a,
-            used_deprecated_fields: @used_deprecated_fields.to_a
+            used_deprecated_fields: @used_deprecated_fields.to_a,
+            used_deprecated_arguments: @used_deprecated_arguments.to_a,
           }
         end
+
+        private
+
+        def extract_deprecated_arguments(argument_values)
+          argument_values.each_pair do |_argument_name, argument|
+            if argument.definition.deprecation_reason
+              @used_deprecated_arguments << argument.definition.path
+            end
+
+            if argument.definition.type.kind.input_object?
+              extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            elsif argument.definition.type.list? && !argument.value.nil?
+              argument
+                .value
+                .select { |value| value.respond_to?(:arguments) }
+                .each { |value| extract_deprecated_arguments(value.arguments.argument_values) } # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
+            end
+          end
+        end
       end
     end
   end

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

@@ -21,16 +21,24 @@ module GraphQL
           # since the lexical binding isn't important.
           HASH_CHILDREN = ->(h, k) { h[k] = {} }
 
-          # @param node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          attr_reader :field_definition, :response_path, :query
+
+          # @param parent_type [Class] The owner of `field_definition`
           # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
-          # @param query [GrpahQL::Query] Used for `query.possible_types`
-          def initialize(node, field_definition, query)
+          # @param query [GraphQL::Query] Used for `query.possible_types`
+          # @param response_path [Array<String>] The path to the response key for the field
+          def initialize(parent_type, field_definition, query, response_path)
+            @parent_type = parent_type
             @field_definition = field_definition
             @query = query
-            @node = node
+            @response_path = response_path
             @scoped_children = nil
+            @nodes = []
           end
 
+          # @return [Array<GraphQL::Language::Nodes::Field>]
+          attr_reader :nodes
+
           # Returns true if this field has no selections, ie, it's a scalar.
           # We need a quick way to check whether we should continue traversing.
           def terminal?
@@ -46,16 +54,7 @@ module GraphQL
           end
 
           def own_complexity(child_complexity)
-            defined_complexity = @field_definition.complexity
-            case defined_complexity
-            when Proc
-              arguments = @query.arguments_for(@node, @field_definition)
-              defined_complexity.call(@query.context, arguments, child_complexity)
-            when Numeric
-              defined_complexity + child_complexity
-            else
-              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
-            end
+            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
           end
         end
 
@@ -73,9 +72,10 @@ module GraphQL
           # `node` and `visitor.field_definition` may appear from a cache,
           # but I think that's ok. If the arguments _didn't_ match,
           # then the query would have been rejected as invalid.
-          complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query)]
+          complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query, visitor.response_path)]
 
-          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(node, visitor.field_definition, visitor.query)
+          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(parent_type, visitor.field_definition, visitor.query, visitor.response_path)
+          complexity.nodes.push(node)
           # Push it on the stack.
           complexities_on_type.push(complexity)
         end
@@ -89,123 +89,140 @@ module GraphQL
           complexities_on_type.pop
         end
 
+        private
+
         # @return [Integer]
         def max_possible_complexity
           @complexities_on_type_by_query.reduce(0) do |total, (query, complexities_on_type)|
             root_complexity = complexities_on_type.last
             # Use this entry point to calculate the total complexity
-            total_complexity_for_query = ComplexityMergeFunctions.merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
+            total_complexity_for_query = merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
             total + total_complexity_for_query
           end
         end
 
-        # These functions use `ScopedTypeComplexity` objects,
-        # especially their `scoped_children`, to traverse down the tree
-        # and find the max complexity for any possible runtime type.
-        # Yowza.
-        module ComplexityMergeFunctions
-          module_function
-          # When looking at two selection scopes, figure out whether the selections on
-          # `right_scope` should be applied when analyzing `left_scope`.
-          # This is like the `Typecast.subtype?`, except it's using query-specific type filtering.
-          def applies_to?(query, left_scope, right_scope)
-            if left_scope == right_scope
-              # This can happen when several branches are being analyzed together
-              true
-            else
-              # Check if these two scopes have _any_ types in common.
-              possible_right_types = query.possible_types(right_scope)
-              possible_left_types = query.possible_types(left_scope)
-              !(possible_right_types & possible_left_types).empty?
-            end
+        # @param query [GraphQL::Query] Used for `query.possible_types`
+        # @param scoped_children_hashes [Array<Hash>] Array of scoped children hashes
+        # @return [Integer]
+        def merged_max_complexity_for_scopes(query, scoped_children_hashes)
+          # Figure out what scopes are possible here.
+          # Use a hash, but ignore the values; it's just a fast way to work with the keys.
+          all_scopes = {}
+          scoped_children_hashes.each do |h|
+            all_scopes.merge!(h)
           end
 
-          def merged_max_complexity_for_scopes(query, scoped_children_hashes)
-            # Figure out what scopes are possible here.
-            # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-            all_scopes = {}
-            scoped_children_hashes.each do |h|
-              all_scopes.merge!(h)
-            end
-
-            # If an abstract scope is present, but _all_ of its concrete types
-            # are also in the list, remove it from the list of scopes to check,
-            # because every possible type is covered by a concrete type.
-            # (That is, there are no remainder types to check.)
-            all_scopes.reject! do |scope, _|
-              scope.kind.abstract? && (
-                query.possible_types(scope).all? { |t| all_scopes.include?(t) }
-              )
+          # If an abstract scope is present, but _all_ of its concrete types
+          # are also in the list, remove it from the list of scopes to check,
+          # because every possible type is covered by a concrete type.
+          # (That is, there are no remainder types to check.)
+          prev_keys = all_scopes.keys
+          prev_keys.each do |scope|
+            next unless scope.kind.abstract?
+
+            missing_concrete_types = query.possible_types(scope).select { |t| !all_scopes.key?(t) }
+            # This concrete type is possible _only_ as a member of the abstract type.
+            # So, attribute to it the complexity which belongs to the abstract type.
+            missing_concrete_types.each do |concrete_scope|
+              all_scopes[concrete_scope] = all_scopes[scope]
             end
+            all_scopes.delete(scope)
+          end
 
-            # This will hold `{ type => int }` pairs, one for each possible branch
-            complexity_by_scope = {}
-
-            # For each scope,
-            # find the lexical selections that might apply to it,
-            # and gather them together into an array.
-            # Then, treat the set of selection hashes
-            # as a set and calculate the complexity for them as a unit
-            all_scopes.each do |scope, _|
-              # These will be the selections on `scope`
-              children_for_scope = []
-              scoped_children_hashes.each do |sc_h|
-                sc_h.each do |inner_scope, children_hash|
-                  if applies_to?(query, scope, inner_scope)
-                    children_for_scope << children_hash
-                  end
+          # This will hold `{ type => int }` pairs, one for each possible branch
+          complexity_by_scope = {}
+
+          # For each scope,
+          # find the lexical selections that might apply to it,
+          # and gather them together into an array.
+          # Then, treat the set of selection hashes
+          # as a set and calculate the complexity for them as a unit
+          all_scopes.each do |scope, _|
+            # These will be the selections on `scope`
+            children_for_scope = []
+            scoped_children_hashes.each do |sc_h|
+              sc_h.each do |inner_scope, children_hash|
+                if applies_to?(query, scope, inner_scope)
+                  children_for_scope << children_hash
                 end
               end
-
-              # Calculate the complexity for `scope`, merging all
-              # possible lexical branches.
-              complexity_value = merged_max_complexity(query, children_for_scope)
-              complexity_by_scope[scope] = complexity_value
             end
 
-            # Return the max complexity among all scopes
-            complexity_by_scope.each_value.max
+            # Calculate the complexity for `scope`, merging all
+            # possible lexical branches.
+            complexity_value = merged_max_complexity(query, children_for_scope)
+            complexity_by_scope[scope] = complexity_value
           end
 
-          # @param children_for_scope [Array<Hash>] An array of `scoped_children[scope]` hashes (`{field_key => complexity}`)
-          # @return [Integer] Complexity value for all these selections in the current scope
-          def merged_max_complexity(query, children_for_scope)
-            all_keys = []
-            children_for_scope.each do |c|
-              all_keys.concat(c.keys)
-            end
-            all_keys.uniq!
-            complexity_for_keys = {}
-            all_keys.each do |child_key|
-
-              scoped_children_for_key = nil
-              complexity_for_key = nil
-              children_for_scope.each do |children_hash|
-                if children_hash.key?(child_key)
-                  complexity_for_key = children_hash[child_key]
-                  if complexity_for_key.terminal?
-                    # Assume that all terminals would return the same complexity
-                    # Since it's a terminal, its child complexity is zero.
-                    complexity_for_key = complexity_for_key.own_complexity(0)
-                    complexity_for_keys[child_key] = complexity_for_key
-                  else
-                    scoped_children_for_key ||= []
-                    scoped_children_for_key << complexity_for_key.scoped_children
-                  end
-                end
-              end
+          # Return the max complexity among all scopes
+          complexity_by_scope.each_value.max
+        end
+
+        def applies_to?(query, left_scope, right_scope)
+          if left_scope == right_scope
+            # This can happen when several branches are being analyzed together
+            true
+          else
+            # Check if these two scopes have _any_ types in common.
+            possible_right_types = query.possible_types(right_scope)
+            possible_left_types = query.possible_types(left_scope)
+            !(possible_right_types & possible_left_types).empty?
+          end
+        end
+
+        # A hook which is called whenever a field's max complexity is calculated.
+        # Override this method to capture individual field complexity details.
+        #
+        # @param scoped_type_complexity [ScopedTypeComplexity]
+        # @param max_complexity [Numeric] Field's maximum complexity including child complexity
+        # @param child_complexity [Numeric, nil] Field's child complexity
+        def field_complexity(scoped_type_complexity, max_complexity:, child_complexity: nil)
+        end
 
-              if scoped_children_for_key
-                child_complexity = merged_max_complexity_for_scopes(query, scoped_children_for_key)
-                # This is the _last_ one we visited; assume it's representative.
-                max_complexity = complexity_for_key.own_complexity(child_complexity)
-                complexity_for_keys[child_key] = max_complexity
+        # @param children_for_scope [Array<Hash>] An array of `scoped_children[scope]` hashes
+        # (`{field_key => complexity}`)
+        # @return [Integer] Complexity value for all these selections in the current scope
+        def merged_max_complexity(query, children_for_scope)
+          all_keys = []
+          children_for_scope.each do |c|
+            all_keys.concat(c.keys)
+          end
+          all_keys.uniq!
+          complexity_for_keys = {}
+
+          all_keys.each do |child_key|
+            scoped_children_for_key = nil
+            complexity_for_key = nil
+            children_for_scope.each do |children_hash|
+              next unless children_hash.key?(child_key)
+
+              complexity_for_key = children_hash[child_key]
+              if complexity_for_key.terminal?
+                # Assume that all terminals would return the same complexity
+                # Since it's a terminal, its child complexity is zero.
+                complexity = complexity_for_key.own_complexity(0)
+                complexity_for_keys[child_key] = complexity
+
+                field_complexity(complexity_for_key, max_complexity: complexity, child_complexity: nil)
+              else
+                scoped_children_for_key ||= []
+                scoped_children_for_key << complexity_for_key.scoped_children
               end
             end
 
-            # Calculate the child complexity by summing the complexity of all selections
-            complexity_for_keys.each_value.inject(0, &:+)
+            next unless scoped_children_for_key
+
+            child_complexity = merged_max_complexity_for_scopes(query, scoped_children_for_key)
+            # This is the _last_ one we visited; assume it's representative.
+            max_complexity = complexity_for_key.own_complexity(child_complexity)
+
+            field_complexity(complexity_for_key, max_complexity: max_complexity, child_complexity: child_complexity)
+
+            complexity_for_keys[child_key] = max_complexity
           end
+
+          # Calculate the child complexity by summing the complexity of all selections
+          complexity_for_keys.each_value.inject(0, &:+)
         end
       end
     end

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

@@ -19,6 +19,7 @@ module GraphQL
           @field_definitions = []
           @argument_definitions = []
           @directive_definitions = []
+          @rescued_errors = []
           @query = query
           @schema = query.schema
           @response_path = []
@@ -32,6 +33,9 @@ module GraphQL
         # @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
@@ -96,7 +100,7 @@ module GraphQL
         def on_field(node, parent)
           @response_path.push(node.alias || node.name)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          field_definition = @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
@@ -134,14 +138,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              arg_type.get_argument(node.name, @query.context)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            directive_defn.get_argument(node.name, @query.context)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            field_defn.get_argument(node.name, @query.context)
           else
             nil
           end
@@ -239,7 +243,11 @@ module GraphQL
 
         def call_analyzers(method, node, parent)
           @analyzers.each do |analyzer|
-            analyzer.public_send(method, node, parent, self)
+            begin
+              analyzer.public_send(method, node, parent, self)
+            rescue AnalysisError => err
+              @rescued_errors << err
+            end
           end
         end
 

data/lib/graphql/analysis/ast.rb

@@ -13,7 +13,12 @@ module GraphQL
       module_function
 
       def use(schema_class)
-        schema_class.analysis_engine = GraphQL::Analysis::AST
+        if schema_class.analysis_engine == self
+          definition_line = caller(2, 1).first
+          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
+        else
+          schema_class.analysis_engine = self
+        end
       end
 
       # Analyze a multiplex, and all queries within.
@@ -67,7 +72,11 @@ module GraphQL
 
             visitor.visit
 
-            query_analyzers.map(&:result)
+            if visitor.rescued_errors.any?
+              visitor.rescued_errors
+            else
+              query_analyzers.map(&:result)
+            end
           else
             []
           end

data/lib/graphql/argument.rb

@@ -3,14 +3,14 @@ module GraphQL
   # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access
+    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access, :deprecation_reason
     attr_reader :default_value
-    attr_accessor :description, :name, :as
+    attr_accessor :description, :name, :as, :deprecation_reason
     attr_accessor :ast_node
     attr_accessor :method_access
     alias :graphql_name :name
 
-    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access)
+    ensure_defined(:name, :description, :default_value, :type=, :type, :as, :expose_as, :prepare, :method_access, :deprecation_reason)
 
     # @api private
     module DefaultPrepare

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     module InspectResult

data/lib/graphql/backtrace/legacy_tracer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module LegacyTracer
+      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"
+          query = metadata[:query] || metadata[:queries].first
+          push_data = query
+          multiplex = query.multiplex
+        when "execute_field", "execute_field_lazy"
+          # The interpreter passes `query:`, legacy passes `context:`
+          context = metadata[:context] || ((q = metadata[:query]) && q.context)
+          push_data = context
+          multiplex = context.query.multiplex
+        else
+          # Custom key, no backtrace data for this
+          nil
+        end
+
+        if push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
+        end
+
+        if key == "execute_multiplex"
+          begin
+            yield
+          rescue StandardError => err
+            # This is an unhandled error from execution,
+            # Re-raise it with a GraphQL trace.
+            potential_context = metadata[:multiplex].context[:last_graphql_backtrace_context]
+
+            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+              raise TracedError.new(err, potential_context)
+            else
+              raise
+            end
+          ensure
+            metadata[:multiplex].context.delete(:last_graphql_backtrace_context)
+          end
+        else
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/graphql/backtrace/table.rb

@@ -1,5 +1,4 @@
 # 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
@@ -79,6 +78,25 @@ module GraphQL
       # @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], 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::FieldResolutionContext
           ctx = context_entry
           field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
@@ -112,16 +130,29 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
+          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
             "#{object.inspect}",
             query.variables.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(query.context.value),
+            Backtrace::InspectResult.inspect_result(value),
           ]
         else
-          raise "Unexpected get_rows subject #{context_entry.inspect}"
+          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

data/lib/graphql/backtrace/traced_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.