n1_loader 1.4.2 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f72c7428f78489c25222fb2ab8d56fde519c680fdc010115b952637c2291ca93
-  data.tar.gz: 7149852481ffed8d1fd0fc25e28fc045eda0a0f2936e748461dd7f43d4f709f1
+  metadata.gz: bf26363e90cf5f0b6759776698445183f4abe8442bf366e7109e1cada18b1eaa
+  data.tar.gz: e082a72dc1f910262fbc73040b484ae28e437beee866ca42277a7556d989072a
 SHA512:
-  metadata.gz: 0d0802914b84d4c25a97c8c328ff2ae4453cf8fcd4eee87de1955b06b810c874d9982498b5fc80ecf1fa77238971e51ef5f162f809914876a1811084b366ddfe
-  data.tar.gz: fa001ab34b7165ee35ba31ef449c837418d538e52977ee984b38e35b767df06c05ef0cb01949c9290c17ae40bcd3e3644f00374cf7f66d7e6811f094515c37da
+  metadata.gz: 52993103afc0075d9d71088e6d7e60925ea1740176ee31829acb5d42009a38955b25d8e9124a17fff981b4735f443c04d3532cbea3186850bffc2908f0e40522
+  data.tar.gz: fdcc21a626ff199ccf4a9af7bd860516745693614404c44159414b27601750ea476de8eae593f7bade3782425b638f784db096e6dcdaafa58c71382f3a08b979

data/.circleci/config.yml

