graphql 1.8.0 → 1.12.12

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

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableNamesAreUnique
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          var_defns = node.variables
-          if var_defns.any?
-            vars_by_name = Hash.new { |h, k| h[k] = [] }
-            var_defns.each { |v| vars_by_name[v.name] << v }
-            vars_by_name.each do |name, defns|
-              if defns.size > 1
-                context.errors << message("There can only be one variable named \"#{name}\"", defns, context: context)
-              end
+    module VariableNamesAreUnique
+      def on_operation_definition(node, parent)
+        var_defns = node.variables
+        if var_defns.any?
+          vars_by_name = Hash.new { |h, k| h[k] = [] }
+          var_defns.each { |v| vars_by_name[v.name] << v }
+          vars_by_name.each do |name, defns|
+            if defns.size > 1
+              add_error(GraphQL::StaticValidation::VariableNamesAreUniqueError.new(
+                "There can only be one variable named \"#{name}\"",
+                nodes: defns,
+                name: name
+              ))
             end
           end
-        }
+        end
+        super
       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

@@ -1,64 +1,67 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableUsagesAreAllowed
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
+    module VariableUsagesAreAllowed
+      def initialize(*)
+        super
         # holds { name => ast_node } pairs
-        declared_variables = {}
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
-        }
-
-        context.visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
-          node_values = if node.value.is_a?(Array)
-            node.value
-          else
-            [node.value]
-          end
-          node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
+        @declared_variables = {}
+      end
+
+      def on_operation_definition(node, parent)
+        @declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+        super
+      end
 
-          return if node_values.none?
+      def on_argument(node, parent)
+        node_values = if node.value.is_a?(Array)
+          node.value
+        else
+          [node.value]
+        end
+        node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
-          arguments = nil
-          case parent
+        if node_values.any?
+          arguments = case parent
           when GraphQL::Language::Nodes::Field
-            arguments = context.field_definition.arguments
+            context.field_definition.arguments
           when GraphQL::Language::Nodes::Directive
-            arguments = context.directive_definition.arguments
+            context.directive_definition.arguments
           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?
+              arguments = arg_type.arguments
+            else
+              # This is some kind of error
+              nil
             end
           else
             raise("Unexpected argument parent: #{parent}")
           end
 
           node_values.each do |node_value|
-            var_defn_ast = declared_variables[node_value.name]
+            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, context)
+            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
           end
-        }
+        end
+        super
       end
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var, context)
-        var_type = context.schema.type_from_ast(ast_var.type)
+      def validate_usage(arguments, 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
 
@@ -71,16 +74,23 @@ module GraphQL
         var_type = wrap_var_type_with_depth_of_arg(var_type, arg_node)
 
         if var_inner_type != arg_inner_type
-          context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
         elsif list_dimension(var_type) != list_dimension(arg_defn_type)
-          context.errors << create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node)
         elsif !non_null_levels_match(arg_defn_type, var_type)
-          context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
         end
       end
 
-      def create_error(error_message, var_type, ast_var, arg_defn, arg_node, context)
-        message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node, context: context)
+      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_type_signature} / #{arg_defn.type.to_type_signature})",
+          nodes: arg_node,
+          name: ast_var.name,
+          type: var_type.to_type_signature,
+          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

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariablesAreInputTypes
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << ->(node, parent) {
-          validate_is_input_type(node, context)
-        }
-      end
-
-      private
-
-      def validate_is_input_type(node, context)
+    module VariablesAreInputTypes
+      def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
         type = context.warden.get_type(type_name)
 
         if type.nil?
-          context.errors << message("#{type_name} isn't a defined input type (on $#{node.name})", node, context: context)
+          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?
-          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node, context: context)
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type.graphql_name} isn't a valid input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
         end
+
+        super
       end
 
+      private
+
       def get_type_name(ast_type)
         if ast_type.respond_to?(:of_type)
           get_type_name(ast_type.of_type)

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

@@ -2,7 +2,7 @@
 module GraphQL
   module StaticValidation
     # The problem is
-    #   - Variable usage must be determined at the OperationDefinition level
+    #   - Variable $usage must be determined at the OperationDefinition level
     #   - You can't tell how fragments use variables until you visit FragmentDefinitions (which may be at the end of the document)
     #
     #  So, this validator includes some crazy logic to follow fragment spreads recursively, while avoiding infinite loops.
