graphql 2.0.31 → 2.6.1

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

@@ -14,9 +14,11 @@ module GraphQL
       end
 
       def message
-        "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
+        @message || "Field '#{field_name}' has #{kind == :argument ? 'an' : 'a'} #{kind} conflict: #{conflicts}?"
       end
 
+      attr_writer :message
+
       def path
         []
       end
@@ -26,7 +28,13 @@ module GraphQL
       end
 
       def add_conflict(node, conflict_str)
-        return if nodes.include?(node)
+        # Check if we already have an error for this exact node.
+        # Use object identity first (fast path), then fall back to
+        # value + location comparison for duplicate AST nodes.
+        if nodes.any? { |n| n.equal?(node) || (n.line == node.line && n.col == node.col && n == node) }
+          # already have an error for this node
+          return
+        end
 
         @nodes << node
         @conflicts << conflict_str

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

@@ -8,8 +8,8 @@ module GraphQL
       end
 
       def on_inline_fragment(node, parent)
-        fragment_parent = context.object_types[-2]
-        fragment_child = context.object_types.last
+        fragment_parent = @parent_object_type
+        fragment_child = @current_object_type
         if fragment_child
           validate_fragment_in_scope(fragment_parent, fragment_child, node, context, context.path)
         end
@@ -17,7 +17,7 @@ module GraphQL
       end
 
       def on_fragment_spread(node, parent)
-        fragment_parent = context.object_types.last
+        fragment_parent = @current_object_type
         @spreads_to_validate << FragmentSpread.new(node: node, parent_type: fragment_parent, path: context.path)
         super
       end
@@ -28,7 +28,7 @@ module GraphQL
           frag_node = context.fragments[frag_spread.node.name]
           if frag_node
             fragment_child_name = frag_node.type.name
-            fragment_child = context.warden.get_type(fragment_child_name)
+            fragment_child = @types.type(fragment_child_name)
             # Might be non-existent type name
             if fragment_child
               validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
@@ -44,8 +44,8 @@ module GraphQL
           # It's not a valid fragment type, this error was handled someplace else
           return
         end
-        parent_types = context.warden.possible_types(parent_type.unwrap)
-        child_types = context.warden.possible_types(child_type.unwrap)
+        parent_types = @types.possible_types(parent_type.unwrap)
+        child_types = @types.possible_types(child_type.unwrap)
 
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""

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

@@ -21,10 +21,23 @@ module GraphQL
           true
         else
           type_name = fragment_node.type.name
-          type = context.warden.get_type(type_name)
+          type = @types.type(type_name)
           if type.nil?
+            suggestion = if @schema.did_you_mean
+              @all_possible_fragment_type_names ||= begin
+                names = []
+                context.types.all_types.each do |type|
+                  if type.kind.fields?
+                    names << type.graphql_name
+                  end
+                end
+                names
+              end
+              context.did_you_mean_suggestion(type_name, @all_possible_fragment_type_names)
+            end
+
             add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
-              "No such type #{type_name}, so it can't be a fragment condition",
+              "No such type #{type_name}, so it can't be a fragment condition#{suggestion}",
               nodes: fragment_node,
               type: type_name
             ))

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

@@ -19,7 +19,7 @@ module GraphQL
           true
         else
           type_name = node_type.to_query_string
-          type_def = context.warden.get_type(type_name)
+          type_def = @types.type(type_name)
           if type_def.nil? || !type_def.kind.composite?
             add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
               "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",

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

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module MutationRootExists
       def on_operation_definition(node, _parent)
-        if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
+        if node.operation_type == 'mutation' && context.query.types.mutation_root.nil?
           add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
             'Schema is not configured for mutations',
             nodes: node

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

@@ -32,7 +32,7 @@ module GraphQL
 
       def on_document(node, parent)
         super
-        if @schema_definition_nodes.any?
+        if !@schema_definition_nodes.empty?
           add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
         end
       end

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

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

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

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     module QueryRootExists
       def on_operation_definition(node, _parent)
