graphql 1.9.17 → 1.11.7

data/lib/graphql/static_validation/all_rules.rb

@@ -34,6 +34,7 @@ module GraphQL
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
       GraphQL::StaticValidation::MutationRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
+      GraphQL::StaticValidation::InputObjectNamesAreUnique,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -71,7 +71,7 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          @object_types.push(object_type)
+          push_type(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
           super
           @object_types.pop
@@ -98,9 +98,9 @@ module GraphQL
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
-            @object_types.push(next_object_type)
+            push_type(next_object_type)
           else
-            @object_types.push(nil)
+            push_type(nil)
           end
           @path.push(node.alias || node.name)
           super
@@ -120,7 +120,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
@@ -187,15 +187,19 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @schema.get_type(node.type.name)
           else
             @object_types.last
           end
-          @object_types.push(object_type)
+          push_type(object_type)
           yield(node)
           @object_types.pop
           @path.pop
         end
+
+        def push_type(t)
+          @object_types.push(t)
+        end
       end
 
       private

data/lib/graphql/static_validation/literal_validator.rb

@@ -6,59 +6,73 @@ module GraphQL
       def initialize(context:)
         @context = context
         @warden = context.warden
+        @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
+        @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
 
       def validate(ast_value, type)
+        catch(:invalid) do
+          recursively_validate(ast_value, type)
+        end
+      end
+
+      private
+
+      def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
           maybe_raise_if_invalid(ast_value) do
-            !type.kind.non_null?
+            type.kind.non_null? ? @invalid_response : @valid_response
           end
         elsif type.kind.non_null?
           maybe_raise_if_invalid(ast_value) do
-            (!ast_value.nil?)
-          end && validate(ast_value, type.of_type)
+            ast_value.nil? ?
+              @invalid_response :
+              recursively_validate(ast_value, type.of_type)
+          end
         elsif type.kind.list?
           item_type = type.of_type
-          ensure_array(ast_value).all? { |val| validate(val, item_type) }
+          results = ensure_array(ast_value).map { |val| recursively_validate(val, item_type) }
+          merge_results(results)
         elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          true
+          @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.valid_input?(ast_value, @context)
+            type.validate_input(ast_value, @context)
           end
         elsif type.kind.enum?
           maybe_raise_if_invalid(ast_value) do
             if ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-              type.valid_input?(ast_value.name, @context)
+              type.validate_input(ast_value.name, @context)
             else
               # if our ast_value isn't an Enum it's going to be invalid so return false
-              false
+              @invalid_response
             end
           end
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           maybe_raise_if_invalid(ast_value) do
-            required_input_fields_are_present(type, ast_value) && present_input_field_values_are_valid(type, ast_value)
+            merge_results([
+              required_input_fields_are_present(type, ast_value),
+              present_input_field_values_are_valid(type, ast_value)
+            ])
           end
         else
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         end
       end
 
-      private
-
+      # When `error_bubbling` is false, we want to bail on the first failure that we find.
+      # Use `throw` to escape the current call stack, returning the invalid response.
       def maybe_raise_if_invalid(ast_value)
         ret = yield
-        if !@context.schema.error_bubbling && !ret
-          e = LiteralValidationError.new
-          e.ast_value = ast_value
-          raise e
+        if !@context.schema.error_bubbling && !ret.valid?
+          throw(:invalid, ret)
         else
           ret
         end
@@ -81,34 +95,45 @@ module GraphQL
       def required_input_fields_are_present(type, ast_node)
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
-        required_field_names = @warden.arguments(type)
-          .select { |f| f.type.kind.non_null? }
+        required_field_names = type.arguments.each_value
+          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
           .map(&:name)
+
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
         if @context.schema.error_bubbling
-          missing_required_field_names.empty?
+          missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
-          missing_required_field_names.all? do |name|
-            validate(GraphQL::Language::Nodes::NullValue.new(name: name), @warden.arguments(type).find { |f| f.name == name }.type )
+          results = missing_required_field_names.map do |name|
+            arg_type = @warden.get_argument(type, name).type
+            recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+          merge_results(results)
         end
       end
 
       def present_input_field_values_are_valid(type, ast_node)
-        field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
-        ast_node.arguments.all? do |value|
-          field = field_map[value.name]
+        results = ast_node.arguments.map do |value|
+          field = @warden.get_argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
-          type = field && field.type
-          validate(value.value, type)
+          field_type = field && field.type
+          recursively_validate(value.value, field_type)
         end
+        merge_results(results)
       end
 
       def ensure_array(value)
         value.is_a?(Array) ? value : [value]
       end
+
+      def merge_results(results_list)
+        merged_result = Query::InputValidationResult.new
+        results_list.each do |inner_result|
+          merged_result.merge_result!([], inner_result)
+        end
+        merged_result
+      end
     end
   end
 end

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

@@ -2,103 +2,63 @@
 module GraphQL
   module StaticValidation
     module ArgumentLiteralsAreCompatible
-      # TODO dedup with ArgumentsAreDefined
       def on_argument(node, parent)
-        parent_defn = case parent
-        when GraphQL::Language::Nodes::InputObject
-          arg_defn = context.argument_definition
-          if arg_defn.nil?
-            nil
-          else
-            arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
-              nil
-            else
-              arg_ret_type
-            end
-          end
-        when GraphQL::Language::Nodes::Directive
-          context.schema.directives[parent.name]
-        when GraphQL::Language::Nodes::Field
-          context.field_definition
-        else
-          raise "Unexpected argument parent: #{parent.class} (##{parent})"
+        # Check the child arguments first;
+        # don't add a new error if one of them reports an error
+        super
+
+        # Don't validate variables here
+        if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          return
         end
 
-        if parent_defn && !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          arg_defn = parent_defn.arguments[node.name]
-          if arg_defn
-            begin
-              valid = context.valid_literal?(node.value, arg_defn.type)
-            rescue GraphQL::CoercionError => err
-              context.schema.error_bubbling
-              if !context.schema.error_bubbling && !arg_defn.type.unwrap.kind.scalar?
-                # if error bubbling is disabled and the arg that caused this error isn't a scalar then
-                # short-circuit here so we avoid bubbling this up to whatever input_object / array contains us
-                return super
-              end
-              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(err.message, nodes: parent, type: "CoercionError", extensions: err.extensions)
-            rescue GraphQL::LiteralValidationError => err
-              # check to see if the ast node that caused the error to be raised is
-              # the same as the node we were checking here.
-              arg_type = arg_defn.type
-              if arg_type.kind.non_null?
-                arg_type = arg_type.of_type
-              end
+        if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+          parent_defn = parent_definition(parent)
 
-              matched = if arg_type.kind.list?
-                # for a list we claim an error if the node is contained in our list
-                Array(node.value).include?(err.ast_value)
-              elsif arg_type.kind.input_object? && node.value.is_a?(GraphQL::Language::Nodes::InputObject)
-                # for an input object we check the arguments
-                node.value.arguments.include?(err.ast_value)
+          if parent_defn && (arg_defn = parent_defn.arguments[node.name])
+            validation_result = context.validate_literal(node.value, arg_defn.type)
+            if !validation_result.valid?
+              kind_of_node = node_type(parent)
+              error_arg_name = parent_name(parent, parent_defn)
+              string_value = if node.value == Float::INFINITY
+                ""
               else
-                # otherwise we just check equality
-                node.value == (err.ast_value)
+                " (#{GraphQL::Language::Printer.new.print(node.value)})"
               end
-              if !matched
-                # This node isn't the node that caused the error,
-                # So halt this visit but continue visiting the rest of the tree
-                return super
-              end
-            end
-
-            if !valid
-              error ||= begin
-                kind_of_node = node_type(parent)
-                error_arg_name = parent_name(parent, parent_defn)
 
-                GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
-                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.",
-                  nodes: parent,
-                  type: kind_of_node,
-                  argument: node.name
-                )
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                message = first_problem["message"]
+                # This is some legacy stuff from when `CoercionError` was raised thru the stack
+                if message
+                  coerce_extensions = first_problem["extensions"] || {
+                    "code" => "argumentLiteralsIncompatible"
+                  }
+                end
               end
