graphql 2.4.3 → 2.5.3

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

@@ -33,26 +33,19 @@ module GraphQL
 
       private
 
-      def field_conflicts
-        @field_conflicts ||= Hash.new do |errors, field|
-          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :field, field_name: field)
-        end
-      end
-
-      def arg_conflicts
-        @arg_conflicts ||= Hash.new do |errors, field|
-          errors[field] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: :argument, field_name: field)
+      def conflicts
+        @conflicts ||= Hash.new do |h, error_type|
+          h[error_type] = Hash.new do |h2, field_name|
+            h2[field_name] = GraphQL::StaticValidation::FieldsWillMergeError.new(kind: error_type, field_name: field_name)
+          end
         end
       end
 
       def setting_errors
-        @field_conflicts = nil
-        @arg_conflicts = nil
-
+        @conflicts = nil
         yield
         # don't initialize these if they weren't initialized in the block:
-        @field_conflicts && @field_conflicts.each_value { |error| add_error(error) }
-        @arg_conflicts && @arg_conflicts.each_value { |error| add_error(error) }
+        @conflicts&.each_value { |error_type| error_type.each_value { |error| add_error(error) } }
       end
 
       def conflicts_within_selection_set(node, parent_type)
@@ -222,7 +215,7 @@ module GraphQL
 
         if !are_mutually_exclusive
           if node1.name != node2.name
-            conflict = field_conflicts[response_key]
+            conflict = conflicts[:field][response_key]
 
             conflict.add_conflict(node1, node1.name)
             conflict.add_conflict(node2, node2.name)
@@ -231,7 +224,7 @@ module GraphQL
           end
 
           if !same_arguments?(node1, node2)
-            conflict = arg_conflicts[response_key]
+            conflict = conflicts[:argument][response_key]
 
             conflict.add_conflict(node1, GraphQL::Language.serialize(serialize_field_args(node1)))
             conflict.add_conflict(node2, GraphQL::Language.serialize(serialize_field_args(node2)))
@@ -240,6 +233,49 @@ module GraphQL
           end
         end
 
+        if !conflicts[:field].key?(response_key) &&
+            (t1 = field1.definition&.type) &&
+            (t2 = field2.definition&.type) &&
+            return_types_conflict?(t1, t2)
+
+          return_error = nil
+          message_override = nil
+          case @schema.allow_legacy_invalid_return_type_conflicts
+          when false
+            return_error = true
+          when true
+            legacy_handling = @schema.legacy_invalid_return_type_conflicts(@context.query, t1, t2, node1, node2)
+            case legacy_handling
+            when nil
+              return_error = false
+            when :return_validation_error
+              return_error = true
+            when String
+              return_error = true
+              message_override = legacy_handling
+            else
+              raise GraphQL::Error, "#{@schema}.legacy_invalid_scalar_conflicts returned unexpected value: #{legacy_handling.inspect}. Expected `nil`, String, or `:return_validation_error`."
+            end
+          else
+            return_error = false
+            @context.query.logger.warn <<~WARN
+              GraphQL-Ruby encountered mismatched types in this query: `#{t1.to_type_signature}` (at #{node1.line}:#{node1.col}) vs. `#{t2.to_type_signature}` (at #{node2.line}:#{node2.col}).
+              This will return an error in future GraphQL-Ruby versions, as per the GraphQL specification
+              Learn about migrating here: https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#allow_legacy_invalid_return_type_conflicts-class_method
+            WARN
+          end
+
+          if return_error
+            conflict = conflicts[:return_type][response_key]
+            if message_override
+              conflict.message = message_override
+            end
+            conflict.add_conflict(node1, "`#{t1.to_type_signature}`")
+            conflict.add_conflict(node2, "`#{t2.to_type_signature}`")
+            @conflict_count += 1
+          end
+        end
+
         find_conflicts_between_sub_selection_sets(
           field1,
           field2,
@@ -247,6 +283,32 @@ module GraphQL
         )
       end
 
+      def return_types_conflict?(type1, type2)
+        if type1.list?
+          if type2.list?
+            return_types_conflict?(type1.of_type, type2.of_type)
+          else
+            true
+          end
+        elsif type2.list?
+          true
+        elsif type1.non_null?
+          if type2.non_null?
+            return_types_conflict?(type1.of_type, type2.of_type)
+          else
+            true
+          end
+        elsif type2.non_null?
+          true
+        elsif type1.kind.leaf? && type2.kind.leaf?
+          type1 != type2
+        else
+          # One or more of these are composite types,
+          # their selections will be validated later on.
+          false
+        end
+      end
+
       def find_conflicts_between_sub_selection_sets(field1, field2, mutually_exclusive:)
         return if field1.definition.nil? ||
           field2.definition.nil? ||
@@ -345,7 +407,7 @@ module GraphQL
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? @types.type(node.type.name) : owner_type
-            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
+            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: fragment_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
           end

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)
+        # Can't use `.include?` here because AST nodes implement `#==`
+        # based on string value, not including location. But sometimes,
+        # identical nodes conflict because of their differing return types.
+        if nodes.any? { |n| n == node && n.line == node.line && n.col == node.col }
+          # already have an error for this node
+          return
+        end
 
         @nodes << node
         @conflicts << conflict_str

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/required_arguments_are_present.rb

