graphql 2.5.9 → 2.5.26

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

@@ -28,10 +28,10 @@ module GraphQL
       end
 
       def add_conflict(node, conflict_str)
-        # 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 }
+        # 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

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

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

@@ -23,18 +23,21 @@ module GraphQL
           type_name = fragment_node.type.name
           type = @types.type(type_name)
           if type.nil?
-            @all_possible_fragment_type_names ||= begin
-              names = []
-              context.types.all_types.each do |type|
-                if type.kind.fields?
-                  names << type.graphql_name
+            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
-              names
+              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#{context.did_you_mean_suggestion(type_name, @all_possible_fragment_type_names)}",
+              "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/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,13 +21,28 @@ module GraphQL
       private
 
       def assert_required_args(ast_node, defn)
-        args = @context.query.types.arguments(defn)
-        return if args.empty?
-        present_argument_names = ast_node.arguments.map(&:name)
-        required_argument_names = context.query.types.arguments(defn)
-          .select { |a| a.type.kind.non_null? && !a.default_value? && context.query.types.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.empty?
           add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(

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|
+      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/variables_are_input_types.rb

@@ -7,17 +7,20 @@ module GraphQL
         type = context.query.types.type(type_name)
 
         if type.nil?
-          @all_possible_input_type_names ||= begin
-            names = []
-            context.types.all_types.each { |(t)|
-              if t.kind.input?
-                names << t.graphql_name
-              end
-            }
-            names
+          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})#{context.did_you_mean_suggestion(type_name, @all_possible_input_type_names)}",
+            "#{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

@@ -32,7 +32,7 @@ module GraphQL
       # 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

data/lib/graphql/subscriptions/action_cable_subscriptions.rb

@@ -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:"

data/lib/graphql/subscriptions/default_subscription_resolve_extension.rb

@@ -2,25 +2,49 @@
 module GraphQL
   class Subscriptions
     class DefaultSubscriptionResolveExtension < GraphQL::Schema::FieldExtension
-      def resolve(context:, object:, arguments:)
-        has_override_implementation = @field.resolver ||
-          object.respond_to?(@field.resolver_method)
+      def resolve(context:, object: nil, objects: nil,  arguments:)
+        if objects
+          has_override_implementation = @field.execution_mode != :direct_send
 
-        if !has_override_implementation
-          if context.query.subscription_update?
-            object.object
+          if !has_override_implementation
+            if context.query.subscription_update?
+              objects
+            else
+              objects.map { |o| context.skip }
+            end
           else
-            context.skip
+            yield(objects, arguments)
           end
         else
-          yield(object, arguments)
+          has_override_implementation = @field.resolver ||
+            object.respond_to?(@field.resolver_method)
+
+          if !has_override_implementation
+            if context.query.subscription_update?
+              object.object
+            else
+              context.skip
+            end
+          else
+            yield(object, arguments)
+          end
+        end
+      end
+
+      def after_resolve(values: nil, value: nil, context:, objects: nil, object: nil, arguments:, **rest)
+        if values
+          values.map do |value|
+            self.class.write_subscription(@field, value, arguments, context)
+          end
+        else
+          self.class.write_subscription(@field, value, arguments, context)
         end
       end
 
-      def after_resolve(value:, context:, object:, arguments:, **rest)
+      def self.write_subscription(field, value, arguments, context)
         if value.is_a?(GraphQL::ExecutionError)
           value
-        elsif @field.resolver&.method_defined?(:subscription_written?) &&
+        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])

data/lib/graphql/subscriptions/event.rb

@@ -104,6 +104,7 @@ module GraphQL
 
         def stringify_args(arg_owner, args, context)
           arg_owner = arg_owner.respond_to?(:unwrap) ? arg_owner.unwrap : arg_owner # remove list and non-null wrappers
+
           case args
           when Hash
             next_args = {}

data/lib/graphql/subscriptions.rb

@@ -80,7 +80,7 @@ module GraphQL
 
       # Normalize symbol-keyed args to strings, try camelizing them
       # Should this accept a real context somehow?
-      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
+      normalized_args = normalize_arguments(normalized_event_name, field, args, @schema.null_context)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
@@ -239,6 +239,41 @@ module GraphQL
       query.context.namespace(:subscriptions)[:subscription_broadcastable]
     end
 
