graphql 2.5.11 → 2.5.19

data/lib/graphql/schema.rb

@@ -1708,7 +1708,7 @@ module GraphQL
       # If you need to support previous, non-spec behavior which allowed selecting union fields
       # but *not* selecting any fields on that union, set this to `true` to continue allowing that behavior.
       #
-      # If this is `true`, then {.legacy_invalid_empty_selections_on_union} will be called with {Query} objects
+      # If this is `true`, then {.legacy_invalid_empty_selections_on_union_with_type} will be called with {Query} objects
       # with that kind of selections. You must implement that method
       # @param new_value [Boolean]
       # @return [true, false, nil]
@@ -1724,6 +1724,22 @@ module GraphQL
         end
       end
 
+      # This method is called during validation when a previously-allowed, but non-spec
+      # query is encountered where a union field has no child selections on it.
+      #
+      # If `legacy_invalid_empty_selections_on_union_with_type` is overridden, this method will not be called.
+      #
+      # You should implement this method or `legacy_invalid_empty_selections_on_union_with_type`
+      # to log the violation so that you can contact clients and notify them about changing their queries.
+      # Then return a suitable value to tell GraphQL-Ruby how to continue.
+      # @param query [GraphQL::Query]
+      # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
+      # @return [String] A validation error to return for this query
+      # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
+      def legacy_invalid_empty_selections_on_union(query)
+        raise "Implement `def self.legacy_invalid_empty_selections_on_union_with_type(query, type)` or `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      end
+
       # This method is called during validation when a previously-allowed, but non-spec
       # query is encountered where a union field has no child selections on it.
       #
@@ -1731,11 +1747,12 @@ module GraphQL
       # and notify them about changing their queries. Then return a suitable value to
       # tell GraphQL-Ruby how to continue.
       # @param query [GraphQL::Query]
+      # @param type [Module] A GraphQL type definition
       # @return [:return_validation_error] Let GraphQL-Ruby return the (new) normal validation error for this query
       # @return [String] A validation error to return for this query
       # @return [nil] Don't send the client an error, continue the legacy behavior (allow this query to execute)
-      def legacy_invalid_empty_selections_on_union(query)
-        raise "Implement `def self.legacy_invalid_empty_selections_on_union(query)` to handle this scenario"
+      def legacy_invalid_empty_selections_on_union_with_type(query, type)
+        legacy_invalid_empty_selections_on_union(query)
       end
 
       # This setting controls how GraphQL-Ruby handles overlapping selections on scalar types when the types

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

@@ -49,7 +49,7 @@ module GraphQL
           if !resolved_type.kind.fields?
             case @schema.allow_legacy_invalid_empty_selections_on_union
             when true
-              legacy_invalid_empty_selection_result = @schema.legacy_invalid_empty_selections_on_union(@context.query)
+              legacy_invalid_empty_selection_result = @schema.legacy_invalid_empty_selections_on_union_with_type(@context.query, resolved_type)
               case legacy_invalid_empty_selection_result
               when :return_validation_error
                 # keep `return_validation_error = true`
@@ -61,7 +61,7 @@ module GraphQL
                 return_validation_error = false
                 legacy_invalid_empty_selection_result = nil
               else
-                raise GraphQL::InvariantError, "Unexpected return value from legacy_invalid_empty_selections_on_union, must be `:return_validation_error`, String, or nil (got: #{legacy_invalid_empty_selection_result.inspect})"
+                raise GraphQL::InvariantError, "Unexpected return value from legacy_invalid_empty_selections_on_union_with_type, must be `:return_validation_error`, String, or nil (got: #{legacy_invalid_empty_selection_result.inspect})"
               end
             when false
               # pass -- error below

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/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

data/lib/graphql/tracing/detailed_trace.rb

@@ -1,18 +1,34 @@
 # frozen_string_literal: true
+if defined?(ActiveRecord)
+  require "graphql/tracing/detailed_trace/active_record_backend"
+end
 require "graphql/tracing/detailed_trace/memory_backend"
 require "graphql/tracing/detailed_trace/redis_backend"
 
 module GraphQL
   module Tracing
-    # `DetailedTrace` can make detailed profiles for a subset of production traffic.
+    # `DetailedTrace` can make detailed profiles for a subset of production traffic. Install it in Rails with `rails generate graphql:detailed_trace`.
     #
     # When `MySchema.detailed_trace?(query)` returns `true`, a profiler-specific `trace_mode: ...` will be used for the query,
     # overriding the one in `context[:trace_mode]`.
     #
