graphql 2.3.7 → 2.4.8

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,
@@ -137,7 +148,7 @@ module GraphQL
         end
 
         def get_arg_definition(arg_owner, arg_name, context)
-          arg_owner.get_argument(arg_name, context) || arg_owner.arguments(context).each_value.find { |v| v.keyword.to_s == arg_name }
+          context.types.argument(arg_owner, arg_name) || context.types.arguments(arg_owner).find { |v| v.keyword.to_s == arg_name }
         end
       end
     end

data/lib/graphql/subscriptions/serialize.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 require "set"
+require "ostruct"
+
 module GraphQL
   class Subscriptions
     # Serialization helpers for passing subscription data around.

data/lib/graphql/subscriptions.rb

@@ -64,12 +64,12 @@ module GraphQL
       event_name = event_name.to_s
 
       # Try with the verbatim input first:
-      field = @schema.get_field(@schema.subscription, event_name, context)
+      field = dummy_query.types.field(@schema.subscription, event_name) # rubocop:disable Development/ContextIsPassedCop
 
       if field.nil?
         # And if it wasn't found, normalize it:
         normalized_event_name = normalize_name(event_name)
-        field = @schema.get_field(@schema.subscription, normalized_event_name, context)
+        field = dummy_query.types.field(@schema.subscription, normalized_event_name) # rubocop:disable Development/ContextIsPassedCop
         if field.nil?
           raise InvalidTriggerError, "No subscription matching trigger: #{event_name} (looked for #{@schema.subscription.graphql_name}.#{normalized_event_name})"
         end
@@ -250,6 +250,8 @@ module GraphQL
     def normalize_arguments(event_name, arg_owner, args, context)
       case arg_owner
       when GraphQL::Schema::Field, Class
+        return args if args.nil?
+
         if arg_owner.is_a?(Class) && !arg_owner.kind.input_object?
           # it's a type, but not an input object
           return args
@@ -289,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)
@@ -302,7 +304,7 @@ module GraphQL
 
         normalized_args
       when GraphQL::Schema::List
-        args.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
+        args&.map { |a| normalize_arguments(event_name, arg_owner.of_type, a, context) }
       when GraphQL::Schema::NonNull
         normalize_arguments(event_name, arg_owner.of_type, args, context)
       else

data/lib/graphql/testing/helpers.rb

@@ -43,7 +43,7 @@ module GraphQL
         type_name, *field_names = field_path.split(".")
         dummy_query = GraphQL::Query.new(schema, "{ __typename }", context: context)
         query_context = dummy_query.context
-        object_type = dummy_query.get_type(type_name) # rubocop:disable Development/ContextIsPassedCop
+        object_type = dummy_query.types.type(type_name) # rubocop:disable Development/ContextIsPassedCop
         if object_type
           graphql_result = object
           field_names.each do |field_name|
@@ -52,12 +52,13 @@ module GraphQL
             if graphql_result.nil?
               return nil
             end
-            visible_field = dummy_query.get_field(object_type, field_name)
+            visible_field = dummy_query.types.field(object_type, field_name) # rubocop:disable Development/ContextIsPassedCop
             if visible_field
               dummy_query.context.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
@@ -90,10 +91,13 @@ module GraphQL
             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)
+          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
+            raise TypeNotDefinedError.new(type_name: type_name)
+          end
         end
       end
 

data/lib/graphql/tracing/active_support_notifications_trace.rb

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

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
 

data/lib/graphql/tracing/appoptics_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
 

data/lib/graphql/tracing/appsignal_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module AppsignalTrace

data/lib/graphql/tracing/appsignal_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class AppsignalTracing < PlatformTracing

data/lib/graphql/tracing/call_legacy_tracers.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module GraphQL
+  module Tracing
+    # This trace class calls legacy-style tracer with payload hashes.
+    # New-style `trace_with` modules significantly reduce the overhead of tracing,
+    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
+    module CallLegacyTracers
+      def lex(query_string:)
+        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
+      end
+
+      def parse(query_string:)
+        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
+      end
+
+      def validate(query:, validate:)
+        query.trace("validate", { validate: validate, query: query }) { super }
+      end
+
+      def analyze_multiplex(multiplex:)
+        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def analyze_query(query:)
+        query.trace("analyze_query", { query: query }) { super }
+      end
+
+      def execute_multiplex(multiplex:)
+        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
+      end
+
+      def execute_query(query:)
+        query.trace("execute_query", { query: query }) { super }
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized(query:, type:, object:)
+        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type(query:, type:, object:)
+        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
+      end
+    end
+  end
+end

data/lib/graphql/tracing/data_dog_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module DataDogTrace

data/lib/graphql/tracing/data_dog_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class DataDogTracing < PlatformTracing

