graphql 2.0.28 → 2.2.11

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, :warden, :schema
+
 
-      def_delegators :@query, :schema, :document, :fragments, :operations, :warden
+      def_delegators :@query, :document, :fragments, :operations
 
       def initialize(query, visitor_class, max_errors)
         @query = query
+        @warden = query.warden
+        @schema = query.schema
         @literal_validator = LiteralValidator.new(context: query.context)
         @errors = []
         @max_errors = max_errors || Float::INFINITY

data/lib/graphql/static_validation/validator.rb

@@ -28,6 +28,7 @@ module GraphQL
       # @return [Array<Hash>]
       def validate(query, validate: true, timeout: nil, max_errors: nil)
         query.current_trace.validate(validate: validate, query: query) do
+          begin_t = Time.now
           errors = if validate == false
             []
           else
@@ -52,11 +53,13 @@ module GraphQL
           end
 
           {
+            remaining_timeout: timeout ? (timeout - (Time.now - begin_t)) : nil,
             errors: errors,
           }
         end
       rescue GraphQL::ExecutionError => e
         {
+          remaining_timeout: nil,
           errors: [e],
         }
       end

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
@@ -124,7 +124,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
 

data/lib/graphql/subscriptions/event.rb

@@ -37,7 +37,7 @@ module GraphQL
       end
 
       # @return [String] an identifier for this unit of subscription
-      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext)
+      def self.serialize(_name, arguments, field, scope:, context: GraphQL::Query::NullContext.instance)
         subscription = field.resolver || GraphQL::Schema::Subscription
         normalized_args = stringify_args(field, arguments.to_h, context)
         subscription.topic_for(arguments: normalized_args, field: field, scope: scope)
@@ -126,7 +126,13 @@ module GraphQL
           when GraphQL::Schema::InputObject
             stringify_args(arg_owner, args.to_h, context)
           else
-            args
+            if arg_owner.is_a?(Class) && arg_owner < GraphQL::Schema::Enum
+              # `prepare:` may have made the value something other than
+              # a defined value of this enum -- use _that_ in this case.
+              arg_owner.coerce_isolated_input(args) || args
+            else
+              args
+            end
           end
         end
 

data/lib/graphql/subscriptions/serialize.rb

@@ -148,6 +148,8 @@ module GraphQL
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
           elsif 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)
           else
             obj
           end

data/lib/graphql/subscriptions.rb

@@ -2,7 +2,6 @@
 require "securerandom"
 require "graphql/subscriptions/broadcast_analyzer"
 require "graphql/subscriptions/event"
-require "graphql/subscriptions/instrumentation"
 require "graphql/subscriptions/serialize"
 require "graphql/subscriptions/action_cable_subscriptions"
 require "graphql/subscriptions/default_subscription_resolve_extension"
@@ -30,8 +29,6 @@ module GraphQL
         raise ArgumentError, "Can't reinstall subscriptions. #{schema} is using #{schema.subscriptions}, can't also add #{self}"
       end
 
-      instrumentation = Subscriptions::Instrumentation.new(schema: schema)
-      defn.instrument(:query, instrumentation)
       options[:schema] = schema
       schema.subscriptions = self.new(**options)
       schema.add_subscription_extension_if_necessary
@@ -62,7 +59,7 @@ module GraphQL
     # @return [void]
     def trigger(event_name, args, object, scope: nil, context: {})
       # Make something as context-like as possible, even though there isn't a current query:
-      dummy_query = GraphQL::Query.new(@schema, "", validate: false, context: context)
+      dummy_query = @schema.query_class.new(@schema, "{ __typename }", validate: false, context: context)
       context = dummy_query.context
       event_name = event_name.to_s
 
@@ -83,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)
+      normalized_args = normalize_arguments(normalized_event_name, field, args, GraphQL::Query::NullContext.instance)
 
       event = Subscriptions::Event.new(
         name: normalized_event_name,
@@ -125,10 +122,10 @@ module GraphQL
         variables: variables,
         root_value: object,
       }
-      
+
        # merge event's and query's context together
       context.merge!(event.context) unless event.context.nil? || context.nil?
-      
+
       execute_options[:validate] = validate_update?(**execute_options)
       result = @schema.execute(**execute_options)
       subscriptions_context = result.context.namespace(:subscriptions)
@@ -136,11 +133,9 @@ module GraphQL
         result = nil
       end
 
-      unsubscribed = subscriptions_context[:unsubscribed]
-
-      if unsubscribed
+      if subscriptions_context[:unsubscribed] && !subscriptions_context[:final_update]
         # `unsubscribe` was called, clean up on our side
-        # TODO also send `{more: false}` to client?
+        # The transport should also send `{more: false}` to client
         delete_subscription(subscription_id)
         result = nil
       end
