lighthouse-graphql 0.1.1 → 0.2.0

data/lib/generators/lighthouse/install/templates/schema.rb.tt

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Executable schema built by Lighthouse from the SDL in <%= sdl_folder %>/. The
+# Dataloader batches relationship loads (@hasMany, @belongsTo, ...) to avoid N+1.
+<%= schema_name %> = Lighthouse::GraphQL::RbLightHouse.get_schema(
+  options: {
+    using: { GraphQL::Dataloader => {} }
+    # base_types: { object: Types::BaseObject } # your graphql-ruby base classes
+  }
+)

data/lib/generators/lighthouse/mutation_generator.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'class_generator'
+
+# `rails generate lighthouse:mutation PublishPost` — a GraphQL::Schema::Mutation
+# that `Mutation.publishPost` resolves to by convention.
+class Lighthouse::Generators::MutationGenerator < Lighthouse::Generators::ClassGenerator
+  desc 'Generate a mutation class (GraphQL::Schema::Mutation) in app/graphql/mutations.'
+
+  private
+
+  def kind = :mutations
+
+  def body
+    <<~RUBY
+      # Resolves Mutation.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
+      # arguments in snake_case; `object` and `context` are available. Raise
+      # GraphQL::ExecutionError for failures the client should see.
+      class #{class_basename} < GraphQL::Schema::Mutation
+        def resolve(**args)
+          raise NotImplementedError
+        end
+      end
+    RUBY
+  end
+
+  def usage
+    "Mutation.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
+  end
+end

data/lib/generators/lighthouse/query_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative 'class_generator'
+
+# `rails generate lighthouse:query LatestPosts` — a GraphQL::Schema::Resolver
+# that `Query.latestPosts` resolves to by convention.
+class Lighthouse::Generators::QueryGenerator < Lighthouse::Generators::ClassGenerator
+  desc 'Generate a query class (GraphQL::Schema::Resolver) in app/graphql/queries.'
+
+  private
+
+  def kind = :queries
+
+  def body
+    <<~RUBY
+      # Resolves Query.#{class_basename.camelize(:lower)}. Keyword arguments are the field's
+      # arguments in snake_case; `object` and `context` are available.
+      class #{class_basename} < GraphQL::Schema::Resolver
+        def resolve(**args)
+          raise NotImplementedError
+        end
+      end
+    RUBY
+  end
+
+  def usage
+    "Query.#{class_basename.camelize(:lower)} resolves to #{full_class_name} — add the field to your SDL without a resolving directive."
+  end
+end

data/lib/generators/lighthouse/validator_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'class_generator'
+
+# `rails generate lighthouse:validator CreatePostInput` — a
+# Dry::Validation::Contract for @validator. Name it after an input type
+# (CreatePostInputValidator) or a field (Mutation::CreatePostValidator).
+class Lighthouse::Generators::ValidatorGenerator < Lighthouse::Generators::ClassGenerator
+  desc 'Generate a validator (Dry::Validation::Contract) for @validator in app/graphql/validators.'
+
+  private
+
+  def kind = :validators
+
+  def class_basename
+    base = super
+    base.end_with?('Validator') ? base : "#{base}Validator"
+  end
+
+  def body
+    <<~RUBY
+      # Arguments arrive with snake_case keys. Remove `option :graphql_context`
+      # if the rules don't need the GraphQL context.
+      class #{class_basename} < Dry::Validation::Contract
+        option :graphql_context, optional: true
+
+        params do
+        end
+      end
+    RUBY
+  end
+
+  def usage
+    'Needs the dry-validation gem. Add @validator to the input type or field it is named after.'
+  end
+end