-              add_error(error)
-            end
-          end
-        end
 
-        super
-      end
+              error_options = {
+                nodes: parent,
+                type: kind_of_node,
+                argument: node.name
+              }
+              if coerce_extensions
+                error_options[:coerce_extensions] = coerce_extensions
+              end
 
+              message ||= "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'."
 
-      private
+              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
+                message,
+                **error_options
+              )
 
-      def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
-          parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
-          parent.name
+              add_error(error)
+            end
+          end
         end
       end
-
-      def node_type(parent)
-        parent.class.name.split("::").last
-      end
     end
   end
 end

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

@@ -5,19 +5,31 @@ module GraphQL
       attr_reader :type_name
       attr_reader :argument_name
 
-      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil)
+      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil, coerce_extensions: nil)
         super(message, path: path, nodes: nodes)
         @type_name = type
         @argument_name = argument
         @extensions = extensions
+        @coerce_extensions = coerce_extensions
       end
 
       # A hash representation of this Message
       def to_h
-        extensions = {
-          "code" => code,
-          "typeName" => type_name
-        }.tap { |h| h["argumentName"] = argument_name unless argument_name.nil? }
+        if @coerce_extensions
+          extensions = @coerce_extensions
+          # This is for legacy compat -- but this key is supposed to be a GraphQL type name :confounded:
+          extensions["typeName"] = "CoercionError"
+        else
+          extensions = {
+            "code" => code,
+            "typeName" => type_name
+          }
+
+          if argument_name
+            extensions["argumentName"] = argument_name
+          end
+        end
+
         extensions.merge!(@extensions) unless @extensions.nil?
         super.merge({
           "extensions" => extensions

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

@@ -3,28 +3,9 @@ module GraphQL
   module StaticValidation
     module ArgumentsAreDefined
       def on_argument(node, parent)
-        parent_defn = case parent
-        when GraphQL::Language::Nodes::InputObject
-          arg_defn = context.argument_definition
-          if arg_defn.nil?
-            nil
-          else
-            arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.is_a?(GraphQL::InputObjectType)
-              nil
-            else
-              arg_ret_type
-            end
-          end
-        when GraphQL::Language::Nodes::Directive
-          context.schema.directives[parent.name]
-        when GraphQL::Language::Nodes::Field
-          context.field_definition
-        else
-          raise "Unexpected argument parent: #{parent.class} (##{parent})"
-        end
+        parent_defn = parent_definition(parent)
 
-        if parent_defn && context.warden.arguments(parent_defn).any? { |arg| arg.name == node.name }
+        if parent_defn && context.warden.get_argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)
@@ -44,19 +25,46 @@ module GraphQL
 
       private
 
+      # TODO smell: these methods are added to all visitors, since they're included in a module.
       def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
+        case parent
+        when GraphQL::Language::Nodes::Field
           parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
+        when GraphQL::Language::Nodes::InputObject
+          type_defn.graphql_name
+        when GraphQL::Language::Nodes::Argument, GraphQL::Language::Nodes::Directive
           parent.name
+        else
+          raise "Invariant: Unexpected parent #{parent.inspect} (#{parent.class})"
         end
       end
 
       def node_type(parent)
         parent.class.name.split("::").last
       end
+
+      def parent_definition(parent)
+        case parent
+        when GraphQL::Language::Nodes::InputObject
+          arg_defn = context.argument_definition
+          if arg_defn.nil?
+            nil
+          else
+            arg_ret_type = arg_defn.type.unwrap
+            if arg_ret_type.kind.input_object?
+              arg_ret_type
+            else
+              nil
+            end
+          end
+        when GraphQL::Language::Nodes::Directive
+          context.schema.directives[parent.name]
+        when GraphQL::Language::Nodes::Field
+          context.field_definition
+        else
+          raise "Unexpected argument parent: #{parent.class} (##{parent})"
+        end
+      end
     end
   end
 end

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

@@ -56,7 +56,7 @@ module GraphQL
             "'@#{directive_defn.graphql_name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})",
             nodes: directive_ast,
             target: location_name,
-            name: directive_defn.name
+            name: directive_defn.graphql_name
           ))
         end
       end

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