@@ -24,7 +24,7 @@ module GraphQL
           .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/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

@@ -21,7 +21,7 @@ module GraphQL
 
       DIRECTIVE_NODE_HOOKS.each do |method_name|
         define_method(method_name) do |node, parent|
-          if node.directives.any?
+          if !node.directives.empty?
             validate_directive_location(node)
           end
           super(node, parent)

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

data/lib/graphql/static_validation/validation_context.rb

@@ -29,6 +29,7 @@ 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

data/lib/graphql/static_validation/validator.rb

@@ -27,6 +27,8 @@ 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
@@ -58,10 +60,13 @@ module GraphQL
           }
         end
       rescue GraphQL::ExecutionError => e
+        errors = [e]
         {
           remaining_timeout: nil,
-          errors: [e],
+          errors: errors,
         }
+      ensure
+        query.current_trace.end_validate(query, validate, errors)
       end
 
       # Invoked when static validation times out.

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -171,7 +171,7 @@ module GraphQL
           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/default_subscription_resolve_extension.rb

@@ -20,12 +20,22 @@ module GraphQL
       def after_resolve(value:, context:, object:, arguments:, **rest)
         if value.is_a?(GraphQL::ExecutionError)
           value
+        elsif @field.resolver&.method_defined?(:subscription_written?) &&
+          (subscription_namespace = context.namespace(:subscriptions)) &&
+          (subscriptions_by_path = subscription_namespace[:subscriptions])
+          (subscription_instance = subscriptions_by_path[context.current_path])
+          # If it was already written, don't append this event to be written later
+          if !subscription_instance.subscription_written?
+            events = context.namespace(:subscriptions)[:events]
+            events << subscription_instance.event
+          end
+          value
         elsif (events = context.namespace(:subscriptions)[:events])
           # This is the first execution, so gather an Event
           # for the backend to register:
           event = Subscriptions::Event.new(
             name: field.name,
-            arguments: arguments_without_field_extras(arguments: arguments),
+            arguments: arguments,
             context: context,
             field: field,
           )
@@ -33,7 +43,7 @@ module GraphQL
           value
         elsif context.query.subscription_topic == Subscriptions::Event.serialize(
             field.name,
-            arguments_without_field_extras(arguments: arguments),
+            arguments,
             field,
             scope: (field.subscription_scope ? context[field.subscription_scope] : nil),
           )
@@ -45,14 +55,6 @@ module GraphQL
           context.skip
         end
       end
-
-      private
-
-      def arguments_without_field_extras(arguments:)
-        arguments.dup.tap do |event_args|
-          field.extras.each { |k| event_args.delete(k) }
-        end
-      end
     end
   end
 end

data/lib/graphql/subscriptions/event.rb

@@ -20,7 +20,7 @@ module GraphQL
 
       def initialize(name:, arguments:, field: nil, context: nil, scope: nil)
         @name = name
-        @arguments = arguments
+        @arguments = self.class.arguments_without_field_extras(arguments: arguments, field: field)
         @context = context
         field ||= context.field
         scope_key = field.subscription_scope
@@ -39,6 +39,7 @@ module GraphQL
       # @return [String] an identifier for this unit of subscription
       def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
         subscription = field.resolver || GraphQL::Schema::Subscription
+        arguments = arguments_without_field_extras(field: field, arguments: arguments)
         normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
       end
@@ -60,6 +61,16 @@ module GraphQL
       end
 
       class << self
+        def arguments_without_field_extras(arguments:, field:)
+          if !field.extras.empty?
+            arguments = arguments.dup
+            field.extras.each do |extra_key|
+              arguments.delete(extra_key)
+            end
+          end
+          arguments
+        end
+
         private
 
         # This method does not support cyclic references in the Hash,

data/lib/graphql/subscriptions/serialize.rb

