graphql 2.5.20 → 2.5.22

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
@@ -192,9 +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, nil] Used by {Schema.execute_batching} 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, nil] Used by {Schema.execute_batching} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
-      # @param resolve_each [Symbol, nil] Used by {Schema.execute_batching} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+      # @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 `__`
@@ -217,7 +220,7 @@ module GraphQL
       # @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_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, 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)
+      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
@@ -267,23 +270,32 @@ module GraphQL
         @resolver_method = (resolver_method || name_s).to_sym
 
         if resolve_static
-          @batch_mode = :resolve_static
-          @batch_mode_key = resolve_static == true ? @method_sym : resolve_static
+          @execution_next_mode = :resolve_static
+          @execution_next_mode_key = resolve_static == true ? @method_sym : resolve_static
         elsif resolve_batch
-          @batch_mode = :resolve_batch
-          @batch_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+          @execution_next_mode = :resolve_batch
+          @execution_next_mode_key = resolve_batch == true ? @method_sym : resolve_batch
         elsif resolve_each
-          @batch_mode = :resolve_each
-          @batch_mode_key = resolve_each == true ? @method_sym : resolve_each
+          @execution_next_mode = :resolve_each
+          @execution_next_mode_key = resolve_each == true ? @method_sym : resolve_each
         elsif hash_key
-          @batch_mode = :hash_key
-          @batch_mode_key = hash_key
+          @execution_next_mode = :hash_key
+          @execution_next_mode_key = hash_key
         elsif dig
-          @batch_mode = :dig
-          @batch_mode_key = dig
+          @execution_next_mode = :dig
+          @execution_next_mode_key = dig
+        elsif resolver_class
+          @execution_next_mode = :resolver_class
+          @execution_next_mode_key = resolver_class
+        elsif resolve_legacy_instance_method
+          @execution_next_mode = :resolve_legacy_instance_method
+          @execution_next_mode_key = resolve_legacy_instance_method == true ? @method_sym : resolve_legacy_instance_method
+        elsif dataload
+          @execution_next_mode = :dataload
+          @execution_next_mode_key = dataload
         else
-          @batch_mode = :direct_send
-          @batch_mode_key = @method_sym
+          @execution_next_mode = :direct_send
+          @execution_next_mode_key = @method_sym
         end
 
         @complexity = complexity
@@ -356,49 +368,8 @@ module GraphQL
         end
       end
 
-      # Called by {Execution::Batching} to resolve this field for each of `objects`
-      # @param field_resolve_step [Execution::Batching::FieldResolveStep] an internal metadata object from execution code
-      # @param objects [Array<Object>] Objects returned from previously-executed fields
-      # @param context [GraphQL::Query::Context]
-      # @param args_hash [Hash<Symbol => Object>] Ruby-style arguments for this field
-      # @return [Array<Object>] One field result for each of `objects`; must have the same length as `objects`
-      # @see #initialize Use `resolve_static:`, `resolve_batch:`, `resolve_each:`, `hash_key:`, or `method:`
       # @api private
-      def resolve_batch(field_resolve_step, objects, context, args_hash)
-        case @batch_mode
-        when :resolve_batch
-          if args_hash.empty?
-            @owner.public_send(@batch_mode_key, objects, context)
-          else
-            @owner.public_send(@batch_mode_key, objects, context, **args_hash)
-          end
-        when :resolve_static
-          result = if args_hash.empty?
-            @owner.public_send(@batch_mode_key, context)
-          else
-            @owner.public_send(@batch_mode_key, context, **args_hash)
-          end
-          Array.new(objects.size, result)
-        when :resolve_each
-          if args_hash.empty?
-            objects.map { |o| @owner.public_send(@batch_mode_key, o, context) }
-          else
-            objects.map { |o| @owner.public_send(@batch_mode_key, o, context, **args_hash) }
-          end
-        when :hash_key
-          objects.map { |o| o[@batch_mode_key] }
-        when :direct_send
-          if args_hash.empty?
-            objects.map { |o| o.public_send(@batch_mode_key) }
-          else
-            objects.map { |o| o.public_send(@batch_mode_key, **args_hash) }
-          end
-        when :dig
-          objects.map { |o| o.dig(*@batch_mode_key) }
-        else
-          raise "Batching execution for #{path} not implemented; provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
-        end
-      end
+      attr_reader :execution_next_mode_key, :execution_next_mode
 
       # Calls the definition block, if one was given.
       # This is deferred so that references to the return type