data/lib/lighthouse/cache_control.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# @cacheControl — compute the HTTP Cache-Control header a response may carry
+# from the fields a query selects, as PHP Lighthouse (after Apollo) does:
+#
+# - max-age is the lowest maxAge among the contributing fields; 0 means
+#   `no-cache`.
+# - The response is `private` if any selected field's scope is PRIVATE.
+# - Defaults: a root field is maxAge 0 and PRIVATE; any other field returning
+#   an object, interface or union is maxAge 0 unless its type carries
+#   @cacheControl; scalar fields inherit their parent and do not contribute.
+#   A directive on the field wins over one on its type, and its omitted
+#   arguments take the directive defaults (maxAge 0, PUBLIC).
+# - `inheritMaxAge: true` uses the parent field's maxAge.
+# - A mutation is never cacheable.
+#
+# The schema runs Analyzer on every query when its SDL uses @cacheControl;
+# read the result with CacheControl.header(result) and set it on the
+# response (see `apply`).
+module Lighthouse::GraphQL::CacheControl
+  DEFINITION = 'directive @cacheControl(maxAge: Int! = 0, scope: CacheControlScope! = PUBLIC, ' \
+               'inheritMaxAge: Boolean! = false) on FIELD_DEFINITION | OBJECT | INTERFACE | UNION'
+
+  TYPE_DEFINITIONS = {
+    'CacheControlScope' => <<~GRAPHQL.chomp
+      "Who a cached response may be shared with."
+      enum CacheControlScope {
+        "The same for every user: shared caches (CDNs, proxies) may store it."
+        PUBLIC
+        "Specific to the user: only the user's own client may store it."
+        PRIVATE
+      }
+    GRAPHQL
+  }.freeze
+
+  CONTEXT_KEY = :lighthouse_cache_control
+
+  module_function
+
+  # The Cache-Control value for an executed query (a GraphQL::Query::Result
+  # or GraphQL::Query), or nil when the schema does not use @cacheControl.
+  def header(result)
+    query = result.respond_to?(:query) ? result.query : result
+    query.respond_to?(:context) ? query.context[CONTEXT_KEY] : nil
+  end
+
+  # Set the header on a Rails (or Rack) response; a no-op without one.
+  def apply(response, result)
+    value = header(result)
+    response.headers['Cache-Control'] = value if value
+    value
+  end
+
+  def to_header(max_age, private_scope)
+    visibility = private_scope ? 'private' : 'public'
+    max_age.positive? ? "max-age=#{max_age}, #{visibility}" : "no-cache#{', private' if private_scope}"
+  end
+
+  class Analyzer < ::GraphQL::Analysis::Analyzer
+    def initialize(subject)
+      super
+      @parents = []
+      @max_age = nil
+      @private = false
+    end
+
+    def on_enter_field(node, _parent, visitor)
+      field = visitor.field_definition
+      return @parents.push(@parents.last) if field.nil? || visitor.skipping?
+
+      max_age, scope = hint_for(field)
+      unless max_age.nil?
+        @max_age = [@max_age, max_age].compact.min
+        @private ||= scope == 'PRIVATE'
+      end
+      @parents.push(max_age.nil? ? @parents.last : max_age)
+      node
+    end
+
+    def on_leave_field(_node, _parent, _visitor)
+      @parents.pop
+    end
+
+    def result
+      value =
+        if query.mutation?
+          'no-cache'
+        else
+          Lighthouse::GraphQL::CacheControl.to_header(@max_age || 0, @private)
+        end
+      query.context[CONTEXT_KEY] = value
+    end
+
+    private
+
+    def root?
+      @parents.empty?
+    end
+
+    # [maxAge, scope] the field contributes, or [nil, nil] to inherit.
+    def hint_for(field)
+      directive = cache_control(field.ast_node)
+      return from_directive(directive) if directive
+      return [0, 'PRIVATE'] if root?
+
+      return_type = field.type.unwrap
+      return [nil, nil] if return_type.kind.leaf?
+
+      type_directive = cache_control(return_type.ast_node)
+      type_directive ? from_directive(type_directive) : [0, 'PUBLIC']
+    end
+
+    def from_directive(directive)
+      scope = Lighthouse::Support::DirectiveArgs.literal(directive, 'scope') || 'PUBLIC'
+      if Lighthouse::Support::DirectiveArgs.literal(directive, 'inheritMaxAge')
+        [@parents.last || 0, scope]
+      else
+        [Lighthouse::Support::DirectiveArgs.literal(directive, 'maxAge') || 0, scope]
+      end
+    end
+
+    def cache_control(ast_node)
+      ast_node&.directives&.find { |d| d.name == 'cacheControl' }
+    end
+  end
+end

