graphql 2.5.14 → 2.5.22

data/lib/graphql/schema/build_from_definition.rb

@@ -512,6 +512,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)
@@ -528,6 +529,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)

data/lib/graphql/schema/directive.rb

@@ -142,7 +142,14 @@ module GraphQL
                 # 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:
-                coerce_value = [coerce_value]
+                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

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

@@ -21,45 +21,25 @@ module GraphQL
           yield(object, next_args, arguments)
         end
 
+        def resolve_next(objects:, arguments:, context:)
+          next_args = arguments.dup
+          next_args.delete(:first)
+          next_args.delete(:last)
+          next_args.delete(:before)
+          next_args.delete(:after)
+          yield(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
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       end
     end
   end

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

@@ -5,24 +5,33 @@ 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
+
+        def after_resolve_next(**kwargs)
+          raise "This should never be called -- it's hardcoded in execution instead."
+        end
       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_next_mode = :resolve_static
+          @execution_next_mode_key = resolve_static == true ? @method_sym : resolve_static
+        elsif resolve_batch
+          @execution_next_mode = :resolve_batch
+          @execution_next_mode_key = resolve_batch == true ? @method_sym : resolve_batch
+        elsif resolve_each
+          @execution_next_mode = :resolve_each
+          @execution_next_mode_key = resolve_each == true ? @method_sym : resolve_each
+        elsif hash_key
+          @execution_next_mode = :hash_key
+          @execution_next_mode_key = hash_key
+        elsif 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
+          @execution_next_mode = :direct_send
+          @execution_next_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_next_mode_key, :execution_next_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,13 @@ module GraphQL
         end
       end
 
+      def authorizes?(context)
+        method(:authorized?).owner != GraphQL::Schema::Field || (
+          (args = context.types.arguments(self)) &&
+            (args.any? { |a| a.authorizes?(context) })
+        )
+      end
+
       def authorized?(object, args, context)
         if @resolver_class
           # The resolver _instance_ will check itself during `resolve()`
@@ -920,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_arguments.rb

@@ -14,29 +14,52 @@ module GraphQL
           cls.extend(ClassConfigured)
         end
 
-        # @see {GraphQL::Schema::Argument#initialize} for parameters
-        # @return [GraphQL::Schema::Argument] An instance of {argument_class}, created from `*args`
-        def argument(*args, **kwargs, &block)
-          kwargs[:owner] = self
-          loads = kwargs[:loads]
-          if loads
-            name = args[0]
-            name_as_string = name.to_s
-
-            inferred_arg_name = case name_as_string
+        # @param arg_name [Symbol] The underscore-cased name of this argument, `name:` keyword also accepted
+        # @param type_expr The GraphQL type of this argument; `type:` keyword also accepted
+        # @param desc [String] Argument description, `description:` keyword also accepted
+        # @option kwargs [Boolean, :nullable] :required 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`.
+        # @option kwargs [String] :description Positional argument also accepted
+        # @option kwargs [Class, Array<Class>] :type Input type; positional argument also accepted
+        # @option kwargs [Symbol] :name positional argument also accepted
+        # @option kwargs [Object] :default_value
+        # @option kwargs [Class, Array<Class>] :loads A GraphQL type to load for the given ID when one is present
+        # @option kwargs [Symbol] :as Override the keyword name when passed to a method
+        # @option kwargs [Symbol] :prepare A method to call to transform this argument's valuebefore sending it to field resolution
+        # @option kwargs [Boolean] :camelize if true, the name will be camelized when building the schema
+        # @option kwargs [Boolean] :from_resolver if true, a Resolver class defined this argument
+        # @option kwargs [Hash{Class => Hash}] :directives
+        # @option kwargs [String] :deprecation_reason
+        # @option kwargs [String] :comment Private, used by GraphQL-Ruby when parsing GraphQL schema files
+        # @option kwargs [GraphQL::Language::Nodes::InputValueDefinition] :ast_node Private, used by GraphQL-Ruby when parsing schema files
+        # @option kwargs [Hash, nil] :validates Options for building validators, if any should be applied
+        # @option kwargs [Boolean] :replace_null_with_default if `true`, incoming values of `null` will be replaced with the configured `default_value`
+        # @param definition_block [Proc] Called with the newly-created {Argument}
+        # @param kwargs [Hash] Keywords for defining an argument. Any keywords not documented here must be handled by your base Argument class.
+        # @return [GraphQL::Schema::Argument] An instance of {argument_class} created from these arguments
+        def argument(arg_name = nil, type_expr = nil, desc = nil, **kwargs, &definition_block)
+          if kwargs[:loads]
+            loads_name = arg_name || kwargs[:name]
+            loads_name_as_string = loads_name.to_s
+
+            inferred_arg_name = case loads_name_as_string
             when /_id$/
-              name_as_string.sub(/_id$/, "").to_sym
+              loads_name_as_string.sub(/_id$/, "").to_sym
             when /_ids$/
-              name_as_string.sub(/_ids$/, "")
+              loads_name_as_string.sub(/_ids$/, "")
                 .sub(/([^s])$/, "\\1s")
                 .to_sym
             else
-              name
+              loads_name
             end
 
             kwargs[:as] ||= inferred_arg_name
           end
-          arg_defn = self.argument_class.new(*args, **kwargs, &block)
+          kwargs[:owner] = self
+          arg_defn = self.argument_class.new(
+            arg_name, type_expr, desc,
+            **kwargs,
+            &definition_block
+          )
           add_argument(arg_defn)
           arg_defn
         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

@@ -20,6 +20,23 @@ module GraphQL
           dataloader.with(source_class, *source_args).load(load_key)
         end
 
+        # 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`
+        def dataload_all(source_class, *source_args, load_keys)
+          dataloader.with(source_class, *source_args).load_all(load_keys)
+        end
+
         # Find an object with ActiveRecord via {Dataloader::ActiveRecordSource}.
         # @param model [Class<ActiveRecord::Base>]
         # @param find_by_value [Object] Usually an `id`, might be another value if `find_by:` is also provided
@@ -39,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.
@@ -56,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