-        if (node.operation_type == 'query' || node.operation_type.nil?) && context.warden.root_type_for_operation("query").nil?
+        if (node.operation_type == 'query' || node.operation_type.nil?) && context.query.types.query_root.nil?
           add_error(GraphQL::StaticValidation::QueryRootExistsError.new(
             'Schema is not configured for queries',
             nodes: node

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

@@ -2,8 +2,13 @@
 module GraphQL
   module StaticValidation
     module RequiredArgumentsArePresent
+      def initialize(*)
+        super
+        @required_args_cache = {}.compare_by_identity
+      end
+
       def on_field(node, _parent)
-        assert_required_args(node, field_definition)
+        assert_required_args(node, @current_field_definition)
         super
       end
 
@@ -16,15 +21,30 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = defn.arguments(context.query.context)
-        return if args.empty?
-        present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = context.warden.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? && context.warden.get_argument(defn, a.name) }
-          .map(&:name)
+        return unless defn
 
+        # Cache required argument names per definition to avoid re-iterating
+        # arguments for the same definition across field instances
+        if @required_args_cache.key?(defn)
+          required_argument_names = @required_args_cache[defn]
+        else
+          args = @types.arguments(defn)
+          required_argument_names = nil
+          if !args.empty?
+            args.each do |a|
+              if a.type.kind.non_null? && !a.default_value? && @types.argument(defn, a.name)
+                (required_argument_names ||= []) << a.graphql_name
+              end
+            end
+          end
+          @required_args_cache[defn] = required_argument_names
+        end
+
+        return if required_argument_names.nil?
+
+        present_argument_names = ast_node.arguments.map(&:name)
         missing_names = required_argument_names - present_argument_names
-        if missing_names.any?
+        if !missing_names.empty?
           add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(
             "#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}",
             nodes: ast_node,

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

@@ -26,7 +26,7 @@ module GraphQL
           context.directive_definition || context.field_definition
         end
 
-        parent_type = context.warden.get_argument(defn, parent_name(parent, defn))
+        parent_type = context.types.argument(defn, parent_name(parent, defn))
         parent_type ? parent_type.type.unwrap : nil
       end
 
@@ -34,16 +34,16 @@ module GraphQL
         parent_type = get_parent_type(context, parent)
         return unless parent_type && parent_type.kind.input_object?
 
-        required_fields = context.warden.arguments(parent_type)
-          .select{|arg| arg.type.kind.non_null?}
-          .map(&:graphql_name)
+        required_fields = context.types.arguments(parent_type)
+          .select{ |arg| arg.type.kind.non_null? && !arg.default_value? }
+          .map!(&:graphql_name)
 
         present_fields = ast_node.arguments.map(&:name)
         missing_fields = required_fields - present_fields
 
         missing_fields.each do |missing_field|
           path = [*context.path, missing_field]
-          missing_field_type = context.warden.get_argument(parent_type, missing_field).type
+          missing_field_type = context.types.argument(parent_type, missing_field).type
           add_error(RequiredInputObjectAttributesArePresentError.new(
             "Argument '#{missing_field}' on InputObject '#{parent_type.to_type_signature}' is required. Expected type #{missing_field_type.to_type_signature}",
             argument_name: missing_field,

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module SubscriptionRootExistsAndSingleSubscriptionSelection
+      def on_operation_definition(node, parent)
+        if node.operation_type == "subscription"
+          if context.types.subscription_root.nil?
+            add_error(GraphQL::StaticValidation::SubscriptionRootExistsError.new(
+              'Schema is not configured for subscriptions',
+              nodes: node
+            ))
+          elsif node.selections.size != 1
+            add_error(GraphQL::StaticValidation::NotSingleSubscriptionError.new(
+              'A subscription operation may only have one selection',
+              nodes: node,
+            ))
+          else
+            super
+          end
+        else
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -19,13 +19,17 @@ module GraphQL
         :on_field,
       ]
 
-      DIRECTIVE_NODE_HOOKS.each do |method_name|
-        define_method(method_name) do |node, parent|
-          if node.directives.any?
+      VALIDATE_DIRECTIVE_LOCATION_ON_NODE = <<~RUBY
+        def %{method_name}(node, parent)
+          if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)
         end
+      RUBY
+      DIRECTIVE_NODE_HOOKS.each do |method_name|
+        # Can't use `define_method {...}` here  because the proc can't be isolated for use in non-main Ractors
+        module_eval(VALIDATE_DIRECTIVE_LOCATION_ON_NODE % { method_name: method_name }) # rubocop:disable Development/NoEvalCop
       end
 
       private

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

@@ -5,36 +5,27 @@ module GraphQL
       def on_variable_definition(node, parent)
         if !node.default_value.nil?
           value = node.default_value
-          if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-            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]
-            ))
+          type = context.schema.type_from_ast(node.type, context: context)
+          if type.nil?
+            # This is handled by another validator
           else
-            type = context.schema.type_from_ast(node.type, context: context)
-            if type.nil?
-              # This is handled by another validator
-            else
-              validation_result = context.validate_literal(value, type)
+            validation_result = context.validate_literal(value, type)
 