+    # Called during execution when a new `subscription ...` operation is received
+    # @param query [GraphQL::Query]
+    # @return [void]
+    def initialize_subscriptions(query)
+      subs_namespace = query.context.namespace(:subscriptions)
+      subs_namespace[:events] = []
+      subs_namespace[:subscriptions] = {}
+      nil
+    end
+
+    # Called during execution when a subscription operation has finished
+    # @param query [GraphQL::Query]
+    # @return [void]
+    def finish_subscriptions(query)
+      if (events = query.context.namespace(:subscriptions)[:events]) && !events.empty?
+        write_subscription(query, events)
+      end
+      nil
+    end
+
+    def finalizer
+      Finalizer.new(self)
+    end
+
+    class Finalizer
+      include Execution::Finalizer
+      def initialize(subscriptions)
+        @subscriptions = subscriptions
+      end
+
+      def finalize_graphql_result(query, result_data, result_key)
+        @subscriptions.finish_subscriptions(query)
+      end
+    end
+
     private
 
     # Recursively normalize `args` as belonging to `arg_owner`:

data/lib/graphql/testing/helpers.rb

@@ -39,9 +39,9 @@ module GraphQL
         end
       end
 
-      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil)
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {}, ast_node: nil, lookahead: nil, visibility_profile: nil)
         type_name, *field_names = field_path.split(".")
-        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
+        dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context, visibility_profile: visibility_profile)
         query_context = dummy_query.context
         dataloader = query_context.dataloader
         object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
@@ -104,32 +104,35 @@ module GraphQL
         end
       end
 
-      def with_resolution_context(schema, type:, object:, context:{})
+      def with_resolution_context(schema, type:, object:, context:{}, visibility_profile: nil)
         resolution_context = ResolutionAssertionContext.new(
           self,
           schema: schema,
           type_name: type,
           object: object,
-          context: context
+          context: context,
+          visibility_profile: visibility_profile,
         )
         yield(resolution_context)
       end
 
       class ResolutionAssertionContext
-        def initialize(test, type_name:, object:, schema:, context:)
+        def initialize(test, type_name:, object:, schema:, context:, visibility_profile:)
           @test = test
           @type_name = type_name
           @object = object
           @schema = schema
           @context = context
+          @visibility_profile = visibility_profile
         end
 
+        attr_reader :visibility_profile
 
         def run_graphql_field(field_name, arguments: {})
           if @schema
-            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           else
-            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context, visibility_profile: @visibility_profile)
           end
         end
       end
@@ -137,8 +140,8 @@ module GraphQL
       module SchemaHelpers
         include Helpers
 
-        def run_graphql_field(field_path, object, arguments: {}, context: {})
-          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context)
+        def run_graphql_field(field_path, object, arguments: {}, context: {}, visibility_profile: nil)
+          super(@@schema_class_for_helpers, field_path, object, arguments: arguments, context: context, visibility_profile: visibility_profile)
         end
 
         def with_resolution_context(*args, **kwargs, &block)