@@ -146,7 +146,7 @@ module GraphQL
           elsif obj.is_a?(Date) || obj.is_a?(Time)
             # DateTime extends Date; for TimeWithZone, call `.utc` first.
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
-          elsif obj.is_a?(OpenStruct)
+          elsif defined?(OpenStruct) && obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
             dump_value(obj.to_a)

data/lib/graphql/subscriptions.rb

@@ -291,7 +291,7 @@ module GraphQL
           end
         end
 
-        if missing_arg_names.any?
+        if !missing_arg_names.empty?
           arg_owner_name = if arg_owner.is_a?(GraphQL::Schema::Field)
             arg_owner.path
           elsif arg_owner.is_a?(Class)

data/lib/graphql/testing/helpers.rb

@@ -43,22 +43,25 @@ module GraphQL
         type_name, *field_names = field_path.split(".")
         dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
         query_context = dummy_query.context
+        dataloader = query_context.dataloader
         object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
         if object_type
           graphql_result = object
           field_names.each do |field_name|
             inner_object = graphql_result
-            graphql_result = object_type.wrap(inner_object, query_context)
+            dataloader.run_isolated {
+              graphql_result = object_type.wrap(inner_object, query_context)
+            }
             if graphql_result.nil?
               return nil
             end
             visible_field = dummy_query.types.field(object_type, field_name) # rubocop:disable Development/ContextIsPassedCop
             if visible_field
-              dummy_query.context.dataloader.run_isolated {
+              dataloader.run_isolated {
                 query_context[:current_field] = visible_field
                 field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
                 field_args = schema.sync_lazy(field_args)
-                if visible_field.extras.any?
+                if !visible_field.extras.empty?
                   extra_args = {}
                   visible_field.extras.each do |extra|
                     extra_args[extra] = case extra
@@ -92,7 +95,7 @@ module GraphQL
           end
           graphql_result
         else
-          unfiltered_type = Schema::Visibility::Profile.null_profile(schema: schema, context: context).type(type_name)
+          unfiltered_type = schema.use_visibility_profile? ? schema.visibility.get_type(type_name) : schema.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
           if unfiltered_type
             raise TypeNotVisibleError.new(type_name: type_name)
           else

data/lib/graphql/tracing/active_support_notifications_trace.rb

@@ -1,11 +1,22 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_trace'
+require "graphql/tracing/notifications_trace"
 
 module GraphQL
   module Tracing
-    # This implementation forwards events to ActiveSupport::Notifications
-    # with a `graphql` suffix.
+    # This implementation forwards events to ActiveSupport::Notifications with a `graphql` suffix.
+    #
+    # @example Sending execution events to ActiveSupport::Notifications
+    #   class MySchema < GraphQL::Schema
+    #     trace_with(GraphQL::Tracing::ActiveSupportNotificationsTrace)
+    #   end
+    #
+    # @example Subscribing to GraphQL events with ActiveSupport::Notifications
+    #   ActiveSupport::Notifications.subscribe(/graphql/) do |event|
+    #     pp event.name
+    #     pp event.payload
+    #   end
+    #
     module ActiveSupportNotificationsTrace
       include NotificationsTrace
       def initialize(engine: ActiveSupport::Notifications, **rest)

data/lib/graphql/tracing/active_support_notifications_tracing.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'graphql/tracing/notifications_tracing'
+require "graphql/tracing/notifications_tracing"
 
 module GraphQL
   module Tracing

data/lib/graphql/tracing/appoptics_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
 
@@ -20,14 +22,18 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used
 
+
       def self.version
         Gem::Version.new('1.0.0')
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       [
         'lex',
         'parse',
@@ -55,6 +61,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field(query:, field:, ast_node:, arguments:, object:)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?
@@ -81,7 +89,7 @@ module GraphQL
         end
       end
 
-      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)
+      def execute_field_lazy(query:, field:, ast_node:, arguments:, object:)  # rubocop:disable Development/TraceCallsSuperCop
         execute_field(query: query, field: field, ast_node: ast_node, arguments: arguments, object: object)
       end
 

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
 
@@ -20,6 +22,11 @@ module GraphQL
       # These GraphQL events will show up as 'graphql.execute' spans
       EXEC_KEYS = ['execute_multiplex', 'execute_query', 'execute_query_lazy'].freeze
 
+      def initialize(...)
+        warn "GraphQL::Tracing::AppOptics tracing is deprecated; update to SolarWindsAPM instead, which uses OpenTelemetry."
+        super
+      end
+
       # During auto-instrumentation this version of AppOpticsTracing is compared
       # with the version provided in the appoptics_apm gem, so that the newer
       # version of the class can be used