-              if !validation_result.valid?
-                problems = validation_result.problems
-                first_problem = problems && problems.first
-                if first_problem
-                  error_message = first_problem["explanation"]
-                end
-
-                error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
-                add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
-                  error_message,
-                  nodes: node,
-                  name: node.name,
-                  type: type.to_type_signature,
-                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
-                ))
+            if !validation_result.valid?
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                error_message = first_problem["explanation"]
               end
+
+              error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
+              add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+                error_message,
+                nodes: node,
+                name: node.name,
+                type: type.to_type_signature,
+                error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
+              ))
             end
           end
         end

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

@@ -4,7 +4,7 @@ module GraphQL
     module VariableNamesAreUnique
       def on_operation_definition(node, parent)
         var_defns = node.variables
-        if var_defns.any?
+        if !var_defns.empty?
           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|

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

@@ -21,7 +21,7 @@ module GraphQL
         end
         node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
 
-        if node_values.any?
+        if !node_values.empty?
           argument_owner = case parent
           when GraphQL::Language::Nodes::Field
             context.field_definition
@@ -65,7 +65,7 @@ module GraphQL
           end
         end
 
-        arg_defn = context.warden.get_argument(argument_owner, arg_node.name)
+        arg_defn = @types.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,

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

@@ -4,11 +4,23 @@ module GraphQL
     module VariablesAreInputTypes
       def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
-        type = context.warden.get_type(type_name)
+        type = context.query.types.type(type_name)
 
         if type.nil?
+          suggestion = if @schema.did_you_mean
+            @all_possible_input_type_names ||= begin
+              names = []
+              context.types.all_types.each { |(t)|
+                if t.kind.input?
+                  names << t.graphql_name
+                end
+              }
+              names
+            end
+            context.did_you_mean_suggestion(type_name, @all_possible_input_type_names)
+          end
           add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
-            "#{type_name} isn't a defined input type (on $#{node.name})",
+            "#{type_name} isn't a defined input type (on $#{node.name})#{suggestion}",
             nodes: node,
             name: node.name,
             type: type_name

data/lib/graphql/static_validation/validation_context.rb

@@ -8,20 +8,20 @@ module GraphQL
     # It provides access to the schema & fragments which validators may read from.
     #
     # It holds a list of errors which each validator may add to.
-    #
-    # It also provides limited access to the {TypeStack} instance,
-    # which tracks state as you climb in and out of different fields.
     class ValidationContext
       extend Forwardable
 
       attr_reader :query, :errors, :visitor,
         :on_dependency_resolve_handlers,
-        :max_errors
+        :max_errors, :types, :schema
+
 
-      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+      def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
+        @types = query.types # TODO update migrated callers to use this accessor
+        @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
         @max_errors = max_errors || Float::INFINITY
@@ -29,9 +29,10 @@ module GraphQL
         @visitor = visitor_class.new(document, self)
       end
 
+      # TODO stop using def_delegators because of Array allocations
       def_delegators :@visitor,
         :path, :type_definition, :field_definition, :argument_definition,
-        :parent_type_definition, :directive_definition, :object_types, :dependencies
+        :parent_type_definition, :directive_definition, :dependencies
 
       def on_dependency_resolve(&handler)
         @on_dependency_resolve_handlers << handler
@@ -48,6 +49,21 @@ module GraphQL
       def schema_directives
         @schema_directives ||= schema.directives
       end
+
+      def did_you_mean_suggestion(name, options)
+        if did_you_mean = schema.did_you_mean
+          suggestions = did_you_mean::SpellChecker.new(dictionary: options).correct(name)
+          case suggestions.size
+          when 0
+            ""
+          when 1
+            " (Did you mean `#{suggestions.first}`?)"
+          else
+            last_sugg = suggestions.pop
+            " (Did you mean #{suggestions.map {|s| "`#{s}`"}.join(", ")} or `#{last_sugg}`?)"
+          end
+        end
+      end
     end
   end
 end

data/lib/graphql/static_validation/validator.rb

@@ -27,7 +27,10 @@ module GraphQL
       # @param max_errors [Integer] Maximum number of errors before aborting validation. Any positive number will limit the number of errors. Defaults to nil for no limit.
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
+        errors = nil
+        query.current_trace.begin_validate(query, validate)
         query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
           errors = if validate == false
             []
           else
@@ -52,13 +55,18 @@ module GraphQL
           end
 
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
           }
         end
       rescue GraphQL::ExecutionError => e
+        errors = [e]
         {
-          errors: [e],
+          remaining_timeout: nil,
+          errors: errors,
         }
+      ensure
+        query.current_trace.end_validate(query, validate, errors)
       end
 
       # Invoked when static validation times out.