data/lib/graphql/testing/mock_action_cable.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+module GraphQL
+  module Testing
+    # A stub implementation of ActionCable.
+    # Any methods to support the mock backend have `mock` in the name.
+    #
+    # @example Configuring your schema to use MockActionCable in the test environment
+    #   class MySchema < GraphQL::Schema
+    #     # Use MockActionCable in test:
+    #     use GraphQL::Subscriptions::ActionCableSubscriptions,
+    #       action_cable: Rails.env.test? ? GraphQL::Testing::MockActionCable : ActionCable
+    #   end
+    #
+    # @example Clearing old data before each test
+    #   setup do
+    #     GraphQL::Testing::MockActionCable.clear_mocks
+    #   end
+    #
+    # @example Using MockActionCable in a test case
+    #   # Create a channel to use in the test, pass it to GraphQL
+    #   mock_channel = GraphQL::Testing::MockActionCable.get_mock_channel
+    #   ActionCableTestSchema.execute("subscription { newsFlash { text } }", context: { channel: mock_channel })
+    #
+    #   # Trigger a subscription update
+    #   ActionCableTestSchema.subscriptions.trigger(:news_flash, {}, {text: "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"})
+    #
+    #   # Check messages on the channel
+    #   expected_msg = {
+    #     result: {
+    #       "data" => {
+    #         "newsFlash" => {
+    #           "text" => "After yesterday's rain, someone stopped on Rio Road to help a box turtle across five lanes of traffic"
+    #         }
+    #       }
+    #     },
+    #     more: true,
+    #   }
+    #   assert_equal [expected_msg], mock_channel.mock_broadcasted_messages
+    #
+    class MockActionCable
+      class MockChannel
+        def initialize
+          @mock_broadcasted_messages = []
+        end
+
+        # @return [Array<Hash>] Payloads "sent" to this channel by GraphQL-Ruby
+        attr_reader :mock_broadcasted_messages
+
+        # Called by ActionCableSubscriptions. Implements a Rails API.
+        def stream_from(stream_name, coder: nil, &block)
+          # Rails uses `coder`, we don't
+          block ||= ->(msg) { @mock_broadcasted_messages << msg }
+          MockActionCable.mock_stream_for(stream_name).add_mock_channel(self, block)
+        end
+      end
+
+      # Used by mock code
+      # @api private
+      class MockStream
+        def initialize
+          @mock_channels = {}
+        end
+
+        def add_mock_channel(channel, handler)
+          @mock_channels[channel] = handler
+        end
+
+        def mock_broadcast(message)
+          @mock_channels.each do |channel, handler|
+            handler && handler.call(message)
+          end
+        end
+      end
+
+      class << self
+        # Call this before each test run to make sure that MockActionCable's data is empty
+        def clear_mocks
+          @mock_streams = {}
+        end
+
+        # Implements Rails API
+        def server
+          self
+        end
+
+        # Implements Rails API
+        def broadcast(stream_name, message)
+          stream = @mock_streams[stream_name]
+          stream && stream.mock_broadcast(message)
+        end
+
+        # Used by mock code
+        def mock_stream_for(stream_name)
+          @mock_streams[stream_name] ||= MockStream.new
+        end
+
+        # Use this as `context[:channel]` to simulate an ActionCable channel
+        #
+        # @return [GraphQL::Testing::MockActionCable::MockChannel]
+        def get_mock_channel
+          MockChannel.new
+        end
+
+        # @return [Array<String>] Streams that currently have subscribers
+        def mock_stream_names
+          @mock_streams.keys
+        end
+      end
+    end
+  end
+end

data/lib/graphql/testing.rb

@@ -1,2 +1,3 @@
 # frozen_string_literal: true
 require "graphql/testing/helpers"
+require "graphql/testing/mock_action_cable"

data/lib/graphql/tracing/detailed_trace/active_record_backend.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    class DetailedTrace
+      class ActiveRecordBackend
+        class GraphqlDetailedTrace < ActiveRecord::Base
+        end
+
+        def initialize(limit: nil, model_class: nil)
+          @limit = limit
+          @model_class = model_class || GraphqlDetailedTrace
+        end
+
+        def traces(last:, before:)
+          gdts = @model_class.all.order("begin_ms DESC")
+          if before
+            gdts = gdts.where("begin_ms < ?", before)
+          end
+          if last
+            gdts = gdts.limit(last)
+          end
+          gdts.map { |gdt| record_to_stored_trace(gdt) }
+        end
+
+        def delete_trace(id)
+          @model_class.where(id: id).destroy_all
+          nil
+        end
+
+        def delete_all_traces
+          @model_class.all.destroy_all
+        end
+
+        def find_trace(id)
+          gdt = @model_class.find_by(id: id)
+          if gdt
+            record_to_stored_trace(gdt)
+          else
+            nil
+          end
+        end
+
+        def save_trace(operation_name, duration_ms, begin_ms, trace_data)
+          gdt = @model_class.create!(
+            begin_ms: begin_ms,
+            operation_name: operation_name,
+            duration_ms: duration_ms,
+            trace_data: trace_data,
+          )
+          if @limit
+            @model_class
+              .where("id NOT IN(SELECT id FROM graphql_detailed_traces ORDER BY begin_ms DESC LIMIT ?)", @limit)
+              .delete_all
+          end
+          gdt.id
+        end
+
+        private
+
+        def record_to_stored_trace(gdt)
+          StoredTrace.new(
+            id: gdt.id,
+            begin_ms: gdt.begin_ms,
+            operation_name: gdt.operation_name,
+            duration_ms: gdt.duration_ms,
+            trace_data: gdt.trace_data
+          )
+
+        end
+      end
+    end
+  end
+end