@@ -954,6 +925,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_next(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

@@ -134,6 +134,24 @@ module GraphQL
         yield(object, arguments, nil)
       end
 
+      # Called before batch-resolving {#field}. It should either:
+      #
+      # - `yield` values to continue execution; OR
+      # - return something else to shortcut field execution.
+      #
+      # Whatever this method returns will be used for execution.
+      #
+      # @param objects [Array<Object>] The objects the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @yieldparam objects [Array<Object>] The objects to continue resolving the field on. Length must be the same as passed-in `objects:`
+      # @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 [Array<Object>] The return value for this field, length matching passed-in `objects:`.
+      def resolve_next(objects:, arguments:, context:)
+        yield(objects, arguments, nil)
+      end
+
       # Called after {#field} was resolved, and after any lazy values (like `Promise`s) were synced,
       # but before the value was added to the GraphQL response.
       #
@@ -148,6 +166,21 @@ module GraphQL
       def after_resolve(object:, arguments:, context:, value:, memo:)
         value
       end
+
+      # Called after {#field} was batch-resolved, and after any lazy values (like `Promise`s) were synced,
+      # but before the value was added to the GraphQL response.
+      #
+      # Whatever this hook returns will be used as the return value.
+      #
+      # @param objects [Array<Object>] The objects the field is being resolved on
+      # @param arguments [Hash] Ruby keyword arguments for resolving this field
+      # @param context [Query::Context] the context for this query
+      # @param values [Array<Object>] Whatever the field returned, one for each of `objects`
+      # @param memo [Object] The third value yielded by {#resolve}, or `nil` if there wasn't one
+      # @return [Array<Object>] The return values for this field, length matching `objects:`.
+      def after_resolve_next(objects:, arguments:, context:, values:, memo:)
+        values
+      end
     end
   end
 end

data/lib/graphql/schema/member/base_dsl_methods.rb

@@ -130,7 +130,7 @@ module GraphQL
           true
         end
 
-        def default_relay
+        def default_relay?
           false
         end
 

data/lib/graphql/schema/member/has_authorization.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  class Schema
+    class Member
+      module HasAuthorization
+        def self.included(child_class)
+          child_class.include(InstanceConfigured)
+        end
+
+        def self.extended(child_class)
+          child_class.extend(ClassConfigured)
+          child_class.class_exec do
+            @authorizes = false
+          end
+        end
+
+        def authorized?(object, context)
+          true
+        end
+
+        module InstanceConfigured
+          def authorizes?(context)
+            raise RequiredImplementationMissingError, "#{self.class} must implement #authorizes?(context)"
+          end
+        end
+
+        module ClassConfigured
+          def authorizes?(context)
+            method(:authorized?).owner != GraphQL::Schema::Member::HasAuthorization
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/schema/member/has_dataloader.rb

@@ -22,6 +22,14 @@ module GraphQL
 
         # A shortcut method for loading many keys from a source.
         # Identical to `dataloader.with(source_class, *source_args).load_all(load_keys)`
+        #
+        # @example
+        #   field :score, Integer, resolve_batch: true
+        #
+        #   def self.score(posts)
+        #     dataload_all(PostScoreSource, posts.map(&:id))
+        #   end
+        #
         # @param source_class [Class<GraphQL::Dataloader::Source>]
         # @param source_args [Array<Object>] Any extra parameters defined in `source_class`'s `initialize` method
         # @param load_keys [Array<Object>] The keys to look up using `def fetch`
@@ -48,6 +56,16 @@ module GraphQL
           source.load(find_by_value)
         end
 
+        # @see dataload_record Like `dataload_record`, but accepts an Array of `find_by_values`
+        def dataload_all_records(model, find_by_values, find_by: nil)
+          source = if find_by
+            dataloader.with(Dataloader::ActiveRecordSource, model, find_by: find_by)
+          else
+            dataloader.with(Dataloader::ActiveRecordSource, model)
+          end
+          source.load_all(find_by_values)
+        end
+
         # Look up an associated record using a Rails association (via {Dataloader::ActiveRecordAssociationSource})
         # @param association_name [Symbol] A `belongs_to` or `has_one` association. (If a `has_many` association is named here, it will be selected without pagination.)
         # @param record [ActiveRecord::Base] The object that the association belongs to.
@@ -65,6 +83,16 @@ module GraphQL
           end
           source.load(record)
         end
+
+        # @see dataload_association Like `dataload_assocation` but accepts an Array of records (required param)
+        def dataload_all_associations(records, association_name, scope: nil)
+          source = if scope
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name, scope)
+          else
+            dataloader.with(Dataloader::ActiveRecordAssociationSource, association_name)
+          end
+          source.load_all(records)
+        end
       end
     end
   end

