graphql 1.9.17 → 1.11.7

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,72 @@ 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 node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          # @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(node, field_definition, query, response_path)
+            @node = node
+            @field_definition = field_definition
+            @query = query
+            @response_path = response_path
+            @scoped_children = nil
+          end
+
+          # 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)
+            defined_complexity = @field_definition.complexity
+            case defined_complexity
+            when Proc
+              arguments = @query.arguments_for(@node, @field_definition)
+              defined_complexity.call(@query.context, arguments.keyword_arguments, child_complexity)
+            when Numeric
+              defined_complexity + child_complexity
+            else
+              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
+            end
+          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(node, visitor.field_definition, visitor.query, visitor.response_path)
+          # Push it on the stack.
+          complexities_on_type.push(complexity)
         end
 
         def on_leave_field(node, parent, visitor)
@@ -34,88 +89,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

@@ -134,7 +134,7 @@ 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.arguments[node.name]
             else
               nil
             end
@@ -214,7 +214,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
@@ -245,7 +245,7 @@ module GraphQL
 
         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,8 @@ module GraphQL
     module AST
       module_function
 
-      def use(schema_defn)
-        schema = schema_defn.target
-        schema.analysis_engine = GraphQL::Analysis::AST
+      def use(schema_class)
+        schema_class.analysis_engine = GraphQL::Analysis::AST
       end
 
       # Analyze a multiplex, and all queries within.
@@ -60,16 +59,18 @@ module GraphQL
             .select { |analyzer| analyzer.analyze? }
 
           analyzers_to_run = query_analyzers + multiplex_analyzers
-          return [] unless analyzers_to_run.any?
+          if analyzers_to_run.any?
+            visitor = GraphQL::Analysis::AST::Visitor.new(
+              query: query,
+              analyzers: analyzers_to_run
+            )
 
-          visitor = GraphQL::Analysis::AST::Visitor.new(
-            query: query,
-            analyzers: analyzers_to_run
-          )
+            visitor.visit
 
-          visitor.visit
-
-          query_analyzers.map(&:result)
+            query_analyzers.map(&:result)
+          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
+    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)
@@ -134,9 +106,9 @@ module GraphQL
       end
 
       if type_or_argument.is_a?(GraphQL::Argument)
-        type_or_argument.redefine(kwargs, &block)
+        type_or_argument.redefine(**kwargs, &block)
       else
-        GraphQL::Argument.define(kwargs, &block)
+        GraphQL::Argument.define(**kwargs, &block)
       end
     end
 

data/lib/graphql/backtrace/table.rb

@@ -84,10 +84,14 @@ module GraphQL
           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,10 +108,14 @@ 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
           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),
           ]

data/lib/graphql/backtrace/tracer.rb

@@ -15,7 +15,8 @@ module GraphQL
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
           metadata[:query] || metadata[:queries]
         when "execute_field", "execute_field_lazy"
-          metadata[:context]
+          # The interpreter passes `query:`, legacy passes `context:`
+          metadata[:context] || ((q = metadata[:query]) && q.context)
         else
           # Custom key, no backtrace data for this
           nil

data/lib/graphql/base_type.rb

@@ -43,6 +43,10 @@ module GraphQL
     # @see {GraphQL::SchemaMember}
     alias :graphql_definition :itself
 
+    def type_class
+      metadata[:type_class]
+    end
+
     def name=(name)
       GraphQL::NameValidator.validate!(name)
       @name = name

data/lib/graphql/compatibility/execution_specification/specification_schema.rb

@@ -43,8 +43,8 @@ module GraphQL
             @storage = storage
           end
 
-          def each
-            @storage.each { |i| yield(i) }
+          def each(&block)
+            @storage.each(&block)
           end
         end
 

data/lib/graphql/compatibility/query_parser_specification/parse_error_specification.rb

@@ -70,15 +70,11 @@ module GraphQL
           ")
         end
 
-        def assert_empty_document(query_string)
-          doc = parse(query_string)
-          assert_equal 0, doc.definitions.length
-        end
-
-        def test_it_parses_blank_queries
-          assert_empty_document("")
-          assert_empty_document(" ")
-          assert_empty_document("\t \t")
+        def test_it_rejects_blank_queries
+          assert_raises_parse_error("")
+          assert_raises_parse_error(" ")
+          assert_raises_parse_error("\t \t")
+          assert_raises_parse_error(" # comment ")
         end
 
         def test_it_restricts_on

data/lib/graphql/define/assign_enum_value.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # Turn enum value configs into a {GraphQL::EnumType::EnumValue} and register it with the {GraphQL::EnumType}
+    # @api deprecated
     module AssignEnumValue
       def self.call(enum_type, name, desc = nil, deprecation_reason: nil, value: name, &block)
         enum_value = GraphQL::EnumType::EnumValue.define(

data/lib/graphql/define/assign_global_id_field.rb

@@ -2,9 +2,9 @@
 module GraphQL
   module Define
     module AssignGlobalIdField
-      def self.call(type_defn, field_name)
+      def self.call(type_defn, field_name, **field_kwargs)
         resolve = GraphQL::Relay::GlobalIdResolve.new(type: type_defn)
-        GraphQL::Define::AssignObjectField.call(type_defn, field_name, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
+        GraphQL::Define::AssignObjectField.call(type_defn, field_name, **field_kwargs, type: GraphQL::ID_TYPE.to_non_null_type, resolve: resolve)
       end
     end
   end

data/lib/graphql/define/assign_object_field.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module Define
-    # Turn field configs into a {GraphQL::Field} and attach it to a {GraphQL::ObjectType} or {GraphQL::InterfaceType}
+    # @api deprecated
     module AssignObjectField
       def self.call(owner_type, name, type_or_field = nil, desc = nil, function: nil, field: nil, relay_mutation_function: nil, **kwargs, &block)
         name_s = name.to_s
@@ -28,9 +28,9 @@ module GraphQL
         end
 
         obj_field = if base_field
-          base_field.redefine(kwargs, &block)
+          base_field.redefine(**kwargs, &block)
         else
-          GraphQL::Field.define(kwargs, &block)
+          GraphQL::Field.define(**kwargs, &block)
         end
 
 

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Define
     # This object delegates most methods to a dictionary of functions, {@dictionary}.
     # {@target} is passed to the specified function, along with any arguments and block.
     # This allows a method-based DSL without adding methods to the defined class.
     class DefinedObjectProxy
+      extend GraphQL::Ruby2Keywords
       # The object which will be defined by definition functions
       attr_reader :target
 
@@ -41,6 +43,7 @@ module GraphQL
           raise NoDefinitionError, msg, caller
         end
       end
+      ruby2_keywords :method_missing
 
       def respond_to_missing?(name, include_private = false)
         @dictionary[name] || super