@@ -9,16 +9,16 @@ module GraphQL
         if field.nil?
           if parent_type.kind.union?
             add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
-              "Selections can't be made directly on unions (see selections on #{parent_type.name})",
+              "Selections can't be made directly on unions (see selections on #{parent_type.graphql_name})",
               nodes: parent,
-              node_name: parent_type.name
+              node_name: parent_type.graphql_name
             ))
           else
             add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
-              "Field '#{node.name}' doesn't exist on type '#{parent_type.name}'",
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
               nodes: node,
               field: node.name,
-              type: parent_type.name
+              type: parent_type.graphql_name
             ))
           end
         else

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

@@ -27,12 +27,12 @@ module GraphQL
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
           if ast_node.selections.first.is_a?(GraphQL::Language::Nodes::InlineFragment)
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has inline fragments [#{ast_node.selections.map(&:type).map(&:name).join(", ")}])"
           else
-            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
+            "Selections can't be made on scalars (%{node_name} returns #{resolved_type.graphql_name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
           end
         elsif resolved_type.kind.fields? && ast_node.selections.empty?
-          "Field must have selections (%{node_name} returns #{resolved_type.name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
+          "Field must have selections (%{node_name} returns #{resolved_type.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else
           nil
         end
@@ -55,13 +55,13 @@ module GraphQL
             "name": node_name.to_s
           }
           unless resolved_type.nil?
-            extensions["type"] = resolved_type.to_s
+            extensions["type"] = resolved_type.to_type_signature
           end
           add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
             msg % { node_name: node_name },
             nodes: ast_node,
             node_name: node_name.to_s,
-            type: resolved_type.nil? ? nil : resolved_type.to_s
+            type: resolved_type.nil? ? nil : resolved_type.graphql_name,
           ))
           false
         else

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

@@ -93,8 +93,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 +146,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])
@@ -202,15 +202,16 @@ module GraphQL
             )
           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 ")}?"
+          if !same_arguments?(node1, node2)
+            args = [serialize_field_args(node1), serialize_field_args(node2)]
+            conflicts = args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
+            msg = "Field '#{response_key}' has an argument conflict: #{conflicts}?"
             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 ")
+              conflicts: conflicts
             )
           end
         end
@@ -316,7 +317,7 @@ module GraphQL
             definition = context.schema.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 +327,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 +353,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

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