data/lib/graphql/schema/member/has_fields.rb

@@ -19,10 +19,11 @@ module GraphQL
         # @option kwargs [Symbol] :method The method to call on the underlying object to resolve this field (defaults to `name`)
         # @option kwargs [String, Symbol] :hash_key The hash key to lookup on the underlying object (if its a Hash) to resolve this field (defaults to `name` or `name.to_s`)
         # @option kwargs [Array<String, Symbol>] :dig The nested hash keys to lookup on the underlying hash to resolve this field using dig
-        # @option kwargs [Symbol] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
-        # @option kwargs [Symbol] :resolve_static Used by {Schema.execute_batching} to produce a single value, shared by all objects which resolve this field. Called on the owner type class with `context, **arguments`
-        # @option kwargs [Symbol] :resolve_batch Used by {Schema.execute_batching} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
-        # @option kwargs [Symbol] :resolve_each Used by {Schema.execute_batching} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+        # @option kwargs [Symbol, true] :resolver_method The method on the type to call to resolve this field (defaults to `name`)
+        # @option kwargs [Symbol, true] :resolve_static 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`
+        # @option kwargs [Symbol, true] :resolve_batch Used by {Schema.execute_next} map `objects` to a same-sized Array of results. Called on the owner type class with `objects, context, **arguments`.
+        # @option kwargs [Symbol, true] :resolve_each Used by {Schema.execute_next} to get a value value for each item. Called on the owner type class with `object, context, **arguments`.
+        # @option kwargs [Symbol, true] :resolve_legacy_instance_method Used by {Schema.execute_next} to get a value value for each item. Calls an instance method on the object type class.
         # @option kwargs [Boolean] :connection `true` if this field should get automagic connection behavior; default is to infer by `*Connection` in the return type name
         # @option kwargs [Class] :connection_extension The extension to add, to implement connections. If `nil`, no extension is added.
         # @option kwargs [Integer, nil] :max_page_size For connections, the maximum number of items to return from this field, or `nil` to allow unlimited results.
@@ -47,6 +48,7 @@ module GraphQL
         # @option kwargs [Boolean] :dynamic_introspection (Private, used by GraphQL-Ruby)
         # @option kwargs [Boolean] :relay_node_field (Private, used by GraphQL-Ruby)
         # @option kwargs [Boolean] :relay_nodes_field (Private, used by GraphQL-Ruby)
+        # @option kwargs [Class, Hash] :dataload Shorthand for dataloader lookups
         # @option kwargs [Array<:ast_node, :parent, :lookahead, :owner, :execution_errors, :graphql_name, :argument_details, Symbol>] :extras Extra arguments to be injected into the resolver for this field
         # @param kwargs [Hash] Keywords for defining the field. Any not documented here will be passed to your base field class where they must be handled.
         # @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}.