data/lib/lighthouse/caching.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+require 'securerandom'
+
+# Keys and invalidation for @cache / @clearCache over Config.cache_store
+# (Rails.cache by default).
+#
+# PHP Lighthouse invalidates with cache tags, which Rails cache stores do not
+# have (and `delete_matched` is not universal). Instead every entry key embeds
+# four version tokens — the type, the type + parent id, the type + field, and
+# the type + parent id + field — and @clearCache replaces the matching token.
+# Old entries are never read again and expire on their own. A token that
+# was evicted is re-created with a fresh value, so eviction only ever causes
+# misses, never stale reads.
+module Lighthouse::GraphQL::Caching
+  PREFIX = 'lighthouse'
+
+  module_function
+
+  def store
+    Lighthouse::Config.cache_store
+  end
+
+  def entry_key(type, id, field, args, user_key)
+    tokens = versions(version_keys(type, id, field))
+    [PREFIX, type, id, field, digest(args), user_key, *tokens].join(':')
+  end
+
+  # @clearCache: invalidate everything cached for `type`, narrowed to one
+  # parent `id` and/or one `field` when given.
+  def clear(type, id: nil, field: nil)
+    key = version_key(type, id, field)
+    store.write(key, SecureRandom.hex(8))
+  end
+
+  def version_keys(type, id, field)
+    [version_key(type, nil, nil), version_key(type, id, nil), version_key(type, nil, field), version_key(type, id, field)]
+      .uniq
+  end
+
+  def version_key(type, id, field)
+    [PREFIX, 'version', type, id, field].join(':')
+  end
+
+  def versions(keys)
+    found = store.read_multi(*keys)
+    keys.map do |key|
+      found[key] || begin
+        store.write(key, SecureRandom.hex(8), unless_exist: true)
+        store.read(key)
+      end
+    end
+  end
+
+  def digest(args)
+    Digest::SHA256.hexdigest(JSON.generate(canonical(Lighthouse::Support::Arguments.plain(args))))[0, 32]
+  end
+
+  def canonical(value)
+    case value
+    when Hash then value.map { |k, v| [k.to_s, canonical(v)] }.sort_by(&:first)
+    when Array then value.map { |v| canonical(v) }
+    else value
+    end
+  end
+end

data/lib/lighthouse/config.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/cache'
+
 module Lighthouse
   # Convenience entrypoint: `Lighthouse.configure { |c| c.resolver_namespaces = [...] }`.
   def self.configure(&block)
@@ -7,12 +9,30 @@ module Lighthouse
   end
 
   module Config
+    # Where each kind of class a schema refers to by name is looked up. Query and
+    # mutation fields resolve to GraphQL::Schema::Resolver / Mutation classes,
+    # builders compose onto a relation, validators check arguments: distinct
+    # contracts, so distinct namespaces (app/graphql/queries, .../mutations, ...).
+    DEFAULT_NAMESPACES = {
+      queries: ['Queries'],
+      mutations: ['Mutations'],
+      builders: ['Builders'],
+      validators: ['Validators']
+    }.freeze
+
+    # Every setting reset! forgets, so the next read falls back to its default.
+    SETTINGS = %i[
+      sdl_folder resolver_namespaces namespaces cache_store transactional_mutations pagination_default_count pagination_max_count
+      schema_cache schema_cache_path watch_sdl persisted_queries persisted_queries_store persisted_queries_ttl
+      persisted_queries_manifest persisted_queries_only on_error directive_map authenticated_user policy_user authorizer
+    ].freeze
+
     class << self
-      attr_writer :sdl_folder, :resolver_namespaces, :on_error,
-                  :authenticated_user, :policy_user, :authorizer
+      attr_writer :sdl_folder, :resolver_namespaces, :on_error, :authenticated_user, :policy_user, :authorizer, :cache_store,
+                  :transactional_mutations, :schema_cache, :watch_sdl, :persisted_queries, :persisted_queries_store, :persisted_queries_only
 
       def sdl_folder