@@ -164,7 +159,14 @@ module GraphQL
       res = execute_update(subscription_id, event, object)
       if !res.nil?
         deliver(subscription_id, res)
+
+        if res.context.namespace(:subscriptions)[:unsubscribed]
+          # `unsubscribe` was called, clean up on our side
+          # The transport should also send `{more: false}` to client
+          delete_subscription(subscription_id)
+        end
       end
+
     end
 
     # Event `event` occurred on `object`,
@@ -229,7 +231,7 @@ module GraphQL
 
     # @return [Boolean] if true, then a query like this one would be broadcasted
     def broadcastable?(query_str, **query_options)
-      query = GraphQL::Query.new(@schema, query_str, **query_options)
+      query = @schema.query_class.new(@schema, query_str, **query_options)
       if !query.valid?
         raise "Invalid query: #{query.validation_errors.map(&:to_h).inspect}"
       end

data/lib/graphql/testing/helpers.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+module GraphQL
+  module Testing
+    module Helpers
+      # @param schema_class [Class<GraphQL::Schema>]
+      # @return [Module] A helpers module which always uses the given schema
+      def self.for(schema_class)
+        SchemaHelpers.for(schema_class)
+      end
+
+      class Error < GraphQL::Error
+      end
+
+      class TypeNotVisibleError < Error
+        def initialize(type_name:)
+          message = "`#{type_name}` should be `visible?` this field resolution and `context`, but it was not"
+          super(message)
+        end
+      end
+
+      class FieldNotVisibleError < Error
+        def initialize(type_name:, field_name:)
+          message = "`#{type_name}.#{field_name}` should be `visible?` for this resolution, but it was not"
+          super(message)
+        end
+      end
+
+      class TypeNotDefinedError < Error
+        def initialize(type_name:)
+          message = "No type named `#{type_name}` is defined; choose another type name or define this type."
+          super(message)
+        end
+      end
+
+      class FieldNotDefinedError < Error
+        def initialize(type_name:, field_name:)
+          message = "`#{type_name}` has no field named `#{field_name}`; pick another name or define this field."
+          super(message)
+        end
+      end
+
+      def run_graphql_field(schema, field_path, object, arguments: {}, context: {})
+        type_name, *field_names = field_path.split(".")
+        dummy_query = GraphQL::Query.new(schema, context: context)
+        query_context = dummy_query.context
+        object_type = dummy_query.get_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)
+            if graphql_result.nil?
+              return nil
+            end
+            visible_field = dummy_query.get_field(object_type, field_name)
+            if visible_field
+              dummy_query.context.dataloader.run_isolated {
+                field_args = visible_field.coerce_arguments(graphql_result, arguments, query_context)
+                field_args = schema.sync_lazy(field_args)
+                graphql_result = visible_field.resolve(graphql_result, field_args.keyword_arguments, query_context)
+                graphql_result = schema.sync_lazy(graphql_result)
+              }
+              object_type = visible_field.type.unwrap
+            elsif object_type.all_field_definitions.any? { |f| f.graphql_name == field_name }
+              raise FieldNotVisibleError.new(field_name: field_name, type_name: type_name)
+            else
+              raise FieldNotDefinedError.new(type_name: type_name, field_name: field_name)
+            end
+          end
+          graphql_result
+        elsif schema.has_defined_type?(type_name)
+          raise TypeNotVisibleError.new(type_name: type_name)
+        else
+          raise TypeNotDefinedError.new(type_name: type_name)
+        end
+      end
+
+      def with_resolution_context(schema, type:, object:, context:{})
+        resolution_context = ResolutionAssertionContext.new(
+          self,
+          schema: schema,
+          type_name: type,
+          object: object,
+          context: context
+        )
+        yield(resolution_context)
+      end
+
+      class ResolutionAssertionContext
+        def initialize(test, type_name:, object:, schema:, context:)
+          @test = test
+          @type_name = type_name
+          @object = object
+          @schema = schema
+          @context = context
+        end
+
+
+        def run_graphql_field(field_name, arguments: {})
+          if @schema
+            @test.run_graphql_field(@schema, "#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+          else
+            @test.run_graphql_field("#{@type_name}.#{field_name}", @object, arguments: arguments, context: @context)
+          end
+        end
+      end
+
+      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)
+        end
+
+        def with_resolution_context(*args, **kwargs, &block)
+          # schema will be added later
+          super(nil, *args, **kwargs, &block)
+        end
+
+        def self.for(schema_class)
+          Module.new do
+            include SchemaHelpers
+            @@schema_class_for_helpers = schema_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/testing.rb

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

data/lib/graphql/tracing/appoptics_trace.rb

