graphql 1.9.18 → 1.13.24

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

@@ -8,7 +8,7 @@ module GraphQL
         # - `complexities_on_type` holds complexity scores for each type in an IRep node
         def initialize(query)
           super
-          @complexities_on_type = [ConcreteTypeComplexity.new]
+          @complexities_on_type_by_query = {}
         end
 
         # Overide this method to use the complexity result
@@ -16,17 +16,68 @@ module GraphQL
           max_possible_complexity
         end
 
+        class ScopedTypeComplexity
+          # A single proc for {#scoped_children} hashes. Use this to avoid repeated allocations,
+          # since the lexical binding isn't important.
+          HASH_CHILDREN = ->(h, k) { h[k] = {} }
+
+          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 [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
+            @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?
+            @scoped_children.nil?
+          end
+
+          # This value is only calculated when asked for to avoid needless hash allocations.
+          # Also, if it's never asked for, we determine that this scope complexity
+          # is a scalar field ({#terminal?}).
+          # @return [Hash<Hash<Class => ScopedTypeComplexity>]
+          def scoped_children
+            @scoped_children ||= Hash.new(&HASH_CHILDREN)
+          end
+
+          def own_complexity(child_complexity)
+            @field_definition.calculate_complexity(query: @query, nodes: @nodes, child_complexity: child_complexity)
+          end
+        end
+
         def on_enter_field(node, parent, visitor)
           # We don't want to visit fragment definitions,
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
-
-          if visitor.type_definition.kind.abstract?
-            @complexities_on_type.push(AbstractTypeComplexity.new)
-          else
-            @complexities_on_type.push(ConcreteTypeComplexity.new)
-          end
+          parent_type = visitor.parent_type_definition
+          field_key = node.alias || node.name
+          # Find the complexity calculation for this field --
+          # if we're re-entering a selection, we'll already have one.
+          # Otherwise, make a new one and store it.
+          #
+          # `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, visitor.response_path)]
+
+          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
 
         def on_leave_field(node, parent, visitor)
@@ -34,88 +85,144 @@ module GraphQL
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
+          complexities_on_type = @complexities_on_type_by_query[visitor.query]
+          complexities_on_type.pop
+        end
 
-          type_complexities = @complexities_on_type.pop
-          child_complexity = type_complexities.max_possible_complexity
-          own_complexity = get_complexity(node, visitor.field_definition, child_complexity, visitor)
+        private
 
-          if @complexities_on_type.last.is_a?(AbstractTypeComplexity)
-            key = selection_key(visitor.response_path, visitor.query)
-            parent_type = visitor.parent_type_definition
-            visitor.query.possible_types(parent_type).each do |type|
-              @complexities_on_type.last.merge(type, key, own_complexity)
-            end
-          else
-            @complexities_on_type.last.merge(own_complexity)
+        # @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 = merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
+            total + total_complexity_for_query
           end
         end
 
+        # @param query [GraphQL::Query] Used for `query.possible_types`
+        # @param scoped_children_hashes [Array<Hash>] Array of scoped children hashes
         # @return [Integer]
-        def max_possible_complexity
-          @complexities_on_type.last.max_possible_complexity
-        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
 
-        private
+          # 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
 
-        def selection_key(response_path, query)
-          # We add the query object id to support multiplex queries
-          # even if they have the same response path, they should
-          # always be added.
-          "#{response_path.join(".")}-#{query.object_id}"
-        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
+            end
 
-        # Get a complexity value for a field,
-        # by getting the number or calling its proc
-        def get_complexity(ast_node, field_defn, child_complexity, visitor)
-        # Return if we've visited this response path before (not counting duplicates)
-          defined_complexity = field_defn.complexity
+            # 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
 
-          arguments = visitor.arguments_for(ast_node, field_defn)
+          # Return the max complexity among all scopes
+          complexity_by_scope.each_value.max
+        end
 
-          case defined_complexity
-          when Proc
-            defined_complexity.call(visitor.query.context, arguments, child_complexity)
-          when Numeric
-            defined_complexity + (child_complexity || 0)
+        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
-            raise("Invalid complexity: #{defined_complexity.inspect} on #{field_defn.name}")
+            # 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
 
-        # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
-        # Find the maximum possible complexity among those combinations.
-        class AbstractTypeComplexity
-          def initialize
-            @types = Hash.new { |h, k| h[k] = {} }
-          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
 
-          # Return the max possible complexity for types in this selection
-          def max_possible_complexity
-            max = 0
-            @types.each_value do |fields|
-              complexity = fields.each_value.inject(:+)
-              max = complexity if complexity > max
-            end
-            max
+        # @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
 
-          # Store the complexity for the branch on `type_defn`.
-          # Later we will see if this is the max complexity among branches.
-          def merge(type_defn, key, complexity)
-            @types[type_defn][key] = complexity
-          end
-        end
+            next unless scoped_children_for_key
 
-        class ConcreteTypeComplexity
-          attr_reader :max_possible_complexity
+            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)
 