-    # __Redis__: The sampler stores its results in a provided Redis database. Depending on your needs,
-    # You can configure this database to retail all data (persistent) or to expire data according to your rules.
+    # By default, the detailed tracer calls `.inspect` on application objects returned from fields. You can customize
+    # this behavior by extending {DetailedTrace} and overriding {#inspect_object}. You can opt out of debug annotations
+    # entirely with `use ..., debug: false` or for a single query with `context: { detailed_trace_debug: false }`.
+    #
+    # You can store saved traces in two ways:
+    #
+    # - __ActiveRecord__: With `rails generate graphql:detailed_trace`, a new migration will be added to your app.
+    # That table will be used to store trace data.
+    #
+    # - __Redis__: Pass `redis: ...` to save trace data to a Redis database. Depending on your needs,
+    # you can configure this database to retain all data (persistent) or to expire data according to your rules.
+    #
     # If you need to save traces indefinitely, you can download them from Perfetto after opening them there.
     #
+    # @example Installing with Rails
+    #   rails generate graphql:detailed_trace # optional: --redis
+    #
     # @example Adding the sampler to your schema
     #   class MySchema < GraphQL::Schema
     #     # Add the sampler:
@@ -27,24 +43,48 @@ module GraphQL
     #   end
     #
     # @see Graphql::Dashboard GraphQL::Dashboard for viewing stored results
+    #
+    # @example Customizing debug output in traces
+    #   class CustomDetailedTrace < GraphQL::Tracing::DetailedTrace
+    #     def inspect_object(object)
+    #       if object.is_a?(SomeThing)
+    #         # handle it specially ...
+    #       else
+    #         super
+    #        end
+    #     end
+    #   end
+    #
+    # @example disabling debug annotations completely
+    #    use DetailedTrace, debug: false, ...
+    #
+    # @example disabling debug annotations for one query
+    #    MySchema.execute(query_str, context: { detailed_trace_debug: false })
+    #
     class DetailedTrace
       # @param redis [Redis] If provided, profiles will be stored in Redis for later review
       # @param limit [Integer] A maximum number of profiles to store
-      def self.use(schema, trace_mode: :profile_sample, memory: false, redis: nil, limit: nil)
+      # @param debug [Boolean] if `false`, it won't create `debug` annotations in Perfetto traces (reduces overhead)
+      # @param model_class [Class<ActiveRecord::Base>] Overrides {ActiveRecordBackend::GraphqlDetailedTrace} if present
+      def self.use(schema, trace_mode: :profile_sample, memory: false, debug: debug?, redis: nil, limit: nil, model_class: nil)
         storage = if redis
           RedisBackend.new(redis: redis, limit: limit)
         elsif memory
           MemoryBackend.new(limit: limit)
+        elsif defined?(ActiveRecord)
+          ActiveRecordBackend.new(limit: limit, model_class: model_class)
         else
-          raise ArgumentError, "Pass `redis: ...` to store traces in Redis for later review"
+          raise ArgumentError, "To store traces, install ActiveRecord or provide `redis: ...`"
         end
-        schema.detailed_trace = self.new(storage: storage, trace_mode: trace_mode)
+        detailed_trace = self.new(storage: storage, trace_mode: trace_mode, debug: debug)
+        schema.detailed_trace = detailed_trace
         schema.trace_with(PerfettoTrace, mode: trace_mode, save_profile: true)
       end
 
-      def initialize(storage:, trace_mode:)
+      def initialize(storage:, trace_mode:, debug:)
         @storage = storage
         @trace_mode = trace_mode
+        @debug = debug
       end
 
       # @return [Symbol] The trace mode to use when {Schema.detailed_trace?} returns `true`
@@ -55,6 +95,11 @@ module GraphQL
         @storage.save_trace(operation_name, duration_ms, begin_ms, trace_data)
       end
 
+      # @return [Boolean]
+      def debug?
+        @debug
+      end
+
       # @param last [Integer]
       # @param before [Integer] Timestamp in milliseconds since epoch
       # @return [Enumerable<StoredTrace>]
@@ -77,6 +122,24 @@ module GraphQL
         @storage.delete_all_traces
       end
 
+      def inspect_object(object)
+        self.class.inspect_object(object)
+      end
+
+      def self.inspect_object(object)
+        if defined?(ActiveRecord::Relation) && object.is_a?(ActiveRecord::Relation)
+          "#{object.class}, .to_sql=#{object.to_sql.inspect}"
+        else
+          object.inspect
+        end
+      end
+
+      # Default debug setting
+      # @return [true]
+      def self.debug?
+        true
+      end
+
       class StoredTrace
         def initialize(id:, operation_name:, duration_ms:, begin_ms:, trace_data:)
           @id = id