data/lib/graphql/tracing/legacy_hooks_trace.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Tracing
     module LegacyHooksTrace

data/lib/graphql/tracing/legacy_trace.rb

@@ -1,67 +1,10 @@
 # frozen_string_literal: true
-module GraphQL
-  module Tracing
-    # This trace class calls legacy-style tracer with payload hashes.
-    # New-style `trace_with` modules significantly reduce the overhead of tracing,
-    # but that advantage is lost when legacy-style tracers are also used (since the payload hashes are still constructed).
-    module CallLegacyTracers
-      def lex(query_string:)
-        (@multiplex || @query).trace("lex", { query_string: query_string }) { super }
-      end
-
-      def parse(query_string:)
-        (@multiplex || @query).trace("parse", { query_string: query_string }) { super }
-      end
-
-      def validate(query:, validate:)
-        query.trace("validate", { validate: validate, query: query }) { super }
-      end
-
-      def analyze_multiplex(multiplex:)
-        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) { super }
-      end
-
-      def analyze_query(query:)
-        query.trace("analyze_query", { query: query }) { super }
-      end
-
-      def execute_multiplex(multiplex:)
-        multiplex.trace("execute_multiplex", { multiplex: multiplex }) { super }
-      end
-
-      def execute_query(query:)
-        query.trace("execute_query", { query: query }) { super }
-      end
-
-      def execute_query_lazy(query:, multiplex:)
-        multiplex.trace("execute_query_lazy", { multiplex: multiplex, query: query }) { super }
-      end
 