-          def initialize
-            @max_possible_complexity = 0
-          end
+            field_complexity(complexity_for_key, max_complexity: max_complexity, child_complexity: child_complexity)
 
-          def merge(complexity)
-            @max_possible_complexity += 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,8 @@ 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)
+          # 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
@@ -134,14 +139,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.input_fields[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
@@ -214,7 +219,7 @@ module GraphQL
           fragment_def = query.fragments[fragment_spread.name]
 
           object_type = if fragment_def.type
-            query.schema.types.fetch(fragment_def.type.name, nil)
+            @query.warden.get_type(fragment_def.type.name)
           else
             object_types.last
           end
@@ -239,13 +244,17 @@ 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
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @query.warden.get_type(node.type.name)
           else
             @object_types.last
           end

data/lib/graphql/analysis/ast.rb

@@ -12,9 +12,13 @@ module GraphQL
     module AST
       module_function
 
-      def use(schema_defn)
-        schema = schema_defn.target
-        schema.analysis_engine = GraphQL::Analysis::AST
+      def use(schema_class)
+        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.
@@ -60,16 +64,22 @@ module GraphQL
             .select { |analyzer| analyzer.analyze? }
 
           analyzers_to_run = query_analyzers + multiplex_analyzers
-          return [] unless analyzers_to_run.any?
-
-          visitor = GraphQL::Analysis::AST::Visitor.new(
-            query: query,
-            analyzers: analyzers_to_run
-          )
+          if analyzers_to_run.any?
+            visitor = GraphQL::Analysis::AST::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run
+            )
 
-          visitor.visit
+            visitor.visit
 
-          query_analyzers.map(&:result)
+            if visitor.rescued_errors.any?
+              visitor.rescued_errors
+            else
+              query_analyzers.map(&:result)
+            end
+          else
+            []
+          end
         end
       end
 

data/lib/graphql/argument.rb

@@ -1,48 +1,16 @@
 # frozen_string_literal: true
 module GraphQL
-  # Used for defined arguments ({Field}, {InputObjectType})
-  #
-  # {#name} must be a String.
-  #
-  # @example defining an argument for a field
-  #   GraphQL::Field.define do
-  #     # ...
-  #     argument :favoriteFood, types.String, "Favorite thing to eat", default_value: "pizza"
-  #   end
-  #
-  # @example defining an argument for an {InputObjectType}
-  #   GraphQL::InputObjectType.define do
-  #     argument :newName, !types.String
-  #   end
-  #
-  # @example defining an argument with a `prepare` function
-  #   GraphQL::Field.define do
-  #     argument :userId, types.ID, prepare: ->(userId) do
-  #       User.find_by(id: userId)
-  #     end
-  #   end
-  #
-  # @example returning an {ExecutionError} from a `prepare` function
-  #   GraphQL::Field.define do
-  #     argument :date do
-  #       type !types.String
-  #       prepare ->(date) do
-  #         return GraphQL::ExecutionError.new("Invalid date format") unless DateValidator.valid?(date)
-  #         Time.zone.parse(date)
-  #       end
-  #     end
-  #   end
-
+  # @api deprecated
   class Argument
     include GraphQL::Define::InstanceDefinable
-    accepts_definitions :name, :type, :description, :default_value, :as, :prepare, :method_access
+    deprecated_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
@@ -113,6 +81,10 @@ module GraphQL
       @prepare_proc = BackwardsCompatibility.wrap_arity(prepare_proc, from: 1, to: 2, name: "Argument#prepare(value, ctx)")
     end
 
+    def type_class
+      metadata[:type_class]
+    end
+
     NO_DEFAULT_VALUE = Object.new
     # @api private
     def self.from_dsl(name, type_or_argument = nil, description = nil, default_value: NO_DEFAULT_VALUE, as: nil, prepare: DefaultPrepare, **kwargs, &block)

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,15 +78,38 @@ 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}"
           position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
           field_alias = ctx.ast_node.alias
+          object = ctx.object
+          if object.is_a?(GraphQL::Schema::Object)
+            object = object.object
+          end
           rows << [
             "#{position}",
             "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{ctx.object.inspect}",
+            "#{object.inspect}",
             ctx.irep_node.arguments.to_h.inspect,
             Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
           ]
@@ -104,16 +126,33 @@ module GraphQL
             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], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
-            "#{query.root_value.inspect}",
+            "#{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}.