@@ -195,7 +195,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -226,7 +226,7 @@ module GraphQL
       end
 
       def graphql_multiplex(data)
-        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
         multiplex_transaction_name(names) if names.size > 1
 
         [:Operations, names.join(', ')]

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -117,7 +117,7 @@ module GraphQL
           else
             [key, data[key]]
           end
-        end.flatten(2).each_slice(2).to_h.merge(Spec: 'graphql')
+        end.tap { _1.flatten!(2) }.each_slice(2).to_h.merge(Spec: 'graphql')
       end
       # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
@@ -148,7 +148,7 @@ module GraphQL
       end
 
       def graphql_multiplex(data)
-        names = data.queries.map(&:operations).map(&:keys).flatten.compact
+        names = data.queries.map(&:operations).map!(&:keys).tap(&:flatten!).tap(&:compact!)
         multiplex_transaction_name(names) if names.size > 1
 
         [:Operations, names.join(', ')]

data/lib/graphql/tracing/legacy_hooks_trace.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+module GraphQL
+  module Tracing
+    module LegacyHooksTrace
+      def execute_multiplex(multiplex:)
+        multiplex_instrumenters = multiplex.schema.instrumenters[:multiplex]
+        query_instrumenters = multiplex.schema.instrumenters[:query]
+        # First, run multiplex instrumentation, then query instrumentation for each query
+        RunHooks.call_hooks(multiplex_instrumenters, multiplex, :before_multiplex, :after_multiplex) do
+          RunHooks.each_query_call_hooks(query_instrumenters, multiplex.queries) do
+            super
+          end
+        end
+      end
+
+      module RunHooks
+        module_function
+        # Call the before_ hooks of each query,
+        # Then yield if no errors.
+        # `call_hooks` takes care of appropriate cleanup.
+        def each_query_call_hooks(instrumenters, queries, i = 0)
+          if i >= queries.length
+            yield
+          else
+            query = queries[i]
+            call_hooks(instrumenters, query, :before_query, :after_query) {
+              each_query_call_hooks(instrumenters, queries, i + 1) {
+                yield
+              }
+            }
+          end
+        end
+
+        # Call each before hook, and if they all succeed, yield.
+        # If they don't all succeed, call after_ for each one that succeeded.
+        def call_hooks(instrumenters, object, before_hook_name, after_hook_name)
+          begin
+            successful = []
+            instrumenters.each do |instrumenter|
+              instrumenter.public_send(before_hook_name, object)
+              successful << instrumenter
+            end
+
+            # if any before hooks raise an exception, quit calling before hooks,
+            # but call the after hooks on anything that succeeded but also
+            # raise the exception that came from the before hook.
+          rescue GraphQL::ExecutionError => err
+            object.context.errors << err
+          rescue => e
+            raise call_after_hooks(successful, object, after_hook_name, e)
+          end
+
+          begin
+            yield # Call the user code
+          ensure
+            ex = call_after_hooks(successful, object, after_hook_name, nil)
+            raise ex if ex
+          end
+        end
+
+        def call_after_hooks(instrumenters, object, after_hook_name, ex)
+          instrumenters.reverse_each do |instrumenter|
+            begin
+              instrumenter.public_send(after_hook_name, object)
+            rescue => e
+              ex = e
+            end
+          end
+          ex
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/platform_tracing.rb

@@ -81,8 +81,10 @@ module GraphQL
           trace_name = tracing_name.sub("Tracing", "Trace")
           if GraphQL::Tracing.const_defined?(trace_name, false)
             trace_module = GraphQL::Tracing.const_get(trace_name)
+            warn("`use(#{self.name})` is deprecated, use the equivalent `trace_with(#{trace_module.name})` instead. More info: https://graphql-ruby.org/queries/tracing.html")
             schema_defn.trace_with(trace_module, **options)
           else
+            warn("`use(#{self.name})` and `Tracing::PlatformTracing` are deprecated. Use a `trace_with(...)` module instead. More info: https://graphql-ruby.org/queries/tracing.html. Please open an issue on the GraphQL-Ruby repo if you want to discuss further!")
             tracer = self.new(**options)
             schema_defn.tracer(tracer)
           end

data/lib/graphql/tracing/{prometheus_tracing → prometheus_trace}/graphql_collector.rb

@@ -2,7 +2,7 @@
 
 module GraphQL
   module Tracing