data/lib/graphql/static_validation.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
-require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
 require "graphql/static_validation/validation_context"
 require "graphql/static_validation/validation_timeout_error"

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -35,7 +35,7 @@ module GraphQL
     #       }
     #
     #       result = MySchema.execute(
-    #         query: query,
+    #         query,
     #         context: context,
     #         variables: variables,
     #         operation_name: operation_name
@@ -81,6 +81,7 @@ module GraphQL
     #       end
     #   end
     #
+    # @see GraphQL::Testing::MockActionCable for test helpers
     class ActionCableSubscriptions < GraphQL::Subscriptions
       SUBSCRIPTION_PREFIX = "graphql-subscription:"
       EVENT_PREFIX = "graphql-event:"
@@ -107,7 +108,7 @@ module GraphQL
         when 2
           true
         else
-          raise ArgumentError, "#{@serializer} must repond to `.load` accepting one or two arguments"
+          raise ArgumentError, "#{@serializer} must respond to `.load` accepting one or two arguments"
         end
         @transmit_ns = namespace
         super
@@ -124,7 +125,8 @@ module GraphQL
       # This subscription was re-evaluated.
       # Send it to the specific stream where this client was waiting.
       def deliver(subscription_id, result)
-        payload = { result: result.to_h, more: true }
+        has_more = !result.context.namespace(:subscriptions)[:final_update]
+        payload = { result: result.to_h, more: has_more }
         @action_cable.server.broadcast(stream_subscription_name(subscription_id), payload)
       end
 
@@ -165,11 +167,12 @@ module GraphQL
       #
       def setup_stream(channel, initial_event)
         topic = initial_event.topic
-        channel.stream_from(stream_event_name(initial_event), coder: @action_cable_coder) do |message|
+        event_stream = stream_event_name(initial_event)
+        channel.stream_from(event_stream, coder: @action_cable_coder) do |message|
           events_by_fingerprint = @events[topic]
           object = nil
           events_by_fingerprint.each do |_fingerprint, events|
-            if events.any? && events.first == initial_event
+            if !events.empty? && events.first == initial_event
               # The fingerprint has told us that this response should be shared by all subscribers,
               # so just run it once, then deliver the result to every subscriber
               first_event = events.first

data/lib/graphql/subscriptions/broadcast_analyzer.rb

@@ -9,7 +9,7 @@ module GraphQL
     # Assign the result to `context.namespace(:subscriptions)[:subscription_broadcastable]`
     # @api private
     # @see Subscriptions#broadcastable? for a public API
-    class BroadcastAnalyzer < GraphQL::Analysis::AST::Analyzer
+    class BroadcastAnalyzer < GraphQL::Analysis::Analyzer
       def initialize(subject)
         super
         @default_broadcastable = subject.schema.subscriptions.default_broadcastable
@@ -28,9 +28,8 @@ module GraphQL
         end
 
         current_field = visitor.field_definition
-        apply_broadcastable(current_field)
-
         current_type = visitor.parent_type_definition
+        apply_broadcastable(current_type, current_field)
         if current_type.kind.interface?
           pt = @query.possible_types(current_type)
           pt.each do |object_type|
@@ -38,7 +37,7 @@ module GraphQL
             # Inherited fields would be exactly the same object;
             # only check fields that are overrides of the inherited one
             if ot_field && ot_field != current_field
-              apply_broadcastable(ot_field)
+              apply_broadcastable(object_type, ot_field)
             end
           end
         end
@@ -55,10 +54,16 @@ module GraphQL
       private
 
       # Modify `@subscription_broadcastable` based on `field_defn`'s configuration (and/or the default value)
-      def apply_broadcastable(field_defn)
+      def apply_broadcastable(owner_type, field_defn)
         current_field_broadcastable = field_defn.introspection? || field_defn.broadcastable?
+
+        if current_field_broadcastable.nil? && owner_type.respond_to?(:default_broadcastable?)
+          current_field_broadcastable = owner_type.default_broadcastable?
+        end
+
         case current_field_broadcastable
         when nil
+          query.logger.debug { "`broadcastable: nil` for field: #{field_defn.path}" }
           # If the value wasn't set, mix in the default value:
           # - If the default is false and the current value is true, make it false
           # - If the default is true and the current value is true, it stays true
@@ -66,6 +71,7 @@ module GraphQL
           # - If the default is true and the current value is false, keep it false
           @subscription_broadcastable = @subscription_broadcastable && @default_broadcastable
         when false
+          query.logger.debug { "`broadcastable: false` for field: #{field_defn.path}" }
           # One non-broadcastable field is enough to make the whole subscription non-broadcastable
           @subscription_broadcastable = false
         when true