-      def execute_field(field:, query:, ast_node:, arguments:, object:)
-        query.trace("execute_field", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
-      end
-
-      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
-        query.trace("execute_field_lazy", { field: field, query: query, ast_node: ast_node, arguments: arguments, object: object, owner: field.owner, path: query.context[:current_path] }) { super }
-      end
-
-      def authorized(query:, type:, object:)
-        query.trace("authorized", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
-      end
-
-      def authorized_lazy(query:, type:, object:)
-        query.trace("authorized_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
-      end
-
-      def resolve_type(query:, type:, object:)
-        query.trace("resolve_type", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
-      end
-
-      def resolve_type_lazy(query:, type:, object:)
-        query.trace("resolve_type_lazy", { context: query.context, type: type, object: object, path: query.context[:current_path] }) { super }
-      end
-    end
+require "graphql/tracing/trace"
+require "graphql/tracing/call_legacy_tracers"
 
+module GraphQL
+  module Tracing
     class LegacyTrace < Trace
       include CallLegacyTracers
     end

data/lib/graphql/tracing/new_relic_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module NewRelicTrace

data/lib/graphql/tracing/new_relic_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class NewRelicTracing < PlatformTracing

data/lib/graphql/tracing/notifications_trace.rb

@@ -33,8 +33,8 @@ module GraphQL
         "resolve_type_lazy" => "resolve_type.graphql",
       }.each do |trace_method, platform_key|
         module_eval <<-RUBY, __FILE__, __LINE__
-          def #{trace_method}(**metadata, &blk)
-            @notifications_engine.instrument("#{platform_key}", metadata, &blk)
+          def #{trace_method}(**metadata, &block)
+            @notifications_engine.instrument("#{platform_key}", metadata) { super(**metadata, &block) }
           end
         RUBY
       end

data/lib/graphql/tracing/notifications_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     # This implementation forwards events to a notification handler (i.e.

data/lib/graphql/tracing/null_trace.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "graphql/tracing/trace"
+
+module GraphQL
+  module Tracing
+    NullTrace = Trace.new
+  end
+end

data/lib/graphql/tracing/prometheus_trace/graphql_collector.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing"
+
 module GraphQL
   module Tracing
     module PrometheusTrace

data/lib/graphql/tracing/prometheus_trace.rb

@@ -1,8 +1,13 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module PrometheusTrace
+      if defined?(PrometheusExporter::Server)
+        autoload :GraphQLCollector, "graphql/tracing/prometheus_trace/graphql_collector"
+      end
       include PlatformTrace
 
       def initialize(client: PrometheusExporter::Client.default, keys_whitelist: ["execute_field", "execute_field_lazy"], collector_type: "graphql", **rest)

data/lib/graphql/tracing/prometheus_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class PrometheusTracing < PlatformTracing

data/lib/graphql/tracing/scout_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module ScoutTrace

data/lib/graphql/tracing/scout_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class ScoutTracing < PlatformTracing

data/lib/graphql/tracing/sentry_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module SentryTrace

data/lib/graphql/tracing/statsd_trace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_trace"
+
 module GraphQL
   module Tracing
     module StatsdTrace

data/lib/graphql/tracing/statsd_tracing.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "graphql/tracing/platform_tracing"
+
 module GraphQL
   module Tracing
     class StatsdTracing < PlatformTracing

data/lib/graphql/tracing/trace.rb

@@ -1,4 +1,7 @@
 # frozen_string_literal: true
+
+require "graphql/tracing"
+
 module GraphQL
   module Tracing
     # This is the base class for a `trace` instance whose methods are called during query execution.

data/lib/graphql/tracing.rb

@@ -1,38 +1,36 @@
 # 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"
-require "graphql/tracing/platform_tracing"
-require "graphql/tracing/appoptics_tracing"
-require "graphql/tracing/appsignal_tracing"
-require "graphql/tracing/data_dog_tracing"
-require "graphql/tracing/new_relic_tracing"
-require "graphql/tracing/scout_tracing"
-require "graphql/tracing/statsd_tracing"
-require "graphql/tracing/prometheus_tracing"
-
-# New Tracing:
-require "graphql/tracing/active_support_notifications_trace"
-require "graphql/tracing/platform_trace"
-require "graphql/tracing/appoptics_trace"
-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_trace/graphql_collector"
-end
 
 module GraphQL
   module Tracing
-    NullTrace = Trace.new
+    autoload :Trace, "graphql/tracing/trace"
+    autoload :CallLegacyTracers, "graphql/tracing/call_legacy_tracers"
+    autoload :LegacyTrace, "graphql/tracing/legacy_trace"
+    autoload :LegacyHooksTrace, "graphql/tracing/legacy_hooks_trace"
+    autoload :NullTrace, "graphql/tracing/null_trace"
+
+    autoload :ActiveSupportNotificationsTracing, "graphql/tracing/active_support_notifications_tracing"
+    autoload :PlatformTracing, "graphql/tracing/platform_tracing"
+    autoload :AppOpticsTracing, "graphql/tracing/appoptics_tracing"
+    autoload :AppsignalTracing, "graphql/tracing/appsignal_tracing"
+    autoload :DataDogTracing, "graphql/tracing/data_dog_tracing"
+    autoload :NewRelicTracing, "graphql/tracing/new_relic_tracing"
+    autoload :NotificationsTracing, "graphql/tracing/notifications_tracing"
+    autoload :ScoutTracing, "graphql/tracing/scout_tracing"
+    autoload :StatsdTracing, "graphql/tracing/statsd_tracing"
+    autoload :PrometheusTracing, "graphql/tracing/prometheus_tracing"
+
+    autoload :ActiveSupportNotificationsTrace, "graphql/tracing/active_support_notifications_trace"
+    autoload :PlatformTrace, "graphql/tracing/platform_trace"
+    autoload :AppOpticsTrace, "graphql/tracing/appoptics_trace"
+    autoload :AppsignalTrace, "graphql/tracing/appsignal_trace"
+    autoload :DataDogTrace, "graphql/tracing/data_dog_trace"
+    autoload :NewRelicTrace, "graphql/tracing/new_relic_trace"
+    autoload :NotificationsTrace, "graphql/tracing/notifications_trace"
+    autoload :SentryTrace, "graphql/tracing/sentry_trace"
+    autoload :ScoutTrace, "graphql/tracing/scout_trace"
+    autoload :StatsdTrace, "graphql/tracing/statsd_trace"
+    autoload :PrometheusTrace, "graphql/tracing/prometheus_trace"
 
     # Objects may include traceable to gain a `.trace(...)` method.
     # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -18,6 +18,7 @@ module GraphQL
             self.node_type = nil
             self.edge_class = nil
           }
+          child_class.default_broadcastable(nil)
           add_page_info_field(child_class)
         end
 
@@ -31,12 +32,21 @@ module GraphQL
             child_class.edge_type = nil
             child_class.node_type = nil
             child_class.edge_class = nil
+            child_class.default_broadcastable(default_broadcastable?)
           end
 
           def default_relay?
             true
           end
 
+          def default_broadcastable?
+            @default_broadcastable
+          end
+
+          def default_broadcastable(new_value)
+            @default_broadcastable = new_value
+          end
+
           # @return [Class]
           attr_reader :node_type
 
@@ -186,7 +196,7 @@ module GraphQL
         def edges
           # Assume that whatever authorization needed to happen
           # already happened at the connection level.
-          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          current_runtime_state = Fiber[:__graphql_runtime_info]
           query_runtime_state = current_runtime_state[context.query]
           query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
           @object.edges
@@ -195,7 +205,7 @@ module GraphQL
         def nodes
           # Assume that whatever authorization needed to happen
           # already happened at the connection level.
-          current_runtime_state = Thread.current[:__graphql_runtime_info]
+          current_runtime_state = Fiber[:__graphql_runtime_info]
           query_runtime_state = current_runtime_state[context.query]
           query_runtime_state.was_authorized_by_scope_items = @object.was_authorized_by_scope_items?
           @object.nodes