-    class PrometheusTracing < PlatformTracing
+    module PrometheusTrace
       class GraphQLCollector < ::PrometheusExporter::Server::TypeCollector
         def initialize
           @graphql_gauge = PrometheusExporter::Metric::Base.default_aggregation.new(
@@ -28,5 +28,7 @@ module GraphQL
         end
       end
     end
+    # Backwards-compat:
+    PrometheusTracing::GraphQLCollector = PrometheusTrace::GraphQLCollector
   end
 end

data/lib/graphql/tracing/sentry_trace.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    module SentryTrace
+      include PlatformTrace
+
+      # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
+      #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
+      #   It can also be specified per-query with `context[:set_sentry_transaction_name]`.
+      def initialize(set_transaction_name: false, **_rest)
+        @set_transaction_name = set_transaction_name
+        super
+      end
+      
+      def execute_query(**data)
+        set_this_txn_name = data[:query].context[:set_sentry_transaction_name]
+        if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
+          Sentry.configure_scope do |scope|
+            scope.set_transaction_name(transaction_name(data[:query]))
+          end
+        end
+        instrument_execution("graphql.execute", "execute_query", data) { super }
+      end
+
+      {
+        "lex" => "graphql.lex",
+        "parse" => "graphql.parse",
+        "validate" => "graphql.validate",
+        "analyze_query" => "graphql.analyze",
+        "analyze_multiplex" => "graphql.analyze_multiplex",
+        "execute_multiplex" => "graphql.execute_multiplex",
+        "execute_query_lazy" => "graphql.execute"
+      }.each do |trace_method, platform_key|
+        module_eval <<-RUBY, __FILE__, __LINE__
+        def #{trace_method}(**data)
+          instrument_execution("#{platform_key}", "#{trace_method}", data) { super }
+        end
+        RUBY
+      end
+
+      def platform_execute_field(platform_key, &block)
+        instrument_execution(platform_key, "execute_field", &block)
+      end
+
+      def platform_execute_field_lazy(platform_key, &block)
+        instrument_execution(platform_key, "execute_field_lazy", &block)
+      end
+
+      def platform_authorized(platform_key, &block)
+        instrument_execution(platform_key, "authorized", &block)
+      end
+
+      def platform_authorized_lazy(platform_key, &block)
+        instrument_execution(platform_key, "authorized_lazy", &block)
+      end
+
+      def platform_resolve_type(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type", &block)
+      end
+
+      def platform_resolve_type_lazy(platform_key, &block)
+        instrument_execution(platform_key, "resolve_type_lazy", &block)
+      end
+
+      def platform_field_key(field)
+        "graphql.field.#{field.path}"
+      end
+
+      def platform_authorized_key(type)
+        "graphql.authorized.#{type.graphql_name}"
+      end
+
+      def platform_resolve_type_key(type)
+        "graphql.resolve_type.#{type.graphql_name}"
+      end
+
+      private
+
+      def instrument_execution(platform_key, trace_method, data=nil, &block)
+        return yield unless Sentry.initialized?
+
+        Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|
+          result = yield
+          return result unless span
+
+          span.finish
+          if trace_method == "execute_multiplex" && data.key?(:multiplex)
+            operation_names = data[:multiplex].queries.map{|q| operation_name(q) }
+            span.set_description(operation_names.join(", "))
+          elsif trace_method == "execute_query" && data.key?(:query)
+            span.set_description(operation_name(data[:query]))
+            span.set_data('graphql.document', data[:query].query_string)
+            span.set_data('graphql.operation.name', data[:query].selected_operation_name) if data[:query].selected_operation_name
+            span.set_data('graphql.operation.type', data[:query].selected_operation.operation_type)
+          end
+
+          result
+        end
+      end
+
+      def operation_name(query)
+        selected_op = query.selected_operation
+        if selected_op
+          [selected_op.operation_type, selected_op.name].compact.join(' ')
+        else
+          'GraphQL Operation'
+        end
+      end
+    end
+  end
+end

data/lib/graphql/tracing/trace.rb

@@ -15,6 +15,7 @@ module GraphQL
         @query = query
       end
 
+      # The Ruby parser doesn't call this method (`graphql/c_parser` does.)
       def lex(query_string:)
         yield
       end

data/lib/graphql/tracing.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require "graphql/tracing/trace"
 require "graphql/tracing/legacy_trace"
+require "graphql/tracing/legacy_hooks_trace"
 
 # Legacy tracing:
 require "graphql/tracing/active_support_notifications_tracing"
@@ -21,11 +22,12 @@ require "graphql/tracing/appsignal_trace"
 require "graphql/tracing/data_dog_trace"
 require "graphql/tracing/new_relic_trace"
 require "graphql/tracing/notifications_trace"
+require "graphql/tracing/sentry_trace"
 require "graphql/tracing/scout_trace"
 require "graphql/tracing/statsd_trace"
 require "graphql/tracing/prometheus_trace"
 if defined?(PrometheusExporter::Server)
-  require "graphql/tracing/prometheus_tracing/graphql_collector"
+  require "graphql/tracing/prometheus_trace/graphql_collector"
 end
 
 module GraphQL