graphql 1.13.24 → 2.5.11

data/lib/graphql/tracing/trace.rb

@@ -0,0 +1,186 @@
+# 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.
+    # "Trace modes" are subclasses of this with custom tracing modules mixed in.
+    #
+    # A trace module may implement any of the methods on `Trace`, being sure to call `super`
+    # to continue any tracing hooks and call the actual runtime behavior.
+    #
+    class Trace
+      # @param multiplex [GraphQL::Execution::Multiplex, nil]
+      # @param query [GraphQL::Query, nil]
+      def initialize(multiplex: nil, query: nil, **_options)
+        @multiplex = multiplex
+        @query = query
+      end
+
+      # The Ruby parser doesn't call this method (`graphql/c_parser` does.)
+      def lex(query_string:)
+        yield
+      end
+
+      # @param query_string [String]
+      # @return [void]
+      def parse(query_string:)
+        yield
+      end
+
+      def validate(query:, validate:)
+        yield
+      end
+
+      def begin_validate(query, validate)
+      end
+
+      def end_validate(query, validate, errors)
+      end
+
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @param analyzers [Array<Class>]
+      # @return [void]
+      def begin_analyze_multiplex(multiplex, analyzers); end
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @param analyzers [Array<Class>]
+      # @return [void]
+      def end_analyze_multiplex(multiplex, analyzers); end
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @return [void]
+      def analyze_multiplex(multiplex:)
+        yield
+      end
+
+      def analyze_query(query:)
+        yield
+      end
+
+      # This wraps an entire `.execute` call.
+      # @param multiplex [GraphQL::Execution::Multiplex]
+      # @return [void]
+      def execute_multiplex(multiplex:)
+        yield
+      end
+
+      def execute_query(query:)
+        yield
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        yield
+      end
+
+      # GraphQL is about to resolve this field
+      # @param field [GraphQL::Schema::Field]
+      # @param object [GraphQL::Schema::Object]
+      # @param arguments [Hash]
+      # @param query [GraphQL::Query]
+      def begin_execute_field(field, object, arguments, query); end
+      # GraphQL just finished resolving this field
+      # @param field [GraphQL::Schema::Field]
+      # @param object [GraphQL::Schema::Object]
+      # @param arguments [Hash]
+      # @param query [GraphQL::Query]
+      # @param result [Object]
+      def end_execute_field(field, object, arguments, query, result); end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        yield
+      end
+
+      def authorized(query:, type:, object:)
+        yield
+      end
+
+      # A call to `.authorized?` is starting
+      # @param type [Class<GraphQL::Schema::Object>]
+      # @param object [Object]
+      # @param context [GraphQL::Query::Context]
+      # @return [void]
+      def begin_authorized(type, object, context)
+      end
+      # A call to `.authorized?` just finished
+      # @param type [Class<GraphQL::Schema::Object>]
+      # @param object [Object]
+      # @param context [GraphQL::Query::Context]
+      # @param authorized_result [Boolean]
+      # @return [void]
+      def end_authorized(type, object, context, authorized_result)
+      end
+
+      def authorized_lazy(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type(query:, type:, object:)
+        yield
+      end
+
+      def resolve_type_lazy(query:, type:, object:)
+        yield
+      end
+
+      # A call to `.resolve_type` is starting
+      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param value [Object]
+      # @param context [GraphQL::Query::Context]
+      # @return [void]
+      def begin_resolve_type(type, value, context)
+      end
+
+      # A call to `.resolve_type` just ended
+      # @param type [Class<GraphQL::Schema::Union>, Module<GraphQL::Schema::Interface>]
+      # @param value [Object]
+      # @param context [GraphQL::Query::Context]
+      # @param resolved_type [Class<GraphQL::Schema::Object>]
+      # @return [void]
+      def end_resolve_type(type, value, context, resolved_type)
+      end
+
+      # A dataloader run is starting
+      # @param dataloader [GraphQL::Dataloader]
+      # @return [void]
+      def begin_dataloader(dataloader); end
+      # A dataloader run has ended
+      # @param dataloder [GraphQL::Dataloader]
+      # @return [void]
+      def end_dataloader(dataloader); end
+
+      # A source with pending keys is about to fetch
+      # @param source [GraphQL::Dataloader::Source]
+      # @return [void]
+      def begin_dataloader_source(source); end
+      # A fetch call has just ended
+      # @param source [GraphQL::Dataloader::Source]
+      # @return [void]
+      def end_dataloader_source(source); end
+
+      # Called when Dataloader spins up a new fiber for GraphQL execution
+      # @param jobs [Array<#call>] Execution steps to run
+      # @return [void]
+      def dataloader_spawn_execution_fiber(jobs); end
+      # Called when Dataloader spins up a new fiber for fetching data
+      # @param pending_sources [GraphQL::Dataloader::Source] Instances with pending keys
+      # @return [void]
+      def dataloader_spawn_source_fiber(pending_sources); end
+      # Called when an execution or source fiber terminates
+      # @return [void]
+      def dataloader_fiber_exit; end
+
+      # Called when a Dataloader fiber is paused to wait for data
+      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call initiated this `yield`
+      # @return [void]
+      def dataloader_fiber_yield(source); end
+      # Called when a Dataloader fiber is resumed because data has been loaded
+      # @param source [GraphQL::Dataloader::Source] The Source whose `load` call previously caused this Fiber to wait
+      # @return [void]
+      def dataloader_fiber_resume(source); end
+    end
+  end
+end

data/lib/graphql/tracing.rb

@@ -1,60 +1,40 @@
 # frozen_string_literal: true
-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/skylight_tracing"
-require "graphql/tracing/statsd_tracing"
-require "graphql/tracing/prometheus_tracing"
 
-if defined?(PrometheusExporter::Server)
-  require "graphql/tracing/prometheus_tracing/graphql_collector"
-end
 
 module GraphQL
-  # Library entry point for performance metric reporting.
-  #
-  # @example Sending custom events
-  #   query.trace("my_custom_event", { ... }) do
-  #     # do stuff ...
-  #   end
-  #
-  # @example Adding a tracer to a schema
-  #  class MySchema < GraphQL::Schema
-  #    tracer MyTracer # <= responds to .trace(key, data, &block)
-  #  end
-  #
-  # @example Adding a tracer to a single query
-  #   MySchema.execute(query_str, context: { backtrace: true })
-  #
-  # Events:
-  #
-  # Key | Metadata
-  # ----|---------
-  # lex | `{ query_string: String }`
-  # parse | `{ query_string: String }`
-  # validate | `{ query: GraphQL::Query, validate: Boolean }`
-  # analyze_multiplex |  `{ multiplex: GraphQL::Execution::Multiplex }`
-  # analyze_query | `{ query: GraphQL::Query }`
-  # execute_multiplex | `{ multiplex: GraphQL::Execution::Multiplex }`
-  # execute_query | `{ query: GraphQL::Query }`
-  # execute_query_lazy | `{ query: GraphQL::Query?, multiplex: GraphQL::Execution::Multiplex? }`
-  # execute_field | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
-  # execute_field_lazy | `{ owner: Class, field: GraphQL::Schema::Field, query: GraphQL::Query, path: Array<String, Integer>, ast_node: GraphQL::Language::Nodes::Field}`
-  # authorized | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
-  # authorized_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
-  # resolve_type | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
-  # resolve_type_lazy | `{ context: GraphQL::Query::Context, type: Class, object: Object, path: Array<String, Integer> }`
-  #
-  # Note that `execute_field` and `execute_field_lazy` receive different data in different settings:
-  #
-  # - When using {GraphQL::Execution::Interpreter}, they receive `{field:, path:, query:}`
-  # - Otherwise, they receive `{context: ...}`
-  #
   module Tracing
+    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 :MonitorTrace, "graphql/tracing/monitor_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"
+    autoload :PerfettoTrace, "graphql/tracing/perfetto_trace"
+    autoload :DetailedTrace, "graphql/tracing/detailed_trace"
+
     # Objects may include traceable to gain a `.trace(...)` method.
     # The object must have a `@tracers` ivar of type `Array<<#trace(k, d, &b)>>`.
     # @api private

data/lib/graphql/type_kinds.rb

@@ -5,17 +5,19 @@ module GraphQL
     # These objects are singletons, eg `GraphQL::TypeKinds::UNION`, `GraphQL::TypeKinds::SCALAR`.
     class TypeKind
       attr_reader :name, :description
-      def initialize(name, abstract: false, fields: false, wraps: false, input: false, description: nil)
+      def initialize(name, abstract: false, leaf: false, fields: false, wraps: false, input: false, description: nil)
         @name = name
         @abstract = abstract
         @fields = fields
         @wraps = wraps
         @input = input
+        @leaf = leaf
         @composite = fields? || abstract?
         @description = description
+        freeze
       end
 
-      # Does this TypeKind have multiple possible implementors?
+      # Does this TypeKind have multiple possible implementers?
       # @deprecated Use `abstract?` instead of `resolves?`.
       def resolves?;  @abstract;  end
       # Is this TypeKind abstract?
@@ -27,6 +29,8 @@ module GraphQL
       # Is this TypeKind a valid query input?
       def input?;     @input;     end
       def to_s;       @name;      end
+      # Is this TypeKind a primitive value?
+      def leaf?; @leaf; end
       # Is this TypeKind composed of many values?
       def composite?; @composite; end
 
@@ -64,11 +68,11 @@ module GraphQL
     end
 
     TYPE_KINDS = [
-      SCALAR =        TypeKind.new("SCALAR", input: true, description: 'Indicates this type is a scalar.'),
+      SCALAR =        TypeKind.new("SCALAR", input: true, leaf: true, description: 'Indicates this type is a scalar.'),
       OBJECT =        TypeKind.new("OBJECT", fields: true, description: 'Indicates this type is an object. `fields` and `interfaces` are valid fields.'),
       INTERFACE =     TypeKind.new("INTERFACE", abstract: true, fields: true, description: 'Indicates this type is an interface. `fields` and `possibleTypes` are valid fields.'),
       UNION =         TypeKind.new("UNION", abstract: true, description: 'Indicates this type is a union. `possibleTypes` is a valid field.'),
-      ENUM =          TypeKind.new("ENUM", input: true, description: 'Indicates this type is an enum. `enumValues` is a valid field.'),
+      ENUM =          TypeKind.new("ENUM", input: true, leaf: true, description: 'Indicates this type is an enum. `enumValues` is a valid field.'),
       INPUT_OBJECT =  TypeKind.new("INPUT_OBJECT", input: true, description: 'Indicates this type is an input object. `inputFields` is a valid field.'),
       LIST =          TypeKind.new("LIST", wraps: true, description: 'Indicates this type is a list. `ofType` is a valid field.'),
       NON_NULL =      TypeKind.new("NON_NULL", wraps: true, description: 'Indicates this type is a non-null. `ofType` is a valid field.'),

data/lib/graphql/types/iso_8601_date.rb

@@ -14,6 +14,7 @@ module GraphQL
     # own Date type.
     class ISO8601Date < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded date"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
       # @param value [Date,Time,DateTime,String]
       # @return [String]
@@ -22,7 +23,7 @@ module GraphQL
       end
 
       # @param str_value [String, Date, DateTime, Time]
-      # @return [Date]
+      # @return [Date, nil]
       def self.coerce_input(value, ctx)
         if value.is_a?(::Date)
           value
@@ -30,6 +31,8 @@ module GraphQL
           value.to_date
         elsif value.is_a?(::Time)
           value.to_date
+        elsif value.nil?
+          nil
         else
           Date.iso8601(value)
         end

data/lib/graphql/types/iso_8601_date_time.rb

@@ -17,6 +17,7 @@ module GraphQL
     # own DateTime type.
     class ISO8601DateTime < GraphQL::Schema::Scalar
       description "An ISO 8601-encoded datetime"
+      specified_by_url "https://tools.ietf.org/html/rfc3339"
 
       # It's not compatible with Rails' default,
       # i.e. ActiveSupport::JSON::Encoder.time_precision (3 by default)
@@ -59,6 +60,9 @@ module GraphQL
           # But without this, it would zero out given any time part of `str_value` (hours and/or minutes)
           if dt.iso8601.start_with?(str_value)
             dt
+          elsif str_value.length == 8 && str_value.match?(/\A\d{8}\Z/)
+            # Allow dates that are missing the "-". eg. "20220404"
+            dt
           else
             nil
           end

data/lib/graphql/types/iso_8601_duration.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module GraphQL
+  module Types
+    # This scalar takes `Duration`s and transmits them as strings,
+    # using ISO 8601 format. ActiveSupport >= 5.0 must be loaded to use
+    # this scalar.
+    #
+    # Use it for fields or arguments as follows:
+    #
+    #     field :age, GraphQL::Types::ISO8601Duration, null: false
+    #
+    #     argument :interval, GraphQL::Types::ISO8601Duration, null: false
+    #
+    # Alternatively, use this built-in scalar as inspiration for your
+    # own Duration type.
+    class ISO8601Duration < GraphQL::Schema::Scalar
+      description "An ISO 8601-encoded duration"
+
+      # @return [Integer, nil]
+      def self.seconds_precision
+        # ActiveSupport::Duration precision defaults to whatever input was given
+        @seconds_precision
+      end
+
+      # @param [Integer, nil] value
+      def self.seconds_precision=(value)
+        @seconds_precision = value
+      end
+
+      # @param value [ActiveSupport::Duration, String]
+      # @return [String]
+      # @raise [GraphQL::Error] if ActiveSupport::Duration is not defined or if an incompatible object is passed
+      def self.coerce_result(value, _ctx)
+        unless defined?(ActiveSupport::Duration)
+          raise GraphQL::Error, "ActiveSupport >= 5.0 must be loaded to use the built-in ISO8601Duration type."
+        end
+
+        begin
+          case value
+          when ActiveSupport::Duration
+            value.iso8601(precision: seconds_precision)
+          when ::String
+            ActiveSupport::Duration.parse(value).iso8601(precision: seconds_precision)
+          else
+            # Try calling as ActiveSupport::Duration compatible as a fallback
+            value.iso8601(precision: seconds_precision)
+          end
+        rescue StandardError => error
+          raise GraphQL::Error, "An incompatible object (#{value.class}) was given to #{self}. Make sure that only ActiveSupport::Durations and well-formatted Strings are used with this type. (#{error.message})"
+        end
+      end
+
+      # @param value [String, ActiveSupport::Duration]
+      # @return [ActiveSupport::Duration, nil]
+      # @raise [GraphQL::Error] if ActiveSupport::Duration is not defined
+      # @raise [GraphQL::DurationEncodingError] if duration cannot be parsed
+      def self.coerce_input(value, ctx)
+        unless defined?(ActiveSupport::Duration)
+          raise GraphQL::Error, "ActiveSupport >= 5.0 must be loaded to use the built-in ISO8601Duration type."
+        end
+
+        begin
+          if value.is_a?(ActiveSupport::Duration)
+            value
+          elsif value.nil?
+            nil
+          else
+            ActiveSupport::Duration.parse(value)
+          end
+        rescue ArgumentError, TypeError
+          err = GraphQL::DurationEncodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
+      end
+    end
+  end
+end

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

@@ -10,6 +10,8 @@ module GraphQL
       # so you can extend your own `BaseObject` instead of `GraphQL::Schema::Object`.
       #
       # @example Implementation a connection and edge
+      #   class BaseObject < GraphQL::Schema::Object; end
+      #
       #   # Given some object in your app ...
       #   class Types::Post < BaseObject
       #   end
@@ -20,14 +22,22 @@ module GraphQL
       #
       #   # Then extend them for the object in your app
       #   class Types::PostEdge < Types::BaseEdge
-      #     node_type(Types::Post)
+      #     node_type Types::Post
       #   end
+      #
       #   class Types::PostConnection < Types::BaseConnection
-      #     edge_type(Types::PostEdge)
-      #     edges_nullable(true)
-      #     edge_nullable(true)
-      #     node_nullable(true)
-      #     has_nodes_field(true)
+      #     edge_type Types::PostEdge,
+      #               edges_nullable: true,
+      #               edge_nullable: true,
+      #               node_nullable: true,
+      #               nodes_field: true
+      #
+      #     # Alternatively, you can call the class methods followed by your edge type
+      #     # edges_nullable true
+      #     # edge_nullable true
+      #     # node_nullable true
+      #     # has_nodes_field true
+      #     # edge_type Types::PostEdge
       #   end
       #
       # @see Relay::BaseEdge for edge types

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

@@ -9,16 +9,44 @@ module GraphQL
 
         def self.included(child_class)
           child_class.extend(ClassMethods)
-          child_class.extend(Relay::DefaultRelay)
-          child_class.default_relay(true)
           child_class.has_nodes_field(true)
           child_class.node_nullable(true)
           child_class.edges_nullable(true)
           child_class.edge_nullable(true)
+          child_class.module_exec {
+            self.edge_type = nil
+            self.node_type = nil
+            self.edge_class = nil
+          }
+          child_class.default_broadcastable(nil)
           add_page_info_field(child_class)
         end
 
         module ClassMethods
+          def inherited(child_class)
+            super
+            child_class.has_nodes_field(has_nodes_field)
+            child_class.node_nullable(node_nullable)
+            child_class.edges_nullable(edges_nullable)
+            child_class.edge_nullable(edge_nullable)
+            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
 
@@ -36,7 +64,7 @@ module GraphQL
           # class name to set defaults. You can call it again in the class definition
           # to override the default (or provide a value, if the default lookup failed).
           # @param field_options [Hash] Any extra keyword arguments to pass to the `field :edges, ...` and `field :nodes, ...` configurations
-          def edge_type(edge_type_class, edge_class: GraphQL::Relay::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
+          def edge_type(edge_type_class, edge_class: GraphQL::Pagination::Connection::Edge, node_type: edge_type_class.node_type, nodes_field: self.has_nodes_field, node_nullable: self.node_nullable, edges_nullable: self.edges_nullable, edge_nullable: self.edge_nullable, field_options: nil)
             # Set this connection's graphql name
             node_type_name = node_type.graphql_name
 
@@ -49,7 +77,7 @@ module GraphQL
               type: [edge_type_class, null: edge_nullable],
               null: edges_nullable,
               description: "A list of edges.",
-              legacy_edge_class: edge_class, # This is used by the old runtime only, for EdgesInstrumentation
+              scope: false, # Assume that the connection was already scoped.
               connection: false,
             }
 
@@ -69,6 +97,19 @@ module GraphQL
             node_type.scope_items(items, context)
           end
 
+          # The connection will skip auth on its nodes if the node_type is configured for that
+          def reauthorize_scoped_objects(new_value = nil)
+            if new_value.nil?
+              if @reauthorize_scoped_objects != nil
+                @reauthorize_scoped_objects
+              else
+                node_type.reauthorize_scoped_objects
+              end
+            else
+              @reauthorize_scoped_objects = new_value
+            end
+          end
+
           # Add the shortcut `nodes` field to this connection and its subclasses
           def nodes_field(node_nullable: self.node_nullable, field_options: nil)
             define_nodes_field(node_nullable, field_options: field_options)
@@ -78,10 +119,6 @@ module GraphQL
             true # Let nodes be filtered out
           end
 
-          def accessible?(ctx)
-            node_type.accessible?(ctx)
-          end
-
           def visible?(ctx)
             # if this is an abstract base class, there may be no `node_type`
             node_type ? node_type.visible?(ctx) : super
@@ -127,6 +164,10 @@ module GraphQL
             end
           end
 
+          protected
+
+          attr_writer :edge_type, :node_type,  :edge_class
+
           private
 
           def define_nodes_field(nullable, field_options: nil)
@@ -136,6 +177,8 @@ module GraphQL
               null: nullable,
               description: "A list of nodes.",
               connection: false,
+              # Assume that the connection was scoped before this step:
+              scope: false,
             }
             if field_options
               base_field_options.merge!(field_options)
@@ -150,23 +193,22 @@ module GraphQL
           end
         end
 
-        # By default this calls through to the ConnectionWrapper's edge nodes method,
-        # but sometimes you need to override it to support the `nodes` field
-        def nodes
-          @object.edge_nodes
+        def edges
+          # Assume that whatever authorization needed to happen
+          # already happened at the connection level.
+          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
         end
 
-        def edges
-          if @object.is_a?(GraphQL::Pagination::Connection)
-            @object.edges
-          elsif context.interpreter?
-            context.schema.after_lazy(object.edge_nodes) do |nodes|
-              nodes.map { |n| self.class.edge_class.new(n, object) }
-            end
-          else
-            # This is done by edges_instrumentation
-            @object.edge_nodes
-          end
+        def nodes
+          # Assume that whatever authorization needed to happen
+          # already happened at the connection level.
+          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
         end
       end
     end