@@ -11,9 +11,7 @@ module GraphQL
     #   - re-visiting the AST for each validator
     #   - allowing validators to say `followSpreads: true`
     #
-    class VariablesAreUsedAndDefined
-      include GraphQL::StaticValidation::Message::MessageHelper
-
+    module VariablesAreUsedAndDefined
       class VariableUsage
         attr_accessor :ast_node, :used_by, :declared_by, :path
         def used?
@@ -25,73 +23,67 @@ module GraphQL
         end
       end
 
-      def variable_hash
-        Hash.new {|h, k| h[k] = VariableUsage.new }
+      def initialize(*)
+        super
+        @variable_usages_for_context = Hash.new {|hash, key| hash[key] = Hash.new {|h, k| h[k] = VariableUsage.new } }
+        @spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
+        @variable_context_stack = []
       end
 
-      def validate(context)
-        variable_usages_for_context = Hash.new {|hash, key| hash[key] = variable_hash }
-        spreads_for_context = Hash.new {|hash, key| hash[key] = [] }
-        variable_context_stack = []
-
-        # OperationDefinitions and FragmentDefinitions
-        # both push themselves onto the context stack (and pop themselves off)
-        push_variable_context_stack = ->(node, parent) {
-          # initialize the hash of vars for this context:
-          variable_usages_for_context[node]
-          variable_context_stack.push(node)
-        }
-
-        pop_variable_context_stack = ->(node, parent) {
-          variable_context_stack.pop
-        }
-
-
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << push_variable_context_stack
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          # mark variables as defined:
-          var_hash = variable_usages_for_context[node]
-          node.variables.each { |var|
-            var_usage = var_hash[var.name]
-            var_usage.declared_by = node
-            var_usage.path = context.path
-          }
+      def on_operation_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        # mark variables as defined:
+        var_hash = @variable_usages_for_context[node]
+        node.variables.each { |var|
+          var_usage = var_hash[var.name]
+          var_usage.declared_by = node
+          var_usage.path = context.path
         }
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition].leave << pop_variable_context_stack
-
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << push_variable_context_stack
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << pop_variable_context_stack
+        super
+        @variable_context_stack.pop
+      end
 
-        # For FragmentSpreads:
-        #  - find the context on the stack
-        #  - mark the context as containing this spread
-        context.visitor[GraphQL::Language::Nodes::FragmentSpread] << ->(node, parent) {
-          variable_context = variable_context_stack.last
-          spreads_for_context[variable_context] << node.name
-        }
+      def on_fragment_definition(node, parent)
+        # initialize the hash of vars for this context:
+        @variable_usages_for_context[node]
+        @variable_context_stack.push(node)
+        super
+        @variable_context_stack.pop
+      end
 
-        # For VariableIdentifiers:
-        #  - mark the variable as used
-        #  - assign its AST node
-        context.visitor[GraphQL::Language::Nodes::VariableIdentifier] << ->(node, parent) {
-          usage_context = variable_context_stack.last
-          declared_variables = variable_usages_for_context[usage_context]
-          usage = declared_variables[node.name]
-          usage.used_by = usage_context
-          usage.ast_node = node
-          usage.path = context.path
-        }
+      # For FragmentSpreads:
+      #  - find the context on the stack
+      #  - mark the context as containing this spread
+      def on_fragment_spread(node, parent)
+        variable_context = @variable_context_stack.last
+        @spreads_for_context[variable_context] << node.name
+        super
+      end
 
+      # For VariableIdentifiers:
+      #  - mark the variable as used
+      #  - assign its AST node
+      def on_variable_identifier(node, parent)
+        usage_context = @variable_context_stack.last
+        declared_variables = @variable_usages_for_context[usage_context]
+        usage = declared_variables[node.name]
+        usage.used_by = usage_context
+        usage.ast_node = node
+        usage.path = context.path
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, parent) {
-          fragment_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
-          operation_definitions = variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
+      def on_document(node, parent)
+        super
+        fragment_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::FragmentDefinition) }
+        operation_definitions = @variable_usages_for_context.select { |key, value| key.is_a?(GraphQL::Language::Nodes::OperationDefinition) }
 
-          operation_definitions.each do |node, node_variables|
-            follow_spreads(node, node_variables, spreads_for_context, fragment_definitions, [])
-            create_errors(node_variables, context)
-          end
-        }
+        operation_definitions.each do |node, node_variables|
+          follow_spreads(node, node_variables, @spreads_for_context, fragment_definitions, [])
+          create_errors(node_variables)
+        end
       end
 
       private