data/lib/graphql/schema/member.rb

@@ -2,6 +2,7 @@
 require 'graphql/schema/member/base_dsl_methods'
 require 'graphql/schema/member/graphql_type_names'
 require 'graphql/schema/member/has_ast_node'
+require 'graphql/schema/member/has_authorization'
 require 'graphql/schema/member/has_dataloader'
 require 'graphql/schema/member/has_directives'
 require 'graphql/schema/member/has_deprecation_reason'
@@ -31,6 +32,10 @@ module GraphQL
       extend HasPath
       extend HasAstNode
       extend HasDirectives
+
+      def self.authorizes?(_ctx)
+        false
+      end
     end
   end
 end

data/lib/graphql/schema/object.rb

@@ -5,6 +5,7 @@ require "graphql/query/null_context"
 module GraphQL
   class Schema
     class Object < GraphQL::Schema::Member
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasFields
       extend GraphQL::Schema::Member::HasInterfaces
       include Member::HasDataloader

data/lib/graphql/schema/resolver.rb

@@ -23,6 +23,7 @@ module GraphQL
       # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
       extend GraphQL::Schema::Member::HasArguments
+      extend GraphQL::Schema::Member::HasAuthorization
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath
       extend Schema::Member::HasPath
@@ -45,6 +46,8 @@ module GraphQL
         @prepared_arguments = nil
       end
 
+      attr_accessor :exec_result, :exec_index, :field_resolve_step
+
       # @return [Object] The application object this field is being resolved on
       attr_accessor :object
 
@@ -56,6 +59,45 @@ module GraphQL
 
       attr_writer :prepared_arguments
 
+      def call
+        if self.class < Schema::HasSingleInputArgument
+          @prepared_arguments = @prepared_arguments[:input]
+        end
+        q = context.query
+        trace_objs = [object]
+        q.current_trace.begin_execute_field(field, @prepared_arguments, trace_objs, q)
+        is_authed, new_return_value = authorized?(**@prepared_arguments)
+
+        if (runner = @field_resolve_step.runner).resolves_lazies && runner.schema.lazy?(is_authed)
+          is_authed, new_return_value = runner.schema.sync_lazy(is_authed)
+        end
+
+        result = if is_authed
+          Schema::Validator.validate!(self.class.validators, object, context, @prepared_arguments, as: @field)
+          call_resolve(@prepared_arguments)
+        else
+          new_return_value
+        end
+        q = context.query
+        q.current_trace.end_execute_field(field, @prepared_arguments, trace_objs, q, [result])
+
+        exec_result[exec_index] = result
+      rescue RuntimeError => err
+        exec_result[exec_index] = err
+      rescue StandardError => stderr
+        exec_result[exec_index] = begin
+          context.query.handle_or_reraise(stderr)
+        rescue GraphQL::ExecutionError => ex_err
+          ex_err
+        end
+      ensure
+        field_pending_steps = field_resolve_step.pending_steps
+        field_pending_steps.delete(self)
+        if field_pending_steps.size == 0 && field_resolve_step.field_results
+          field_resolve_step.runner.add_step(field_resolve_step)
+        end
+      end
+
       def arguments
         @prepared_arguments || raise("Arguments have not been prepared yet, still waiting for #load_arguments to resolve. (Call `.arguments` later in the code.)")
       end

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

@@ -7,10 +7,17 @@ module GraphQL
       module HasNodeField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
+          child_class.extend(ExecutionMethods)
+        end
+
+        module ExecutionMethods
+          def get_relay_node(context, id:)
+            context.schema.object_from_id(id, context)
+          end
         end
 
         def get_relay_node(id:)
-          context.schema.object_from_id(id, context)
+          self.class.get_relay_node(context, id: id)
         end
 
         class << self
@@ -21,7 +28,8 @@ module GraphQL
               null: true,
               description: "Fetches an object given its ID.",
               relay_node_field: true,
-              resolver_method: :get_relay_node
+              resolver_method: :get_relay_node,
+              resolve_static: :get_relay_node,
             }
           end
 

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

