graphql 0.16.0 → 2.0.15

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

@@ -1,16 +1,64 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
-      def validate_node(parent, node, defn, context)
-        return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-        validator = GraphQL::StaticValidation::LiteralValidator.new
-        arg_defn = defn.arguments[node.name]
-        return unless arg_defn
-        valid = validator.validate(node.value, arg_defn.type)
-        if !valid
-          kind_of_node = node_type(parent)
-          error_arg_name = parent_name(parent, defn)
-          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent)
+    module ArgumentLiteralsAreCompatible
+      def on_argument(node, 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 @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+          parent_defn = parent_definition(parent)
+
+          if parent_defn && (arg_defn = context.warden.get_argument(parent_defn, 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
+                " (#{GraphQL::Language::Printer.new.print(node.value)})"
+              end
+
+              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
+
+              error_options = {
+                nodes: parent,
+                type: kind_of_node,
+                argument_name: node.name,
+                argument: arg_defn,
+                value: node.value
+              }
+              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}'."
+
+              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
+                message,
+                **error_options
+              )
+
+              add_error(error)
+            end
+          end
         end
       end
     end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :argument_name
+      attr_reader :argument
+      attr_reader :value
+
+      def initialize(message, path: nil, nodes: [], type:, argument_name: nil, extensions: nil, coerce_extensions: nil, argument: nil, value: nil)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @argument_name = argument_name
+        @extensions = extensions
+        @coerce_extensions = coerce_extensions
+        @argument = argument
+        @value = value
+      end
+
+      # A hash representation of this Message
+      def to_h
+        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
+        })
+      end
+
+      def code
+        "argumentLiteralsIncompatible"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module ArgumentNamesAreUnique
+      include GraphQL::StaticValidation::Error::ErrorHelper
+
+      def on_field(node, parent)
+        validate_arguments(node)
+        super
+      end
+
+      def on_directive(node, parent)
+        validate_arguments(node)
+        super
+      end
+
+      def validate_arguments(node)
+        argument_defns = node.arguments
+        if argument_defns.any?
+          args_by_name = Hash.new { |h, k| h[k] = [] }
+          argument_defns.each { |a| args_by_name[a.name] << a }
+          args_by_name.each do |name, defns|
+            if defns.size > 1
+              add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"", nodes: defns, name: name))
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentNamesAreUniqueError < 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
+        "argumentNotUnique"
+      end
+    end
+  end
+end
+

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

@@ -1,15 +1,69 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
-      def validate_node(parent, node, defn, context)
-        argument_defn = defn.arguments[node.name]
-        if argument_defn.nil?
+    module ArgumentsAreDefined
+      def on_argument(node, parent)
+        parent_defn = parent_definition(parent)
+
+        if parent_defn && context.warden.get_argument(parent_defn, node.name)
+          super
+        elsif parent_defn
           kind_of_node = node_type(parent)
-          error_arg_name = parent_name(parent, defn)
-          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent)
-          GraphQL::Language::Visitor::SKIP
+          error_arg_name = parent_name(parent, parent_defn)
+          add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'",
+            nodes: node,
+            name: error_arg_name,
+            type: kind_of_node,
+            argument_name: node.name,
+            parent: parent_defn
+          ))
         else
-          nil
+          # Some other weird error
+          super
+        end
+      end
+
+      private
+
+      # TODO smell: these methods are added to all visitors, since they're included in a module.
+      def parent_name(parent, type_defn)
+        case parent
+        when GraphQL::Language::Nodes::Field
+          parent.alias || parent.name
+        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

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentsAreDefinedError < StaticValidation::Error
+      attr_reader :name
+      attr_reader :type_name
+      attr_reader :argument_name
+      attr_reader :parent
+
+      def initialize(message, path: nil, nodes: [], name:, type:, argument_name:, parent:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+        @type_name = type
+        @argument_name = argument_name
+        @parent = parent
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name,
+          "typeName" => type_name,
+          "argumentName" => argument_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "argumentNotAccepted"
+      end
+    end
+  end
+end

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

@@ -1,20 +1,27 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class DirectivesAreDefined
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        directive_names = context.schema.directives.keys
-        context.visitor[GraphQL::Language::Nodes::Directive] << -> (node, parent) {
-          validate_directive(node, directive_names, context.errors)
-        }
+    module DirectivesAreDefined
+      def initialize(*)
+        super
+        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
-      private
-
-      def validate_directive(ast_directive, directive_names, errors)
-        if !directive_names.include?(ast_directive.name)
-          errors << message("Directive @#{ast_directive.name} is not defined", ast_directive)
+      def on_directive(node, parent)
+        if !@directive_names.include?(node.name)
+          @directives_are_defined_errors_by_name ||= {}
+          error = @directives_are_defined_errors_by_name[node.name] ||= begin
+            err = GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+              "Directive @#{node.name} is not defined",
+              nodes: [],
+              directive: node.name
+            )
+            add_error(err)
+            err
+          end
+          error.nodes << node
+        else
+          super
         end
       end
     end

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

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

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