-        @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? File.join(Rails.root, 'graphql') : nil)
+        @sdl_folder ||= (defined?(Rails) && Rails.respond_to?(:root) ? Rails.root.join('graphql').to_s : nil)
       end
 
       def directive_map
@@ -27,6 +47,57 @@ module Lighthouse
         @resolver_namespaces ||= ['App::Graphql']
       end
 
+      # { queries:, mutations:, builders:, validators: } => [namespace, ...].
+      # Assigning a partial hash overrides only the kinds it names.
+      def namespaces
+        @namespaces ||= DEFAULT_NAMESPACES.transform_values(&:dup)
+      end
+
+      def namespaces=(overrides)
+        @namespaces = namespaces.merge(overrides.to_h.transform_keys(&:to_sym).transform_values { |v| Array(v) })
+      end
+
+      # Store backing @cache and @clearCache. Defaults to Rails.cache.
+      def cache_store
+        @cache_store ||=
+          if defined?(Rails) && Rails.respond_to?(:cache) && Rails.cache
+            Rails.cache
+          else
+            ActiveSupport::Cache::MemoryStore.new
+          end
+      end
+
+      # --- Scale options: all off by default ----------------------------------
+      #
+      # schema_cache          cache the built schema document in tmp/cache (SchemaCache)
+      # schema_cache_path     where; default Rails.root/tmp/cache/lighthouse
+      # watch_sdl             reload the app (and so the schema) when a .graphql file changes
+      # persisted_queries     accept Apollo's Automatic Persisted Queries (PersistedQueries)
+      # persisted_queries_store     where APQ keeps queries; default cache_store
+      # persisted_queries_ttl       how long they live there (seconds; nil: until evicted)
+      # persisted_queries_manifest  a manifest of trusted operations, served by hash
+      # persisted_queries_only      reject any operation not in the manifest
+      attr_accessor :schema_cache_path, :persisted_queries_ttl, :persisted_queries_manifest
+
+      def schema_cache = @schema_cache || false
+      def watch_sdl = @watch_sdl || false
+      def persisted_queries = @persisted_queries || false
+      def persisted_queries_only = @persisted_queries_only || false
+
+      def persisted_queries_store
+        @persisted_queries_store || cache_store
+      end
+
+      # Pagination defaults, overridden by a directive's defaultCount / maxCount.
+      # Without a default count, paginated fields require `first`.
+      attr_accessor :pagination_default_count, :pagination_max_count
+
+      # Run @create/@update/... in a database transaction, so a failing record
+      # (e.g. the third of five in @createMany) leaves nothing behind.
+      def transactional_mutations
+        @transactional_mutations.nil? || @transactional_mutations
+      end
+
       # Hook invoked when a directive/resolver swallows an error. Defaults to
       # re-raising in test (so failures surface) and logging otherwise. Override
       # via `Lighthouse.configure { |c| c.on_error = ->(e, ctx) { ... } }`.
@@ -56,8 +127,10 @@ module Lighthouse
         end
       end
 
-      # Checks an ability: `->(user, record, ability) { true/false }`.
-      # Defaults to Pundit: `Pundit.policy!(user, record).<ability>?`.
+      # Checks an ability: `->(user, record, ability, args = []) { true/false }`.
+      # `record` may be a model class (@canModel). `args` carries the @can*
+      # `args:` values and, with `injectArgs: true`, the field's arguments first.
+      # Defaults to Pundit: `Pundit.policy!(user, record).<ability>?(*args)`.
       def authorizer
         @authorizer ||= default_authorizer
       end
@@ -66,29 +139,22 @@ module Lighthouse
         yield(self) if block_given?
       end
 
-      def [](k)
-        public_send(k)
+      def [](key)
+        public_send(key)
       end
 
       def reset!
-        @sdl_folder = nil
-        @resolver_namespaces = nil
-        @on_error = nil
-        @directive_map = nil
-        @authenticated_user = nil
-        @policy_user = nil
-        @authorizer = nil
+        SETTINGS.each { |setting| instance_variable_set("@#{setting}", nil) }
       end
 
       private
 
       def default_authorizer
