graphql 1.9.0.pre1 → 1.9.0.pre2

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class RequiredInputObjectAttributesArePresentError < StaticValidation::Error
+      attr_reader :argument_type
+      attr_reader :argument_name
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, argument_type:, argument_name:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @argument_type = argument_type
+        @argument_name = argument_name
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "argumentName" => argument_name,
+          "argumentType" => argument_type,
+          "inputObjectType" => input_object_type,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingRequiredInputObjectAttribute"
+      end
+    end
+  end
+end

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

@@ -4,7 +4,10 @@ module GraphQL
     module SubscriptionRootExists
       def on_operation_definition(node, _parent)
         if node.operation_type == "subscription" && context.warden.root_type_for_operation("subscription").nil?
-          add_error('Schema is not configured for subscriptions', node)
+          add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
+            'Schema is not configured for subscriptions',
+            nodes: node
+          ))
         else
           super
         end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class SubscriptionRootExistsError < 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
+        "missingSubscriptionConfiguration"
+      end
+    end
+  end
+end

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

@@ -35,10 +35,11 @@ module GraphQL
         node.directives.each do |ast_directive|
           directive_name = ast_directive.name
           if used_directives[directive_name]
-            add_error(
+            add_error(GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
               "The directive \"#{directive_name}\" can only be used once at this location.",
-              [used_directives[directive_name], ast_directive]
-            )
+              nodes: [used_directives[directive_name], ast_directive],
+              directive: directive_name,
+            ))
           else
             used_directives[directive_name] = ast_directive
           end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class UniqueDirectivesPerLocationError < 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
+        "directiveNotUniqueForLocation"
+      end
+    end
+  end
+end

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

@@ -6,7 +6,12 @@ module GraphQL
         if !node.default_value.nil?
           value = node.default_value
           if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-            add_error("Non-null variable $#{node.name} can't have a default value", node)
+            add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+              "Non-null variable $#{node.name} can't have a default value",
+              nodes: node,
+              name: node.name,
+              error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
+            ))
           else
             type = context.schema.type_from_ast(node.type)
             if type.nil?
@@ -16,18 +21,27 @@ module GraphQL
                 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
 
               if !valid
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
-                add_error(error_message, node)
+                VariableDefaultValuesAreCorrectlyTypedError
+                add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+                  error_message,
+                  nodes: node,
+                  name: node.name,
+                  type: type.to_s,
+                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
+                ))
               end
-            end 
-          end 
+            end
+          end
         end
-        
+
         super
       end
     end
-  end 
+  end
 end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableDefaultValuesAreCorrectlyTypedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :type_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :INVALID_TYPE         => "defaultValueInvalidType",
+        :INVALID_ON_NON_NULL  => "defaultValueInvalidOnNonNullVariable",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, type: nil, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        @type_name = type
+        raise("Unexpected error type: #{error_type}") if !VIOLATIONS.values.include?(error_type)
+        @violation = error_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name
+        }.tap { |h| h["typeName"] = type_name unless type_name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

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

@@ -9,7 +9,11 @@ module GraphQL
           var_defns.each { |v| vars_by_name[v.name] << v }
           vars_by_name.each do |name, defns|
             if defns.size > 1
-              add_error("There can only be one variable named \"#{name}\"", defns)
+              add_error(GraphQL::StaticValidation::VariableNamesAreUniqueError.new(
+                "There can only be one variable named \"#{name}\"",
+                nodes: defns,
+                name: name
+              ))
             end
           end
         end

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

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

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

@@ -84,7 +84,14 @@ module GraphQL
       end
 
       def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
-        add_error("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", 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})",
+          nodes: arg_node,
+          name: ast_var.name,
+          type: var_type.to_s,
+          argument: arg_node.name,
+          error: error_message
+        ))
       end
 
       def wrap_var_type_with_depth_of_arg(var_type, arg_node)

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableUsagesAreAllowedError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :variable_name
+      attr_reader :argument_name
+      attr_reader :error_message
+
+      def initialize(message, path: nil, nodes: [], type:, name:, argument:, error:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @variable_name = name
+        @argument_name = argument
+        @error_message = error
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name,
+          "typeName" => type_name,
+          "argumentName" => argument_name,
+          "errorMessage" => error_message
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "variableMismatch"
+      end
+    end
+  end
+end

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

@@ -7,9 +7,19 @@ module GraphQL
         type = context.warden.get_type(type_name)
 
         if type.nil?
-          add_error("#{type_name} isn't a defined input type (on $#{node.name})", node)
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type_name} isn't a defined input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
         elsif !type.kind.input?
-          add_error("#{type.name} isn't a valid input type (on $#{node.name})", node)
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type.name} isn't a valid input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
         end
 
         super

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

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

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

@@ -125,12 +125,28 @@ module GraphQL
         # Declared but not used:
         node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
-          .each { |var_name, usage| add_error("Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by, path: usage.path) }
+          .each { |var_name, usage|
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is declared by #{usage.declared_by.name} but not used",
+              nodes: usage.declared_by,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_USED]
+            ))
+          }
 
         # Used but not declared:
         node_variables
           .select { |name, usage| usage.used? && !usage.declared? }
-          .each { |var_name, usage| add_error("Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node, path: usage.path) }
+          .each { |var_name, usage|
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is used by #{usage.used_by.name} but not declared",
+              nodes: usage.ast_node,
+              path: usage.path,
+              name: var_name,
+              error_type: VariablesAreUsedAndDefinedError::VIOLATIONS[:VARIABLE_NOT_DEFINED]
+            ))
+          }
       end
     end
   end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariablesAreUsedAndDefinedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :VARIABLE_NOT_USED     => "variableNotUsed",
+        :VARIABLE_NOT_DEFINED  => "variableNotDefined",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        raise("Unexpected error type: #{error_type}") if !VIOLATIONS.values.include?(error_type)
+        @violation = error_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/validator.rb

@@ -23,27 +23,37 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true)
         query.trace("validate", { validate: validate, query: query }) do
+          can_skip_rewrite = query.context.interpreter? && query.schema.using_ast_analysis?
+          errors = if validate == false && can_skip_rewrite
+            []
+          else
+            rules_to_use = validate ? @rules : []
+            visitor_class = BaseVisitor.including_rules(rules_to_use, rewrite: !can_skip_rewrite)
 
-          rules_to_use = validate ? @rules : []
-          visitor_class = BaseVisitor.including_rules(rules_to_use)
+            context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
 
-          context = GraphQL::StaticValidation::ValidationContext.new(query, visitor_class)
-
-          # Attach legacy-style rules
-          rules_to_use.each do |rule_class_or_module|
-            if rule_class_or_module.method_defined?(:validate)
-              rule_class_or_module.new.validate(context)
+            # Attach legacy-style rules
+            rules_to_use.each do |rule_class_or_module|
+              if rule_class_or_module.method_defined?(:validate)
+                rule_class_or_module.new.validate(context)
+              end
             end
+
+            context.visitor.visit
+            context.errors
           end
 
-          context.visitor.visit
-          # Post-validation: allow validators to register handlers on rewritten query nodes
-          rewrite_result = context.visitor.rewrite_document
+
+          irep = if errors.none? && context
+            # Only return this if there are no errors and validation was actually run
+            context.visitor.rewrite_document
+          else
+            nil
+          end
 
           {
-            errors: context.errors,
-            # If there were errors, the irep is garbage
-            irep: context.errors.any? ? nil : rewrite_result,
+            errors: errors,
+            irep: irep,
           }
         end
       end