@@ -129,16 +121,34 @@ module GraphQL
 
       # Determine all the error messages,
       # Then push messages into the validation context
-      def create_errors(node_variables, context)
+      def create_errors(node_variables)
         # Declared but not used:
         node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
-          .each { |var_name, usage| context.errors << message("Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by, path: usage.path) }
+          .each { |var_name, usage|
+            declared_by_error_name = usage.declared_by.name || "anonymous #{usage.declared_by.operation_type}"
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is declared by #{declared_by_error_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| context.errors << message("Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node, path: usage.path) }
+          .each { |var_name, usage|
+            used_by_error_name = usage.used_by.name || "anonymous #{usage.used_by.operation_type}"
+            add_error(GraphQL::StaticValidation::VariablesAreUsedAndDefinedError.new(
+              "Variable $#{var_name} is used by #{used_by_error_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/type_stack.rb

@@ -55,7 +55,7 @@ module GraphQL
       module FragmentWithTypeStrategy
         def push(stack, node)
           object_type = if node.type
-            stack.schema.types.fetch(node.type.name, nil)
+            stack.schema.get_type(node.type.name)
           else
             stack.object_types.last
           end
@@ -148,7 +148,7 @@ module GraphQL
           if stack.argument_definitions.last
             arg_type = stack.argument_definitions.last.type.unwrap
             if arg_type.kind.input_object?
-              argument_defn = arg_type.input_fields[node.name]
+              argument_defn = arg_type.arguments[node.name]
             else
               argument_defn = nil
             end

data/lib/graphql/static_validation/validation_context.rb

@@ -14,73 +14,28 @@ module GraphQL
     class ValidationContext
       extend Forwardable
 
-      attr_reader :query, :schema,
-        :document, :errors, :visitor,
-        :warden, :dependencies, :each_irep_node_handlers
+      attr_reader :query, :errors, :visitor,
+        :on_dependency_resolve_handlers
 
       def_delegators :@query, :schema, :document, :fragments, :operations, :warden
 
-      def initialize(query)
+      def initialize(query, visitor_class)
         @query = query
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
-        @visitor = GraphQL::Language::Visitor.new(document)
-        @type_stack = GraphQL::StaticValidation::TypeStack.new(schema, visitor)
-        definition_dependencies = DefinitionDependencies.mount(self)
         @on_dependency_resolve_handlers = []
-        @each_irep_node_handlers = []
-        visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) {
-          @dependencies = definition_dependencies.dependency_map { |defn, spreads, frag|
-            @on_dependency_resolve_handlers.each { |h| h.call(defn, spreads, frag) }
-          }
-        }
+        @visitor = visitor_class.new(document, self)
       end
 
+      def_delegators :@visitor,
+        :path, :type_definition, :field_definition, :argument_definition,
+        :parent_type_definition, :directive_definition, :object_types, :dependencies
+
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler
       end
 
-      def object_types
-        @type_stack.object_types
-      end
-
-      def each_irep_node(&handler)
-        @each_irep_node_handlers << handler
-      end
-
-      # @return [GraphQL::BaseType] The current object type
-      def type_definition
-        object_types.last
-      end
-
-      # @return [GraphQL::BaseType] The type which the current type came from
-      def parent_type_definition
-        object_types[-2]
-      end
-
-      # @return [GraphQL::Field, nil] The most-recently-entered GraphQL::Field, if currently inside one
-      def field_definition
-        @type_stack.field_definitions.last
-      end
-
-      # @return [Array<String>] Field names to get to the current field
-      def path
-        @type_stack.path.dup
-      end
-
-      # @return [GraphQL::Directive, nil] The most-recently-entered GraphQL::Directive, if currently inside one
-      def directive_definition
-        @type_stack.directive_definitions.last
-      end
-
-      # @return [GraphQL::Argument, nil] The most-recently-entered GraphQL::Argument, if currently inside one
-      def argument_definition
-        # Don't get the _last_ one because that's the current one.
-        # Get the second-to-last one, which is the parent of the current one.
-        @type_stack.argument_definitions[-2]
-      end
-
-      def valid_literal?(ast_value, type)
+      def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
     end

data/lib/graphql/static_validation/validation_timeout_error.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ValidationTimeoutError < 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
+        "validationTimeout"
+      end
+    end
+  end
+end