@@ -1,57 +1,63 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class DirectivesAreInValidLocations
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module DirectivesAreInValidLocations
       include GraphQL::Language
 
-      def validate(context)
-        directives = context.schema.directives
-
-        context.visitor[Nodes::Directive] << -> (node, parent) {
-          validate_location(node, parent, directives, context.errors)
-        }
+      def on_directive(node, parent)
+        validate_location(node, parent, context.schema_directives)
+        super
       end
 
       private
 
       LOCATION_MESSAGE_NAMES = {
-        GraphQL::Directive::QUERY =>               "queries",
-        GraphQL::Directive::MUTATION =>            "mutations",
-        GraphQL::Directive::SUBSCRIPTION =>        "subscriptions",
-        GraphQL::Directive::FIELD =>               "fields",
-        GraphQL::Directive::FRAGMENT_DEFINITION => "fragment definitions",
-        GraphQL::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
-        GraphQL::Directive::INLINE_FRAGMENT =>     "inline fragments",
+        GraphQL::Schema::Directive::QUERY =>               "queries",
+        GraphQL::Schema::Directive::MUTATION =>            "mutations",
+        GraphQL::Schema::Directive::SUBSCRIPTION =>        "subscriptions",
+        GraphQL::Schema::Directive::FIELD =>               "fields",
+        GraphQL::Schema::Directive::FRAGMENT_DEFINITION => "fragment definitions",
+        GraphQL::Schema::Directive::FRAGMENT_SPREAD =>     "fragment spreads",
+        GraphQL::Schema::Directive::INLINE_FRAGMENT =>     "inline fragments",
       }
 
       SIMPLE_LOCATIONS = {
-        Nodes::Field =>               GraphQL::Directive::FIELD,
-        Nodes::InlineFragment =>      GraphQL::Directive::INLINE_FRAGMENT,
-        Nodes::FragmentSpread =>      GraphQL::Directive::FRAGMENT_SPREAD,
-        Nodes::FragmentDefinition =>  GraphQL::Directive::FRAGMENT_DEFINITION,
+        Nodes::Field =>               GraphQL::Schema::Directive::FIELD,
+        Nodes::InlineFragment =>      GraphQL::Schema::Directive::INLINE_FRAGMENT,
+        Nodes::FragmentSpread =>      GraphQL::Schema::Directive::FRAGMENT_SPREAD,
+        Nodes::FragmentDefinition =>  GraphQL::Schema::Directive::FRAGMENT_DEFINITION,
       }
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
 
-      def validate_location(ast_directive, ast_parent, directives, errors)
+      def validate_location(ast_directive, ast_parent, directives)
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
-          required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          required_location = GraphQL::Schema::Directive.const_get(ast_parent.operation_type.upcase)
+          assert_includes_location(directive_defn, ast_directive, required_location)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          assert_includes_location(directive_defn, ast_directive, required_location)
         else
-          errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive)
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "Directives can't be applied to #{ast_parent.class.name}s",
+            nodes: ast_directive,
+            target: ast_parent.class.name
+          ))
         end
       end
 
-      def assert_includes_location(directive_defn, directive_ast, required_location, errors)
+      def assert_includes_location(directive_defn, directive_ast, required_location)
         if !directive_defn.locations.include?(required_location)
           location_name = LOCATION_MESSAGE_NAMES[required_location]
           allowed_location_names = directive_defn.locations.map { |loc| LOCATION_MESSAGE_NAMES[loc] }
