graphql 1.10.4 → 1.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abb84b7f4f94ae78b7d23d8726590780465d0018a3b225fb9b0cefbd557e6c1b
-  data.tar.gz: 78222841f7996f8449081d272169e6bd7e120f5937a08ea04a33c04217ff21dd
+  metadata.gz: ace6be63c92b2a2139381664968aef4eeed01a5b1e3936af31ef3b0d7735b944
+  data.tar.gz: 6d572562697f474dc82f81e3c28e9d234bf9348ef2446db41a10fa4b6d52cec4
 SHA512:
-  metadata.gz: d935f76873acb5bf0f15f9fa7c6d74a1a8ac5268d4885216698b206c66cda923b5cc269f90cf708ac296bf5d2973f9e45fb52558b5223cc3c345ae2650933e0c
-  data.tar.gz: 601450b86d9d6e9f9445060c24ba0dc74ce88ab2d69b2551b5e8836b4f02d35a0794e75e32c6db60eaefffc22878c87b07162c77a65b8ea1b5e241d6262881ca
+  metadata.gz: 4da367c261c3fd79192aea827be4b0cebc864820d4dba6ed74a3c57d9c7772511bf6b96bdd4316e9186bd751954a964b09bc1e455fed4f687edb958d869f25e5
+  data.tar.gz: a5d4c7c349cebf6ce1e064763c47a61e6018a29d4b563ce833390ed5d378f5dd977b884f2a1809a7935e43902a9e33e23682662192cc3ff5ab8079c75c1b5fb6

data/lib/graphql.rb

@@ -109,7 +109,6 @@ require "graphql/introspection"
 
 require "graphql/analysis_error"
 require "graphql/coercion_error"
-require "graphql/literal_validation_error"
 require "graphql/runtime_type_error"
 require "graphql/invalid_null_error"
 require "graphql/invalid_name_error"

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

@@ -21,13 +21,17 @@ module GraphQL
           # 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 [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(node, field_definition, query, response_path)
+            @node = node
             @field_definition = field_definition
             @query = query
-            @node = node
+            @response_path = response_path
             @scoped_children = nil
           end
 
@@ -73,9 +77,9 @@ 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(node, visitor.field_definition, visitor.query, visitor.response_path)
           # Push it on the stack.
           complexities_on_type.push(complexity)
         end
@@ -89,132 +93,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)
+          # 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
 
-            # 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.)
-            #
-            # TODO redocument
-            prev_keys = all_scopes.keys
-            prev_keys.each do |scope|
-              if 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]
+          # 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
-                all_scopes.delete(scope)
               end
             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
+            # 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
 
-              # 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
+        end
 
-            # Return the max complexity among all scopes
-            complexity_by_scope.each_value.max
+        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
 
-          # @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
+        # 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/execution/lookahead.rb

@@ -51,7 +51,15 @@ module GraphQL
 
       # @return [Hash<Symbol, Object>]
       def arguments
-        @arguments ||= @field && ArgumentHelpers.arguments(@query, @field, ast_nodes.first)
+        if defined?(@arguments)
+          @arguments
+        else
+          @arguments = if @field
+            @query.arguments_for(@ast_nodes.first, @field)
+          else
+            nil
+          end
+        end
       end
 
       # True if this node has a selection on `field_name`.
@@ -81,7 +89,7 @@ module GraphQL
       def selection(field_name, selected_type: @selected_type, arguments: nil)
         next_field_name = normalize_name(field_name)
 
-        next_field_defn = FieldHelpers.get_field(@query.schema, selected_type, next_field_name)
+        next_field_defn = get_class_based_field(selected_type, next_field_name)
         if next_field_defn
           next_nodes = []
           @ast_nodes.each do |ast_node|
@@ -127,7 +135,7 @@ module GraphQL
 
         subselections_by_type.each do |type, ast_nodes_by_response_key|
           ast_nodes_by_response_key.each do |response_key, ast_nodes|
-            field_defn = FieldHelpers.get_field(@query.schema, type, ast_nodes.first.name)
+            field_defn = get_class_based_field(type, ast_nodes.first.name)
             lookahead = Lookahead.new(query: @query, ast_nodes: ast_nodes, field: field_defn, owner_type: type)
             subselections.push(lookahead)
           end
@@ -203,12 +211,19 @@ module GraphQL
         end
       end
 
+      # Wrap get_field and ensure that it returns a GraphQL::Schema::Field.
+      # Remove this when legacy execution is removed.
+      def get_class_based_field(type, name)
+        f = @query.get_field(type, name)
+        f && f.type_class
+      end
+
       def skipped_by_directive?(ast_selection)
         ast_selection.directives.each do |directive|
           dir_defn = @query.schema.directives.fetch(directive.name)
           directive_class = dir_defn.type_class
           if directive_class
-            dir_args = GraphQL::Execution::Lookahead::ArgumentHelpers.arguments(@query, dir_defn, directive)
+            dir_args = @query.arguments_for(directive, dir_defn)
             return true unless directive_class.static_include?(dir_args, @query.context)
           end
         end
@@ -227,7 +242,7 @@ module GraphQL
             elsif arguments.nil? || arguments.empty?
               selections_on_type[response_key] = [ast_selection]
             else
-              field_defn = FieldHelpers.get_field(@query.schema, selected_type, ast_selection.name)
+              field_defn = get_class_based_field(selected_type, ast_selection.name)
               if arguments_match?(arguments, field_defn, ast_selection)
                 selections_on_type[response_key] = [ast_selection]
               end
@@ -278,115 +293,13 @@ module GraphQL
       end
 
       def arguments_match?(arguments, field_defn, field_node)
-        query_kwargs = ArgumentHelpers.arguments(@query, field_defn, field_node)
+        query_kwargs = @query.arguments_for(field_node, field_defn)
         arguments.all? do |arg_name, arg_value|
           arg_name = normalize_keyword(arg_name)
           # Make sure the constraint is present with a matching value
           query_kwargs.key?(arg_name) && query_kwargs[arg_name] == arg_value
         end
       end
-
-      # TODO Dedup with interpreter
-      module ArgumentHelpers
-        module_function
-
-        def arguments(query, arg_owner, ast_node)
-          kwarg_arguments = {}
-          arg_defns = arg_owner.arguments
-          ast_node.arguments.each do |arg|
-            arg_defn = arg_defns[arg.name] || raise("Invariant: missing argument definition for #{arg.name.inspect} in #{arg_defns.keys} from #{arg_owner}")
-            # Need to distinguish between client-provided `nil`
-            # and nothing-at-all
-            is_present, value = arg_to_value(query, arg_defn.type, arg.value)
-            if is_present
-              kwarg_arguments[arg_defn.keyword] = value
-            end
-          end
-          arg_defns.each do |name, arg_defn|
-            if arg_defn.default_value? && !kwarg_arguments.key?(arg_defn.keyword)
-              kwarg_arguments[arg_defn.keyword] = arg_defn.default_value
-            end
-          end
-          kwarg_arguments
-        end
-
-        # Get a Ruby-ready value from a client query.
-        # @param graphql_object [Object] The owner of the field whose argument this is
-        # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
-        # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
-        # @return [Array(is_present, value)]
-        def arg_to_value(query, arg_type, ast_value)
-          if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-            # If it's not here, it will get added later
-            if query.variables.key?(ast_value.name)
-              return true, query.variables[ast_value.name]
-            else
-              return false, nil
-            end
-          elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-            return true, nil
-          elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(query, arg_type.of_type, ast_value)
-          elsif arg_type.is_a?(GraphQL::Schema::List)
-            # Treat a single value like a list
-            arg_value = Array(ast_value)
-            list = []
-            arg_value.map do |inner_v|
-              _present, value = arg_to_value(query, arg_type.of_type, inner_v)
-              list << value
-            end
-            return true, list
-          elsif arg_type.is_a?(Class) && arg_type < GraphQL::Schema::InputObject
-            # For these, `prepare` is applied during `#initialize`.
-            # Pass `nil` so it will be skipped in `#arguments`.
-            # What a mess.
-            args = arguments(query, nil, arg_type, ast_value)
-            # We're not tracking defaults_used, but for our purposes
-            # we compare the value to the default value.
-            return true, arg_type.new(ruby_kwargs: args, context: query.context, defaults_used: nil)
-          else
-            flat_value = flatten_ast_value(query, ast_value)
-            return true, arg_type.coerce_input(flat_value, query.context)
-          end
-        end
-
-        def flatten_ast_value(query, v)
-          case v
-          when GraphQL::Language::Nodes::Enum
-            v.name
-          when GraphQL::Language::Nodes::InputObject
-            h = {}
-            v.arguments.each do |arg|
-              h[arg.name] = flatten_ast_value(query, arg.value)
-            end
-            h
-          when Array
-            v.map { |v2| flatten_ast_value(query, v2) }
-          when GraphQL::Language::Nodes::VariableIdentifier
-            flatten_ast_value(query.variables[v.name])
-          else
-            v
-          end
-        end
-      end
-
-      # TODO dedup with interpreter
-      module FieldHelpers
-        module_function
-
-        def get_field(schema, owner_type, field_name)
-          field_defn = owner_type.get_field(field_name)
-          field_defn ||= if owner_type == schema.query.type_class && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
-            entry_point_field.type_class
-          elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-            dynamic_field.type_class
-          else
-            nil
-          end
-
-          field_defn
-        end
-      end
     end
   end
 end