@@ -106,7 +106,8 @@ workflows:
               ]
               activerecord-gemfile: [
                 "ar_5_latest",
-                "ar_6_latest"
+                "ar_6_latest",
+                "ar_7_latest"
               ]
               ar_lazy_preload-gemfile: [
                 "ar_lazy_preload_0.6.1",
@@ -115,21 +116,40 @@ workflows:
             exclude:
               # Ruby 2.5 and AR Lazy Preload 1+
               - ruby-version: "2.5"
-                activerecord-gemfile: "ar_5_latest"
                 ar_lazy_preload-gemfile: "ar_lazy_preload_master"
+                activerecord-gemfile: "ar_5_latest"
 
               - ruby-version: "2.5"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_master"
                 activerecord-gemfile: "ar_6_latest"
+
+              - ruby-version: "2.5"
                 ar_lazy_preload-gemfile: "ar_lazy_preload_master"
+                activerecord-gemfile: "ar_7_latest"
 
               # AR 5 and ruby 3+
               - ruby-version: "latest"
                 activerecord-gemfile: "ar_5_latest"
                 ar_lazy_preload-gemfile: "ar_lazy_preload_0.6.1"
+
               - ruby-version: "latest"
                 activerecord-gemfile: "ar_5_latest"
                 ar_lazy_preload-gemfile: "ar_lazy_preload_master"
 
+              # AR 7 and ar_lazy_preload < 1
+              - ruby-version: "2.5"
+                activerecord-gemfile: "ar_7_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_0.6.1"
+
+              - ruby-version: "2.7"
+                activerecord-gemfile: "ar_7_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_0.6.1"
+
+              - ruby-version: "latest"
+                activerecord-gemfile: "ar_7_latest"
+                ar_lazy_preload-gemfile: "ar_lazy_preload_0.6.1"
+
+
           name: ruby-<< matrix.ruby-version >>-<< matrix.activerecord-gemfile >>-<< matrix.ar_lazy_preload-gemfile >>
       - rubocop:
           requires:

data/.gitignore

@@ -8,4 +8,5 @@
 /tmp/
 /.idea
 .rspec_status
-Gemfile.lock
+Gemfile.lock
+.ruby-version

data/.rubocop.yml

@@ -1,5 +1,7 @@
 AllCops:
   TargetRubyVersion: 2.5
+  Exclude:
+    - examples/**/*
 
 Style/StringLiterals:
   Enabled: true

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## [1.5.0] - 2022/05/01
+
+- Add support of Rails 7
+
+## [1.4.4] - 2022/04/29
+
+- Inject `N1Loader::Loadable` to `ActiveRecord::Base` automatically
+- Make `reload` to call `n1_clear_cache`
+
+## [1.4.3] - 2022-04-13
+
+- Add `default` support to arguments
+
 ## [1.4.2] - 2022-03-01
 
 - Add n1_clear_cache method which is useful for cases like reload in ActiveRecord

data/README.md

@@ -3,298 +3,147 @@
 [![CircleCI][1]][2]
 [![Gem Version][3]][4]
 
-Are you tired of fixing [N+1 issues][7]? Does it feel unnatural to you to fix it case by case in places where you need the data?
-We have a solution for you! 
+N1Loader is designed to provide a simple way for avoiding [N+1 issues][7] of any kind. 
+For example, it can help with resolving N+1 for:
+- database querying (most common case)
+- 3rd party service calls
+- complex calculations
+- and many more
 
-[N1Loader][8] is designed to solve the issue for good!
+> [Toptal](https://www.toptal.com#snag-only-shrewd-web-development-experts) is hiring! [Join](https://www.toptal.com#snag-only-shrewd-web-development-experts) as Freelancer or [write me](mailto:lawliet.djez@gmail.com) if you want to join Core team.
 
-It has many benefits:
-- it can be [isolated](#isolated-loaders)
-- it loads data [lazily](#lazy-loading)
-- it supports [shareable loaders](#shareable-loaders) between multiple classes
-- it supports [reloading](#reloading)
-- it supports optimized [single object loading](#optimized-single-case)
-- it supports [arguments](#arguments)
-- it has an integration with [ActiveRecord][5] which makes it brilliant ([example](#activerecord))
-- it has an integration with [ArLazyPreload][6] which makes it excellent ([example](#arlazypreload))
+## Killer feature for GraphQL API
 
-... and even more features to come! Stay tuned!
+N1Loader in combination with [ArLazyPreload][6] is a killer feature for your GraphQL API. 
+Give it a try now and see incredible results instantly! Check out the [example](examples/graphql.rb) and start benefiting from it in your projects!
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'n1_loader'
-```
-
-You can add integration with [ActiveRecord][5] by:
-```ruby
-gem 'n1_loader', require: 'n1_loader/active_record'
-```
-
-You can add the integration with [ActiveRecord][5] and [ArLazyPreload][6] by:
 ```ruby
 gem 'n1_loader', require: 'n1_loader/ar_lazy_preload'
 ```
 
-## Usage
+## Enhance [ActiveRecord][5]
 
-```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-    
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-# For single object
-user = User.new
-user.orders_count 
+Are you working with well-known Rails application? Try it out and see how well N1Loader fulfills missing gaps when you can't define ActiveRecord associations!
 
-# For multiple objects without N+1
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map(&:orders_count)
+```ruby
+gem 'n1_loader', require: 'n1_loader/active_record'
 ```
 
-### Lazy loading
+Are you ready to forget about N+1 once and for all? Install [ArLazyPreload][6] and see dreams come true!
 
 ```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-user = User.new # => nothing was done for loading
-user.orders_count # => first time loading
-
-users = [User.new, User.new] # => nothing was done for loading
-N1Loader::Preloader.new([users]).preload(:orders_count) # => we only initialized loader but didn't perform it yet
-users.map(&:orders_count) # => loading has happen for the first time (without N+1)
+gem 'n1_loader', require: 'n1_loader/ar_lazy_preload'
 ```
 
+## Standalone mode
 
-### Shareable loaders
+Are you not working with [ActiveRecord][5]? N1Loader is ready to be used as standalone solution! ([full snippet](examples/core.rb))
 
 ```ruby
-class OrdersCountLoader < N1Loader::Loader
-  def perform(users)
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count, OrdersCountLoader
-end
-
-class Customer
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count, OrdersCountLoader
-end
-
-User.new.orders_count # => works
-Customer.new.orders_count  # => works
+gem 'n1_loader'
 ```
 
-### Reloading
-
-```ruby
-class User
-  include N1Loader::Loadable
-
-  # with inline loader
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
-
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-user = User.new
-user.orders_count # => loader is executed first time and value was cached
-user.orders_count(reload: true) # => loader is executed again and a new value was cached
-# or
-user.n1_clear_cache
-user.orders_count
-
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized but not yet executed
-users.map(&:orders_count) # => loader was executed first time without N+1 issue and values were cached
+## How to use it?
 
-N1Loader::Preloader.new(users).preload(:orders_count) # => loader was initialized again but not yet executed
-users.map(&:orders_count) # => new loader was executed first time without N+1 issue and new values were cached
-```
+N1Loader provides DSL that allows you to define N+1 ready loaders that can 
+be injected into your objects in a way that you can avoid N+1 issues.
 
-### Isolated loaders
+> _Disclaimer_: examples below are working but designed to show N1Loader potentials only.
+In real live applications, N1Loader can be applied anywhere and in more [elegant way](examples/isolated_loader.rb).  
 
+Let's look at simple example below ([full snippet](examples/active_record_integration.rb)):
 ```ruby
-class IsolatedLoader < N1Loader::Loader
-  def perform(elements)
-    elements.each { |element| fulfill(element, [element]) }
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = 
+      Payment.group(:user_id)
+        .where(user: users)
+        .sum(:amount)
+        .tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
   end
 end
 
-objects = [1, 2, 3, 4]
-loader = IsolatedLoader.new(objects)
-objects.each do |object|
-  loader.for(object) # => it has no N+1 and it doesn't require to be injected in the class
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
 end
-```
 
-### Optimized single case
+# A user has many payments. 
+# Assuming, we want to know for group of users, what is a total of their payments, we can do the following:
 
-```ruby
-class User
-  include N1Loader::Loadable
+# Has N+1 issue
+p User.all.map { |user| user.payments.sum(&:amount) }
 
-  n1_optimized :orders_count do # no arguments passed to the block, so we can override both perform and single.
-    def perform(users)
-      orders_per_user = Order.where(user: users).group(:user_id).count
+# Has no N+1 but we load too many data that we don't actually need
+p User.all.includes(:payments).map { |user| user.payments.sum(&:amount) }
 
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
-    end
-    
-    # Optimized for single object loading
-    def single(user)
-      user.orders.count
-    end
-  end
-end
-
-user = User.new
-user.orders_count # single will be used here
-
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map(&:orders_count) # perform will be used once without N+1
+# Has no N+1 and we load only what we need
+p User.all.includes(:payments_total).map { |user| user.payments_total }
 ```
 
-### Arguments
+Let's assume now, that we want to calculate the total of payments for the given period for a group of users. 
+N1Loader can do that as well! ([full snippet](examples/arguments_support.rb)) 
 
 ```ruby
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do 
-    argument :type 
-    
-    def perform(users)
-      orders_per_user = Order.where(type: type, user: users).group(:user_id).count
-      
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
-    end
-  end
-end
-
-user = User.new
-user.orders_count(type: :gifts) # The loader will be performed first time for this argument
-user.orders_count(type: :sales) # The loader will be performed first time for this argument
-user.orders_count(type: :gifts) # The cached value will be used
-
-users = [User.new, User.new]
-N1Loader::Preloader.new(users).preload(:orders_count)
-users.map { |user| user.orders_count(type: :gifts) } # No N+1 here
-```
+class User < ActiveRecord::Base
+  has_many :payments
 
-_Note_: By default, we use `arguments.map(&:object_id)` to identify arguments but in some cases, 
-you may want to override it, for example:
+  n1_optimized :payments_total do
+    argument :from
+    argument :to
 
-```ruby
-class User
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do
-    argument :sale 
-    
-    cache_key { sale.id }
-    
     def perform(users)
-      orders_per_user = Order.where(sale: sale, user: users).group(:user_id).count
-      
-      users.each { |user| fulfill(user, orders_per_user[user.id]) }
+      total_per_user =
+        Payment
+          .group(:user_id)
+          .where(created_at: from..to)
+          .where(user: users)
+          .sum(:amount)
+          .tap { |h| h.default = 0 }
+
+      users.each do |user|
+        total = total_per_user[user.id]
+        fulfill(user, total)
+      end
     end
   end
 end
 
-user = User.new
-user.orders_count(sale: Sale.first) # perform will be executed and value will be cached
-user.orders_count(sale: Sale.first) # the cached value will be returned
-```
-
-
-## Integrations
-
-### [ActiveRecord][5]
-
-_Note_: Rails 7 support is coming soon! Stay tuned!
-
-```ruby
-class User < ActiveRecord::Base
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
+class Payment < ActiveRecord::Base
+  belongs_to :user
 
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
+  validates :amount, presence: true
 end
 
-# For single user
-user = User.first
-user.orders_count 
-
-# For many users without N+1
-User.limit(5).includes(:orders_count).map(&:orders_count)
+# Has N+1
+p User.all.map { |user| user.payments.select { |payment| payment.created_at >= from && payment.created_at <= to }.sum(&:amount) }
 
-# or with explicit preloader
-users = User.limit(5).to_a
-N1Loader::Preloader.new(users).preload(:orders_count)
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user| user.payments.select { |payment| payment.created_at >= from && payment.created_at <= to }.sum(&:amount) }
 
-# No N+1 here
-users.map(&:orders_count)
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map { |user| user.payments_total(from: from, to: to) }
 ```
 
-### [ArLazyPreload][6]
-
-```ruby
-class User < ActiveRecord::Base
-  include N1Loader::Loadable
-
-  n1_optimized :orders_count do |users|
-    orders_per_user = Order.where(user: users).group(:user_id).count
+## Features and benefits
 
-    users.each { |user| fulfill(user, orders_per_user[user.id]) }
-  end
-end
-
-# For single user
-user = User.first
-user.orders_count
-
-# For many users without N+1
-User.lazy_preload(:orders_count).all.map(&:orders_count)
-# or 
-User.preload_associations_lazily.all.map(&:orders_count)
-# or 
-ArLazyPreload.config.auto_preload = true
-User.all.map(:orders_count)
-```
+- N1Loader doesn't use Promises which means it's easy to debug
+- Doesn't require injection to objects, can be used in [isolation](examples/isolated_loader.rb)
+- Loads data [lazily](examples/lazy_loading.rb)
+- Loaders can be [shared](examples/shared_loader.rb) between multiple classes
+- Loaded data can be [re-fetched](examples/reloading.rb)
+- Loader can be optimized for [single cases](examples/single_case.rb)
+- Loader support [arguments](examples/arguments_support.rb)
+- Has [integration](examples/active_record_integration.rb) with [ActiveRecord][5] which makes it brilliant
+- Has [integration](examples/ar_lazy_integration.rb) with [ArLazyPreload][6] which makes it excellent
 
 ## Contributing
 
@@ -324,4 +173,4 @@ Copyright (c) Evgeniy Demin. See [LICENSE.txt](LICENSE.txt) for further details.
 [5]: https://github.com/rails/rails/tree/main/activerecord
 [6]: https://github.com/DmitryTsepelev/ar_lazy_preload
 [7]: https://stackoverflow.com/questions/97197/what-is-the-n1-selects-problem-in-orm-object-relational-mapping
-[8]: https://github.com/djezzzl/n1_loader
+[8]: https://github.com/djezzzl/n1_loader

data/activerecord-gemfiles/ar_7_latest.gemfile

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+gem "activerecord", "~> 7"

data/examples/active_record_integration.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "n1_loader/active_record"
+
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+# Has N+1
+p User.all.map { |user| user.payments.sum(&:amount) }
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user| user.payments.sum(&:amount) }
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map(&:payments_total)

data/examples/ar_lazy_integration.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "n1_loader/ar_lazy_preload"
+
+require_relative 'context/setup_ar_lazy'
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+# Has N+1
+p User.all.map { |user| user.payments.sum(&:amount) }
+
+# Has no N+1 but we load too many data that we don't need
+p User.preload_associations_lazily.map(&:payments_total)
+
+# Has no N+1 and calculation is the most efficient
+ArLazyPreload.config.auto_preload = true
+User.all.map(&:payments_total)

data/examples/arguments_support.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "n1_loader/active_record"
+
+require_relative 'context/setup_database'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do
+    # Arguments can be:
+    # argument :something, optional: true
+    # argument :something, default: -> { 100 }
+    #
+    # Note: do not use mutable (mostly timing related) defaults like:
+    # argument :from, default -> { 2.minutes.from_now }
+    # because such values will be unique for every loader call which will make N+1 issue stay
+    argument :from
+    argument :to
+
+    # This is used to define logic how loaders are compared to each other
+    # default is:
+    # cache_key { *arguments.map(&:object_id) }
+    cache_key { [from, to] }
+
+    def perform(users)
+      total_per_user =
+        Payment
+        .group(:user_id)
+        .where(created_at: from..to)
+        .where(user: users)
+        .sum(:amount)
+        .tap { |h| h.default = 0 }
+
+      users.each do |user|
+        total = total_per_user[user.id]
+        fulfill(user, total)
+      end
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+fill_database
+
+from = 2.days.ago
+to = 1.day.ago
+
+# Has N+1
+p User.all.map { |user|
+  user.payments.select do |payment|
+    payment.created_at >= from && payment.created_at <= to
+  end.sum(&:amount)
+}
+# Has no N+1 but we load too many data that we don't need
+p User.all.includes(:payments).map { |user|
+  user.payments.select do |payment|
+    payment.created_at >= from && payment.created_at <= to
+  end.sum(&:amount)
+}
+# Has no N+1 and calculation is the most efficient
+p User.all.includes(:payments_total).map { |user| user.payments_total(from: from, to: to) }

data/examples/context/service.rb

@@ -0,0 +1,20 @@
+# 3rd party service, or database, or anything else that can perform in batches
+class Service
+  def self.count
+    @count ||= 0
+  end
+
+  def self.increase!
+    @count = (@count || 0) + 1
+  end
+
+  def self.receive(*users)
+    increase!
+
+    users.flatten.map(&:object_id)
+  end
+
+  def self.single(user)
+    user.object_id
+  end
+end

data/examples/context/setup_ar_lazy.rb

@@ -0,0 +1,15 @@
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Base.include(ArLazyPreload::Base)
+
+  ActiveRecord::Relation.prepend(ArLazyPreload::Relation)
+  ActiveRecord::AssociationRelation.prepend(ArLazyPreload::AssociationRelation)
+  ActiveRecord::Relation::Merger.prepend(ArLazyPreload::Merger)
+
+  [
+    ActiveRecord::Associations::CollectionAssociation,
+    ActiveRecord::Associations::Association
+  ].each { |klass| klass.prepend(ArLazyPreload::Association) }
+
+  ActiveRecord::Associations::CollectionAssociation.prepend(ArLazyPreload::CollectionAssociation)
+  ActiveRecord::Associations::CollectionProxy.prepend(ArLazyPreload::CollectionProxy)
+end

data/examples/context/setup_database.rb

@@ -0,0 +1,26 @@
+require "sqlite3"
+
+ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
+ActiveRecord::Base.connection.tables.each do |table|
+  ActiveRecord::Base.connection.drop_table(table, force: :cascade)
+end
+ActiveRecord::Schema.verbose = false
+ActiveRecord::Base.logger = Logger.new($stdout)
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table(:payments) do |t|
+    t.belongs_to :user
+    t.integer :amount
+    t.timestamps
+  end
+  create_table(:users)
+end
+
+def fill_database
+  10.times do
+    user = User.create!
+    10.times do
+      Payment.create!(user: user, amount: rand(1000))
+    end
+  end
+end

data/examples/core.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "n1_loader"
+
+require_relative 'context/service'
+
+# Class that wants to request 3rd party service without N+1
+class User
+  include N1Loader::Loadable
+
+  def unoptimized_call
+    Service.receive(self)[0]
+  end
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+# works fine for single case
+user = User.new
+p "Works correctly: #{user.unoptimized_call == user.optimized_call}"
+
+users = [User.new, User.new]
+
+# Has N+1
+count_before = Service.count
+p users.map(&:unoptimized_call)
+p "Has N+1 #{Service.count == count_before + users.count}"
+
+# Has no N+1
+count_before = Service.count
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p users.map(&:optimized_call)
+p "Has no N+1: #{Service.count == count_before + 1}"

data/examples/graphql.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "n1_loader/ar_lazy_preload"
+require 'graphql'
+
+require_relative 'context/setup_database'
+require_relative 'context/setup_ar_lazy'
+
+class User < ActiveRecord::Base
+  has_many :payments
+
+  n1_optimized :payments_total do |users|
+    total_per_user = Payment.group(:user_id).where(user: users).sum(:amount).tap { |h| h.default = 0 }
+
+    users.each do |user|
+      total = total_per_user[user.id]
+      fulfill(user, total)
+    end
+  end
+end
+
+class Payment < ActiveRecord::Base
+  belongs_to :user
+
+  validates :amount, presence: true
+end
+
+10.times do
+  user = User.create!
+  10.times do
+    Payment.create!(user: user, amount: rand(1000))
+  end
+end
+
+ArLazyPreload.config.auto_preload = true
+# Or use +preload_associations_lazily+ when loading objects from database
+
+class UserType < GraphQL::Schema::Object
+  field :payments_total, Integer
+end
+
+class QueryType < GraphQL::Schema::Object
+  field  :users, [UserType]
+
+  def users
+    User.all
+  end
+end
+
+class Schema < GraphQL::Schema
+  query QueryType
+end
+
+query_string = <<~GQL
+  {
+    users {
+      paymentsTotal
+    }
+  }
+GQL
+
+# No N+1. And never will be!
+p Schema.execute(query_string)['data']

data/examples/isolated_loader.rb

@@ -0,0 +1,13 @@
+require 'n1_loader'
+
+class IsolatedLoader < N1Loader::Loader
+  def perform(elements)
+    elements.each { |element| fulfill(element, [element]) }
+  end
+end
+
+objects = [1, 2, 3, 4]
+loader = IsolatedLoader.new(objects)
+objects.each do |object|
+  loader.for(object) # => it has no N+1 and it doesn't require to be injected in the class
+end

data/examples/lazy_loading.rb

@@ -0,0 +1,26 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Class that wants to request 3rd party service without N+1
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+users = [User.new, User.new, User.new]
+
+# Initialized loader but didn't perform it yet
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p "No calls yet: #{Service.count == 0}"
+
+# First time loading
+users.map(&:optimized_call)
+p "First time loaded: #{Service.count == 1}"

data/examples/reloading.rb

@@ -0,0 +1,32 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call do |users|
+    data = Service.receive(users)
+
+    users.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+users = [User.new, User.new, User.new]
+
+# Initialized loader but didn't perform it yet
+N1Loader::Preloader.new(users).preload(:optimized_call)
+p "No calls yet: #{Service.count == 0}"
+
+# First time loading
+users.map(&:optimized_call)
+p "First time loaded: #{Service.count == 1}"
+
+users.first.optimized_call(reload: true)
+p "Reloaded for this object only: #{Service.count == 2}"
+
+users.first.n1_clear_cache
+users.first.optimized_call
+p "Reloaded for this object only: #{Service.count == 3}"

data/examples/shared_loader.rb

@@ -0,0 +1,34 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Loader that will be shared between multiple classes
+class SharedLoader < N1Loader::Loader
+  def perform(objects)
+    data = Service.receive(objects)
+
+    objects.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+end
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, SharedLoader
+end
+
+class Payment
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, SharedLoader
+end
+
+objects = [User.new, Payment.new, User.new, Payment.new]
+
+N1Loader::Preloader.new(objects).preload(:optimized_call)
+
+# First time loading for all objects
+objects.map(&:optimized_call)
+p "Loaded for all once: #{Service.count == 1}"

data/examples/single_case.rb

@@ -0,0 +1,34 @@
+require 'n1_loader'
+
+require_relative 'context/service'
+
+# Loader that will be shared between multiple classes
+class OptimizedLoader < N1Loader::Loader
+  def perform(objects)
+    data = Service.receive(objects)
+
+    objects.each_with_index do |user, index|
+      fulfill(user, data[index])
+    end
+  end
+
+  def single(object)
+    Service.single(object)
+  end
+end
+
+class User
+  include N1Loader::Loadable
+
+  n1_optimized :optimized_call, OptimizedLoader
+end
+
+objects = [User.new, User.new]
+
+N1Loader::Preloader.new(objects).preload(:optimized_call)
+
+objects.map(&:optimized_call)
+p "Used multi-case perform: #{Service.count == 1}"
+
+User.new.optimized_call
+p "Used single-case perform: #{Service.count == 1}"

data/lib/n1_loader/active_record/associations_preloader_v7.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ActiveRecord
+    module Associations
+      module Preloader # :nodoc:
+        N1LoaderReflection = Struct.new(:key, :loader) do
+          def options
+            {}
+          end
+        end
+
+        def preloaders_for_reflection(reflection, records)
+          return super unless reflection.is_a?(N1LoaderReflection)
+
+          N1Loader::Preloader.new(records).preload(reflection.key)
+        end
+
+        def grouped_records # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+          n1_load_records, records = source_records.partition do |record|
+            record.class.respond_to?(:n1_loader_defined?) && record.class.n1_loader_defined?(association)
+          end
+
+          h = n1_load_records.group_by do |record|
+            N1LoaderReflection.new(association, record.class.n1_loader(association))
+          end
+
+          polymorphic_parent = !root? && parent.polymorphic?
+          records.each do |record|
+            reflection = record.class._reflect_on_association(association)
+            next if polymorphic_parent && !reflection || !record.association(association).klass
+
+            (h[reflection] ||= []) << record
+          end
+          h
+        end
+      end
+    end
+  end
+end

data/lib/n1_loader/active_record/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module N1Loader
+  module ActiveRecord
+    # Extension module for ActiveRecord::Base
+    module Base
+      extend ActiveSupport::Concern
+
+      include N1Loader::Loadable
+
+      # Clear N1Loader cache on reloading the object
+      def reload(*)
+        n1_clear_cache
+        super
+      end
+    end
+  end
+end

data/lib/n1_loader/active_record/loader_collection.rb

@@ -5,3 +5,11 @@ N1Loader::LoaderCollection.define_method :preloaded_records do
 
   with.preloaded_records
 end
+
+N1Loader::LoaderCollection.define_method :runnable_loaders do
+  [self]
+end
+
+N1Loader::LoaderCollection.define_method :run? do
+  true
+end

data/lib/n1_loader/active_record.rb

@@ -16,13 +16,19 @@ end
 ActiveSupport.on_load(:active_record) do
   require_relative "active_record/loader"
   require_relative "active_record/loader_collection"
+  require_relative "active_record/base"
 
   case ActiveRecord::VERSION::MAJOR
   when 6
     require_relative "active_record/associations_preloader_v6"
-  else
+    ActiveRecord::Associations::Preloader.prepend(N1Loader::ActiveRecord::Associations::Preloader)
+  when 5
     require_relative "active_record/associations_preloader_v5"
+    ActiveRecord::Associations::Preloader.prepend(N1Loader::ActiveRecord::Associations::Preloader)
+  else
+    require_relative "active_record/associations_preloader_v7"
+    ActiveRecord::Associations::Preloader::Branch.prepend(N1Loader::ActiveRecord::Associations::Preloader)
   end
 
-  ActiveRecord::Associations::Preloader.prepend(N1Loader::ActiveRecord::Associations::Preloader)
+  ActiveRecord::Base.include(N1Loader::ActiveRecord::Base)
 end

data/lib/n1_loader/core/loader.rb

@@ -17,10 +17,13 @@ module N1Loader
       # @param name [Symbol]
       # @param opts [Hash]
       # @option opts [Boolean] optional false by default
+      # @option opts [Proc] default
       def argument(name, **opts)
+        opts[:optional] = true if opts[:default]
+
         @arguments ||= []
 
-        define_method(name) { args[name] }
+        define_method(name) { args[name] ||= opts[:default]&.call }
 
         @arguments << opts.merge(name: name)
       end

data/lib/n1_loader/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module N1Loader
-  VERSION = "1.4.2"
+  VERSION = "1.5.0"
 end

data/n1_loader.gemspec

@@ -24,7 +24,8 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "activerecord", ">= 5"
   spec.add_development_dependency "ar_lazy_preload", ">= 0.6"
-  spec.add_development_dependency "db-query-matchers", "~> 0.10"
+  spec.add_development_dependency "db-query-matchers", "~> 0.11"
+  spec.add_development_dependency "graphql", "~> 2.0"
   spec.add_development_dependency "rails", ">= 5"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "rspec_junit_formatter", "~> 0.4"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: n1_loader
 version: !ruby/object:Gem::Version
-  version: 1.4.2
+  version: 1.5.0
 platform: ruby
 authors:
 - Evgeniy Demin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-01 00:00:00.000000000 Z
+date: 2022-05-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -44,14 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.10'
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: graphql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
@@ -141,14 +155,30 @@ files:
 - Rakefile
 - activerecord-gemfiles/ar_5_latest.gemfile
 - activerecord-gemfiles/ar_6_latest.gemfile
+- activerecord-gemfiles/ar_7_latest.gemfile
 - ar_lazy_preload-gemfiles/ar_lazy_preload_0.6.1.gemfile
 - ar_lazy_preload-gemfiles/ar_lazy_preload_master.gemfile
 - bin/console
 - bin/setup
+- examples/active_record_integration.rb
+- examples/ar_lazy_integration.rb
+- examples/arguments_support.rb
+- examples/context/service.rb
+- examples/context/setup_ar_lazy.rb
+- examples/context/setup_database.rb
+- examples/core.rb
+- examples/graphql.rb
+- examples/isolated_loader.rb
+- examples/lazy_loading.rb
+- examples/reloading.rb
+- examples/shared_loader.rb
+- examples/single_case.rb
 - lib/n1_loader.rb
 - lib/n1_loader/active_record.rb
 - lib/n1_loader/active_record/associations_preloader_v5.rb
 - lib/n1_loader/active_record/associations_preloader_v6.rb
+- lib/n1_loader/active_record/associations_preloader_v7.rb
+- lib/n1_loader/active_record/base.rb
 - lib/n1_loader/active_record/loader.rb
 - lib/n1_loader/active_record/loader_collection.rb
 - lib/n1_loader/ar_lazy_preload.rb
@@ -186,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.1.6
 signing_key: 
 specification_version: 4
 summary: Loader to solve N+1 issue for good.