graphql 0.16.0 → 2.0.15

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    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
+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,69 +1,133 @@
+# 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) {
-          return if !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          if parent.is_a?(GraphQL::Language::Nodes::Field)
-            arguments = context.field_definition.arguments
-          elsif parent.is_a?(GraphQL::Language::Nodes::Directive)
-            arguments = context.directive_definition.arguments
-          elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-            arguments = context.argument_definition.type.unwrap.input_fields
+        @declared_variables = {}
+      end
+
+      def on_operation_definition(node, parent)
+        @declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+        super
+      end
+
+      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 }
+
+        if node_values.any?
+          argument_owner = case parent
+          when GraphQL::Language::Nodes::Field
+            context.field_definition
+          when GraphQL::Language::Nodes::Directive
+            context.directive_definition
+          when GraphQL::Language::Nodes::InputObject
+            arg_type = context.argument_definition.type.unwrap
+            if arg_type.kind.input_object?
+              arg_type
+            else
+              # This is some kind of error
+              nil
+            end
           else
             raise("Unexpected argument parent: #{parent}")
           end
-          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 && validate_usage(arguments, node, var_defn_ast, context)
-        }
+
+          node_values.each do |node_value|
+            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 && argument_owner && validate_usage(argument_owner, node, var_defn_ast)
+          end
+        end
+        super
       end
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var, context)
-        var_type = to_query_type(ast_var.type, context.schema.types)
+      def validate_usage(argument_owner, arg_node, ast_var)
+        var_type = context.schema.type_from_ast(ast_var.type, context: context)
+        if var_type.nil?
+          return
+        end
         if !ast_var.default_value.nil?
-          var_type = GraphQL::NonNullType.new(of_type: var_type)
+          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 = var_type.to_non_null_type
+          end
         end
 
-        arg_defn = arguments[arg_node.name]
+        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
         arg_defn_type = arg_defn.type
 
+        # If the argument is non-null, but it was given a default value,
+        # then treat it as nullable in practice, see https://github.com/rmosolgo/graphql-ruby/issues/3793
+        if arg_defn_type.non_null? && arg_defn.default_value?
+          arg_defn_type = arg_defn_type.of_type
+        end
+
         var_inner_type = var_type.unwrap
         arg_inner_type = arg_defn_type.unwrap
 
+        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)
+          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)
+          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)
+          create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
         end
       end
 
-      def to_query_type(ast_type, types)
-        if ast_type.is_a?(GraphQL::Language::Nodes::NonNullType)
-          GraphQL::NonNullType.new(of_type: to_query_type(ast_type.of_type, types))
-        elsif ast_type.is_a?(GraphQL::Language::Nodes::ListType)
-          GraphQL::ListType.new(of_type: to_query_type(ast_type.of_type, types))
-        else
-          types[ast_type.name]
+      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)
+        arg_node_value = arg_node.value
+        return var_type unless arg_node_value.is_a?(Array)
+        new_var_type = var_type
+
+        depth_of_array(arg_node_value).times do
+          # Since the array _is_ present, treat it like a non-null type
+          # (It satisfies a non-null requirement AND a nullable requirement)
+          new_var_type = new_var_type.to_list_type.to_non_null_type
         end
+
+        new_var_type
       end
 
-      def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
-        message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node)
+      # @return [Integer] Returns the max depth of `array`, or `0` if it isn't an array at all
+      def depth_of_array(array)
+        case array
+        when Array
+          max_child_depth = 0
+          array.each do |item|
+            item_depth = depth_of_array(item)
+            if item_depth > max_child_depth
+              max_child_depth = item_depth
+            end
+          end
+          1 + max_child_depth
+        else
+          0
+        end
       end
 
       def list_dimension(type)

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,24 +1,32 @@
+# frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariablesAreInputTypes
-      include GraphQL::StaticValidation::Message::MessageHelper
+    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?
+          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(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
 
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << -> (node, parent) {
-          validate_is_input_type(node, context)
-        }
+        super
       end
 
       private
 
-      def validate_is_input_type(node, context)
-        type_name = get_type_name(node.type)
-        type = context.schema.types[type_name]
-        if !type.kind.input?
-          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node)
-        end
-      end
-
       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

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
 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.
@@ -10,11 +11,9 @@ 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
+        attr_accessor :ast_node, :used_by, :declared_by, :path
         def used?
           !!@used_by
         end
@@ -24,68 +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
+      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
         }
+        super
+        @variable_context_stack.pop
+      end
 
+      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
 
-        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_hash[var.name].declared_by = node }
-        }
-        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
-
-        # 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
-        }
-
-        # 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
-        }
+      # 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
@@ -96,7 +94,17 @@ module GraphQL
       def follow_spreads(node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
         spreads = spreads_for_context[node] - visited_fragments
         spreads.each do |spread_name|
-          def_node, variables = fragment_definitions.find { |def_node, vars| def_node.name == spread_name }
+          def_node = nil
+          variables = nil
+          # Implement `.find` by hand to avoid Ruby's internal allocations
+          fragment_definitions.each do |frag_def_node, vars|
+            if frag_def_node.name == spread_name
+              def_node = frag_def_node
+              variables = vars
+              break
+            end
+          end
+
           next if !def_node
           visited_fragments << spread_name
           variables.each do |name, child_usage|
@@ -104,6 +112,7 @@ module GraphQL
             if child_usage.used?
               parent_usage.ast_node   = child_usage.ast_node
               parent_usage.used_by    = child_usage.used_by
+              parent_usage.path       = child_usage.path
             end
           end
           follow_spreads(def_node, parent_variables, spreads_for_context, fragment_definitions, visited_fragments)
@@ -112,21 +121,34 @@ module GraphQL
 
       # Determine all the error messages,
       # Then push messages into the validation context
-      def create_errors(node_variables, context)
-        errors = []
+      def create_errors(node_variables)
         # Declared but not used:
-        errors += node_variables
+        node_variables
           .select { |name, usage| usage.declared? && !usage.used? }
-          .map { |var_name, usage| ["Variable $#{var_name} is declared by #{usage.declared_by.name} but not used", usage.declared_by] }
+          .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:
-        errors += node_variables
+        node_variables
           .select { |name, usage| usage.used? && !usage.declared? }
-          .map { |var_name, usage| ["Variable $#{var_name} is used by #{usage.used_by.name} but not declared", usage.ast_node] }
-
-        errors.each do |error_args|
-          context.errors << message(*error_args)
-        end
+          .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