-          errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast)
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "'@#{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.graphql_name
+          ))
         end
       end
     end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class DirectivesAreInValidLocationsError < StaticValidation::Error
+      attr_reader :target_name
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], target:, name: nil)
+        super(message, path: path, nodes: nodes)
+        @target_name = target
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "targetName" => target_name
+        }.tap { |h| h["name"] = name unless name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "directiveCannotBeApplied"
+      end
+    end
+  end
+end

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

@@ -1,30 +1,28 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FieldsAreDefinedOnType
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module FieldsAreDefinedOnType
+      def on_field(node, parent)
+        parent_type = @object_types[-2]
+        field = context.warden.get_field(parent_type, node.name)
 
-      def validate(context)
-        visitor = context.visitor
-        visitor[GraphQL::Language::Nodes::Field] << -> (node, parent) {
-          return if context.skip_field?(node.name)
-          parent_type = context.object_types[-2]
-          parent_type = parent_type.unwrap
-          validate_field(context.errors, node, parent_type, parent)
-        }
-      end
-
-      private
-
-      def validate_field(errors, ast_field, parent_type, parent)
-        if parent_type.kind.union?
-          errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent)
-          return GraphQL::Language::Visitor::SKIP
-        end
-
-        field =  parent_type.get_field(ast_field.name)
         if field.nil?
-          errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent)
-          return GraphQL::Language::Visitor::SKIP
+          if parent_type.kind.union?
+            add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
+              "Selections can't be made directly on unions (see selections on #{parent_type.graphql_name})",
+              nodes: parent,
+              node_name: parent_type.graphql_name
+            ))
+          else
+            add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.graphql_name}'",
+              nodes: node,
+              field: node.name,
+              type: parent_type.graphql_name
+            ))
+          end
+        else
+          super
         end
       end
     end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsAreDefinedOnTypeError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :field_name
+
+      def initialize(message, path: nil, nodes: [], type:, field:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @field_name = field
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "fieldName" => field_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "undefinedField"
+      end
+    end
+  end
+end

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

@@ -1,34 +1,71 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
     # Scalars _can't_ have selections
     # Objects _must_ have selections
-    class FieldsHaveAppropriateSelections
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module FieldsHaveAppropriateSelections
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::Field] << -> (node, parent)  {
-          return if context.skip_field?(node.name)
-          field_defn = context.field_definition
-          validate_field_selections(node, field_defn, context.errors)
-        }
+      def on_field(node, parent)
+        field_defn = field_definition
+        if validate_field_selections(node, field_defn.type.unwrap)
+          super
+        end
+      end
+
+      def on_operation_definition(node, _parent)
+        if validate_field_selections(node, type_definition)
+          super
+        end
       end
 
       private
 
-      def validate_field_selections(ast_field, field_defn, errors)
-        resolved_type = field_defn.type.unwrap
 
-        if resolved_type.kind.scalar? && ast_field.selections.any?
-          error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field)
-        elsif resolved_type.kind.object? && ast_field.selections.none?
-          error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field)
+      def validate_field_selections(ast_node, resolved_type)
+        msg = if resolved_type.nil?
+          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.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.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.graphql_name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else
-          error = nil
+          nil
         end
 
-        if !error.nil?
-          errors << error
-          GraphQL::Language::Visitor::SKIP
+        if msg
+          node_name = case ast_node
+          when GraphQL::Language::Nodes::Field
+            "field '#{ast_node.name}'"
+          when GraphQL::Language::Nodes::OperationDefinition
+            if ast_node.name.nil?
+              "anonymous query"
+            else
+              "#{ast_node.operation_type} '#{ast_node.name}'"
+            end
+          else
+            raise("Unexpected node #{ast_node}")
+          end
+          extensions = {
+            "rule": "StaticValidation::FieldsHaveAppropriateSelections",
+            "name": node_name.to_s
+          }
+          unless resolved_type.nil?
+            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.graphql_name,
+          ))
+          false
+        else
+          true
         end
       end
     end