-        lambda do |user, record, ability|
-          unless defined?(::Pundit)
-            raise 'Lighthouse: configure `Config.authorizer` to use @can (Pundit not detected).'
-          end
+        lambda do |user, record, ability, args = []|
+          raise 'Lighthouse: configure `Config.authorizer` to use the @can* directives (Pundit not detected).' unless defined?(::Pundit)
 
-          ::Pundit.policy!(user, record).public_send("#{ability}?")
+          check = ::Pundit.policy!(user, record).method("#{ability}?")
+          check.arity.zero? ? check.call : check.call(*args)
         end
       end
 

data/lib/lighthouse/contracts/arg_builder.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive on a field ARGUMENT that composes a constraint onto an
-    # ActiveRecord relation at resolve time, e.g. @eq, @neq, @in, @notIn, @like,
-    # @where, @orderBy. These compose in SDL argument order via the
-    # ArgBuilderPipeline.
-    #
-    # Implementors provide `#handle_builder(relation, value)` returning a relation.
-    module ArgBuilder
-      include Directive
-    end
-  end
+# A directive on a field ARGUMENT that composes a constraint onto an
+# ActiveRecord relation at resolve time, e.g. @eq, @neq, @in, @notIn, @like,
+# @where, @orderBy. These compose in SDL argument order via the
+# ArgBuilderPipeline.
+#
+# Implementors provide `#handle_builder(relation, value)` returning a relation.
+module Lighthouse::Contracts::ArgBuilder
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/arg_manipulator.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive on a field ARGUMENT that mutates the schema AST before build,
-    # e.g. @whereConditions / @whereHasConditions generating input/enum types and
-    # swapping the `_` placeholder argument type.
-    #
-    # Implementors provide (at the class level)
-    # `manipulate_argument_definition(manipulation_context, parent, field, arg, directive)`.
-    module ArgManipulator
-      include Directive
-    end
-  end
+# A directive on a field ARGUMENT that mutates the schema AST before build,
+# e.g. @whereConditions / @whereHasConditions generating input/enum types and
+# swapping the `_` placeholder argument type.
+#
+# Implementors provide (at the class level)
+# `manipulate_argument_definition(manipulation_context, parent, field, arg, directive)`.
+module Lighthouse::Contracts::ArgManipulator
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/directive.rb

@@ -1,17 +1,13 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  # Contracts are duck-typed marker modules that mirror the PHP Lighthouse
-  # directive interfaces. A directive class includes whichever contracts it
-  # fulfils; the DirectiveRegistry and SchemaGenerator detect capabilities via
-  # `klass.include?(Contracts::X)` and invoke the corresponding hook.
-  module Contracts
-    # Base marker. Every Lighthouse directive class includes this.
-    #
-    # Implementors are expected to expose (at the class level):
-    #   - `directive_name` -> String   the SDL name without the leading '@'
-    #   - `definition`     -> String?  the SDL `directive @name(...) on ...` line
-    module Directive
-    end
-  end
+# Contracts are duck-typed marker modules that mirror the PHP Lighthouse
+# directive interfaces. A directive class includes whichever contracts it
+# fulfils; the DirectiveRegistry and SchemaGenerator detect capabilities via
+# `klass.include?(Contracts::X)` and invoke the corresponding hook.
+# Base marker. Every Lighthouse directive class includes this.
+#
+# Implementors are expected to expose (at the class level):
+#   - `directive_name` -> String   the SDL name without the leading '@'
+#   - `definition`     -> String?  the SDL `directive @name(...) on ...` line
+module Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_manipulator.rb

@@ -2,16 +2,12 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that mutates the schema AST before it is built, e.g. @paginate
-    # and the relationship directives injecting Connection/Paginator types, or
-    # @orderBy generating its column enum.
-    #
-    # Implementors provide (at the class level)
-    # `manipulate_field_definition(manipulation_context, parent, field, directive)`.
-    module FieldManipulator
-      include Directive
-    end
-  end
+# A directive that mutates the schema AST before it is built, e.g. @paginate
+# and the relationship directives injecting Connection/Paginator types, or
+# @orderBy generating its column enum.
+#
+# Implementors provide (at the class level)
+# `manipulate_field_definition(manipulation_context, parent, field, directive)`.
+module Lighthouse::Contracts::FieldManipulator
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_middleware.rb