@@ -7,10 +7,17 @@ module GraphQL
       module HasNodesField
         def self.included(child_class)
           child_class.field(**field_options, &field_block)
+          child_class.extend(ExecutionMethods)
+        end
+
+        module ExecutionMethods
+          def get_relay_nodes(context, ids:)
+            ids.map { |id| context.schema.object_from_id(id, context) }
+          end
         end
 
         def get_relay_nodes(ids:)
-          ids.map { |id| context.schema.object_from_id(id, context) }
+          self.class.get_relay_nodes(context, ids: ids)
         end
 
         class << self
@@ -21,7 +28,8 @@ module GraphQL
               null: false,
               description: "Fetches a list of objects given a list of IDs.",
               relay_nodes_field: true,
-              resolver_method: :get_relay_nodes
+              resolver_method: :get_relay_nodes,
+              resolve_static: :get_relay_nodes
             }
           end
 

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

@@ -6,12 +6,13 @@ module GraphQL
       module NodeBehaviors
         def self.included(child_module)
           child_module.extend(ClassMethods)
+          child_module.extend(ExecutionMethods)
           child_module.description("An object with an ID.")
-          child_module.field(:id, ID, null: false, description: "ID of the object.", resolver_method: :default_global_id)
+          child_module.field(:id, ID, null: false, description: "ID of the object.", resolver_method: :default_global_id, resolve_each: :default_global_id)
         end
 
         def default_global_id
-          context.schema.id_from_object(object, self.class, context)
+          self.class.default_global_id(object, context)
         end
 
         module ClassMethods
@@ -19,6 +20,16 @@ module GraphQL
             true
           end
         end
+
+        module ExecutionMethods
+          def default_global_id(object, context)
+            context.schema.id_from_object(object, self, context)
+          end
+
+          def included(child_class)
+            child_class.extend(ExecutionMethods)
+          end
+        end
       end
     end
   end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.5.20"
+  VERSION = "2.5.22"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.5.20
+  version: 2.5.22
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-02-23 00:00:00.000000000 Z
+date: 2026-03-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -491,12 +491,6 @@ files:
 - lib/graphql/dig.rb
 - lib/graphql/duration_encoding_error.rb
 - lib/graphql/execution.rb
-- lib/graphql/execution/batching.rb
-- lib/graphql/execution/batching/field_compatibility.rb
-- lib/graphql/execution/batching/field_resolve_step.rb
-- lib/graphql/execution/batching/prepare_object_step.rb
-- lib/graphql/execution/batching/runner.rb
-- lib/graphql/execution/batching/selections_step.rb
 - lib/graphql/execution/directive_checks.rb
 - lib/graphql/execution/errors.rb
 - lib/graphql/execution/interpreter.rb
@@ -512,6 +506,12 @@ files:
 - lib/graphql/execution/lazy/lazy_method_map.rb
 - lib/graphql/execution/lookahead.rb
 - lib/graphql/execution/multiplex.rb
+- lib/graphql/execution/next.rb
+- lib/graphql/execution/next/field_resolve_step.rb
+- lib/graphql/execution/next/load_argument_step.rb
+- lib/graphql/execution/next/prepare_object_step.rb
+- lib/graphql/execution/next/runner.rb
+- lib/graphql/execution/next/selections_step.rb
 - lib/graphql/execution_error.rb
 - lib/graphql/integer_decoding_error.rb
 - lib/graphql/integer_encoding_error.rb
@@ -617,6 +617,7 @@ files:
 - lib/graphql/schema/member/graphql_type_names.rb
 - lib/graphql/schema/member/has_arguments.rb
 - lib/graphql/schema/member/has_ast_node.rb
+- lib/graphql/schema/member/has_authorization.rb
 - lib/graphql/schema/member/has_dataloader.rb
 - lib/graphql/schema/member/has_deprecation_reason.rb
 - lib/graphql/schema/member/has_directives.rb
@@ -830,7 +831,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 4.0.8
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []