graphql 2.5.11 → 2.6.10

data/lib/graphql/railtie.rb

@@ -15,7 +15,8 @@ module GraphQL
     initializer("graphql.cache") do |app|
       if config.graphql.parser_cache
         Language::Parser.cache ||= Language::Cache.new(
-          app.root.join("tmp/cache/graphql")
+          app.root.join("tmp/cache/graphql"),
+          secret: app.secret_key_base
         )
       end
     end

data/lib/graphql/runtime_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module GraphQL
+  class RuntimeError < Error
+    include GraphQL::Execution::Finalizer
+  end
+end

data/lib/graphql/schema/argument.rb

@@ -4,6 +4,7 @@ module GraphQL
     class Argument
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasAuthorization
       include GraphQL::Schema::Member::HasDirectives
       include GraphQL::Schema::Member::HasDeprecationReason
       include GraphQL::Schema::Member::HasValidators
@@ -39,9 +40,14 @@ module GraphQL
       # @param arg_name [Symbol]
       # @param type_expr
       # @param desc [String]
+      # @param type [Class, Array<Class>] Input type; positional argument also accepted
+      # @param name [Symbol] positional argument also accepted        # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
+      # @param definition_block [Proc] Called with the newly-created {Argument}
+      # @param owner [Class] Private, used by GraphQL-Ruby during schema definition
       # @param required [Boolean, :nullable] if true, this argument is non-null; if false, this argument is nullable. If `:nullable`, then the argument must be provided, though it may be `null`.
       # @param description [String]
       # @param default_value [Object]
+      # @param loads [Class, Array<Class>] A GraphQL type to load for the given ID when one is present
       # @param as [Symbol] Override the keyword name when passed to a method
       # @param prepare [Symbol] A method to call to transform this argument's valuebefore sending it to field resolution
       # @param camelize [Boolean] if true, the name will be camelized when building the schema
@@ -50,6 +56,8 @@ module GraphQL
       # @param deprecation_reason [String]
       # @param validates [Hash, nil] Options for building validators, if any should be applied
       # @param replace_null_with_default [Boolean] if `true`, incoming values of `null` will be replaced with the configured `default_value`
+      # @param comment [String] Private, used by GraphQL-Ruby when parsing GraphQL schema files
+      # @param ast_node [GraphQL::Language::Nodes::InputValueDefinition] Private, used by GraphQL-Ruby when parsing schema files
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
@@ -86,7 +94,7 @@ module GraphQL
         end
 
         if required == :nullable
-          self.owner.validates(required: { argument: arg_name })
+          self.owner.validates(required: { argument: @keyword })
         end
 
         if definition_block
@@ -157,6 +165,10 @@ module GraphQL
         true
       end
 
+      def authorizes?(context)
+        self.method(:authorized?).owner != GraphQL::Schema::Argument || type.unwrap.authorizes?(context)
+      end
+
       def authorized?(obj, value, ctx)
         authorized_as_type?(obj, value, ctx, as_type: type)
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -82,6 +82,7 @@ module GraphQL
           replace_late_bound_types_with_built_in(types)
 
           schema_extensions = nil
+          definitions_by_name = nil
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
@@ -99,6 +100,23 @@ module GraphQL
               # It's possible that this was already loaded by the directives
               prev_type = types[definition.name]
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
+                if definition.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) || definition.is_a?(Language::Nodes::InterfaceTypeDefinition)
+                  interface_names = definition.interfaces.map(&:name)
+                  if !interface_names.empty?
+                    definitions_by_name ||= document.definitions.each_with_object({}) do |d, by_name|
+                      by_name[d.name] ||= d if d.respond_to?(:name)
+                    end
+                    transitive_names = interface_names.map { |n| definitions_by_name[n]&.interfaces&.map(&:name) }
+                    transitive_names.flatten!
+                    transitive_names.compact!
+                  else
+                    transitive_names = interface_names
+                  end
+                  if !(missing_transitive_interfaces = transitive_names - interface_names).empty?
+                    raise GraphQL::Schema::InvalidDocumentError, "type #{definition.name} is missing one or more transitive interface names: #{missing_transitive_interfaces.join(", ")}. Add them to the type's `implements` list and try again."
+                  end
+                end
+
                 types[definition.name] = build_definition_from_node(definition, type_resolver, default_resolve, base_types)
               end
             end
@@ -266,6 +284,8 @@ module GraphQL
             build_scalar_type(definition, type_resolver, base_types[:scalar], default_resolve: default_resolve)
           when GraphQL::Language::Nodes::InputObjectTypeDefinition
             build_input_object_type(definition, type_resolver, base_types[:input_object])
+          when GraphQL::Language::Nodes::DirectiveDefinition
+            build_directive(definition, type_resolver)
           end
         end
 
@@ -510,6 +530,7 @@ module GraphQL
               camelize: false,
               directives: prepare_directives(field_definition, type_resolver),
               resolver_method: resolve_method_name,
+              resolve_batch: resolve_method_name,
             )
 
             builder.build_arguments(schema_field_defn, field_definition.arguments, type_resolver)
@@ -526,6 +547,12 @@ module GraphQL
             field_instance = context.types.field(owner, field_name)
             context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
           }
+          owner.define_singleton_method(method_name) { |objects, context, **args|
+            field_instance = context.types.field(owner, field_name)
+            objects.map do |object|
+              context.schema.definition_default_resolve.call(self, field_instance, object, args, context)
+            end
+          }
         end
 
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
@@ -544,7 +571,7 @@ module GraphQL
             when GraphQL::Language::Nodes::ListType
               resolve_type_proc.call(ast_node.of_type).to_list_type
             when String
-              directives[ast_node]
+              directives[ast_node] ||= missing_type_handler.call(ast_node)
             else
               raise "Unexpected ast_node: #{ast_node.inspect}"
             end

data/lib/graphql/schema/directive/feature.rb

@@ -60,6 +60,10 @@ module GraphQL
         def self.enabled?(flag_name, object, context)
           raise GraphQL::RequiredImplementationMissingError, "Implement `.enabled?(flag_name, object, context)` to return true or false for the feature flag (#{flag_name.inspect})"
         end
+
+        def self.resolve_field(...); end
+        def self.resolve_fragment_spread(...); end
+        def self.resolve_inline_fragment(...); end
       end
     end
   end

data/lib/graphql/schema/directive/transform.rb

@@ -54,6 +54,26 @@ module GraphQL
             nil
           end
         end
+
+        def self.resolve_field(ast_nodes, parent_type, field_defn, objects, arguments, context)
+          transform_name = arguments[:by]
+          if TRANSFORMS.include?(transform_name)
+            Transformer.new(transform_name)
+          else
+            nil
+          end
+        end
+
+        class Transformer
+          include Execution::PostProcessor
+          def initialize(transform)
+            @transform = transform
+          end
+          def after_resolve(field_results)
+            field_results.map! { |r| r.respond_to?(@transform) ? r.public_send(@transform) : r }
+            field_results
+          end
+        end
       end
     end
   end

data/lib/graphql/schema/directive.rb

@@ -31,17 +31,25 @@ module GraphQL
 
         def locations(*new_locations)
           if !new_locations.empty?
+            is_runtime = false
             new_locations.each do |new_loc|
-              if !LOCATIONS.include?(new_loc.to_sym)
+              loc_sym = new_loc.to_sym
+              if !LOCATIONS.include?(loc_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
               end
+              is_runtime ||= RUNTIME_LOCATIONS.include?(loc_sym)
             end
             @locations = new_locations
+            @is_runtime = is_runtime
           else
             @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
           end
         end
 
+        def runtime?
+          @is_runtime
+        end
+
         def default_directive(new_default_directive = nil)
           if new_default_directive != nil
             @default_directive = new_default_directive
@@ -104,8 +112,12 @@ module GraphQL
 
         def inherited(subclass)
           super
+          parent_class = self
           subclass.class_exec do
             @default_graphql_name ||= nil
+            @locations = parent_class.locations
+            @is_runtime = parent_class.runtime?
+            @repeatable = false
           end
         end
       end
@@ -129,20 +141,41 @@ module GraphQL
         # not runtime arguments.
         context = Query::NullContext.instance
         self.class.all_argument_definitions.each do |arg_defn|
-          if arguments.key?(arg_defn.keyword)
-            value = arguments[arg_defn.keyword]
+          keyword = arg_defn.keyword
+          arg_type = arg_defn.type
+          if arguments.key?(keyword)
+            value = arguments[keyword]
             # This is a Ruby-land value; convert it to graphql for validation
             graphql_value = begin
-              arg_defn.type.unwrap.coerce_isolated_result(value)
+              coerce_value = value
+              if arg_type.list? && (!coerce_value.nil?) && (!coerce_value.is_a?(Array))
+                # When validating inputs, GraphQL accepts a single item
+                # and implicitly converts it to a one-item list.
+                # However, we're using result coercion here to go from Ruby value
+                # to GraphQL value, so it doesn't have that feature.
+                # Keep the GraphQL-type behavior but implement it manually:
+                wrap_type = arg_type
+                while wrap_type.list?
+                  if wrap_type.non_null?
+                    wrap_type = wrap_type.of_type
+                  end
+                  wrap_type = wrap_type.of_type
+                  coerce_value = [coerce_value]
+                end
+              end
+              arg_type.coerce_isolated_result(coerce_value)
             rescue GraphQL::Schema::Enum::UnresolvedValueError
               # Let validation handle this
               value
             end
+          elsif arg_defn.default_value?
+            value = arg_defn.default_value
+            graphql_value = arg_type.coerce_isolated_result(value) unless value.nil?
           else
             value = graphql_value = nil
           end
 
-          result = arg_defn.type.validate_input(graphql_value, context)
+          result = arg_type.validate_input(graphql_value, context)
           if !result.valid?
             raise InvalidArgumentError, "@#{graphql_name}.#{arg_defn.graphql_name} on #{owner.path} is invalid (#{value.inspect}): #{result.problems.first["explanation"]}"
           end
@@ -159,13 +192,16 @@ module GraphQL
       end
 
       LOCATIONS = [
-        QUERY =                  :QUERY,
-        MUTATION =               :MUTATION,
-        SUBSCRIPTION =           :SUBSCRIPTION,
-        FIELD =                  :FIELD,
-        FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-        FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-        INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+        *(RUNTIME_LOCATIONS = [
+          QUERY =                  :QUERY,
+          MUTATION =               :MUTATION,
+          SUBSCRIPTION =           :SUBSCRIPTION,
+          FIELD =                  :FIELD,
+          FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+          FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+          INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+          VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
+        ]),
         SCHEMA =                 :SCHEMA,
         SCALAR =                 :SCALAR,
         OBJECT =                 :OBJECT,
@@ -177,7 +213,6 @@ module GraphQL
         ENUM_VALUE =             :ENUM_VALUE,
         INPUT_OBJECT =           :INPUT_OBJECT,
         INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-        VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
       ]
 
       DEFAULT_DEPRECATION_REASON = 'No longer supported'

data/lib/graphql/schema/field/connection_extension.rb

@@ -12,52 +12,19 @@ module GraphQL
         end
 
         # Remove pagination args before passing it to a user method
-        def resolve(object:, arguments:, context:)
+        def resolve(object: nil, objects: nil, arguments:, context:)
           next_args = arguments.dup
           next_args.delete(:first)
           next_args.delete(:last)
           next_args.delete(:before)
           next_args.delete(:after)
-          yield(object, next_args, arguments)
+          yield(object || objects, next_args, arguments)
         end
 
         def after_resolve(value:, object:, arguments:, context:, memo:)
           original_arguments = memo
-          # rename some inputs to avoid conflicts inside the block
-          maybe_lazy = value
-          value = nil
-          context.query.after_lazy(maybe_lazy) do |resolved_value|
-            value = resolved_value
-            if value.is_a? GraphQL::ExecutionError
-              # This isn't even going to work because context doesn't have ast_node anymore
-              context.add_error(value)
-              nil
-            elsif value.nil?
-              nil
-            elsif value.is_a?(GraphQL::Pagination::Connection)
-              # update the connection with some things that may not have been provided
-              value.context ||= context
-              value.parent ||= object.object
-              value.first_value ||= original_arguments[:first]
-              value.after_value ||= original_arguments[:after]
-              value.last_value ||= original_arguments[:last]
-              value.before_value ||= original_arguments[:before]
-              value.arguments ||= original_arguments # rubocop:disable Development/ContextIsPassedCop -- unrelated .arguments method
-              value.field ||= field
-              if field.has_max_page_size? && !value.has_max_page_size_override?
-                value.max_page_size = field.max_page_size
-              end
-              if field.has_default_page_size? && !value.has_default_page_size_override?
-                value.default_page_size = field.default_page_size
-              end
-              if (custom_t = context.schema.connections.edge_class_for_field(@field))
-                value.edge_class = custom_t
-              end
-              value
-            else
-              context.namespace(:connections)[:all_wrappers] ||= context.schema.connections.all_wrappers
-              context.schema.connections.wrap(field, object.object, value, original_arguments, context)
-            end
+          context.query.after_lazy(value) do |resolved_value|
+            context.schema.connections.populate_connection(field, object.object, resolved_value, original_arguments, context)
           end
         end
       end

data/lib/graphql/schema/field/scope_extension.rb

@@ -5,22 +5,27 @@ module GraphQL
     class Field
       class ScopeExtension < GraphQL::Schema::FieldExtension
         def after_resolve(object:, arguments:, context:, value:, memo:)
-          if value.nil?
-            value
-          else
-            ret_type = @field.type.unwrap
-            if ret_type.respond_to?(:scope_items)
-              scoped_items = ret_type.scope_items(value, context)
-              if !scoped_items.equal?(value) && !ret_type.reauthorize_scoped_objects
-                if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
-                    (query_runtime_state = current_runtime_state[context.query])
-                  query_runtime_state.was_authorized_by_scope_items = true
+          if object.is_a?(GraphQL::Schema::Object)
+            if value.nil?
+              value
+            else
+              return_type = field.type.unwrap
+              if return_type.respond_to?(:scope_items)
+                scoped_items = return_type.scope_items(value, context)
+                if !scoped_items.equal?(value) && !return_type.reauthorize_scoped_objects
+                  if (current_runtime_state = Fiber[:__graphql_runtime_info]) &&
+                      (query_runtime_state = current_runtime_state[context.query])
+                    query_runtime_state.was_authorized_by_scope_items = true
+                  end
                 end
+                scoped_items
+              else
+                value
               end
-              scoped_items
-            else
-              value
             end
+          else
+            # TODO skip this entirely?
+            value
           end
         end
       end

data/lib/graphql/schema/field.rb

@@ -8,6 +8,7 @@ module GraphQL
       include GraphQL::Schema::Member::HasArguments
       include GraphQL::Schema::Member::HasArguments::FieldConfigured
       include GraphQL::Schema::Member::HasAstNode
+      include GraphQL::Schema::Member::HasAuthorization
       include GraphQL::Schema::Member::HasPath
       include GraphQL::Schema::Member::HasValidators
       extend GraphQL::Schema::FindInheritedValue
@@ -109,52 +110,6 @@ module GraphQL
       end
       attr_writer :subscription_scope
 
-      # Create a field instance from a list of arguments, keyword arguments, and a block.
-      #
-      # This method implements prioritization between the `resolver` or `mutation` defaults
-      # and the local overrides via other keywords.
-      #
-      # It also normalizes positional arguments into keywords for {Schema::Field#initialize}.
-      # @param resolver [Class] A {GraphQL::Schema::Resolver} class to use for field configuration
-      # @param mutation [Class] A {GraphQL::Schema::Mutation} class to use for field configuration
-      # @param subscription [Class] A {GraphQL::Schema::Subscription} class to use for field configuration
-      # @return [GraphQL::Schema:Field] an instance of `self`
-      # @see {.initialize} for other options
-      def self.from_options(name = nil, type = nil, desc = nil, comment: nil, resolver: nil, mutation: nil, subscription: nil,**kwargs, &block)
-        if (resolver_class = resolver || mutation || subscription)
-          # Add a reference to that parent class
-          kwargs[:resolver_class] = resolver_class
-        end
-
-        if name
-          kwargs[:name] = name
-        end
-
-        if comment
-          kwargs[:comment] = comment
-        end
-
-        if !type.nil?
-          if desc
-            if kwargs[:description]
-              raise ArgumentError, "Provide description as a positional argument or `description:` keyword, but not both (#{desc.inspect}, #{kwargs[:description].inspect})"
-            end
-
-            kwargs[:description] = desc
-            kwargs[:type] = type
-          elsif (resolver || mutation) && type.is_a?(String)
-            # The return type should be copied from the resolver, and the second positional argument is the description
-            kwargs[:description] = type
-          else
-            kwargs[:type] = type
-          end
-          if type.is_a?(Class) && type < GraphQL::Schema::Mutation
-            raise ArgumentError, "Use `field #{name.inspect}, mutation: Mutation, ...` to provide a mutation to this field instead"
-          end
-        end
-        new(**kwargs, &block)
-      end
-
       # Can be set with `connection: true|false` or inferred from a type name ending in `*Connection`
       # @return [Boolean] if true, this field will be wrapped with Relay connection behavior
       def connection?
@@ -238,6 +193,11 @@ module GraphQL
       # @param resolver_method [Symbol] The method on the type to call to resolve this field (defaults to `name`)
       # @param connection [Boolean] `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
       # @param connection_extension [Class] The extension to add, to implement connections. If `nil`, no extension is added.
+      # @param resolve_static [Symbol, true, nil] Used by {Schema.execute_next} to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
+      # @param resolve_batch [Symbol, true, nil] Used by {Schema.execute_next} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+      # @param resolve_each [Symbol, true, nil] Used by {Schema.execute_next} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+      # @param resolve_legacy_instance_method [Symbol, true, nil] Used by {Schema.execute_next} to get a value value for each item. Calls an instance method on the object type class.
+      # @param dataload [Class, Hash] Shorthand for making dataloader calls
       # @param max_page_size [Integer, nil] For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
       # @param default_page_size [Integer, nil] For connections, the default number of items to return from this field, or `nil` to return unlimited results.
       # @param introspection [Boolean] If true, this field will be marked as `#introspection?` and the name may begin with `__`
@@ -255,7 +215,12 @@ module GraphQL
       # @param method_conflict_warning [Boolean] If false, skip the warning if this field's method conflicts with a built-in method
       # @param validates [Array<Hash>] Configurations for validating this field
       # @param fallback_value [Object] A fallback value if the method is not defined
-      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, comment: NOT_CONFIGURED, deprecation_reason: nil, method: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
+      # @param dynamic_introspection [Boolean] (Private, used by GraphQL-Ruby)
+      # @param relay_node_field [Boolean] (Private, used by GraphQL-Ruby)
+      # @param relay_nodes_field [Boolean] (Private, used by GraphQL-Ruby)
+      # @param extras [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] Extra arguments to be injected into the resolver for this field
+      # @param definition_block [Proc] an additional block for configuring the field. Receive the field as a block param, or, if no block params are defined, then the block is `instance_eval`'d on the new {Field}.
+      def initialize(type: nil, name: nil, owner: nil, null: nil, description: NOT_CONFIGURED, comment: NOT_CONFIGURED, deprecation_reason: nil, method: nil, resolve_legacy_instance_method: nil, resolve_static: nil, resolve_each: nil, resolve_batch: nil, hash_key: nil, dig: nil, resolver_method: nil, connection: nil, max_page_size: NOT_CONFIGURED, default_page_size: NOT_CONFIGURED, scope: nil, introspection: false, camelize: true, trace: nil, complexity: nil, dataload: nil, ast_node: nil, extras: EMPTY_ARRAY, extensions: EMPTY_ARRAY, connection_extension: self.class.connection_extension, resolver_class: nil, subscription_scope: nil, relay_node_field: false, relay_nodes_field: false, method_conflict_warning: true, broadcastable: NOT_CONFIGURED, arguments: EMPTY_HASH, directives: EMPTY_HASH, validates: EMPTY_ARRAY, fallback_value: NOT_CONFIGURED, dynamic_introspection: false, &definition_block)
         if name.nil?
           raise ArgumentError, "missing first `name` argument or keyword `name:`"
         end
@@ -303,6 +268,36 @@ module GraphQL
         @method_str = -method_name.to_s
         @method_sym = method_name.to_sym
         @resolver_method = (resolver_method || name_s).to_sym
+
+        if resolve_static
+          @execution_mode = :resolve_static
+          @execution_mode_key = resolve_static == true ? @method_sym : resolve_static
+        elsif resolve_batch
+          @execution_mode = :resolve_batch
+          @execution_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+        elsif resolve_each
+          @execution_mode = :resolve_each
+          @execution_mode_key = resolve_each == true ? @method_sym : resolve_each
+        elsif hash_key
+          @execution_mode = :hash_key
+          @execution_mode_key = hash_key
+        elsif dig
+          @execution_mode = :dig
+          @execution_mode_key = dig
+        elsif resolver_class
+          @execution_mode = :resolver_class
+          @execution_mode_key = resolver_class
+        elsif resolve_legacy_instance_method
+          @execution_mode = :resolve_legacy_instance_method
+          @execution_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
+        elsif dataload
+          @execution_mode = :dataload
+          @execution_mode_key = dataload
+        else
+          @execution_mode = :direct_send
+          @execution_mode_key = @method_sym
+        end
+
         @complexity = complexity
         @dynamic_introspection = dynamic_introspection
         @return_type_expr = type
@@ -347,7 +342,7 @@ module GraphQL
 
         @extensions = EMPTY_ARRAY
         @call_after_define = false
-        set_pagination_extensions(connection_extension: connection_extension)
+        set_pagination_extensions(connection_extension: NOT_CONFIGURED.equal?(connection_extension) ? self.class.connection_extension : connection_extension)
         # Do this last so we have as much context as possible when initializing them:
         if !extensions.empty?
           self.extensions(extensions)
@@ -373,6 +368,9 @@ module GraphQL
         end
       end
 
+      # @api private
+      attr_reader :execution_mode_key, :execution_mode
+
       # Calls the definition block, if one was given.
       # This is deferred so that references to the return type
       # can be lazily evaluated, reducing Rails boot time.
@@ -666,6 +664,12 @@ module GraphQL
         end
       end
 
+      def authorizes?(context)
+        method(:authorized?).owner != GraphQL::Schema::Field ||
+          ((args = context.types.arguments(self)) && (args.any? { |a| a.authorizes?(context) })) ||
+          (@resolver_class&.authorizes?(context)) || false
+      end
+
       def authorized?(object, args, context)
         if @resolver_class
           # The resolver _instance_ will check itself during `resolve()`
@@ -920,6 +924,33 @@ ERR
         end
       end
 
+      public
+
+      def run_next_extensions_before_resolve(objs, args, ctx, extended, idx: 0, &block)
+        extension = @extensions[idx]
+        if extension
+          extension.resolve(objects: objs, arguments: args, context: ctx) do |extended_objs, extended_args, memo|
+            if memo
+              memos = extended.memos ||= {}
+              memos[idx] = memo
+            end
+
+            if (extras = extension.added_extras)
+              ae = extended.added_extras ||= []
+              ae.concat(extras)
+            end
+
+            extended.object = extended_objs
+            extended.arguments = extended_args
+            run_next_extensions_before_resolve(extended_objs, extended_args, ctx, extended, idx: idx + 1, &block)
+          end
+        else
+          yield(objs, args)
+        end
+      end
+
+      private
+
       def run_extensions_before_resolve(obj, args, ctx, extended, idx: 0)
         extension = @extensions[idx]
         if extension

data/lib/graphql/schema/field_extension.rb

@@ -123,15 +123,16 @@ module GraphQL
       #
       # Whatever this method returns will be used for execution.
       #
-      # @param object [Object] The object the field is being resolved on
+      # @param object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The objects the field is being resolved on (passed by new execution)
       # @param arguments [Hash] Ruby keyword arguments for resolving this field
       # @param context [Query::Context] the context for this query
-      # @yieldparam object [Object] The object to continue resolving the field on
+      # @yieldparam object_or_objects [Object, Array<Object>] The object or objects (new execution) to continue resolving the field on
       # @yieldparam arguments [Hash] The keyword arguments to continue resolving with
       # @yieldparam memo [Object] Any extension-specific value which will be passed to {#after_resolve} later
       # @return [Object] The return value for this field.
-      def resolve(object:, arguments:, context:)
-        yield(object, arguments, nil)
+      def resolve(object: nil, objects: nil, arguments:, context:)
+        yield(object.nil? ? objects : object, arguments, nil)
       end
 
       # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
@@ -139,14 +140,16 @@ module GraphQL
       #
       # Whatever this hook returns will be used as the return value.
       #
-      # @param object [Object] The object the field is being resolved on
+      # @param object [Object] The object the field is being resolved on (not passed by new execution)
+      # @param objects [Array<Object>] The object the field is being resolved on (passed by new execution)
       # @param arguments [Hash] Ruby keyword arguments for resolving this field
       # @param context [Query::Context] the context for this query
-      # @param value [Object] Whatever the field previously returned
+      # @param value [Object] Whatever the field previously returned (not passed by new execution)
+      # @param values [Array<Object>] Whatever the field previously returned (passed by new execution)
       # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
       # @return [Object] The return value for this field.
-      def after_resolve(object:, arguments:, context:, value:, memo:)
-        value
+      def after_resolve(object: nil, objects: nil, arguments:, context:, values: nil, value: nil, memo:)
+        value.nil? ? values : value
       end
     end
   end