@@ -2,15 +2,11 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that wraps an existing field resolver, e.g. @auth wrapping the
-    # underlying resolver to enforce authentication.
-    #
-    # Implementors provide `#wrap_resolver(next_resolver)` returning a new
-    # `#call(obj, args, ctx)` lambda that may invoke `next_resolver`.
-    module FieldMiddleware
-      include Directive
-    end
-  end
+# A directive that wraps an existing field resolver, e.g. @auth wrapping the
+# underlying resolver to enforce authentication.
+#
+# Implementors provide `#wrap_resolver(next_resolver)` returning a new
+# `#call(obj, args, ctx)` lambda that may invoke `next_resolver`.
+module Lighthouse::Contracts::FieldMiddleware
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/contracts/field_resolver.rb

@@ -2,17 +2,13 @@
 
 require_relative 'directive'
 
-module Lighthouse
-  module Contracts
-    # A directive that provides the runtime resolver for a field, e.g. @all,
-    # @find, @paginate, @hasMany, @belongsTo, @field, @auth, @aggregate.
-    #
-    # During the resolution phase the SchemaGenerator instantiates the directive
-    # and installs its resolver onto the field. Legacy resolvers fulfil this via
-    # `#define_resolver(target_type)`; clean directives implement `#resolve_field`
-    # returning a `#call(obj, args, ctx)` lambda.
-    module FieldResolver
-      include Directive
-    end
-  end
+# A directive that provides the runtime resolver for a field, e.g. @all,
+# @find, @paginate, @hasMany, @belongsTo, @field, @auth, @aggregate.
+#
+# During the resolution phase the SchemaGenerator instantiates the directive
+# and installs its resolver onto the field. Legacy resolvers fulfil this via
+# `#define_resolver(target_type)`; clean directives implement `#resolve_field`
+# returning a `#call(obj, args, ctx)` lambda.
+module Lighthouse::Contracts::FieldResolver
+  include Lighthouse::Contracts::Directive
 end

data/lib/lighthouse/dataloader_sources/association_loader.rb

@@ -1,25 +1,34 @@
 # frozen_string_literal: true
 
-module Lighthouse
-  module GraphQL
-    module DataloaderSources
-      class AssociationLoader < ::GraphQL::Dataloader::Source
-        def initialize(model_class, association_name)
-          @model_class = model_class
-          @association_name = association_name.to_s
-        end
+# Loads one association for many parents in a single query per batch, with
+# ActiveRecord's preloader — the N+1 fix behind @hasMany, @belongsTo, ...
+class Lighthouse::GraphQL::DataloaderSources::AssociationLoader < GraphQL::Dataloader::Source
+  def initialize(model_class, association_name)
+    super()
+    @model_class = model_class
+    @association_name = association_name.to_s
+  end
+
+  # keys: the parent records
+  def fetch(parents)
+    preload(parents.select { |parent| association?(parent) })
+    parents.map { |parent| parent.respond_to?(@association_name) ? parent.public_send(@association_name) : nil }
+  end
+
+  private
+
+  def association?(parent)
+    parent.class.respond_to?(:reflect_on_association) && parent.class.reflect_on_association(@association_name)
+  end
+
+  def preload(records)
+    return if records.empty?
 
-        # keys: array of parent objects
-        def fetch(keys)
-          keys.map do |parent|
-            if parent.respond_to?(@association_name)
-              parent.public_send(@association_name)
-            else
-              nil
-            end
-          end
-        end
-      end
+    preloader = ::ActiveRecord::Associations::Preloader
+    if preloader.method_defined?(:call)
+      preloader.new(records: records, associations: @association_name.to_sym).call # Rails >= 7
+    else
+      preloader.new.preload(records, @association_name.to_sym)                       # Rails 6
     end
   end
 end