graphql 1.9.18 → 1.13.24

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -10,6 +10,7 @@ module GraphQL
       #
       # Original Algorithm: https://github.com/graphql/graphql-js/blob/master/src/validation/rules/OverlappingFieldsCanBeMerged.js
       NO_ARGS = {}.freeze
+
       Field = Struct.new(:node, :definition, :owner_type, :parents)
       FragmentSpread = Struct.new(:name, :parents)
 
@@ -17,24 +18,47 @@ module GraphQL
         super
         @visited_fragments = {}
         @compared_fragments = {}
+        @conflict_count = 0
       end
 
       def on_operation_definition(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       def on_field(node, _parent)
-        conflicts_within_selection_set(node, type_definition)
+        setting_errors { conflicts_within_selection_set(node, type_definition) }
         super
       end
 
       private
 
+      def field_conflicts
+        @field_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :field, field_name: field)
+        end
+      end
+
+      def arg_conflicts
+        @arg_conflicts ||= Hash.new do |errors, field|
+          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :argument, field_name: field)
+        end
+      end
+
+      def setting_errors
+        @field_conflicts = nil
+        @arg_conflicts = nil
+
+        yield
+        # don't initialize these if they weren't initialized in the block:
+        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
+        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
+      end
+
       def conflicts_within_selection_set(node, parent_type)
         return if parent_type.nil?
 
-        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: [])
+        fields, fragment_spreads = fields_and_fragments_from_selection(node, owner_type: parent_type, parents: nil)
 
         # (A) Find find all conflicts "within" the fields of this selection set.
         find_conflicts_within(fields)
@@ -93,8 +117,8 @@ module GraphQL
 
         return if fragment1.nil? || fragment2.nil?
 
-        fragment_type1 = context.schema.types[fragment1.type.name]
-        fragment_type2 = context.schema.types[fragment2.type.name]
+        fragment_type1 = context.warden.get_type(fragment1.type.name)
+        fragment_type2 = context.warden.get_type(fragment2.type.name)
 
         return if fragment_type1.nil? || fragment_type2.nil?
 
@@ -146,7 +170,7 @@ module GraphQL
         fragment = context.fragments[fragment_name]
         return if fragment.nil?
 
-        fragment_type = context.schema.types[fragment.type.name]
+        fragment_type = context.warden.get_type(fragment.type.name)
         return if fragment_type.nil?
 
         fragment_fields, fragment_spreads = fields_and_fragments_from_selection(fragment, owner_type: fragment_type, parents: [*fragment_spread.parents, fragment_type])
@@ -174,15 +198,21 @@ module GraphQL
         response_keys.each do |key, fields|
           next if fields.size < 2
           # find conflicts within nodes
-          for i in 0..fields.size - 1
-            for j in i + 1..fields.size - 1
+          i = 0
+          while i < fields.size
+            j = i + 1
+            while j < fields.size
               find_conflict(key, fields[i], fields[j])
+              j += 1
             end
+            i += 1
           end
         end
       end
 
       def find_conflict(response_key, field1, field2, mutually_exclusive: false)
+        return if @conflict_count >= context.max_errors
+
         node1 = field1.node
         node2 = field2.node
 
@@ -191,27 +221,21 @@ module GraphQL
 
         if !are_mutually_exclusive
           if node1.name != node2.name
-            errored_nodes = [node1.name, node2.name].sort.join(" or ")
-            msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
-              msg,
-              nodes: [node1, node2],
-              path: [],
-              field_name: response_key,
-              conflicts: errored_nodes
-            )
+            conflict = field_conflicts[response_key]
+
+            conflict.add_conflict(node1, node1.name)
+            conflict.add_conflict(node2, node2.name)
+
+            @conflict_count += 1
           end
 
-          args = possible_arguments(node1, node2)
-          if args.size > 1
-            msg = "Field '#{response_key}' has an argument conflict: #{args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")}?"
-            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
-              msg,
-              nodes: [node1, node2],
-              path: [],
-              field_name: response_key,
-              conflicts: args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
-            )
+          if !same_arguments?(node1, node2)
+            conflict = arg_conflicts[response_key]
+
+            conflict.add_conflict(node1, GraphQL::Language.serialize(serialize_field_args(node1)))
+            conflict.add_conflict(node2, GraphQL::Language.serialize(serialize_field_args(node2)))
+
+            @conflict_count += 1
           end
         end
 
@@ -223,7 +247,9 @@ module GraphQL
       end
 
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
-        return if field1.definition.nil? || field2.definition.nil?
+        return if field1.definition.nil? ||
+          field2.definition.nil? ||
+          (field1.node.selections.empty? && field2.node.selections.empty?)
 
         return_type1 = field1.definition.type.unwrap
         return_type2 = field2.definition.type.unwrap
@@ -303,6 +329,7 @@ module GraphQL
         if node.selections.empty?
           NO_SELECTIONS
         else
+          parents ||= []
           fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents, fields: [], fragment_spreads: [])
           response_keys = fields.group_by { |f| f.node.alias || f.node.name }
           [response_keys, fragment_spreads]
@@ -313,10 +340,10 @@ module GraphQL
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field
-            definition = context.schema.get_field(owner_type, node.name)
+            definition = context.query.get_field(owner_type, node.name)
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
-            fragment_type = node.type ? context.schema.types[node.type.name] : owner_type
+            fragment_type = node.type ? context.warden.get_type(node.type.name) : owner_type
             find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
@@ -326,20 +353,19 @@ module GraphQL
         [fields, fragment_spreads]
       end
 
-      def possible_arguments(field1, field2)
+      def same_arguments?(field1, field2)
         # Check for incompatible / non-identical arguments on this node:
-        [field1, field2].map do |n|
-          if n.arguments.any?
-            serialized_args = {}
-            n.arguments.each do |a|
-              arg_value = a.value
-              serialized_args[a.name] = serialize_arg(arg_value)
-            end
-            serialized_args
-          else
-            NO_ARGS
-          end
-        end.uniq
+        arguments1 = field1.arguments
+        arguments2 = field2.arguments
+
+        return false if arguments1.length != arguments2.length
+
+        arguments1.all? do |argument1|
+          argument2 = arguments2.find { |argument| argument.name == argument1.name }
+          return false if argument2.nil?
+
+          serialize_arg(argument1.value) == serialize_arg(argument2.value)
+        end
       end
 
       def serialize_arg(arg_value)
@@ -353,6 +379,14 @@ module GraphQL
         end
       end
 
+      def serialize_field_args(field)
+        serialized_args = {}
+        field.arguments.each do |argument|
+          serialized_args[argument.name] = serialize_arg(argument.value)
+        end
+        serialized_args
+      end
+
       def compared_fragments_key(frag1, frag2, exclusive)
         # Cache key to not compare two fragments more than once.
         # The key includes both fragment names sorted (this way we
@@ -365,17 +399,26 @@ module GraphQL
       # In this context, `parents` represends the "self scope" of the field,
       # what types may be found at this point in the query.
       def mutually_exclusive?(parents1, parents2)
-        parents1.each do |type1|
-          parents2.each do |type2|
-            # If the types we're comparing are both different object types,
-            # they have to be mutually exclusive.
-            if type1 != type2 && type1.kind.object? && type2.kind.object?
-              return true
+        if parents1.empty? || parents2.empty?
+          false
+        elsif parents1.length == parents2.length
+          parents1.length.times.any? do |i|
+            type1 = parents1[i - 1]
+            type2 = parents2[i - 1]
+            if type1 == type2
+              # If the types we're comparing are the same type,
+              # then they aren't mutually exclusive
+              false
+            else
+              # Check if these two scopes have _any_ types in common.
+              possible_right_types = context.query.possible_types(type1)
+              possible_left_types = context.query.possible_types(type2)
+              (possible_right_types & possible_left_types).empty?
             end
           end
+        else
+          true
         end
-
-        false
       end
     end
   end

data/lib/graphql/static_validation/rules/fields_will_merge_error.rb

@@ -3,12 +3,33 @@ module GraphQL
   module StaticValidation
     class FieldsWillMergeError < StaticValidation::Error
       attr_reader :field_name
-      attr_reader :conflicts
+      attr_reader :kind
+
+      def initialize(kind:, field_name:)
+        super(nil)
 
-      def initialize(message, path: nil, nodes: [], field_name:, conflicts:)
-        super(message, path: path, nodes: nodes)
         @field_name = field_name
-        @conflicts = conflicts
+        @kind = kind
+        @conflicts = []
+      end
+
+      def message
+        "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
+      end
+
+      def path
+        []
+      end
+
+      def conflicts
+        @conflicts.join(' or ')
+      end
+
+      def add_conflict(node, conflict_str)
+        return if nodes.include?(node)
+
+        @nodes << node
+        @conflicts << conflict_str
       end
 
       # A hash representation of this Message

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -50,12 +50,12 @@ module GraphQL
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
           add_error(GraphQL::StaticValidation::FragmentSpreadsArePossibleError.new(
-            "Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}",
+            "Fragment#{name} on #{child_type.graphql_name} can't be spread inside #{parent_type.graphql_name}",
             nodes: node,
             path: path,
             fragment_name: name.empty? ? "unknown" : name,
-            type: child_type.name,
-            parent: parent_type.name
+            type: child_type.graphql_name,
+            parent: parent_type.graphql_name
           ))
         end
       end

data/lib/graphql/static_validation/rules/fragments_are_finite.rb

@@ -7,12 +7,12 @@ module GraphQL
         dependency_map = context.dependencies
         dependency_map.cyclical_definitions.each do |defn|
           if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+            add_error(GraphQL::StaticValidation::FragmentsAreFiniteError.new(
               "Fragment #{defn.name} contains an infinite loop",
               nodes: defn.node,
               path: defn.path,
               name: defn.name
-            )
+            ))
           end
         end
       end

data/lib/graphql/static_validation/rules/input_object_names_are_unique.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module InputObjectNamesAreUnique
+      def on_input_object(node, parent)
+        validate_input_fields(node)
+        super
+      end
+
+      private
+
+      def validate_input_fields(node)
+        input_field_defns = node.arguments
+        input_fields_by_name = Hash.new { |h, k| h[k] = [] }
+        input_field_defns.each { |a| input_fields_by_name[a.name] << a }
+
+        input_fields_by_name.each do |name, defns|
+          if defns.size > 1
+            error = GraphQL::StaticValidation::InputObjectNamesAreUniqueError.new(
+              "There can be only one input field named \"#{name}\"",
+              nodes: defns,
+              name: name
+            )
+            add_error(error)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/input_object_names_are_unique_error.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class InputObjectNamesAreUniqueError < StaticValidation::Error
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], name:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "inputFieldNotUnique"
+      end
+    end
+  end
+end
+

data/lib/graphql/static_validation/rules/query_root_exists.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module QueryRootExists
+      def on_operation_definition(node, _parent)
+        if (node.operation_type == 'query' || node.operation_type.nil?) && context.warden.root_type_for_operation("query").nil?
+          add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
+            'Schema is not configured for queries',
+            nodes: node
+          ))
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/query_root_exists_error.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class QueryRootExistsError < StaticValidation::Error
+
+      def initialize(message, path: nil, nodes: [])
+        super(message, path: path, nodes: nodes)
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingQueryConfiguration"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/required_arguments_are_present.rb

@@ -8,7 +8,7 @@ module GraphQL
       end
 
       def on_directive(node, _parent)
-        directive_defn = context.schema.directives[node.name]
+        directive_defn = context.schema_directives[node.name]
         assert_required_args(node, directive_defn)
         super
       end
@@ -16,9 +16,11 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
+        args = defn.arguments(context.query.context)
+        return if args.empty?
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? }
+          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
           .map(&:name)
 
         missing_names = required_argument_names - present_argument_names

data/lib/graphql/static_validation/rules/required_input_object_attributes_are_present.rb

@@ -23,11 +23,10 @@ module GraphQL
         defn = if arg_defn && arg_defn.type.unwrap.kind.input_object?
           arg_defn.type.unwrap
         else
-          context.field_definition
+          context.directive_definition || context.field_definition
         end
 
-        parent_type = context.warden.arguments(defn)
-          .find{|f| f.name == parent_name(parent, defn) }
+        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
         parent_type ? parent_type.type.unwrap : nil
       end
 
@@ -35,21 +34,21 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = parent_type.arguments
-          .select{|k,v| v.type.kind.non_null?}
-          .keys
+        required_fields = context.warden.arguments(parent_type)
+          .select{|arg| arg.type.kind.non_null?}
+          .map(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = parent_type.arguments[missing_field].type
+          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
-            "Argument '#{missing_field}' on InputObject '#{parent_type}' is required. Expected type #{missing_field_type}",
+            "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,
-            argument_type: missing_field_type.to_s,
-            input_object_type: parent_type.to_s,
+            argument_type: missing_field_type.to_type_signature,
+            input_object_type: parent_type.to_type_signature,
             path: path,
             nodes: ast_node,
           ))

data/lib/graphql/static_validation/rules/unique_directives_per_location.rb

@@ -40,7 +40,7 @@ module GraphQL
               nodes: [used_directives[directive_name], ast_directive],
               directive: directive_name,
             ))
-          else
+          elsif !((dir_defn = context.schema_directives[directive_name]) && dir_defn.repeatable?)
             used_directives[directive_name] = ast_directive
           end
         end

data/lib/graphql/static_validation/rules/variable_default_values_are_correctly_typed.rb

@@ -13,27 +13,26 @@ module GraphQL
               error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
             ))
           else
-            type = context.schema.type_from_ast(node.type)
+            type = context.schema.type_from_ast(node.type, context: context)
             if type.nil?
               # This is handled by another validator
             else
-              begin
-                valid = context.valid_literal?(value, type)
-              rescue GraphQL::CoercionError => err
-                error_message = err.message
-              rescue GraphQL::LiteralValidationError
-                # noop, we just want to stop any LiteralValidationError from propagating
-              end
+              validation_result = context.validate_literal(value, type)
+
+              if !validation_result.valid?
+                problems = validation_result.problems
+                first_problem = problems && problems.first
+                if first_problem
+                  error_message = first_problem["message"]
+                end
 
-              if !valid
-                error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
-                VariableDefaultValuesAreCorrectlyTypedError
+                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
                 add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
                   error_message,
                   nodes: node,
                   name: node.name,
-                  type: type.to_s,
-                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
+                  type: type.to_type_signature,
+                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
                 ))
               end
             end

data/lib/graphql/static_validation/rules/variable_usages_are_allowed.rb

@@ -22,15 +22,15 @@ module GraphQL
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
         if node_values.any?
-          arguments = case parent
+          argument_owner = case parent
           when GraphQL::Language::Nodes::Field
-            context.field_definition.arguments
+            context.field_definition
           when GraphQL::Language::Nodes::Directive
-            context.directive_definition.arguments
+            context.directive_definition
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
-            if arg_type.is_a?(GraphQL::InputObjectType)
-              arguments = arg_type.input_fields
+            if arg_type.kind.input_object?
+              arg_type
             else
               # This is some kind of error
               nil
@@ -43,7 +43,7 @@ module GraphQL
             var_defn_ast = @declared_variables[node_value.name]
             # Might be undefined :(
             # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
+            var_defn_ast && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
           end
         end
         super
@@ -51,24 +51,29 @@ module GraphQL
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var)
-        var_type = context.schema.type_from_ast(ast_var.type)
+      def validate_usage(argument_owner, arg_node, ast_var)
+        var_type = context.schema.type_from_ast(ast_var.type, context: context)
         if var_type.nil?
           return
         end
         if !ast_var.default_value.nil?
-          unless var_type.is_a?(GraphQL::NonNullType)
+          unless var_type.kind.non_null?
             # If the value is required, but the argument is not,
             # and yet there's a non-nil default, then we impliclty
             # make the argument also a required type.
-
-            var_type = GraphQL::NonNullType.new(of_type: var_type)
+            var_type = var_type.to_non_null_type
           end
         end
 
-        arg_defn = arguments[arg_node.name]
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
+        # If the argument is non-null, but it was given a default value,
+        # then treat it as nullable in practice, see https://github.com/rmosolgo/graphql-ruby/issues/3793
+        if arg_defn_type.non_null? && arg_defn.default_value?
+          arg_defn_type = arg_defn_type.of_type
+        end
+
         var_inner_type = var_type.unwrap
         arg_inner_type = arg_defn_type.unwrap
 
@@ -85,10 +90,10 @@ module GraphQL
 
       def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
         add_error(GraphQL::StaticValidation::VariableUsagesAreAllowedError.new(
-          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})",
+          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_type_signature} / #{arg_defn.type.to_type_signature})",
           nodes: arg_node,
           name: ast_var.name,
-          type: var_type.to_s,
+          type: var_type.to_type_signature,
           argument: arg_node.name,
           error: error_message
         ))

data/lib/graphql/static_validation/rules/variables_are_input_types.rb

@@ -15,7 +15,7 @@ module GraphQL
           ))
         elsif !type.kind.input?
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type.name} isn't a valid input type (on $#{node.name})",
+            "#{type.graphql_name} isn't a valid input type (on $#{node.name})",
             nodes: node,
             name: node.name,
             type: type_name